LIBDRM_REQUIRED=2.4.24
LIBDRM_RADEON_REQUIRED=2.4.31
LIBDRM_INTEL_REQUIRED=2.4.32
+LIBDRM_NVVIEUX_REQUIRED=2.4.33
LIBDRM_NOUVEAU_REQUIRED=0.6
DRI2PROTO_REQUIRED=2.6
GLPROTO_REQUIRED=1.4.14
case $DRI_DIRS in
*nouveau*)
- PKG_CHECK_MODULES([NOUVEAU], [libdrm_nouveau >= $LIBDRM_NOUVEAU_REQUIRED])
+ PKG_CHECK_MODULES([NOUVEAU], [libdrm_nouveau >= $LIBDRM_NVVIEUX_REQUIRED])
HAVE_NOUVEAU_DRI=yes;
;;
esac
nouveau_state.c \
nouveau_bufferobj.c \
nouveau_span.c \
- nouveau_bo_state.c \
nouveau_texture.c \
nouveau_surface.c \
nouveau_scratch.c \
#include "nouveau_driver.h"
#include "nouveau_array.h"
#include "nouveau_bufferobj.h"
+#include "nouveau_context.h"
#define EXTRACT(in_t, out_t) extract_func_##in_t##_to_##out_t
void
nouveau_init_array(struct nouveau_array *a, int attr, int stride,
int fields, int type, struct gl_buffer_object *obj,
- const void *ptr, GLboolean map)
+ const void *ptr, GLboolean map, struct gl_context *ctx)
{
+ struct nouveau_client *client = context_client(ctx);
+
a->attr = attr;
a->stride = stride;
a->fields = fields;
a->offset = (intptr_t)ptr;
if (map) {
- nouveau_bo_map(a->bo, NOUVEAU_BO_RD);
+ nouveau_bo_map(a->bo, NOUVEAU_BO_RD, client);
a->buf = a->bo->map + a->offset;
}
void
nouveau_deinit_array(struct nouveau_array *a)
{
- if (a->bo) {
- if (a->bo->map)
- nouveau_bo_unmap(a->bo);
- }
-
a->buf = NULL;
a->fields = 0;
}
void
nouveau_init_array(struct nouveau_array *a, int attr, int stride,
int fields, int type, struct gl_buffer_object *obj,
- const void *ptr, GLboolean map);
+ const void *ptr, GLboolean map, struct gl_context *ctx);
void
nouveau_deinit_array(struct nouveau_array *a);
+++ /dev/null
-/*
- * Copyright (C) 2009 Francisco Jerez.
- * All Rights Reserved.
- *
- * 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, sublicense, 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 NONINFRINGEMENT.
- * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS 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 "nouveau_driver.h"
-#include "nouveau_context.h"
-
-static GLboolean
-nouveau_bo_marker_emit(struct gl_context *ctx, struct nouveau_bo_marker *m,
- uint32_t flags)
-{
- struct nouveau_channel *chan = context_chan(ctx);
- uint32_t packet;
-
- if (m->gr->bound == NOUVEAU_GROBJ_UNBOUND)
- nouveau_grobj_autobind(m->gr);
-
- if (MARK_RING(chan, 2, 2))
- return GL_FALSE;
-
- packet = (m->gr->subc << 13) | (1 << 18) | m->mthd;
-
- if (flags) {
- if (nouveau_pushbuf_emit_reloc(chan, chan->cur++, m->bo,
- packet, 0, flags |
- (m->flags & (NOUVEAU_BO_VRAM |
- NOUVEAU_BO_GART |
- NOUVEAU_BO_RDWR)),
- 0, 0))
- goto fail;
- } else {
- *(chan->cur++) = packet;
- }
-
- if (nouveau_pushbuf_emit_reloc(chan, chan->cur++, m->bo, m->data,
- m->data2, flags | m->flags,
- m->vor, m->tor))
- goto fail;
-
- return GL_TRUE;
-
-fail:
- MARK_UNDO(chan);
- return GL_FALSE;
-}
-
-static GLboolean
-nouveau_bo_context_grow(struct nouveau_bo_context *bctx)
-{
- struct nouveau_bo_marker *marker = bctx->marker;
- int allocated = bctx->allocated + 1;
-
- marker = realloc(marker, allocated * sizeof(struct nouveau_bo_marker));
- if (!marker)
- return GL_FALSE;
-
- bctx->marker = marker;
- bctx->allocated = allocated;
-
- return GL_TRUE;
-}
-
-GLboolean
-nouveau_bo_mark(struct nouveau_bo_context *bctx, struct nouveau_grobj *gr,
- uint32_t mthd, struct nouveau_bo *bo,
- uint32_t data, uint32_t data2, uint32_t vor, uint32_t tor,
- uint32_t flags)
-{
- struct nouveau_bo_state *s = &to_nouveau_context(bctx->ctx)->bo;
- struct nouveau_bo_marker *m;
-
- if (bctx->count == bctx->allocated) {
- if (!nouveau_bo_context_grow(bctx))
- goto fail;
- }
-
- m = &bctx->marker[bctx->count];
-
- *m = (struct nouveau_bo_marker) {
- .gr = gr,
- .mthd = mthd,
- .data = data,
- .data2 = data2,
- .vor = vor,
- .tor = tor,
- .flags = flags,
- };
- nouveau_bo_ref(bo, &m->bo);
-
- s->count++;
- bctx->count++;
-
- if (!nouveau_bo_marker_emit(bctx->ctx, m, 0))
- goto fail;
-
- return GL_TRUE;
-
-fail:
- nouveau_bo_context_reset(bctx);
- return GL_FALSE;
-}
-
-void
-nouveau_bo_context_reset(struct nouveau_bo_context *bctx)
-{
- struct nouveau_bo_state *s = &to_nouveau_context(bctx->ctx)->bo;
- int i, n = bctx->count;
-
- s->count -= n;
- bctx->count = 0;
-
- for (i = 0; i < n; i++)
- nouveau_bo_ref(NULL, &bctx->marker[i].bo);
-}
-
-GLboolean
-nouveau_bo_state_emit(struct gl_context *ctx)
-{
- struct nouveau_bo_state *s = &to_nouveau_context(ctx)->bo;
- int i, j;
-
- for (i = 0; i < NUM_NOUVEAU_BO_CONTEXT; i++) {
- struct nouveau_bo_context *bctx = &s->context[i];
-
- for (j = 0; j < bctx->count; j++) {
- if (!nouveau_bo_marker_emit(ctx, &bctx->marker[j],
- NOUVEAU_BO_DUMMY))
- return GL_FALSE;
- }
- }
-
- return GL_TRUE;
-}
-
-void
-nouveau_bo_state_init(struct gl_context *ctx)
-{
- struct nouveau_bo_state *s = &to_nouveau_context(ctx)->bo;
- int i;
-
- for (i = 0; i < NUM_NOUVEAU_BO_CONTEXT; i++)
- s->context[i].ctx = ctx;
-}
-
-void
-nouveau_bo_state_destroy(struct gl_context *ctx)
-{
- struct nouveau_bo_state *s = &to_nouveau_context(ctx)->bo;
- int i, j;
-
- for (i = 0; i < NUM_NOUVEAU_BO_CONTEXT; i++) {
- struct nouveau_bo_context *bctx = &s->context[i];
-
- for (j = 0; j < bctx->count; j++)
- nouveau_bo_ref(NULL, &bctx->marker[j].bo);
-
- if (bctx->marker)
- free(bctx->marker);
- }
-}
+++ /dev/null
-/*
- * Copyright (C) 2009 Francisco Jerez.
- * All Rights Reserved.
- *
- * 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, sublicense, 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 NONINFRINGEMENT.
- * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS 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.
- *
- */
-
-#ifndef __NOUVEAU_BO_STATE_H__
-#define __NOUVEAU_BO_STATE_H__
-
-enum {
- NOUVEAU_BO_CONTEXT_FRAMEBUFFER = 0,
- NOUVEAU_BO_CONTEXT_HIERZ,
- NOUVEAU_BO_CONTEXT_SURFACE,
- NOUVEAU_BO_CONTEXT_TEXTURE0,
- NOUVEAU_BO_CONTEXT_TEXTURE1,
- NOUVEAU_BO_CONTEXT_TEXTURE2,
- NOUVEAU_BO_CONTEXT_TEXTURE3,
- NOUVEAU_BO_CONTEXT_VERTEX,
- NUM_NOUVEAU_BO_CONTEXT
-};
-
-struct nouveau_bo_marker {
- struct nouveau_grobj *gr;
- uint32_t mthd;
-
- struct nouveau_bo *bo;
- uint32_t data;
- uint32_t data2;
- uint32_t vor;
- uint32_t tor;
- uint32_t flags;
-};
-
-struct nouveau_bo_context {
- struct gl_context *ctx;
-
- struct nouveau_bo_marker *marker;
- int allocated;
- int count;
-};
-
-struct nouveau_bo_state {
- struct nouveau_bo_context context[NUM_NOUVEAU_BO_CONTEXT];
- int count;
-};
-
-GLboolean
-nouveau_bo_mark(struct nouveau_bo_context *bctx, struct nouveau_grobj *gr,
- uint32_t mthd, struct nouveau_bo *bo,
- uint32_t data, uint32_t data2, uint32_t vor, uint32_t tor,
- uint32_t flags);
-
-#define nouveau_bo_markl(bctx, gr, mthd, bo, data, flags) \
- nouveau_bo_mark(bctx, gr, mthd, bo, data, 0, 0, 0, \
- flags | NOUVEAU_BO_LOW);
-
-#define nouveau_bo_marko(bctx, gr, mthd, bo, flags) \
- nouveau_bo_mark(bctx, gr, mthd, bo, 0, 0, \
- context_chan(ctx)->vram->handle, \
- context_chan(ctx)->gart->handle, \
- flags | NOUVEAU_BO_OR);
-
-void
-nouveau_bo_context_reset(struct nouveau_bo_context *bctx);
-
-GLboolean
-nouveau_bo_state_emit(struct gl_context *ctx);
-
-void
-nouveau_bo_state_init(struct gl_context *ctx);
-
-void
-nouveau_bo_state_destroy(struct gl_context *ctx);
-
-#define __context_bctx(ctx, i) \
- ({ \
- struct nouveau_context *nctx = to_nouveau_context(ctx); \
- struct nouveau_bo_context *bctx = &nctx->bo.context[i]; \
- nouveau_bo_context_reset(bctx); \
- bctx; \
- })
-#define context_bctx(ctx, s) \
- __context_bctx(ctx, NOUVEAU_BO_CONTEXT_##s)
-#define context_bctx_i(ctx, s, i) \
- __context_bctx(ctx, NOUVEAU_BO_CONTEXT_##s##0 + (i))
-
-#endif
#include "main/bufferobj.h"
static inline char *
-get_bufferobj_map(struct gl_buffer_object *obj, unsigned flags)
+get_bufferobj_map(struct gl_context *ctx, struct gl_buffer_object *obj,
+ unsigned flags)
{
struct nouveau_bufferobj *nbo = to_nouveau_bufferobj(obj);
void *map = NULL;
if (nbo->sys) {
map = nbo->sys;
} else if (nbo->bo) {
- nouveau_bo_map(nbo->bo, flags);
+ nouveau_bo_map(nbo->bo, flags, context_client(ctx));
map = nbo->bo->map;
- nouveau_bo_unmap(nbo->bo);
}
return map;
/* Get a hardware BO */
ret = nouveau_bo_new(context_dev(ctx),
NOUVEAU_BO_GART | NOUVEAU_BO_MAP, 0,
- size, &nbo->bo);
+ size, NULL, &nbo->bo);
assert(!ret);
}
if (data)
- memcpy(get_bufferobj_map(obj, NOUVEAU_BO_WR), data, size);
+ memcpy(get_bufferobj_map(ctx, obj, NOUVEAU_BO_WR), data, size);
return GL_TRUE;
}
GLsizeiptrARB size, const GLvoid *data,
struct gl_buffer_object *obj)
{
- memcpy(get_bufferobj_map(obj, NOUVEAU_BO_WR) + offset, data, size);
+ memcpy(get_bufferobj_map(ctx, obj, NOUVEAU_BO_WR) + offset, data, size);
}
static void
GLsizeiptrARB size, GLvoid *data,
struct gl_buffer_object *obj)
{
- memcpy(data, get_bufferobj_map(obj, NOUVEAU_BO_RD) + offset, size);
+ memcpy(data, get_bufferobj_map(ctx, obj, NOUVEAU_BO_RD) + offset, size);
}
static void *
assert(!obj->Pointer);
- if (access & GL_MAP_READ_BIT)
- flags |= NOUVEAU_BO_RD;
- if (access & GL_MAP_WRITE_BIT)
- flags |= NOUVEAU_BO_WR;
- if (access & GL_MAP_UNSYNCHRONIZED_BIT)
- flags |= NOUVEAU_BO_NOSYNC;
+ if (!(access & GL_MAP_UNSYNCHRONIZED_BIT)) {
+ if (access & GL_MAP_READ_BIT)
+ flags |= NOUVEAU_BO_RD;
+ if (access & GL_MAP_WRITE_BIT)
+ flags |= NOUVEAU_BO_WR;
+ }
- map = get_bufferobj_map(obj, flags);
+ map = get_bufferobj_map(ctx, obj, flags);
if (!map)
return NULL;
#include "nouveau_context.h"
#include "nouveau_bufferobj.h"
#include "nouveau_fbo.h"
+#include "nv_object.xml.h"
#include "main/dd.h"
#include "main/framebuffer.h"
#include "tnl/tnl.h"
#include "tnl/t_context.h"
-static void
-nouveau_channel_flush_notify(struct nouveau_channel *chan)
-{
- struct nouveau_context *nctx = chan->user_private;
- struct gl_context *ctx = &nctx->base;
-
- if (nctx->fallback < SWRAST)
- nouveau_bo_state_emit(ctx);
-}
-
GLboolean
nouveau_context_create(gl_api api,
const struct gl_config *visual, __DRIcontext *dri_ctx,
share_ctx, &functions, NULL);
nouveau_state_init(ctx);
- nouveau_bo_state_init(ctx);
nouveau_scratch_init(ctx);
_mesa_meta_init(ctx);
_swrast_CreateContext(ctx);
_mesa_allow_light_in_model(ctx, GL_FALSE);
/* Allocate a hardware channel. */
- ret = nouveau_channel_alloc(context_dev(ctx), 0xbeef0201, 0xbeef0202,
- 512*1024, &nctx->hw.chan);
+ ret = nouveau_object_new(&context_dev(ctx)->object, 0xbeef0000,
+ NOUVEAU_FIFO_CHANNEL_CLASS,
+ &(struct nv04_fifo){
+ .vram = 0xbeef0201,
+ .gart = 0xbeef0202
+ }, sizeof(struct nv04_fifo), &nctx->hw.chan);
if (ret) {
nouveau_error("Error initializing the FIFO.\n");
return GL_FALSE;
}
- nctx->hw.chan->flush_notify = nouveau_channel_flush_notify;
- nctx->hw.chan->user_private = nctx;
+ /* Allocate a client (thread data) */
+ ret = nouveau_client_new(context_dev(ctx), &nctx->hw.client);
+ if (ret) {
+ nouveau_error("Error creating thread data\n");
+ return GL_FALSE;
+ }
+
+ /* Allocate a push buffer */
+ ret = nouveau_pushbuf_new(nctx->hw.client, nctx->hw.chan, 4,
+ 512 * 1024, true, &nctx->hw.pushbuf);
+ if (ret) {
+ nouveau_error("Error allocating DMA push buffer\n");
+ return GL_FALSE;
+ }
+
+ /* Allocate buffer context */
+ ret = nouveau_bufctx_new(nctx->hw.client, 16, &nctx->hw.bufctx);
+ if (ret) {
+ nouveau_error("Error allocating buffer context\n");
+ return GL_FALSE;
+ }
+
+ nctx->hw.pushbuf->user_priv = nctx->hw.bufctx;
+
+ /* Allocate NULL object */
+ ret = nouveau_object_new(nctx->hw.chan, 0x00000000, NV01_NULL_CLASS,
+ NULL, 0, &nctx->hw.null);
+ if (ret) {
+ nouveau_error("Error allocating NULL object\n");
+ return GL_FALSE;
+ }
/* Enable any supported extensions. */
ctx->Extensions.EXT_blend_color = true;
if (ctx->Meta)
_mesa_meta_free(ctx);
- if (nctx->hw.chan)
- nouveau_channel_free(&nctx->hw.chan);
+ nouveau_bufctx_del(&nctx->hw.bufctx);
+ nouveau_pushbuf_del(&nctx->hw.pushbuf);
+ nouveau_client_del(&nctx->hw.client);
+ nouveau_object_del(&nctx->hw.chan);
nouveau_scratch_destroy(ctx);
- nouveau_bo_state_destroy(ctx);
_mesa_free_context_data(ctx);
}
s->cpp = buffers[i].cpp;
if (index == BUFFER_DEPTH && s->bo) {
- ret = nouveau_bo_handle_get(s->bo, &old_name);
+ ret = nouveau_bo_name_get(s->bo, &old_name);
/*
* Disable fast Z clears in the next frame, the
* depth buffer contents are undefined.
}
nouveau_bo_ref(NULL, &s->bo);
- ret = nouveau_bo_handle_ref(context_dev(ctx),
- buffers[i].name, &s->bo);
+ ret = nouveau_bo_name_ref(context_dev(ctx),
+ buffers[i].name, &s->bo);
assert(!ret);
}
/* Clean up references to the old framebuffer objects. */
context_dirty(ctx, FRAMEBUFFER);
- context_bctx(ctx, FRAMEBUFFER);
- FIRE_RING(context_chan(ctx));
+ nouveau_bufctx_reset(to_nouveau_context(ctx)->hw.bufctx, BUFCTX_FB);
+ PUSH_KICK(context_push(ctx));
}
GLboolean
if (mode < SWRAST) {
nouveau_state_emit(ctx);
+#if 0
nouveau_bo_state_emit(ctx);
+#endif
} else {
- FIRE_RING(context_chan(ctx));
+ PUSH_KICK(context_push(ctx));
}
}
#include "nouveau_screen.h"
#include "nouveau_state.h"
-#include "nouveau_bo_state.h"
#include "nouveau_scratch.h"
#include "nouveau_render.h"
SWRAST,
};
+#define BUFCTX_FB 0
+#define BUFCTX_VTX 1
+#define BUFCTX_TEX(i) (2 + (i))
+
struct nouveau_hw_state {
- struct nouveau_channel *chan;
-
- struct nouveau_notifier *ntfy;
- struct nouveau_grobj *eng3d;
- struct nouveau_grobj *eng3dm;
- struct nouveau_grobj *surf3d;
- struct nouveau_grobj *m2mf;
- struct nouveau_grobj *surf2d;
- struct nouveau_grobj *rop;
- struct nouveau_grobj *patt;
- struct nouveau_grobj *rect;
- struct nouveau_grobj *swzsurf;
- struct nouveau_grobj *sifm;
+ struct nouveau_object *chan;
+ struct nouveau_client *client;
+ struct nouveau_pushbuf *pushbuf;
+ struct nouveau_bufctx *bufctx;
+
+ struct nouveau_object *null;
+ struct nouveau_object *ntfy;
+ struct nouveau_object *eng3d;
+ struct nouveau_object *eng3dm;
+ struct nouveau_object *surf3d;
+ struct nouveau_object *m2mf;
+ struct nouveau_object *surf2d;
+ struct nouveau_object *rop;
+ struct nouveau_object *patt;
+ struct nouveau_object *rect;
+ struct nouveau_object *swzsurf;
+ struct nouveau_object *sifm;
};
struct nouveau_context {
enum nouveau_fallback fallback;
struct nouveau_hw_state hw;
- struct nouveau_bo_state bo;
struct nouveau_render_state render;
struct nouveau_scratch_state scratch;
(context_dev(ctx)->chipset)
#define context_chan(ctx) \
(to_nouveau_context(ctx)->hw.chan)
+#define context_client(ctx) \
+ (to_nouveau_context(ctx)->hw.client)
+#define context_push(ctx) \
+ (to_nouveau_context(ctx)->hw.pushbuf)
#define context_eng3d(ctx) \
(to_nouveau_context(ctx)->hw.eng3d)
#define context_drv(ctx) \
nouveau_flush(struct gl_context *ctx)
{
struct nouveau_context *nctx = to_nouveau_context(ctx);
- struct nouveau_channel *chan = context_chan(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
- FIRE_RING(chan);
+ PUSH_KICK(push);
if (ctx->DrawBuffer->Name == 0 &&
ctx->DrawBuffer->_ColorDrawBufferIndexes[0] == BUFFER_FRONT_LEFT) {
#undef NDEBUG
#include <assert.h>
-#include "nouveau_device.h"
-#include "nouveau_grobj.h"
-#include "nouveau_channel.h"
-#include "nouveau_bo.h"
-#include "nouveau_notifier.h"
+#include <libdrm/nouveau.h>
#include "nouveau_screen.h"
#include "nouveau_state.h"
#include "nouveau_surface.h"
-#include "nv04_pushbuf.h"
+#include "nouveau_local.h"
#define DRIVER_AUTHOR "Nouveau"
if (mode & GL_MAP_WRITE_BIT)
flags |= NOUVEAU_BO_WR;
- nouveau_bo_map(s->bo, flags);
+ nouveau_bo_map(s->bo, flags, context_client(ctx));
map = s->bo->map;
stride = s->pitch;
nouveau_renderbuffer_unmap(struct gl_context *ctx,
struct gl_renderbuffer *rb)
{
- struct nouveau_surface *s = &to_nouveau_renderbuffer(rb)->surface;
-
- nouveau_bo_unmap(s->bo);
}
static GLboolean
--- /dev/null
+/*
+ * Copyright 2007 Nouveau 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, sublicense,
+ * 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 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 NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS 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.
+ */
+
+#ifndef __NOUVEAU_LOCAL_H__
+#define __NOUVEAU_LOCAL_H__
+
+static inline uint32_t
+PUSH_AVAIL(struct nouveau_pushbuf *push)
+{
+ return push->end - push->cur;
+}
+
+static inline int
+PUSH_SPACE(struct nouveau_pushbuf *push, uint32_t size)
+{
+ if (PUSH_AVAIL(push) < size)
+ return nouveau_pushbuf_space(push, size, 0, 0) == 0;
+ return 1;
+}
+
+static inline void
+PUSH_DATA(struct nouveau_pushbuf *push, uint32_t data)
+{
+ *push->cur++ = data;
+}
+
+static inline void
+PUSH_DATAf(struct nouveau_pushbuf *push, float v)
+{
+ union { float f; uint32_t i; } d = { .f = v };
+ PUSH_DATA(push, d.i);
+}
+
+static inline void
+PUSH_DATAb(struct nouveau_pushbuf *push, GLboolean x)
+{
+ PUSH_DATA(push, x ? 1 : 0);
+}
+
+static inline void
+PUSH_DATAm(struct nouveau_pushbuf *push, float m[16])
+{
+ int i, j;
+
+ for (i = 0; i < 4; i++)
+ for (j = 0; j < 4; j++)
+ PUSH_DATAf(push, m[4*j + i]);
+}
+
+static inline void
+PUSH_DATAp(struct nouveau_pushbuf *push, const void *data, uint32_t size)
+{
+ memcpy(push->cur, data, size * 4);
+ push->cur += size;
+}
+
+static inline void
+PUSH_RELOC(struct nouveau_pushbuf *push, struct nouveau_bo *bo, uint32_t offset,
+ uint32_t flags, uint32_t vor, uint32_t tor)
+{
+ nouveau_pushbuf_reloc(push, bo, offset, flags, vor, tor);
+}
+
+static inline void
+PUSH_KICK(struct nouveau_pushbuf *push)
+{
+ nouveau_pushbuf_kick(push, push->channel);
+}
+
+static struct nouveau_bufctx *
+BUFCTX(struct nouveau_pushbuf *push)
+{
+ return push->user_priv;
+}
+
+static inline void
+PUSH_RESET(struct nouveau_pushbuf *push, int bin)
+{
+ nouveau_bufctx_reset(BUFCTX(push), bin);
+}
+
+static inline void
+PUSH_MTHDl(struct nouveau_pushbuf *push, int subc, int mthd, int bin,
+ struct nouveau_bo *bo, uint32_t offset, uint32_t access)
+{
+ nouveau_bufctx_mthd(BUFCTX(push), bin, (1 << 18) | (subc << 13) | mthd,
+ bo, offset, access | NOUVEAU_BO_LOW, 0, 0);
+ PUSH_DATA(push, bo->offset + offset);
+}
+
+static inline void
+PUSH_MTHDs(struct nouveau_pushbuf *push, int subc, int mthd, int bin,
+ struct nouveau_bo *bo, uint32_t data, uint32_t access,
+ uint32_t vor, uint32_t tor)
+{
+ nouveau_bufctx_mthd(BUFCTX(push), bin, (1 << 18) | (subc << 13) | mthd,
+ bo, data, access | NOUVEAU_BO_OR, vor, tor);
+
+ if (bo->flags & NOUVEAU_BO_VRAM)
+ PUSH_DATA(push, data | vor);
+ else
+ PUSH_DATA(push, data | tor);
+}
+
+static inline void
+PUSH_MTHD(struct nouveau_pushbuf *push, int subc, int mthd, int bin,
+ struct nouveau_bo *bo, uint32_t data, uint32_t access,
+ uint32_t vor, uint32_t tor)
+{
+ nouveau_bufctx_mthd(BUFCTX(push), bin, (1 << 18) | (subc << 13) | mthd,
+ bo, data, access | NOUVEAU_BO_OR, vor, tor);
+
+ if (access & NOUVEAU_BO_LOW)
+ data += bo->offset;
+
+ if (access & NOUVEAU_BO_OR) {
+ if (bo->flags & NOUVEAU_BO_VRAM)
+ data |= vor;
+ else
+ data |= tor;
+ }
+
+ PUSH_DATA(push, data);
+}
+
+static inline void
+BEGIN_NV04(struct nouveau_pushbuf *push, int subc, int mthd, int size)
+{
+ PUSH_SPACE(push, size + 1);
+ PUSH_DATA (push, 0x00000000 | (size << 18) | (subc << 13) | mthd);
+}
+
+static inline void
+BEGIN_NI04(struct nouveau_pushbuf *push, int subc, int mthd, int size)
+{
+ PUSH_SPACE(push, size + 1);
+ PUSH_DATA (push, 0x40000000 | (size << 18) | (subc << 13) | mthd);
+}
+
+/* subchannel assignment */
+#define SUBC_M2MF(mthd) 0, (mthd)
+#define NV03_M2MF(mthd) SUBC_M2MF(NV04_M2MF_##mthd)
+#define SUBC_NVSW(mthd) 1, (mthd)
+#define SUBC_SF2D(mthd) 2, (mthd)
+#define NV04_SF2D(mthd) SUBC_SF2D(NV04_CONTEXT_SURFACES_2D_##mthd)
+#define NV10_SF2D(mthd) SUBC_SF2D(NV10_CONTEXT_SURFACES_2D_##mthd)
+#define SUBC_PATT(mthd) 3, (mthd)
+#define NV01_PATT(mthd) SUBC_PATT(NV04_IMAGE_PATTERN_##mthd)
+#define NV01_ROP(mthd) SUBC_PATT(NV03_CONTEXT_ROP_##mthd)
+#define SUBC_GDI(mthd) 4, (mthd)
+#define NV04_GDI(mthd) SUBC_GDI(NV04_GDI_RECTANGLE_TEXT_##mthd)
+#define SUBC_SIFM(mthd) 5, (mthd)
+#define NV03_SIFM(mthd) SUBC_SIFM(NV03_SCALED_IMAGE_FROM_MEMORY_##mthd)
+#define NV05_SIFM(mthd) SUBC_SIFM(NV05_SCALED_IMAGE_FROM_MEMORY_##mthd)
+#define SUBC_SURF(mthd) 6, (mthd)
+#define NV04_SSWZ(mthd) SUBC_SURF(NV04_SWIZZLED_SURFACE_##mthd)
+#define NV04_SF3D(mthd) SUBC_SURF(NV04_CONTEXT_SURFACES_3D_##mthd)
+#define SUBC_3D(mthd) 7, (mthd)
+#define NV04_TTRI(mthd) SUBC_3D(NV04_TEXTURED_TRIANGLE_##mthd)
+#define NV04_MTRI(mthd) SUBC_3D(NV04_MULTITEX_TRIANGLE_##mthd)
+#define NV10_3D(mthd) SUBC_3D(NV10_3D_##mthd)
+#define NV11_3D(mthd) SUBC_3D(NV11_3D_##mthd)
+#define NV17_3D(mthd) SUBC_3D(NV17_3D_##mthd)
+#define NV20_3D(mthd) SUBC_3D(NV20_3D_##mthd)
+#define NV25_3D(mthd) SUBC_3D(NV25_3D_##mthd)
+
+#define NV01_SUBC(subc, mthd) SUBC_##subc((NV01_SUBCHAN_##mthd))
+#define NV11_SUBC(subc, mthd) SUBC_##subc((NV11_SUBCHAN_##mthd))
+
+#define NV04_GRAPH(subc, mthd) SUBC_##subc((NV04_GRAPH_##mthd))
+
+#endif
dispatch_l(struct gl_context *ctx, unsigned int start, int delta,
unsigned int n)
{
- struct nouveau_channel *chan = context_chan(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
RENDER_LOCALS(ctx);
EMIT_VBO(L, ctx, start, delta, n);
dispatch_i32(struct gl_context *ctx, unsigned int start, int delta,
unsigned int n)
{
- struct nouveau_channel *chan = context_chan(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
RENDER_LOCALS(ctx);
EMIT_VBO(I32, ctx, start, delta, n);
dispatch_i16(struct gl_context *ctx, unsigned int start, int delta,
unsigned int n)
{
- struct nouveau_channel *chan = context_chan(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
RENDER_LOCALS(ctx);
EMIT_VBO(I32, ctx, start, delta, n & 1);
nouveau_get_scratch(struct gl_context *ctx, unsigned size,
struct nouveau_bo **bo, unsigned *offset)
{
+ struct nouveau_client *client = context_client(ctx);
struct nouveau_scratch_state *scratch =
&to_nouveau_context(ctx)->scratch;
void *buf;
scratch->index = (scratch->index + 1) % NOUVEAU_SCRATCH_COUNT;
nouveau_bo_ref(scratch->bo[scratch->index], bo);
- nouveau_bo_map(*bo, NOUVEAU_BO_WR);
+ nouveau_bo_map(*bo, NOUVEAU_BO_WR, client);
buf = scratch->buf = (*bo)->map;
- nouveau_bo_unmap(*bo);
*offset = 0;
scratch->offset = size;
} else {
- nouveau_bo_new(context_dev(ctx),
- NOUVEAU_BO_MAP | NOUVEAU_BO_GART, 0, size, bo);
+ nouveau_bo_new(context_dev(ctx), NOUVEAU_BO_GART |
+ NOUVEAU_BO_MAP, 0, size, NULL, bo);
- nouveau_bo_map(*bo, NOUVEAU_BO_WR);
+ nouveau_bo_map(*bo, NOUVEAU_BO_WR, client);
buf = (*bo)->map;
- nouveau_bo_unmap(*bo);
*offset = 0;
}
int ret, i;
for (i = 0; i < NOUVEAU_SCRATCH_COUNT; i++) {
- ret = nouveau_bo_new(context_dev(ctx),
- NOUVEAU_BO_MAP | NOUVEAU_BO_GART,
- 0, NOUVEAU_SCRATCH_SIZE, &scratch->bo[i]);
+ ret = nouveau_bo_new(context_dev(ctx), NOUVEAU_BO_GART |
+ NOUVEAU_BO_MAP, 0, NOUVEAU_SCRATCH_SIZE,
+ NULL, &scratch->bo[i]);
assert(!ret);
}
}
#include "nouveau_context.h"
#include "nouveau_fbo.h"
#include "nouveau_texture.h"
-#include "nouveau_drmif.h"
#include "nv04_driver.h"
#include "nv10_driver.h"
#include "nv20_driver.h"
screen->dri_screen = dri_screen;
/* Open the DRM device. */
- ret = nouveau_device_open_existing(&screen->device, 0, dri_screen->fd,
- 0);
+ ret = nouveau_device_wrap(dri_screen->fd, 0, &screen->device);
if (ret) {
nouveau_error("Error opening the DRM device.\n");
goto fail;
if (!screen)
return;
- if (screen->device)
- nouveau_device_close(&screen->device);
+ nouveau_device_del(&screen->device);
FREE(screen);
dri_screen->driverPrivate = NULL;
#include "nouveau_driver.h"
#include "nouveau_fbo.h"
#include "nouveau_context.h"
-#include "nouveau_bo.h"
#include "swrast/swrast.h"
#include "swrast/s_context.h"
static void
-renderbuffer_map_unmap(struct gl_renderbuffer *rb, GLboolean map)
+renderbuffer_map_unmap(struct gl_context *ctx, struct gl_renderbuffer *rb,
+ GLboolean map)
{
struct nouveau_surface *s = &to_nouveau_renderbuffer(rb)->surface;
- if (map) {
- nouveau_bo_map(s->bo, NOUVEAU_BO_RDWR);
- } else {
- nouveau_bo_unmap(s->bo);
- }
+ if (map)
+ nouveau_bo_map(s->bo, NOUVEAU_BO_RDWR, context_client(ctx));
}
static void
-framebuffer_map_unmap(struct gl_framebuffer *fb, GLboolean map)
+framebuffer_map_unmap(struct gl_context *ctx, struct gl_framebuffer *fb, GLboolean map)
{
int i;
for (i = 0; i < fb->_NumColorDrawBuffers; i++)
- renderbuffer_map_unmap(fb->_ColorDrawBuffers[i], map);
+ renderbuffer_map_unmap(ctx, fb->_ColorDrawBuffers[i], map);
- renderbuffer_map_unmap(fb->_ColorReadBuffer, map);
+ renderbuffer_map_unmap(ctx, fb->_ColorReadBuffer, map);
if (fb->Attachment[BUFFER_DEPTH].Renderbuffer)
- renderbuffer_map_unmap(fb->Attachment[BUFFER_DEPTH].Renderbuffer, map);
+ renderbuffer_map_unmap(ctx, fb->Attachment[BUFFER_DEPTH].Renderbuffer, map);
}
static void
{
int i;
- framebuffer_map_unmap(ctx->DrawBuffer, map);
+ framebuffer_map_unmap(ctx, ctx->DrawBuffer, map);
if (ctx->ReadBuffer != ctx->DrawBuffer)
- framebuffer_map_unmap(ctx->ReadBuffer, map);
+ framebuffer_map_unmap(ctx, ctx->ReadBuffer, map);
for (i = 0; i < ctx->Const.MaxTextureUnits; i++)
if (map)
unsigned flags, unsigned format,
unsigned width, unsigned height)
{
- unsigned tile_mode = 0, tile_flags = 0;
+ union nouveau_bo_config config = {};
int ret, cpp = _mesa_get_format_bytes(format);
nouveau_bo_ref(NULL, &s->bo);
if (layout == TILED) {
s->pitch = align(s->pitch, 256);
- tile_mode = s->pitch;
+ config.nv04.surf_pitch = s->pitch;
if (cpp == 4)
- tile_flags = NOUVEAU_BO_TILE_32BPP;
+ config.nv04.surf_flags = NV04_BO_32BPP;
else if (cpp == 2)
- tile_flags = NOUVEAU_BO_TILE_16BPP;
+ config.nv04.surf_flags = NV04_BO_16BPP;
if (_mesa_get_format_bits(format, GL_DEPTH_BITS))
- tile_flags |= NOUVEAU_BO_TILE_ZETA;
+ config.nv04.surf_flags |= NV04_BO_ZETA;
} else {
s->pitch = align(s->pitch, 64);
}
- ret = nouveau_bo_new_tile(context_dev(ctx), flags, 0, s->pitch * height,
- tile_mode, tile_flags, &s->bo);
+ ret = nouveau_bo_new(context_dev(ctx), flags, 0, s->pitch * height,
+ &config, &s->bo);
assert(!ret);
}
struct nouveau_render_state *render = to_render_state(ctx);
int i, attr;
+ TAG(render_release_vertices)(ctx);
+
FOR_EACH_BOUND_ATTR(render, i, attr) {
nouveau_bo_ref(NULL, &render->attrs[attr].bo);
render->map[i] = -1;
static void
swtnl_flush_vertices(struct gl_context *ctx)
{
- struct nouveau_channel *chan = context_chan(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
struct nouveau_swtnl_state *swtnl = &to_render_state(ctx)->swtnl;
- unsigned push, start = 0, count = swtnl->vertex_count;
+ unsigned npush, start = 0, count = swtnl->vertex_count;
RENDER_LOCALS(ctx);
swtnl_bind_vertices(ctx);
while (count) {
- push = get_max_vertices(ctx, NULL, AVAIL_RING(chan));
- push = MIN2(push / 12 * 12, count);
- count -= push;
+ npush = get_max_vertices(ctx, NULL, PUSH_AVAIL(push));
+ npush = MIN2(npush / 12 * 12, count);
+ count -= npush;
- if (!push) {
- FIRE_RING(chan);
+ if (!npush) {
+ PUSH_KICK(push);
continue;
}
BATCH_BEGIN(nvgl_primitive(swtnl->primitive));
- EMIT_VBO(L, ctx, start, 0, push);
+ EMIT_VBO(L, ctx, start, 0, npush);
BATCH_END();
- FIRE_RING(chan);
+ PUSH_KICK(push);
}
swtnl_alloc_vertices(ctx);
struct nouveau_teximage *nti = to_nouveau_teximage(ti);
struct nouveau_surface *s = &nti->surface;
struct nouveau_surface *st = &nti->transfer.surface;
+ struct nouveau_client *client = context_client(ctx);
if (s->bo) {
if (!(access & GL_MAP_READ_BIT) &&
- nouveau_bo_pending(s->bo)) {
+ nouveau_pushbuf_refd(context_push(ctx), s->bo)) {
/*
* Heuristic: use a bounce buffer to pipeline
* teximage transfers.
flags |= NOUVEAU_BO_WR;
if (!s->bo->map) {
- ret = nouveau_bo_map(s->bo, flags);
+ ret = nouveau_bo_map(s->bo, flags, client);
assert(!ret);
}
st->width, st->height);
nouveau_surface_ref(NULL, st);
- } else if (s->bo) {
- nouveau_bo_unmap(s->bo);
}
-
nti->base.Map = NULL;
}
struct nouveau_teximage *nti = to_nouveau_teximage(ti);
struct nouveau_surface *s = &nti->surface;
struct nouveau_surface *st = &nti->transfer.surface;
+ struct nouveau_client *client = context_client(ctx);
/* Nouveau has no support for 3D or cubemap textures. */
assert(slice == 0);
if (s->bo) {
if (!(mode & GL_MAP_READ_BIT) &&
- nouveau_bo_pending(s->bo)) {
+ nouveau_pushbuf_refd(context_push(ctx), s->bo)) {
/*
* Heuristic: use a bounce buffer to pipeline
* teximage transfers.
flags |= NOUVEAU_BO_WR;
if (!s->bo->map) {
- ret = nouveau_bo_map(s->bo, flags);
+ ret = nouveau_bo_map(s->bo, flags, client);
assert(!ret);
}
st->width, st->height);
nouveau_surface_ref(NULL, st);
- } else if (s->bo) {
- nouveau_bo_unmap(s->bo);
}
nti->base.Map = NULL;
ret = nouveau_bo_new(context_dev(ctx), NOUVEAU_BO_MAP |
NOUVEAU_BO_GART | NOUVEAU_BO_VRAM,
- 0, size, &ss[last].bo);
+ 0, size, NULL, &ss[last].bo);
assert(!ret);
for (i = t->BaseLevel; i < last; i++)
s->width, s->height, 1);
}
- FIRE_RING(context_chan(ctx));
+ PUSH_KICK(context_push(ctx));
}
return GL_TRUE;
a[2] = fb->_DepthMaxF * (vp->Far + vp->Near) / 2;
}
-static inline void
-OUT_RINGb(struct nouveau_channel *chan, GLboolean x)
-{
- OUT_RING(chan, x ? 1 : 0);
-}
-
-static inline void
-OUT_RINGm(struct nouveau_channel *chan, float m[16])
-{
- int i, j;
-
- for (i = 0; i < 4; i++)
- for (j = 0; j < 4; j++)
- OUT_RINGf(chan, m[4*j + i]);
-}
-
static inline GLboolean
is_color_operand(int op)
{
*
*/
+#include "nouveau_driver.h"
#include "nouveau_bufferobj.h"
#include "nouveau_util.h"
if (ib)
nouveau_init_array(&render->ib, 0, 0, ib->count, ib->type,
- ib->obj, ib->ptr, GL_TRUE);
+ ib->obj, ib->ptr, GL_TRUE, ctx);
FOR_EACH_BOUND_ATTR(render, i, attr) {
const struct gl_client_array *array = arrays[attr];
get_array_stride(ctx, array),
array->Size, array->Type,
imm ? array->BufferObj : NULL,
- array->Ptr, imm);
+ array->Ptr, imm, ctx);
}
}
vbo_emit_attr(struct gl_context *ctx, const struct gl_client_array **arrays,
int attr)
{
- struct nouveau_channel *chan = context_chan(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
struct nouveau_render_state *render = to_render_state(ctx);
const struct gl_client_array *array = arrays[attr];
struct nouveau_array *a = &render->attrs[attr];
/* Constant attribute. */
nouveau_init_array(a, attr, array->StrideB, array->Size,
array->Type, array->BufferObj, array->Ptr,
- GL_TRUE);
+ GL_TRUE, ctx);
EMIT_IMM(ctx, a, 0);
nouveau_deinit_array(a);
{
struct nouveau_context *nctx = to_nouveau_context(ctx);
struct nouveau_render_state *render = to_render_state(ctx);
- unsigned pushbuf_avail = PUSHBUF_DWORDS - 2 * (nctx->bo.count +
+ struct nouveau_bufctx *bufctx = nctx->hw.bufctx;
+ unsigned pushbuf_avail = PUSHBUF_DWORDS - 2 * (bufctx->relocs +
render->attr_count),
vert_avail = get_max_vertices(ctx, NULL, pushbuf_avail),
idx_avail = get_max_vertices(ctx, ib, pushbuf_avail);
int base, unsigned min_index, unsigned max_index, int *pdelta)
{
struct nouveau_render_state *render = to_render_state(ctx);
- struct nouveau_channel *chan = context_chan(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
struct nouveau_bo *bo[NUM_VERTEX_ATTRS];
unsigned offset[NUM_VERTEX_ATTRS];
GLboolean dirty = GL_FALSE;
a->bo = bo[i];
}
+ TAG(render_release_vertices)(ctx);
TAG(render_bind_vertices)(ctx);
-
} else {
/* Just cleanup. */
FOR_EACH_BOUND_ATTR(render, i, attr)
const struct _mesa_index_buffer *ib, GLuint min_index,
GLuint max_index)
{
- struct nouveau_channel *chan = context_chan(ctx);
+ struct nouveau_context *nctx = to_nouveau_context(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
dispatch_t dispatch = get_array_dispatch(&to_render_state(ctx)->ib);
int i, delta = 0, basevertex = 0;
RENDER_LOCALS(ctx);
basevertex = prims[i].basevertex;
vbo_bind_vertices(ctx, arrays, basevertex, min_index,
max_index, &delta);
+
+ nouveau_pushbuf_bufctx(push, nctx->hw.bufctx);
+ if (nouveau_pushbuf_validate(push)) {
+ nouveau_pushbuf_bufctx(push, NULL);
+ return;
+ }
}
- if (count > get_max_vertices(ctx, ib, AVAIL_RING(chan)))
- WAIT_RING(chan, PUSHBUF_DWORDS);
+ if (count > get_max_vertices(ctx, ib, PUSH_AVAIL(push)))
+ PUSH_SPACE(push, PUSHBUF_DWORDS);
BATCH_BEGIN(nvgl_primitive(prims[i].mode));
dispatch(ctx, start, delta, count);
BATCH_END();
}
+
+ nouveau_pushbuf_bufctx(push, NULL);
+ TAG(render_release_vertices)(ctx);
}
/* Immediate rendering path. */
GLuint max_index)
{
struct nouveau_render_state *render = to_render_state(ctx);
- struct nouveau_channel *chan = context_chan(ctx);
+ struct nouveau_context *nctx = to_nouveau_context(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
extract_u_t extract = ib ? render->ib.extract_u : extract_id;
int i, j, k, attr;
RENDER_LOCALS(ctx);
+ nouveau_pushbuf_bufctx(push, nctx->hw.bufctx);
+ if (nouveau_pushbuf_validate(push)) {
+ nouveau_pushbuf_bufctx(push, NULL);
+ return;
+ }
+
for (i = 0; i < nr_prims; i++) {
unsigned start = prims[i].start,
end = start + prims[i].count;
if (prims[i].count > get_max_vertices(ctx, ib,
- AVAIL_RING(chan)))
- WAIT_RING(chan, PUSHBUF_DWORDS);
+ PUSH_AVAIL(push)))
+ PUSH_SPACE(push, PUSHBUF_DWORDS);
BATCH_BEGIN(nvgl_primitive(prims[i].mode));
BATCH_END();
}
+
+ nouveau_pushbuf_bufctx(push, NULL);
}
/* draw_prims entry point when we're doing hw-tnl. */
u->EnvMode == GL_ADD;
}
-struct nouveau_grobj *
+struct nouveau_object *
nv04_context_engine(struct gl_context *ctx)
{
struct nv04_context *nctx = to_nv04_context(ctx);
struct nouveau_hw_state *hw = &to_nouveau_context(ctx)->hw;
- struct nouveau_grobj *fahrenheit;
+ struct nouveau_pushbuf *push = context_push(ctx);
+ struct nouveau_object *fahrenheit;
if ((ctx->Texture.Unit[0]._ReallyEnabled &&
texunit_needs_combiners(&ctx->Texture.Unit[0])) ||
if (fahrenheit != nctx->eng3d) {
nctx->eng3d = fahrenheit;
+ BEGIN_NV04(push, NV01_SUBC(3D, OBJECT), 1);
+ PUSH_DATA (push, fahrenheit->handle);
+
if (nv04_mtex_engine(fahrenheit)) {
context_dirty_i(ctx, TEX_ENV, 0);
context_dirty_i(ctx, TEX_ENV, 1);
context_dirty(ctx, CONTROL);
context_dirty(ctx, BLEND);
} else {
- context_bctx_i(ctx, TEXTURE, 1);
+ nouveau_bufctx_reset(to_nouveau_context(ctx)->hw.
+ bufctx, BUFCTX_TEX(1));
context_dirty_i(ctx, TEX_ENV, 0);
context_dirty_i(ctx, TEX_OBJ, 0);
context_dirty(ctx, CONTROL);
}
static void
-nv04_channel_flush_notify(struct nouveau_channel *chan)
-{
- struct nouveau_context *nctx = chan->user_private;
- struct gl_context *ctx = &nctx->base;
-
- if (nctx->fallback < SWRAST) {
- nouveau_bo_state_emit(ctx);
-
- /* Reemit the engine state. */
- context_emit(ctx, TEX_OBJ0);
- context_emit(ctx, TEX_OBJ1);
- context_emit(ctx, TEX_ENV0);
- context_emit(ctx, TEX_ENV1);
- context_emit(ctx, CONTROL);
- context_emit(ctx, BLEND);
- }
-}
-
-static void
nv04_hwctx_init(struct gl_context *ctx)
{
- struct nouveau_channel *chan = context_chan(ctx);
struct nouveau_hw_state *hw = &to_nouveau_context(ctx)->hw;
- struct nouveau_grobj *surf3d = hw->surf3d;
- struct nouveau_grobj *eng3d = hw->eng3d;
- struct nouveau_grobj *eng3dm = hw->eng3dm;
-
- BIND_RING(chan, surf3d, 7);
- BEGIN_RING(chan, surf3d, NV04_CONTEXT_SURFACES_3D_DMA_NOTIFY, 3);
- OUT_RING(chan, hw->ntfy->handle);
- OUT_RING(chan, chan->vram->handle);
- OUT_RING(chan, chan->vram->handle);
-
- BEGIN_RING(chan, eng3d, NV04_TEXTURED_TRIANGLE_DMA_NOTIFY, 4);
- OUT_RING(chan, hw->ntfy->handle);
- OUT_RING(chan, chan->vram->handle);
- OUT_RING(chan, chan->gart->handle);
- OUT_RING(chan, surf3d->handle);
-
- BEGIN_RING(chan, eng3dm, NV04_MULTITEX_TRIANGLE_DMA_NOTIFY, 4);
- OUT_RING(chan, hw->ntfy->handle);
- OUT_RING(chan, chan->vram->handle);
- OUT_RING(chan, chan->gart->handle);
- OUT_RING(chan, surf3d->handle);
-
- FIRE_RING(chan);
+ struct nouveau_pushbuf *push = context_push(ctx);
+ struct nv04_fifo *fifo = hw->chan->data;
+
+ BEGIN_NV04(push, NV01_SUBC(SURF, OBJECT), 1);
+ PUSH_DATA (push, hw->surf3d->handle);
+ BEGIN_NV04(push, NV04_SF3D(DMA_NOTIFY), 3);
+ PUSH_DATA (push, hw->ntfy->handle);
+ PUSH_DATA (push, fifo->vram);
+ PUSH_DATA (push, fifo->vram);
+
+ BEGIN_NV04(push, NV01_SUBC(3D, OBJECT), 1);
+ PUSH_DATA (push, hw->eng3d->handle);
+ BEGIN_NV04(push, NV04_TTRI(DMA_NOTIFY), 4);
+ PUSH_DATA (push, hw->ntfy->handle);
+ PUSH_DATA (push, fifo->vram);
+ PUSH_DATA (push, fifo->gart);
+ PUSH_DATA (push, hw->surf3d->handle);
+
+ BEGIN_NV04(push, NV01_SUBC(3D, OBJECT), 1);
+ PUSH_DATA (push, hw->eng3dm->handle);
+ BEGIN_NV04(push, NV04_MTRI(DMA_NOTIFY), 4);
+ PUSH_DATA (push, hw->ntfy->handle);
+ PUSH_DATA (push, fifo->vram);
+ PUSH_DATA (push, fifo->gart);
+ PUSH_DATA (push, hw->surf3d->handle);
+
+ PUSH_KICK (push);
}
static void
NOUVEAU_BO_MAP | NOUVEAU_BO_VRAM,
MESA_FORMAT_ARGB8888, 1, 1);
- nouveau_bo_map(s->bo, NOUVEAU_BO_WR);
+ nouveau_bo_map(s->bo, NOUVEAU_BO_WR, context_client(ctx));
*(uint32_t *)s->bo->map = 0xffffffff;
- nouveau_bo_unmap(s->bo);
}
static void
nv04_render_destroy(ctx);
nouveau_surface_ref(NULL, &to_nv04_context(ctx)->dummy_texture);
- nouveau_grobj_free(&nctx->hw.eng3d);
- nouveau_grobj_free(&nctx->hw.eng3dm);
- nouveau_grobj_free(&nctx->hw.surf3d);
+ nouveau_object_del(&nctx->hw.eng3d);
+ nouveau_object_del(&nctx->hw.eng3dm);
+ nouveau_object_del(&nctx->hw.surf3d);
nouveau_context_deinit(ctx);
FREE(ctx);
if (!nouveau_context_init(ctx, screen, visual, share_ctx))
goto fail;
- hw->chan->flush_notify = nv04_channel_flush_notify;
-
/* GL constants. */
ctx->Const.MaxTextureLevels = 11;
ctx->Const.MaxTextureCoordUnits = NV04_TEXTURE_UNITS;
goto fail;
/* 3D engine. */
- ret = nouveau_grobj_alloc(context_chan(ctx), 0xbeef0001,
- NV04_TEXTURED_TRIANGLE, &hw->eng3d);
+ ret = nouveau_object_new(context_chan(ctx), 0xbeef0001,
+ NV04_TEXTURED_TRIANGLE_CLASS, NULL, 0,
+ &hw->eng3d);
if (ret)
goto fail;
- ret = nouveau_grobj_alloc(context_chan(ctx), 0xbeef0002,
- NV04_MULTITEX_TRIANGLE, &hw->eng3dm);
+ ret = nouveau_object_new(context_chan(ctx), 0xbeef0002,
+ NV04_MULTITEX_TRIANGLE_CLASS, NULL, 0,
+ &hw->eng3dm);
if (ret)
goto fail;
- ret = nouveau_grobj_alloc(context_chan(ctx), 0xbeef0003,
- NV04_CONTEXT_SURFACES_3D, &hw->surf3d);
+ ret = nouveau_object_new(context_chan(ctx), 0xbeef0003,
+ NV04_SURFACE_3D_CLASS, NULL, 0,
+ &hw->surf3d);
if (ret)
goto fail;
struct nv04_context {
struct nouveau_context base;
- struct nouveau_grobj *eng3d;
+ struct nouveau_object *eng3d;
struct nouveau_surface dummy_texture;
float viewport[16];
};
#define to_nv04_context(ctx) ((struct nv04_context *)(ctx))
-#define nv04_mtex_engine(obj) ((obj)->grclass == NV04_MULTITEX_TRIANGLE)
+#define nv04_mtex_engine(obj) ((obj)->oclass == NV04_MULTITEX_TRIANGLE_CLASS)
-struct nouveau_grobj *
+struct nouveau_object *
nv04_context_engine(struct gl_context *ctx);
extern const struct nouveau_driver nv04_driver;
swtnl_choose_attrs(struct gl_context *ctx)
{
TNLcontext *tnl = TNL_CONTEXT(ctx);
- struct nouveau_grobj *fahrenheit = nv04_context_engine(ctx);
+ struct nouveau_object *fahrenheit = nv04_context_engine(ctx);
struct nv04_context *nctx = to_nv04_context(ctx);
static struct tnl_attr_map map[NUM_VERTEX_ATTRS];
int n = 0;
static void
swtnl_start(struct gl_context *ctx)
{
+ struct nouveau_pushbuf *push = context_push(ctx);
+
+ nouveau_pushbuf_bufctx(push, push->user_priv);
+ nouveau_pushbuf_validate(push);
+
swtnl_choose_attrs(ctx);
}
static void
swtnl_finish(struct gl_context *ctx)
{
- FIRE_RING(context_chan(ctx));
+ struct nouveau_pushbuf *push = context_push(ctx);
+
+ nouveau_pushbuf_bufctx(push, NULL);
+ PUSH_KICK(push);
}
static void
/* Primitive rendering */
#define BEGIN_PRIMITIVE(n) \
- struct nouveau_channel *chan = context_chan(ctx); \
- struct nouveau_grobj *fahrenheit = nv04_context_engine(ctx); \
+ struct nouveau_pushbuf *push = context_push(ctx); \
+ struct nouveau_object *fahrenheit = nv04_context_engine(ctx); \
int vertex_len = TNL_CONTEXT(ctx)->clipspace.vertex_size / 4; \
\
if (nv04_mtex_engine(fahrenheit)) \
- BEGIN_RING(chan, fahrenheit, \
- NV04_MULTITEX_TRIANGLE_TLMTVERTEX_SX(0), \
+ BEGIN_NV04(push, NV04_MTRI(TLMTVERTEX_SX(0)), \
n * vertex_len); \
else \
- BEGIN_RING(chan, fahrenheit, \
- NV04_TEXTURED_TRIANGLE_TLVERTEX_SX(0), \
+ BEGIN_NV04(push, NV04_TTRI(TLVERTEX_SX(0)), \
n * vertex_len); \
-#define OUT_VERTEX(i) \
- OUT_RINGp(chan, _tnl_get_vertex(ctx, i), vertex_len);
+#define OUT_VERTEX(i) \
+ PUSH_DATAp(push, _tnl_get_vertex(ctx, i), vertex_len);
#define END_PRIMITIVE(draw) \
if (nv04_mtex_engine(fahrenheit)) { \
- BEGIN_RING(chan, fahrenheit, \
- NV04_MULTITEX_TRIANGLE_DRAWPRIMITIVE(0), 1); \
- OUT_RING(chan, draw); \
+ BEGIN_NV04(push, NV04_MTRI(DRAWPRIMITIVE(0)), 1); \
+ PUSH_DATA (push, draw); \
} else { \
- BEGIN_RING(chan, fahrenheit, \
- NV04_TEXTURED_TRIANGLE_DRAWPRIMITIVE(0), 1); \
- OUT_RING(chan, draw); \
+ BEGIN_NV04(push, NV04_TTRI(DRAWPRIMITIVE(0)), 1); \
+ PUSH_DATA (push, draw); \
}
static void
static void
swtnl_triangle(struct gl_context *ctx, GLuint v1, GLuint v2, GLuint v3)
{
+ context_emit(ctx, TEX_OBJ0);
+ context_emit(ctx, TEX_OBJ1);
+ context_emit(ctx, TEX_ENV0);
+ context_emit(ctx, TEX_ENV1);
+ context_emit(ctx, CONTROL);
+ context_emit(ctx, BLEND);
+
BEGIN_PRIMITIVE(3);
OUT_VERTEX(v1);
OUT_VERTEX(v2);
static void
swtnl_quad(struct gl_context *ctx, GLuint v1, GLuint v2, GLuint v3, GLuint v4)
{
+ context_emit(ctx, TEX_OBJ0);
+ context_emit(ctx, TEX_OBJ1);
+ context_emit(ctx, TEX_ENV0);
+ context_emit(ctx, TEX_ENV1);
+ context_emit(ctx, CONTROL);
+ context_emit(ctx, BLEND);
+
BEGIN_PRIMITIVE(4);
OUT_VERTEX(v1);
OUT_VERTEX(v2);
void
nv04_emit_framebuffer(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_hw_state *hw = &to_nouveau_context(ctx)->hw;
- struct nouveau_grobj *surf3d = hw->surf3d;
- struct nouveau_bo_context *bctx = context_bctx(ctx, FRAMEBUFFER);
+ struct nouveau_pushbuf *push = context_push(ctx);
struct gl_framebuffer *fb = ctx->DrawBuffer;
struct nouveau_surface *s;
uint32_t rt_format = NV04_CONTEXT_SURFACES_3D_FORMAT_TYPE_PITCH;
if (fb->_Status != GL_FRAMEBUFFER_COMPLETE_EXT)
return;
+ PUSH_RESET(push, BUFCTX_FB);
+
/* Render target */
if (fb->_ColorDrawBuffers[0]) {
s = &to_nouveau_renderbuffer(
rt_format |= get_rt_format(s->format);
zeta_pitch = rt_pitch = s->pitch;
- nouveau_bo_markl(bctx, surf3d,
- NV04_CONTEXT_SURFACES_3D_OFFSET_COLOR,
+ BEGIN_NV04(push, NV04_SF3D(OFFSET_COLOR), 1);
+ PUSH_MTHDl(push, NV04_SF3D(OFFSET_COLOR), BUFCTX_FB,
s->bo, 0, bo_flags);
}
zeta_pitch = s->pitch;
- nouveau_bo_markl(bctx, surf3d,
- NV04_CONTEXT_SURFACES_3D_OFFSET_ZETA,
+ BEGIN_NV04(push, NV04_SF3D(OFFSET_ZETA), 1);
+ PUSH_MTHDl(push, NV04_SF3D(OFFSET_ZETA), BUFCTX_FB,
s->bo, 0, bo_flags);
}
- BEGIN_RING(chan, surf3d, NV04_CONTEXT_SURFACES_3D_FORMAT, 1);
- OUT_RING(chan, rt_format);
- BEGIN_RING(chan, surf3d, NV04_CONTEXT_SURFACES_3D_PITCH, 1);
- OUT_RING(chan, zeta_pitch << 16 | rt_pitch);
+ BEGIN_NV04(push, NV04_SF3D(FORMAT), 1);
+ PUSH_DATA (push, rt_format);
+ BEGIN_NV04(push, NV04_SF3D(PITCH), 1);
+ PUSH_DATA (push, zeta_pitch << 16 | rt_pitch);
/* Recompute the scissor state. */
context_dirty(ctx, SCISSOR);
void
nv04_emit_scissor(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_hw_state *hw = &to_nouveau_context(ctx)->hw;
- struct nouveau_grobj *surf3d = hw->surf3d;
+ struct nouveau_pushbuf *push = context_push(ctx);
int x, y, w, h;
get_scissors(ctx->DrawBuffer, &x, &y, &w, &h);
- BEGIN_RING(chan, surf3d, NV04_CONTEXT_SURFACES_3D_CLIP_HORIZONTAL, 2);
- OUT_RING(chan, w << 16 | x);
- OUT_RING(chan, h << 16 | y);
+ BEGIN_NV04(push, NV04_SF3D(CLIP_HORIZONTAL), 2);
+ PUSH_DATA (push, w << 16 | x);
+ PUSH_DATA (push, h << 16 | y);
/* Messing with surf3d invalidates the engine state. */
context_dirty_i(ctx, TEX_ENV, 0);
nv04_emit_tex_env(struct gl_context *ctx, int emit)
{
const int i = emit - NOUVEAU_STATE_TEX_ENV0;
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *fahrenheit = nv04_context_engine(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
+ struct nouveau_object *fahrenheit = nv04_context_engine(ctx);
struct combiner_state rc_a = {}, rc_c = {};
if (!nv04_mtex_engine(fahrenheit)) {
}
/* Write the register combiner state out to the hardware. */
- BEGIN_RING(chan, fahrenheit,
- NV04_MULTITEX_TRIANGLE_COMBINE_ALPHA(i), 2);
- OUT_RING(chan, rc_a.hw);
- OUT_RING(chan, rc_c.hw);
-
- BEGIN_RING(chan, fahrenheit,
- NV04_MULTITEX_TRIANGLE_COMBINE_FACTOR, 1);
- OUT_RING(chan, pack_rgba_f(MESA_FORMAT_ARGB8888,
- ctx->Texture.Unit[0].EnvColor));
+ BEGIN_NV04(push, NV04_MTRI(COMBINE_ALPHA(i)), 2);
+ PUSH_DATA (push, rc_a.hw);
+ PUSH_DATA (push, rc_c.hw);
+
+ BEGIN_NV04(push, NV04_MTRI(COMBINE_FACTOR), 1);
+ PUSH_DATA (push, pack_rgba_f(MESA_FORMAT_ARGB8888,
+ ctx->Texture.Unit[0].EnvColor));
}
void
nv04_emit_control(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *fahrenheit = nv04_context_engine(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
+ struct nouveau_object *fahrenheit = nv04_context_engine(ctx);
if (nv04_mtex_engine(fahrenheit)) {
int cull_mode = ctx->Polygon.CullFaceMode;
get_stencil_op(ctx->Stencil.ZFailFunc[0]) << 4 |
get_stencil_op(ctx->Stencil.FailFunc[0]);
- BEGIN_RING(chan, fahrenheit, NV04_MULTITEX_TRIANGLE_CONTROL0, 3);
- OUT_RING(chan, ctrl0);
- OUT_RING(chan, ctrl1);
- OUT_RING(chan, ctrl2);
+ BEGIN_NV04(push, NV04_MTRI(CONTROL0), 3);
+ PUSH_DATA (push, ctrl0);
+ PUSH_DATA (push, ctrl1);
+ PUSH_DATA (push, ctrl2);
} else {
int cull_mode = ctx->Polygon.CullFaceMode;
ctrl |= get_comparison_op(ctx->Color.AlphaFunc) << 8 |
FLOAT_TO_UBYTE(ctx->Color.AlphaRef);
- BEGIN_RING(chan, fahrenheit, NV04_TEXTURED_TRIANGLE_CONTROL, 1);
- OUT_RING(chan, ctrl);
+ BEGIN_NV04(push, NV04_TTRI(CONTROL), 1);
+ PUSH_DATA (push, ctrl);
}
}
void
nv04_emit_blend(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *fahrenheit = nv04_context_engine(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
+ struct nouveau_object *fahrenheit = nv04_context_engine(ctx);
if (nv04_mtex_engine(fahrenheit)) {
uint32_t blend = 0x2 << 4 |
if (ctx->Fog.Enabled)
blend |= NV04_MULTITEX_TRIANGLE_BLEND_FOG_ENABLE;
- BEGIN_RING(chan, fahrenheit, NV04_MULTITEX_TRIANGLE_BLEND, 1);
- OUT_RING(chan, blend);
+ BEGIN_NV04(push, NV04_MTRI(BLEND), 1);
+ PUSH_DATA (push, blend);
- BEGIN_RING(chan, fahrenheit, NV04_MULTITEX_TRIANGLE_FOGCOLOR, 1);
- OUT_RING(chan, pack_rgba_f(MESA_FORMAT_ARGB8888,
- ctx->Fog.Color));
+ BEGIN_NV04(push, NV04_MTRI(FOGCOLOR), 1);
+ PUSH_DATA (push, pack_rgba_f(MESA_FORMAT_ARGB8888,
+ ctx->Fog.Color));
} else {
uint32_t blend = 0x2 << 4 |
if (ctx->Fog.Enabled)
blend |= NV04_TEXTURED_TRIANGLE_BLEND_FOG_ENABLE;
- BEGIN_RING(chan, fahrenheit, NV04_TEXTURED_TRIANGLE_BLEND, 1);
- OUT_RING(chan, blend);
+ BEGIN_NV04(push, NV04_TTRI(BLEND), 1);
+ PUSH_DATA (push, blend);
- BEGIN_RING(chan, fahrenheit, NV04_TEXTURED_TRIANGLE_FOGCOLOR, 1);
- OUT_RING(chan, pack_rgba_f(MESA_FORMAT_ARGB8888,
- ctx->Fog.Color));
+ BEGIN_NV04(push, NV04_TTRI(FOGCOLOR), 1);
+ PUSH_DATA (push, pack_rgba_f(MESA_FORMAT_ARGB8888,
+ ctx->Fog.Color));
}
}
nv04_emit_tex_obj(struct gl_context *ctx, int emit)
{
const int i = emit - NOUVEAU_STATE_TEX_OBJ0;
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *fahrenheit = nv04_context_engine(ctx);
- struct nouveau_bo_context *bctx = context_bctx_i(ctx, TEXTURE, i);
+ struct nouveau_pushbuf *push = context_push(ctx);
+ struct nouveau_object *fahrenheit = nv04_context_engine(ctx);
const int bo_flags = NOUVEAU_BO_RD | NOUVEAU_BO_GART | NOUVEAU_BO_VRAM;
struct nouveau_surface *s;
uint32_t format = 0xa0, filter = 0x1010;
+ PUSH_RESET(push, BUFCTX_TEX(i));
+
if (i && !nv04_mtex_engine(fahrenheit))
return;
}
if (nv04_mtex_engine(fahrenheit)) {
- nouveau_bo_markl(bctx, fahrenheit,
- NV04_MULTITEX_TRIANGLE_OFFSET(i),
+ BEGIN_NV04(push, NV04_MTRI(OFFSET(i)), 1);
+ PUSH_MTHDl(push, NV04_MTRI(OFFSET(i)), BUFCTX_TEX(i),
s->bo, s->offset, bo_flags);
- nouveau_bo_mark(bctx, fahrenheit,
- NV04_MULTITEX_TRIANGLE_FORMAT(i),
- s->bo, format, 0,
- NV04_MULTITEX_TRIANGLE_FORMAT_DMA_A,
- NV04_MULTITEX_TRIANGLE_FORMAT_DMA_B,
- bo_flags | NOUVEAU_BO_OR);
+ BEGIN_NV04(push, NV04_MTRI(FORMAT(i)), 1);
+ PUSH_MTHD (push, NV04_MTRI(FORMAT(i)), BUFCTX_TEX(i),
+ s->bo, format, bo_flags | NOUVEAU_BO_OR,
+ NV04_MULTITEX_TRIANGLE_FORMAT_DMA_A,
+ NV04_MULTITEX_TRIANGLE_FORMAT_DMA_B);
- BEGIN_RING(chan, fahrenheit, NV04_MULTITEX_TRIANGLE_FILTER(i), 1);
- OUT_RING(chan, filter);
+ BEGIN_NV04(push, NV04_MTRI(FILTER(i)), 1);
+ PUSH_DATA (push, filter);
} else {
- nouveau_bo_markl(bctx, fahrenheit,
- NV04_TEXTURED_TRIANGLE_OFFSET,
+ BEGIN_NV04(push, NV04_TTRI(OFFSET), 1);
+ PUSH_MTHDl(push, NV04_TTRI(OFFSET), BUFCTX_TEX(0),
s->bo, s->offset, bo_flags);
- nouveau_bo_mark(bctx, fahrenheit,
- NV04_TEXTURED_TRIANGLE_FORMAT,
- s->bo, format, 0,
- NV04_TEXTURED_TRIANGLE_FORMAT_DMA_A,
- NV04_TEXTURED_TRIANGLE_FORMAT_DMA_B,
- bo_flags | NOUVEAU_BO_OR);
+ BEGIN_NV04(push, NV04_TTRI(FORMAT), 1);
+ PUSH_MTHD (push, NV04_TTRI(FORMAT), BUFCTX_TEX(0),
+ s->bo, format, bo_flags | NOUVEAU_BO_OR,
+ NV04_TEXTURED_TRIANGLE_FORMAT_DMA_A,
+ NV04_TEXTURED_TRIANGLE_FORMAT_DMA_B);
- BEGIN_RING(chan, fahrenheit, NV04_TEXTURED_TRIANGLE_COLORKEY, 1);
- OUT_RING(chan, 0);
+ BEGIN_NV04(push, NV04_TTRI(COLORKEY), 1);
+ PUSH_DATA (push, 0);
- BEGIN_RING(chan, fahrenheit, NV04_TEXTURED_TRIANGLE_FILTER, 1);
- OUT_RING(chan, filter);
+ BEGIN_NV04(push, NV04_TTRI(FILTER), 1);
+ PUSH_DATA (push, filter);
}
}
int dx, int dy, int sx, int sy,
int w, int h)
{
- struct nouveau_channel *chan = context_chan(ctx);
+ struct nouveau_pushbuf_refn refs[] = {
+ { src->bo, NOUVEAU_BO_RD | NOUVEAU_BO_VRAM | NOUVEAU_BO_GART },
+ { dst->bo, NOUVEAU_BO_WR | NOUVEAU_BO_VRAM },
+ };
+ struct nouveau_pushbuf *push = context_push(ctx);
struct nouveau_hw_state *hw = &to_nouveau_context(ctx)->hw;
- struct nouveau_grobj *swzsurf = hw->swzsurf;
- struct nouveau_grobj *sifm = hw->sifm;
- struct nouveau_bo_context *bctx = context_bctx(ctx, SURFACE);
- const unsigned bo_flags = NOUVEAU_BO_VRAM | NOUVEAU_BO_GART;
+ struct nouveau_object *swzsurf = hw->swzsurf;
+ struct nv04_fifo *fifo = hw->chan->data;
/* Max width & height may not be the same on all HW, but must be POT */
const unsigned max_w = 1024;
const unsigned max_h = 1024;
assert(_mesa_is_pow_two(dst->width) &&
_mesa_is_pow_two(dst->height));
- nouveau_bo_marko(bctx, sifm, NV03_SCALED_IMAGE_FROM_MEMORY_DMA_IMAGE,
- src->bo, bo_flags | NOUVEAU_BO_RD);
- nouveau_bo_marko(bctx, swzsurf, NV04_SWIZZLED_SURFACE_DMA_IMAGE,
- dst->bo, NOUVEAU_BO_VRAM | NOUVEAU_BO_WR);
- nouveau_bo_markl(bctx, swzsurf, NV04_SWIZZLED_SURFACE_OFFSET,
- dst->bo, dst->offset, NOUVEAU_BO_VRAM | NOUVEAU_BO_WR);
-
- BEGIN_RING(chan, swzsurf, NV04_SWIZZLED_SURFACE_FORMAT, 1);
- OUT_RING (chan, swzsurf_format(dst->format) |
- log2i(dst->width) << 16 |
- log2i(dst->height) << 24);
-
- BEGIN_RING(chan, sifm, NV04_SCALED_IMAGE_FROM_MEMORY_SURFACE, 1);
- OUT_RING (chan, swzsurf->handle);
+ if (context_chipset(ctx) < 0x10) {
+ BEGIN_NV04(push, NV01_SUBC(SURF, OBJECT), 1);
+ PUSH_DATA (push, swzsurf->handle);
+ }
for (y = 0; y < h; y += sub_h) {
sub_h = MIN2(sub_h, h - y);
for (x = 0; x < w; x += sub_w) {
sub_w = MIN2(sub_w, w - x);
- MARK_RING(chan, 15, 1);
-
- BEGIN_RING(chan, sifm,
- NV03_SCALED_IMAGE_FROM_MEMORY_COLOR_FORMAT, 8);
- OUT_RING(chan, sifm_format(src->format));
- OUT_RING(chan, NV03_SCALED_IMAGE_FROM_MEMORY_OPERATION_SRCCOPY);
- OUT_RING(chan, (y + dy) << 16 | (x + dx));
- OUT_RING(chan, sub_h << 16 | sub_w);
- OUT_RING(chan, (y + dy) << 16 | (x + dx));
- OUT_RING(chan, sub_h << 16 | sub_w);
- OUT_RING(chan, 1 << 20);
- OUT_RING(chan, 1 << 20);
-
- BEGIN_RING(chan, sifm,
- NV03_SCALED_IMAGE_FROM_MEMORY_SIZE, 4);
- OUT_RING(chan, align(sub_h, 2) << 16 | align(sub_w, 2));
- OUT_RING(chan, src->pitch |
- NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_ORIGIN_CENTER |
- NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_FILTER_POINT_SAMPLE);
- OUT_RELOCl(chan, src->bo, src->offset +
- (y + sy) * src->pitch +
- (x + sx) * src->cpp,
- bo_flags | NOUVEAU_BO_RD);
- OUT_RING(chan, 0);
+ if (nouveau_pushbuf_space(push, 64, 4, 0) ||
+ nouveau_pushbuf_refn (push, refs, 2))
+ return;
+
+ BEGIN_NV04(push, NV04_SSWZ(DMA_IMAGE), 1);
+ PUSH_DATA (push, fifo->vram);
+ BEGIN_NV04(push, NV04_SSWZ(FORMAT), 2);
+ PUSH_DATA (push, swzsurf_format(dst->format) |
+ log2i(dst->width) << 16 |
+ log2i(dst->height) << 24);
+ PUSH_RELOC(push, dst->bo, dst->offset, NOUVEAU_BO_LOW, 0, 0);
+
+ BEGIN_NV04(push, NV03_SIFM(DMA_IMAGE), 1);
+ PUSH_RELOC(push, src->bo, 0, NOUVEAU_BO_OR, fifo->vram, fifo->gart);
+ BEGIN_NV04(push, NV05_SIFM(SURFACE), 1);
+ PUSH_DATA (push, swzsurf->handle);
+
+ BEGIN_NV04(push, NV03_SIFM(COLOR_FORMAT), 8);
+ PUSH_DATA (push, sifm_format(src->format));
+ PUSH_DATA (push, NV03_SCALED_IMAGE_FROM_MEMORY_OPERATION_SRCCOPY);
+ PUSH_DATA (push, (y + dy) << 16 | (x + dx));
+ PUSH_DATA (push, sub_h << 16 | sub_w);
+ PUSH_DATA (push, (y + dy) << 16 | (x + dx));
+ PUSH_DATA (push, sub_h << 16 | sub_w);
+ PUSH_DATA (push, 1 << 20);
+ PUSH_DATA (push, 1 << 20);
+
+ BEGIN_NV04(push, NV03_SIFM(SIZE), 4);
+ PUSH_DATA (push, align(sub_h, 2) << 16 | align(sub_w, 2));
+ PUSH_DATA (push, src->pitch |
+ NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_ORIGIN_CENTER |
+ NV03_SCALED_IMAGE_FROM_MEMORY_FORMAT_FILTER_POINT_SAMPLE);
+ PUSH_RELOC(push, src->bo, src->offset + (y + sy) * src->pitch +
+ (x + sx) * src->cpp, NOUVEAU_BO_LOW, 0, 0);
+ PUSH_DATA (push, 0);
}
}
- nouveau_bo_context_reset(bctx);
-
- if (context_chipset(ctx) < 0x10)
- FIRE_RING(chan);
+ if (context_chipset(ctx) < 0x10) {
+ BEGIN_NV04(push, NV01_SUBC(SURF, OBJECT), 1);
+ PUSH_DATA (push, hw->surf3d->handle);
+ PUSH_KICK(push);
+ }
}
static void
int dx, int dy, int sx, int sy,
int w, int h)
{
- struct nouveau_channel *chan = context_chan(ctx);
+ struct nouveau_pushbuf_refn refs[] = {
+ { src->bo, NOUVEAU_BO_RD | NOUVEAU_BO_VRAM | NOUVEAU_BO_GART },
+ { dst->bo, NOUVEAU_BO_WR | NOUVEAU_BO_VRAM | NOUVEAU_BO_GART },
+ };
+ struct nouveau_pushbuf *push = context_push(ctx);
struct nouveau_hw_state *hw = &to_nouveau_context(ctx)->hw;
- struct nouveau_grobj *m2mf = hw->m2mf;
- struct nouveau_bo_context *bctx = context_bctx(ctx, SURFACE);
- const unsigned bo_flags = NOUVEAU_BO_VRAM | NOUVEAU_BO_GART;
+ struct nv04_fifo *fifo = hw->chan->data;
unsigned dst_offset = dst->offset + dy * dst->pitch + dx * dst->cpp;
unsigned src_offset = src->offset + sy * src->pitch + sx * src->cpp;
- nouveau_bo_marko(bctx, m2mf, NV04_M2MF_DMA_BUFFER_IN,
- src->bo, bo_flags | NOUVEAU_BO_RD);
- nouveau_bo_marko(bctx, m2mf, NV04_M2MF_DMA_BUFFER_OUT,
- dst->bo, bo_flags | NOUVEAU_BO_WR);
-
while (h) {
int count = (h > 2047) ? 2047 : h;
- MARK_RING(chan, 9, 2);
+ if (nouveau_pushbuf_space(push, 16, 4, 0) ||
+ nouveau_pushbuf_refn (push, refs, 2))
+ return;
+
+ BEGIN_NV04(push, NV03_M2MF(DMA_BUFFER_IN), 2);
+ PUSH_RELOC(push, src->bo, 0, NOUVEAU_BO_OR, fifo->vram, fifo->gart);
+ PUSH_RELOC(push, dst->bo, 0, NOUVEAU_BO_OR, fifo->vram, fifo->gart);
+ BEGIN_NV04(push, NV03_M2MF(OFFSET_IN), 8);
+ PUSH_RELOC(push, src->bo, src->offset, NOUVEAU_BO_LOW, 0, 0);
+ PUSH_RELOC(push, dst->bo, dst->offset, NOUVEAU_BO_LOW, 0, 0);
+ PUSH_DATA (push, src->pitch);
+ PUSH_DATA (push, dst->pitch);
+ PUSH_DATA (push, w * src->cpp);
+ PUSH_DATA (push, count);
+ PUSH_DATA (push, 0x0101);
+ PUSH_DATA (push, 0);
- BEGIN_RING(chan, m2mf, NV04_M2MF_OFFSET_IN, 8);
- OUT_RELOCl(chan, src->bo, src_offset,
- bo_flags | NOUVEAU_BO_RD);
- OUT_RELOCl(chan, dst->bo, dst_offset,
- bo_flags | NOUVEAU_BO_WR);
- OUT_RING (chan, src->pitch);
- OUT_RING (chan, dst->pitch);
- OUT_RING (chan, w * src->cpp);
- OUT_RING (chan, count);
- OUT_RING (chan, 0x0101);
- OUT_RING (chan, 0);
-
- h -= count;
src_offset += src->pitch * count;
dst_offset += dst->pitch * count;
+ h -= count;
}
- nouveau_bo_context_reset(bctx);
-
if (context_chipset(ctx) < 0x10)
- FIRE_RING(chan);
+ PUSH_KICK(push);
}
typedef unsigned (*get_offset_t)(struct nouveau_surface *s,
get_swizzled_offset : get_linear_offset);
void *dp, *sp;
- nouveau_bo_map(dst->bo, NOUVEAU_BO_WR);
- nouveau_bo_map(src->bo, NOUVEAU_BO_RD);
+ nouveau_bo_map(dst->bo, NOUVEAU_BO_WR, context_client(ctx));
+ nouveau_bo_map(src->bo, NOUVEAU_BO_RD, context_client(ctx));
dp = dst->bo->map + dst->offset;
sp = src->bo->map + src->offset;
sp + get_src(src, sx + x, sy + y), dst->cpp);
}
}
-
- nouveau_bo_unmap(src->bo);
- nouveau_bo_unmap(dst->bo);
}
void
unsigned mask, unsigned value,
int dx, int dy, int w, int h)
{
- struct nouveau_channel *chan = context_chan(ctx);
+ struct nouveau_pushbuf_refn refs[] = {
+ { dst->bo, NOUVEAU_BO_WR | NOUVEAU_BO_VRAM | NOUVEAU_BO_GART },
+ };
+ struct nouveau_pushbuf *push = context_push(ctx);
struct nouveau_hw_state *hw = &to_nouveau_context(ctx)->hw;
- struct nouveau_grobj *surf2d = hw->surf2d;
- struct nouveau_grobj *patt = hw->patt;
- struct nouveau_grobj *rect = hw->rect;
- unsigned bo_flags = NOUVEAU_BO_VRAM | NOUVEAU_BO_GART;
-
- MARK_RING (chan, 19, 4);
-
- BEGIN_RING(chan, surf2d, NV04_CONTEXT_SURFACES_2D_DMA_IMAGE_SOURCE, 2);
- OUT_RELOCo(chan, dst->bo, bo_flags | NOUVEAU_BO_WR);
- OUT_RELOCo(chan, dst->bo, bo_flags | NOUVEAU_BO_WR);
- BEGIN_RING(chan, surf2d, NV04_CONTEXT_SURFACES_2D_FORMAT, 4);
- OUT_RING (chan, surf2d_format(dst->format));
- OUT_RING (chan, (dst->pitch << 16) | dst->pitch);
- OUT_RELOCl(chan, dst->bo, dst->offset, bo_flags | NOUVEAU_BO_WR);
- OUT_RELOCl(chan, dst->bo, dst->offset, bo_flags | NOUVEAU_BO_WR);
-
- BEGIN_RING(chan, patt, NV04_IMAGE_PATTERN_COLOR_FORMAT, 1);
- OUT_RING (chan, rect_format(dst->format));
- BEGIN_RING(chan, patt, NV04_IMAGE_PATTERN_MONOCHROME_COLOR1, 1);
- OUT_RING (chan, mask | ~0ll << (8 * dst->cpp));
-
- BEGIN_RING(chan, rect, NV04_GDI_RECTANGLE_TEXT_COLOR_FORMAT, 1);
- OUT_RING (chan, rect_format(dst->format));
- BEGIN_RING(chan, rect, NV04_GDI_RECTANGLE_TEXT_COLOR1_A, 1);
- OUT_RING (chan, value);
- BEGIN_RING(chan, rect,
- NV04_GDI_RECTANGLE_TEXT_UNCLIPPED_RECTANGLE_POINT(0), 2);
- OUT_RING (chan, (dx << 16) | dy);
- OUT_RING (chan, ( w << 16) | h);
+ struct nv04_fifo *fifo = hw->chan->data;
+
+ if (nouveau_pushbuf_space(push, 64, 4, 0) ||
+ nouveau_pushbuf_refn (push, refs, 1))
+ return;
+
+ BEGIN_NV04(push, NV04_SF2D(DMA_IMAGE_SOURCE), 2);
+ PUSH_RELOC(push, dst->bo, 0, NOUVEAU_BO_OR, fifo->vram, fifo->gart);
+ PUSH_RELOC(push, dst->bo, 0, NOUVEAU_BO_OR, fifo->vram, fifo->gart);
+ BEGIN_NV04(push, NV04_SF2D(FORMAT), 4);
+ PUSH_DATA (push, surf2d_format(dst->format));
+ PUSH_DATA (push, (dst->pitch << 16) | dst->pitch);
+ PUSH_RELOC(push, dst->bo, dst->offset, NOUVEAU_BO_LOW, 0, 0);
+ PUSH_RELOC(push, dst->bo, dst->offset, NOUVEAU_BO_LOW, 0, 0);
+
+ BEGIN_NV04(push, NV01_PATT(COLOR_FORMAT), 1);
+ PUSH_DATA (push, rect_format(dst->format));
+ BEGIN_NV04(push, NV01_PATT(MONOCHROME_COLOR1), 1);
+ PUSH_DATA (push, mask | ~0ll << (8 * dst->cpp));
+
+ BEGIN_NV04(push, NV04_GDI(COLOR_FORMAT), 1);
+ PUSH_DATA (push, rect_format(dst->format));
+ BEGIN_NV04(push, NV04_GDI(COLOR1_A), 1);
+ PUSH_DATA (push, value);
+ BEGIN_NV04(push, NV04_GDI(UNCLIPPED_RECTANGLE_POINT(0)), 2);
+ PUSH_DATA (push, (dx << 16) | dy);
+ PUSH_DATA (push, ( w << 16) | h);
if (context_chipset(ctx) < 0x10)
- FIRE_RING(chan);
+ PUSH_KICK(push);
}
void
{
struct nouveau_hw_state *hw = &to_nouveau_context(ctx)->hw;
- nouveau_grobj_free(&hw->swzsurf);
- nouveau_grobj_free(&hw->sifm);
- nouveau_grobj_free(&hw->rect);
- nouveau_grobj_free(&hw->rop);
- nouveau_grobj_free(&hw->patt);
- nouveau_grobj_free(&hw->surf2d);
- nouveau_grobj_free(&hw->m2mf);
- nouveau_notifier_free(&hw->ntfy);
+ nouveau_object_del(&hw->swzsurf);
+ nouveau_object_del(&hw->sifm);
+ nouveau_object_del(&hw->rect);
+ nouveau_object_del(&hw->rop);
+ nouveau_object_del(&hw->patt);
+ nouveau_object_del(&hw->surf2d);
+ nouveau_object_del(&hw->m2mf);
+ nouveau_object_del(&hw->ntfy);
}
GLboolean
nv04_surface_init(struct gl_context *ctx)
{
- struct nouveau_channel *chan = context_chan(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
struct nouveau_hw_state *hw = &to_nouveau_context(ctx)->hw;
+ struct nouveau_object *chan = hw->chan;
unsigned handle = 0x88000000, class;
int ret;
/* Notifier object. */
- ret = nouveau_notifier_alloc(chan, handle++, 1, &hw->ntfy);
+ ret = nouveau_object_new(chan, handle++, NOUVEAU_NOTIFIER_CLASS,
+ &(struct nv04_notify) {
+ .length = 32,
+ }, sizeof(struct nv04_notify), &hw->ntfy);
if (ret)
goto fail;
/* Memory to memory format. */
- ret = nouveau_grobj_alloc(chan, handle++, NV04_M2MF, &hw->m2mf);
+ ret = nouveau_object_new(chan, handle++, NV03_M2MF_CLASS,
+ NULL, 0, &hw->m2mf);
if (ret)
goto fail;
- BEGIN_RING(chan, hw->m2mf, NV04_M2MF_DMA_NOTIFY, 1);
- OUT_RING (chan, hw->ntfy->handle);
+ BEGIN_NV04(push, NV01_SUBC(M2MF, OBJECT), 1);
+ PUSH_DATA (push, hw->m2mf->handle);
+ BEGIN_NV04(push, NV03_M2MF(DMA_NOTIFY), 1);
+ PUSH_DATA (push, hw->ntfy->handle);
/* Context surfaces 2D. */
if (context_chipset(ctx) < 0x10)
- class = NV04_CONTEXT_SURFACES_2D;
+ class = NV04_SURFACE_2D_CLASS;
else
- class = NV10_CONTEXT_SURFACES_2D;
+ class = NV10_SURFACE_2D_CLASS;
- ret = nouveau_grobj_alloc(chan, handle++, class, &hw->surf2d);
+ ret = nouveau_object_new(chan, handle++, class, NULL, 0, &hw->surf2d);
if (ret)
goto fail;
+ BEGIN_NV04(push, NV01_SUBC(SF2D, OBJECT), 1);
+ PUSH_DATA (push, hw->surf2d->handle);
+
/* Raster op. */
- ret = nouveau_grobj_alloc(chan, handle++, NV03_CONTEXT_ROP, &hw->rop);
+ ret = nouveau_object_new(chan, handle++, NV03_ROP_CLASS,
+ NULL, 0, &hw->rop);
if (ret)
goto fail;
- BEGIN_RING(chan, hw->rop, NV03_CONTEXT_ROP_DMA_NOTIFY, 1);
- OUT_RING (chan, hw->ntfy->handle);
+ BEGIN_NV04(push, NV01_SUBC(PATT, OBJECT), 1);
+ PUSH_DATA (push, hw->rop->handle);
+ BEGIN_NV04(push, NV01_ROP(DMA_NOTIFY), 1);
+ PUSH_DATA (push, hw->ntfy->handle);
- BEGIN_RING(chan, hw->rop, NV03_CONTEXT_ROP_ROP, 1);
- OUT_RING (chan, 0xca); /* DPSDxax in the GDI speech. */
+ BEGIN_NV04(push, NV01_ROP(ROP), 1);
+ PUSH_DATA (push, 0xca); /* DPSDxax in the GDI speech. */
/* Image pattern. */
- ret = nouveau_grobj_alloc(chan, handle++, NV04_IMAGE_PATTERN,
- &hw->patt);
+ ret = nouveau_object_new(chan, handle++, NV04_PATTERN_CLASS,
+ NULL, 0, &hw->patt);
if (ret)
goto fail;
- BEGIN_RING(chan, hw->patt, NV04_IMAGE_PATTERN_DMA_NOTIFY, 1);
- OUT_RING (chan, hw->ntfy->handle);
+ BEGIN_NV04(push, NV01_SUBC(PATT, OBJECT), 1);
+ PUSH_DATA (push, hw->patt->handle);
+ BEGIN_NV04(push, NV01_PATT(DMA_NOTIFY), 1);
+ PUSH_DATA (push, hw->ntfy->handle);
- BEGIN_RING(chan, hw->patt, NV04_IMAGE_PATTERN_MONOCHROME_FORMAT, 3);
- OUT_RING (chan, NV04_IMAGE_PATTERN_MONOCHROME_FORMAT_LE);
- OUT_RING (chan, NV04_IMAGE_PATTERN_MONOCHROME_SHAPE_8X8);
- OUT_RING (chan, NV04_IMAGE_PATTERN_PATTERN_SELECT_MONO);
+ BEGIN_NV04(push, NV01_PATT(MONOCHROME_FORMAT), 3);
+ PUSH_DATA (push, NV04_IMAGE_PATTERN_MONOCHROME_FORMAT_LE);
+ PUSH_DATA (push, NV04_IMAGE_PATTERN_MONOCHROME_SHAPE_8X8);
+ PUSH_DATA (push, NV04_IMAGE_PATTERN_PATTERN_SELECT_MONO);
- BEGIN_RING(chan, hw->patt, NV04_IMAGE_PATTERN_MONOCHROME_COLOR0, 4);
- OUT_RING (chan, 0);
- OUT_RING (chan, 0);
- OUT_RING (chan, ~0);
- OUT_RING (chan, ~0);
+ BEGIN_NV04(push, NV01_PATT(MONOCHROME_COLOR0), 4);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, ~0);
+ PUSH_DATA (push, ~0);
/* GDI rectangle text. */
- ret = nouveau_grobj_alloc(chan, handle++, NV04_GDI_RECTANGLE_TEXT,
- &hw->rect);
+ ret = nouveau_object_new(chan, handle++, NV04_GDI_CLASS,
+ NULL, 0, &hw->rect);
if (ret)
goto fail;
- BEGIN_RING(chan, hw->rect, NV04_GDI_RECTANGLE_TEXT_DMA_NOTIFY, 1);
- OUT_RING (chan, hw->ntfy->handle);
- BEGIN_RING(chan, hw->rect, NV04_GDI_RECTANGLE_TEXT_SURFACE, 1);
- OUT_RING (chan, hw->surf2d->handle);
- BEGIN_RING(chan, hw->rect, NV04_GDI_RECTANGLE_TEXT_ROP, 1);
- OUT_RING (chan, hw->rop->handle);
- BEGIN_RING(chan, hw->rect, NV04_GDI_RECTANGLE_TEXT_PATTERN, 1);
- OUT_RING (chan, hw->patt->handle);
-
- BEGIN_RING(chan, hw->rect, NV04_GDI_RECTANGLE_TEXT_OPERATION, 1);
- OUT_RING (chan, NV04_GDI_RECTANGLE_TEXT_OPERATION_ROP_AND);
- BEGIN_RING(chan, hw->rect,
- NV04_GDI_RECTANGLE_TEXT_MONOCHROME_FORMAT, 1);
- OUT_RING (chan, NV04_GDI_RECTANGLE_TEXT_MONOCHROME_FORMAT_LE);
+ BEGIN_NV04(push, NV01_SUBC(GDI, OBJECT), 1);
+ PUSH_DATA (push, hw->rect->handle);
+ BEGIN_NV04(push, NV04_GDI(DMA_NOTIFY), 1);
+ PUSH_DATA (push, hw->ntfy->handle);
+ BEGIN_NV04(push, NV04_GDI(SURFACE), 1);
+ PUSH_DATA (push, hw->surf2d->handle);
+ BEGIN_NV04(push, NV04_GDI(ROP), 1);
+ PUSH_DATA (push, hw->rop->handle);
+ BEGIN_NV04(push, NV04_GDI(PATTERN), 1);
+ PUSH_DATA (push, hw->patt->handle);
+
+ BEGIN_NV04(push, NV04_GDI(OPERATION), 1);
+ PUSH_DATA (push, NV04_GDI_RECTANGLE_TEXT_OPERATION_ROP_AND);
+ BEGIN_NV04(push, NV04_GDI(MONOCHROME_FORMAT), 1);
+ PUSH_DATA (push, NV04_GDI_RECTANGLE_TEXT_MONOCHROME_FORMAT_LE);
/* Swizzled surface. */
if (context_chipset(ctx) < 0x20)
- class = NV04_SWIZZLED_SURFACE;
+ class = NV04_SURFACE_SWZ_CLASS;
else
- class = NV20_SWIZZLED_SURFACE;
+ class = NV20_SURFACE_SWZ_CLASS;
- ret = nouveau_grobj_alloc(chan, handle++, class, &hw->swzsurf);
+ ret = nouveau_object_new(chan, handle++, class, NULL, 0, &hw->swzsurf);
if (ret)
goto fail;
+ BEGIN_NV04(push, NV01_SUBC(SURF, OBJECT), 1);
+ PUSH_DATA (push, hw->swzsurf->handle);
+
/* Scaled image from memory. */
if (context_chipset(ctx) < 0x10)
- class = NV04_SCALED_IMAGE_FROM_MEMORY;
+ class = NV04_SIFM_CLASS;
else
- class = NV10_SCALED_IMAGE_FROM_MEMORY;
+ class = NV10_SIFM_CLASS;
- ret = nouveau_grobj_alloc(chan, handle++, class, &hw->sifm);
+ ret = nouveau_object_new(chan, handle++, class, NULL, 0, &hw->sifm);
if (ret)
goto fail;
+ BEGIN_NV04(push, NV01_SUBC(SIFM, OBJECT), 1);
+ PUSH_DATA (push, hw->sifm->handle);
+
if (context_chipset(ctx) >= 0x10) {
- BEGIN_RING(chan, hw->sifm,
- NV05_SCALED_IMAGE_FROM_MEMORY_COLOR_CONVERSION, 1);
- OUT_RING(chan, NV05_SCALED_IMAGE_FROM_MEMORY_COLOR_CONVERSION_TRUNCATE);
+ BEGIN_NV04(push, NV05_SIFM(COLOR_CONVERSION), 1);
+ PUSH_DATA (push, NV05_SCALED_IMAGE_FROM_MEMORY_COLOR_CONVERSION_TRUNCATE);
}
return GL_TRUE;
nv17_zclear(struct gl_context *ctx, GLbitfield *buffers)
{
struct nouveau_context *nctx = to_nouveau_context(ctx);
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
struct nouveau_framebuffer *nfb = to_nouveau_framebuffer(
ctx->DrawBuffer);
struct nouveau_surface *s = &to_nouveau_renderbuffer(
nfb->base.Attachment[BUFFER_DEPTH].Renderbuffer)->surface;
/* Clear the hierarchical depth buffer */
- BEGIN_RING(chan, celsius, NV17_3D_HIERZ_FILL_VALUE, 1);
- OUT_RING(chan, pack_zs_f(s->format, ctx->Depth.Clear, 0));
- BEGIN_RING(chan, celsius, NV17_3D_HIERZ_BUFFER_CLEAR, 1);
- OUT_RING(chan, 1);
+ BEGIN_NV04(push, NV17_3D(HIERZ_FILL_VALUE), 1);
+ PUSH_DATA (push, pack_zs_f(s->format, ctx->Depth.Clear, 0));
+ BEGIN_NV04(push, NV17_3D(HIERZ_BUFFER_CLEAR), 1);
+ PUSH_DATA (push, 1);
/* Mark the depth buffer as cleared */
if (use_fast_zclear(ctx, *buffers)) {
static void
nv10_clear(struct gl_context *ctx, GLbitfield buffers)
{
+ struct nouveau_context *nctx = to_nouveau_context(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
+
nouveau_validate_framebuffer(ctx);
+ nouveau_pushbuf_bufctx(push, nctx->hw.bufctx);
+ if (nouveau_pushbuf_validate(push)) {
+ nouveau_pushbuf_bufctx(push, NULL);
+ return;
+ }
+
if ((buffers & BUFFER_BIT_DEPTH) && ctx->Depth.Mask) {
if (context_chipset(ctx) >= 0x17)
nv17_zclear(ctx, &buffers);
_mesa_update_state(ctx);
}
+ nouveau_pushbuf_bufctx(push, NULL);
nouveau_clear(ctx, buffers);
}
static void
nv10_hwctx_init(struct gl_context *ctx)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
struct nouveau_hw_state *hw = &to_nouveau_context(ctx)->hw;
+ struct nv04_fifo *fifo = hw->chan->data;
int i;
- BEGIN_RING(chan, celsius, NV10_3D_DMA_NOTIFY, 1);
- OUT_RING(chan, hw->ntfy->handle);
+ BEGIN_NV04(push, NV01_SUBC(3D, OBJECT), 1);
+ PUSH_DATA (push, hw->eng3d->handle);
+ BEGIN_NV04(push, NV10_3D(DMA_NOTIFY), 1);
+ PUSH_DATA (push, hw->ntfy->handle);
- BEGIN_RING(chan, celsius, NV10_3D_DMA_TEXTURE0, 3);
- OUT_RING(chan, chan->vram->handle);
- OUT_RING(chan, chan->gart->handle);
- OUT_RING(chan, chan->gart->handle);
- BEGIN_RING(chan, celsius, NV10_3D_DMA_COLOR, 2);
- OUT_RING(chan, chan->vram->handle);
- OUT_RING(chan, chan->vram->handle);
+ BEGIN_NV04(push, NV10_3D(DMA_TEXTURE0), 3);
+ PUSH_DATA (push, fifo->vram);
+ PUSH_DATA (push, fifo->gart);
+ PUSH_DATA (push, fifo->gart);
+ BEGIN_NV04(push, NV10_3D(DMA_COLOR), 2);
+ PUSH_DATA (push, fifo->vram);
+ PUSH_DATA (push, fifo->vram);
- BEGIN_RING(chan, celsius, NV04_GRAPH_NOP, 1);
- OUT_RING(chan, 0);
+ BEGIN_NV04(push, NV04_GRAPH(3D, NOP), 1);
+ PUSH_DATA (push, 0);
- BEGIN_RING(chan, celsius, NV10_3D_RT_HORIZ, 2);
- OUT_RING(chan, 0);
- OUT_RING(chan, 0);
+ BEGIN_NV04(push, NV10_3D(RT_HORIZ), 2);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0);
- BEGIN_RING(chan, celsius, NV10_3D_VIEWPORT_CLIP_HORIZ(0), 1);
- OUT_RING(chan, 0x7ff << 16 | 0x800);
- BEGIN_RING(chan, celsius, NV10_3D_VIEWPORT_CLIP_VERT(0), 1);
- OUT_RING(chan, 0x7ff << 16 | 0x800);
+ BEGIN_NV04(push, NV10_3D(VIEWPORT_CLIP_HORIZ(0)), 1);
+ PUSH_DATA (push, 0x7ff << 16 | 0x800);
+ BEGIN_NV04(push, NV10_3D(VIEWPORT_CLIP_VERT(0)), 1);
+ PUSH_DATA (push, 0x7ff << 16 | 0x800);
for (i = 1; i < 8; i++) {
- BEGIN_RING(chan, celsius, NV10_3D_VIEWPORT_CLIP_HORIZ(i), 1);
- OUT_RING(chan, 0);
- BEGIN_RING(chan, celsius, NV10_3D_VIEWPORT_CLIP_VERT(i), 1);
- OUT_RING(chan, 0);
+ BEGIN_NV04(push, NV10_3D(VIEWPORT_CLIP_HORIZ(i)), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV10_3D(VIEWPORT_CLIP_VERT(i)), 1);
+ PUSH_DATA (push, 0);
}
- BEGIN_RING(chan, celsius, 0x290, 1);
- OUT_RING(chan, 0x10 << 16 | 1);
- BEGIN_RING(chan, celsius, 0x3f4, 1);
- OUT_RING(chan, 0);
+ BEGIN_NV04(push, SUBC_3D(0x290), 1);
+ PUSH_DATA (push, 0x10 << 16 | 1);
+ BEGIN_NV04(push, SUBC_3D(0x3f4), 1);
+ PUSH_DATA (push, 0);
- BEGIN_RING(chan, celsius, NV04_GRAPH_NOP, 1);
- OUT_RING(chan, 0);
+ BEGIN_NV04(push, NV04_GRAPH(3D, NOP), 1);
+ PUSH_DATA (push, 0);
if (context_chipset(ctx) >= 0x17) {
- BEGIN_RING(chan, celsius, NV17_3D_UNK01AC, 2);
- OUT_RING(chan, chan->vram->handle);
- OUT_RING(chan, chan->vram->handle);
+ BEGIN_NV04(push, NV17_3D(UNK01AC), 2);
+ PUSH_DATA (push, fifo->vram);
+ PUSH_DATA (push, fifo->vram);
- BEGIN_RING(chan, celsius, 0xd84, 1);
- OUT_RING(chan, 0x3);
+ BEGIN_NV04(push, SUBC_3D(0xd84), 1);
+ PUSH_DATA (push, 0x3);
- BEGIN_RING(chan, celsius, NV17_3D_COLOR_MASK_ENABLE, 1);
- OUT_RING(chan, 1);
+ BEGIN_NV04(push, NV17_3D(COLOR_MASK_ENABLE), 1);
+ PUSH_DATA (push, 1);
}
if (context_chipset(ctx) >= 0x11) {
- BEGIN_RING(chan, celsius, 0x120, 3);
- OUT_RING(chan, 0);
- OUT_RING(chan, 1);
- OUT_RING(chan, 2);
+ BEGIN_NV04(push, SUBC_3D(0x120), 3);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 1);
+ PUSH_DATA (push, 2);
- BEGIN_RING(chan, celsius, NV04_GRAPH_NOP, 1);
- OUT_RING(chan, 0);
+ BEGIN_NV04(push, NV04_GRAPH(3D, NOP), 1);
+ PUSH_DATA (push, 0);
}
- BEGIN_RING(chan, celsius, NV04_GRAPH_NOP, 1);
- OUT_RING(chan, 0);
+ BEGIN_NV04(push, NV04_GRAPH(3D, NOP), 1);
+ PUSH_DATA (push, 0);
/* Set state */
- BEGIN_RING(chan, celsius, NV10_3D_FOG_ENABLE, 1);
- OUT_RING(chan, 0);
- BEGIN_RING(chan, celsius, NV10_3D_ALPHA_FUNC_ENABLE, 1);
- OUT_RING(chan, 0);
- BEGIN_RING(chan, celsius, NV10_3D_ALPHA_FUNC_FUNC, 2);
- OUT_RING(chan, 0x207);
- OUT_RING(chan, 0);
- BEGIN_RING(chan, celsius, NV10_3D_TEX_ENABLE(0), 2);
- OUT_RING(chan, 0);
- OUT_RING(chan, 0);
-
- BEGIN_RING(chan, celsius, NV10_3D_BLEND_FUNC_ENABLE, 1);
- OUT_RING(chan, 0);
- BEGIN_RING(chan, celsius, NV10_3D_DITHER_ENABLE, 2);
- OUT_RING(chan, 1);
- OUT_RING(chan, 0);
- BEGIN_RING(chan, celsius, NV10_3D_LINE_SMOOTH_ENABLE, 1);
- OUT_RING(chan, 0);
- BEGIN_RING(chan, celsius, NV10_3D_VERTEX_WEIGHT_ENABLE, 2);
- OUT_RING(chan, 0);
- OUT_RING(chan, 0);
- BEGIN_RING(chan, celsius, NV10_3D_BLEND_FUNC_SRC, 4);
- OUT_RING(chan, 1);
- OUT_RING(chan, 0);
- OUT_RING(chan, 0);
- OUT_RING(chan, 0x8006);
- BEGIN_RING(chan, celsius, NV10_3D_STENCIL_MASK, 8);
- OUT_RING(chan, 0xff);
- OUT_RING(chan, 0x207);
- OUT_RING(chan, 0);
- OUT_RING(chan, 0xff);
- OUT_RING(chan, 0x1e00);
- OUT_RING(chan, 0x1e00);
- OUT_RING(chan, 0x1e00);
- OUT_RING(chan, 0x1d01);
- BEGIN_RING(chan, celsius, NV10_3D_NORMALIZE_ENABLE, 1);
- OUT_RING(chan, 0);
- BEGIN_RING(chan, celsius, NV10_3D_FOG_ENABLE, 2);
- OUT_RING(chan, 0);
- OUT_RING(chan, 0);
- BEGIN_RING(chan, celsius, NV10_3D_LIGHT_MODEL, 1);
- OUT_RING(chan, 0);
- BEGIN_RING(chan, celsius, NV10_3D_SEPARATE_SPECULAR_ENABLE, 1);
- OUT_RING(chan, 0);
- BEGIN_RING(chan, celsius, NV10_3D_ENABLED_LIGHTS, 1);
- OUT_RING(chan, 0);
- BEGIN_RING(chan, celsius, NV10_3D_POLYGON_OFFSET_POINT_ENABLE, 3);
- OUT_RING(chan, 0);
- OUT_RING(chan, 0);
- OUT_RING(chan, 0);
- BEGIN_RING(chan, celsius, NV10_3D_DEPTH_FUNC, 1);
- OUT_RING(chan, 0x201);
- BEGIN_RING(chan, celsius, NV10_3D_DEPTH_WRITE_ENABLE, 1);
- OUT_RING(chan, 0);
- BEGIN_RING(chan, celsius, NV10_3D_DEPTH_TEST_ENABLE, 1);
- OUT_RING(chan, 0);
- BEGIN_RING(chan, celsius, NV10_3D_POLYGON_OFFSET_FACTOR, 2);
- OUT_RING(chan, 0);
- OUT_RING(chan, 0);
- BEGIN_RING(chan, celsius, NV10_3D_POINT_SIZE, 1);
- OUT_RING(chan, 8);
- BEGIN_RING(chan, celsius, NV10_3D_POINT_PARAMETERS_ENABLE, 2);
- OUT_RING(chan, 0);
- OUT_RING(chan, 0);
- BEGIN_RING(chan, celsius, NV10_3D_LINE_WIDTH, 1);
- OUT_RING(chan, 8);
- BEGIN_RING(chan, celsius, NV10_3D_LINE_SMOOTH_ENABLE, 1);
- OUT_RING(chan, 0);
- BEGIN_RING(chan, celsius, NV10_3D_POLYGON_MODE_FRONT, 2);
- OUT_RING(chan, 0x1b02);
- OUT_RING(chan, 0x1b02);
- BEGIN_RING(chan, celsius, NV10_3D_CULL_FACE, 2);
- OUT_RING(chan, 0x405);
- OUT_RING(chan, 0x901);
- BEGIN_RING(chan, celsius, NV10_3D_POLYGON_SMOOTH_ENABLE, 1);
- OUT_RING(chan, 0);
- BEGIN_RING(chan, celsius, NV10_3D_CULL_FACE_ENABLE, 1);
- OUT_RING(chan, 0);
- BEGIN_RING(chan, celsius, NV10_3D_TEX_GEN_MODE(0, 0), 8);
+ BEGIN_NV04(push, NV10_3D(FOG_ENABLE), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV10_3D(ALPHA_FUNC_ENABLE), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV10_3D(ALPHA_FUNC_FUNC), 2);
+ PUSH_DATA (push, 0x207);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV10_3D(TEX_ENABLE(0)), 2);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0);
+
+ BEGIN_NV04(push, NV10_3D(BLEND_FUNC_ENABLE), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV10_3D(DITHER_ENABLE), 2);
+ PUSH_DATA (push, 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV10_3D(LINE_SMOOTH_ENABLE), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV10_3D(VERTEX_WEIGHT_ENABLE), 2);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV10_3D(BLEND_FUNC_SRC), 4);
+ PUSH_DATA (push, 1);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0x8006);
+ BEGIN_NV04(push, NV10_3D(STENCIL_MASK), 8);
+ PUSH_DATA (push, 0xff);
+ PUSH_DATA (push, 0x207);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0xff);
+ PUSH_DATA (push, 0x1e00);
+ PUSH_DATA (push, 0x1e00);
+ PUSH_DATA (push, 0x1e00);
+ PUSH_DATA (push, 0x1d01);
+ BEGIN_NV04(push, NV10_3D(NORMALIZE_ENABLE), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV10_3D(FOG_ENABLE), 2);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV10_3D(LIGHT_MODEL), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV10_3D(SEPARATE_SPECULAR_ENABLE), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV10_3D(ENABLED_LIGHTS), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV10_3D(POLYGON_OFFSET_POINT_ENABLE), 3);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV10_3D(DEPTH_FUNC), 1);
+ PUSH_DATA (push, 0x201);
+ BEGIN_NV04(push, NV10_3D(DEPTH_WRITE_ENABLE), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV10_3D(DEPTH_TEST_ENABLE), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV10_3D(POLYGON_OFFSET_FACTOR), 2);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV10_3D(POINT_SIZE), 1);
+ PUSH_DATA (push, 8);
+ BEGIN_NV04(push, NV10_3D(POINT_PARAMETERS_ENABLE), 2);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV10_3D(LINE_WIDTH), 1);
+ PUSH_DATA (push, 8);
+ BEGIN_NV04(push, NV10_3D(LINE_SMOOTH_ENABLE), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV10_3D(POLYGON_MODE_FRONT), 2);
+ PUSH_DATA (push, 0x1b02);
+ PUSH_DATA (push, 0x1b02);
+ BEGIN_NV04(push, NV10_3D(CULL_FACE), 2);
+ PUSH_DATA (push, 0x405);
+ PUSH_DATA (push, 0x901);
+ BEGIN_NV04(push, NV10_3D(POLYGON_SMOOTH_ENABLE), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV10_3D(CULL_FACE_ENABLE), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV10_3D(TEX_GEN_MODE(0, 0)), 8);
for (i = 0; i < 8; i++)
- OUT_RING(chan, 0);
-
- BEGIN_RING(chan, celsius, NV10_3D_TEX_MATRIX_ENABLE(0), 2);
- OUT_RING(chan, 0);
- OUT_RING(chan, 0);
- BEGIN_RING(chan, celsius, NV10_3D_FOG_COEFF(0), 3);
- OUT_RING(chan, 0x3fc00000); /* -1.50 */
- OUT_RING(chan, 0xbdb8aa0a); /* -0.09 */
- OUT_RING(chan, 0); /* 0.00 */
-
- BEGIN_RING(chan, celsius, NV04_GRAPH_NOP, 1);
- OUT_RING(chan, 0);
-
- BEGIN_RING(chan, celsius, NV10_3D_FOG_MODE, 2);
- OUT_RING(chan, 0x802);
- OUT_RING(chan, 2);
+ PUSH_DATA (push, 0);
+
+ BEGIN_NV04(push, NV10_3D(TEX_MATRIX_ENABLE(0)), 2);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV10_3D(FOG_COEFF(0)), 3);
+ PUSH_DATA (push, 0x3fc00000); /* -1.50 */
+ PUSH_DATA (push, 0xbdb8aa0a); /* -0.09 */
+ PUSH_DATA (push, 0); /* 0.00 */
+
+ BEGIN_NV04(push, NV04_GRAPH(3D, NOP), 1);
+ PUSH_DATA (push, 0);
+
+ BEGIN_NV04(push, NV10_3D(FOG_MODE), 2);
+ PUSH_DATA (push, 0x802);
+ PUSH_DATA (push, 2);
/* for some reason VIEW_MATRIX_ENABLE need to be 6 instead of 4 when
* using texturing, except when using the texture matrix
*/
- BEGIN_RING(chan, celsius, NV10_3D_VIEW_MATRIX_ENABLE, 1);
- OUT_RING(chan, 6);
- BEGIN_RING(chan, celsius, NV10_3D_COLOR_MASK, 1);
- OUT_RING(chan, 0x01010101);
+ BEGIN_NV04(push, NV10_3D(VIEW_MATRIX_ENABLE), 1);
+ PUSH_DATA (push, 6);
+ BEGIN_NV04(push, NV10_3D(COLOR_MASK), 1);
+ PUSH_DATA (push, 0x01010101);
/* Set vertex component */
- BEGIN_RING(chan, celsius, NV10_3D_VERTEX_COL_4F_R, 4);
- OUT_RINGf(chan, 1.0);
- OUT_RINGf(chan, 0.0);
- OUT_RINGf(chan, 0.0);
- OUT_RINGf(chan, 1.0);
- BEGIN_RING(chan, celsius, NV10_3D_VERTEX_COL2_3F_R, 3);
- OUT_RING(chan, 0);
- OUT_RING(chan, 0);
- OUT_RING(chan, 0);
- BEGIN_RING(chan, celsius, NV10_3D_VERTEX_NOR_3F_X, 3);
- OUT_RING(chan, 0);
- OUT_RING(chan, 0);
- OUT_RINGf(chan, 1.0);
- BEGIN_RING(chan, celsius, NV10_3D_VERTEX_TX0_4F_S, 4);
- OUT_RINGf(chan, 0.0);
- OUT_RINGf(chan, 0.0);
- OUT_RINGf(chan, 0.0);
- OUT_RINGf(chan, 1.0);
- BEGIN_RING(chan, celsius, NV10_3D_VERTEX_TX1_4F_S, 4);
- OUT_RINGf(chan, 0.0);
- OUT_RINGf(chan, 0.0);
- OUT_RINGf(chan, 0.0);
- OUT_RINGf(chan, 1.0);
- BEGIN_RING(chan, celsius, NV10_3D_VERTEX_FOG_1F, 1);
- OUT_RINGf(chan, 0.0);
- BEGIN_RING(chan, celsius, NV10_3D_EDGEFLAG_ENABLE, 1);
- OUT_RING(chan, 1);
-
- BEGIN_RING(chan, celsius, NV10_3D_DEPTH_RANGE_NEAR, 2);
- OUT_RINGf(chan, 0.0);
- OUT_RINGf(chan, 16777216.0);
-
- FIRE_RING(chan);
+ BEGIN_NV04(push, NV10_3D(VERTEX_COL_4F_R), 4);
+ PUSH_DATAf(push, 1.0);
+ PUSH_DATAf(push, 0.0);
+ PUSH_DATAf(push, 0.0);
+ PUSH_DATAf(push, 1.0);
+ BEGIN_NV04(push, NV10_3D(VERTEX_COL2_3F_R), 3);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV10_3D(VERTEX_NOR_3F_X), 3);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0);
+ PUSH_DATAf(push, 1.0);
+ BEGIN_NV04(push, NV10_3D(VERTEX_TX0_4F_S), 4);
+ PUSH_DATAf(push, 0.0);
+ PUSH_DATAf(push, 0.0);
+ PUSH_DATAf(push, 0.0);
+ PUSH_DATAf(push, 1.0);
+ BEGIN_NV04(push, NV10_3D(VERTEX_TX1_4F_S), 4);
+ PUSH_DATAf(push, 0.0);
+ PUSH_DATAf(push, 0.0);
+ PUSH_DATAf(push, 0.0);
+ PUSH_DATAf(push, 1.0);
+ BEGIN_NV04(push, NV10_3D(VERTEX_FOG_1F), 1);
+ PUSH_DATAf(push, 0.0);
+ BEGIN_NV04(push, NV10_3D(EDGEFLAG_ENABLE), 1);
+ PUSH_DATA (push, 1);
+
+ BEGIN_NV04(push, NV10_3D(DEPTH_RANGE_NEAR), 2);
+ PUSH_DATAf(push, 0.0);
+ PUSH_DATAf(push, 16777216.0);
+
+ PUSH_KICK (push);
}
static void
nv10_swtnl_destroy(ctx);
nv10_vbo_destroy(ctx);
- nouveau_grobj_free(&nctx->hw.eng3d);
+ nouveau_object_del(&nctx->hw.eng3d);
nouveau_context_deinit(ctx);
FREE(ctx);
/* 3D engine. */
if (context_chipset(ctx) >= 0x17)
- celsius_class = NV17_3D;
+ celsius_class = NV17_3D_CLASS;
else if (context_chipset(ctx) >= 0x11)
- celsius_class = NV11_3D;
+ celsius_class = NV15_3D_CLASS;
else
- celsius_class = NV10_3D;
+ celsius_class = NV10_3D_CLASS;
- ret = nouveau_grobj_alloc(context_chan(ctx), 0xbeef0001, celsius_class,
- &nctx->hw.eng3d);
+ ret = nouveau_object_new(context_chan(ctx), 0xbeef0001, celsius_class,
+ NULL, 0, &nctx->hw.eng3d);
if (ret)
goto fail;
nv10_render_set_format(struct gl_context *ctx)
{
struct nouveau_render_state *render = to_render_state(ctx);
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
int i, attr, hw_format;
FOR_EACH_ATTR(render, i, attr) {
hw_format = NV10_3D_VTXBUF_FMT_TYPE_V32_FLOAT;
}
- BEGIN_RING(chan, celsius, NV10_3D_VTXBUF_FMT(i), 1);
- OUT_RING(chan, hw_format);
+ BEGIN_NV04(push, NV10_3D(VTXBUF_FMT(i)), 1);
+ PUSH_DATA (push, hw_format);
}
}
nv10_render_bind_vertices(struct gl_context *ctx)
{
struct nouveau_render_state *render = to_render_state(ctx);
- struct nouveau_bo_context *bctx = context_bctx(ctx, VERTEX);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
int i, attr;
FOR_EACH_BOUND_ATTR(render, i, attr) {
struct nouveau_array *a = &render->attrs[attr];
- nouveau_bo_markl(bctx, celsius,
- NV10_3D_VTXBUF_OFFSET(i),
- a->bo, a->offset,
- NOUVEAU_BO_GART | NOUVEAU_BO_RD);
+ BEGIN_NV04(push, NV10_3D(VTXBUF_OFFSET(i)), 1);
+ PUSH_MTHDl(push, NV10_3D(VTXBUF_OFFSET(i)), BUFCTX_VTX,
+ a->bo, a->offset, NOUVEAU_BO_GART |
+ NOUVEAU_BO_RD);
}
}
+static void
+nv10_render_release_vertices(struct gl_context *ctx)
+{
+ PUSH_RESET(context_push(ctx), BUFCTX_VTX);
+}
+
/* Vertex array rendering defs. */
-#define RENDER_LOCALS(ctx) \
- struct nouveau_grobj *celsius = context_eng3d(ctx)
+#define RENDER_LOCALS(ctx)
#define BATCH_VALIDATE() \
- BEGIN_RING(chan, celsius, NV10_3D_VTXBUF_VALIDATE, 1); \
- OUT_RING(chan, 0)
+ BEGIN_NV04(push, NV10_3D(VTXBUF_VALIDATE), 1); \
+ PUSH_DATA (push, 0)
#define BATCH_BEGIN(prim) \
- BEGIN_RING(chan, celsius, NV10_3D_VTXBUF_BEGIN_END, 1); \
- OUT_RING(chan, prim)
+ BEGIN_NV04(push, NV10_3D(VTXBUF_BEGIN_END), 1); \
+ PUSH_DATA (push, prim)
#define BATCH_END() \
- BEGIN_RING(chan, celsius, NV10_3D_VTXBUF_BEGIN_END, 1); \
- OUT_RING(chan, 0)
+ BEGIN_NV04(push, NV10_3D(VTXBUF_BEGIN_END), 1); \
+ PUSH_DATA (push, 0)
#define MAX_PACKET 0x400
#define MAX_OUT_L 0x100
#define BATCH_PACKET_L(n) \
- BEGIN_RING_NI(chan, celsius, NV10_3D_VTXBUF_BATCH, n)
+ BEGIN_NI04(push, NV10_3D(VTXBUF_BATCH), n)
#define BATCH_OUT_L(i, n) \
- OUT_RING(chan, ((n) - 1) << 24 | (i))
+ PUSH_DATA (push, ((n) - 1) << 24 | (i))
#define MAX_OUT_I16 0x2
#define BATCH_PACKET_I16(n) \
- BEGIN_RING_NI(chan, celsius, NV10_3D_VTXBUF_ELEMENT_U16, n)
+ BEGIN_NI04(push, NV10_3D(VTXBUF_ELEMENT_U16), n)
#define BATCH_OUT_I16(i0, i1) \
- OUT_RING(chan, (i1) << 16 | (i0))
+ PUSH_DATA (push, (i1) << 16 | (i0))
#define MAX_OUT_I32 0x1
#define BATCH_PACKET_I32(n) \
- BEGIN_RING_NI(chan, celsius, NV10_3D_VTXBUF_ELEMENT_U32, n)
+ BEGIN_NI04(push, NV10_3D(VTXBUF_ELEMENT_U32), n)
#define BATCH_OUT_I32(i) \
- OUT_RING(chan, i)
+ PUSH_DATA (push, i)
#define IMM_PACKET(m, n) \
- BEGIN_RING(chan, celsius, m, n)
+ BEGIN_NV04(push, SUBC_3D(m), n)
#define IMM_OUT(x) \
- OUT_RINGf(chan, x)
+ PUSH_DATAf(push, x)
#define TAG(x) nv10_##x
#include "nouveau_render_t.c"
static void
setup_hierz_buffer(struct gl_context *ctx)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
- struct nouveau_bo_context *bctx = context_bctx(ctx, HIERZ);
+ struct nouveau_pushbuf *push = context_push(ctx);
struct gl_framebuffer *fb = ctx->DrawBuffer;
struct nouveau_framebuffer *nfb = to_nouveau_framebuffer(fb);
unsigned pitch = align(fb->Width, 128),
size = pitch * height;
if (!nfb->hierz.bo || nfb->hierz.bo->size != size) {
+ union nouveau_bo_config config = {
+ .nv04.surf_flags = NV04_BO_ZETA,
+ .nv04.surf_pitch = 0
+ };
+
nouveau_bo_ref(NULL, &nfb->hierz.bo);
- nouveau_bo_new_tile(context_dev(ctx), NOUVEAU_BO_VRAM, 0, size,
- 0, NOUVEAU_BO_TILE_ZETA, &nfb->hierz.bo);
+ nouveau_bo_new(context_dev(ctx), NOUVEAU_BO_VRAM, 0, size,
+ &config, &nfb->hierz.bo);
}
- nouveau_bo_markl(bctx, celsius, NV17_3D_HIERZ_OFFSET,
+ PUSH_SPACE(push, 11);
+ BEGIN_NV04(push, NV17_3D(HIERZ_OFFSET), 1);
+ PUSH_MTHDl(push, NV17_3D(HIERZ_OFFSET), BUFCTX_FB,
nfb->hierz.bo, 0, NOUVEAU_BO_VRAM | NOUVEAU_BO_RDWR);
+ BEGIN_NV04(push, NV17_3D(HIERZ_WINDOW_X), 4);
+ PUSH_DATAf(push, - 1792);
+ PUSH_DATAf(push, - 2304 + fb->Height);
+ PUSH_DATAf(push, fb->_DepthMaxF / 2);
+ PUSH_DATAf(push, 0);
- WAIT_RING(chan, 9);
- BEGIN_RING(chan, celsius, NV17_3D_HIERZ_WINDOW_X, 4);
- OUT_RINGf(chan, - 1792);
- OUT_RINGf(chan, - 2304 + fb->Height);
- OUT_RINGf(chan, fb->_DepthMaxF / 2);
- OUT_RINGf(chan, 0);
-
- BEGIN_RING(chan, celsius, NV17_3D_HIERZ_PITCH, 1);
- OUT_RING(chan, pitch);
+ BEGIN_NV04(push, NV17_3D(HIERZ_PITCH), 1);
+ PUSH_DATA (push, pitch);
- BEGIN_RING(chan, celsius, NV17_3D_HIERZ_ENABLE, 1);
- OUT_RING(chan, 1);
+ BEGIN_NV04(push, NV17_3D(HIERZ_ENABLE), 1);
+ PUSH_DATA (push, 1);
}
void
nv10_emit_framebuffer(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
- struct nouveau_bo_context *bctx = context_bctx(ctx, FRAMEBUFFER);
+ struct nouveau_pushbuf *push = context_push(ctx);
struct gl_framebuffer *fb = ctx->DrawBuffer;
struct nouveau_surface *s;
unsigned rt_format = NV10_3D_RT_FORMAT_TYPE_LINEAR;
if (fb->_Status != GL_FRAMEBUFFER_COMPLETE_EXT)
return;
+ PUSH_RESET(push, BUFCTX_FB);
+
/* At least nv11 seems to get sad if we don't do this before
* swapping RTs.*/
if (context_chipset(ctx) < 0x17) {
int i;
for (i = 0; i < 6; i++) {
- BEGIN_RING(chan, celsius, NV04_GRAPH_NOP, 1);
- OUT_RING(chan, 0);
+ BEGIN_NV04(push, NV04_GRAPH(3D, NOP), 1);
+ PUSH_DATA (push, 0);
}
}
rt_format |= get_rt_format(s->format);
zeta_pitch = rt_pitch = s->pitch;
- nouveau_bo_markl(bctx, celsius, NV10_3D_COLOR_OFFSET,
+ BEGIN_NV04(push, NV10_3D(COLOR_OFFSET), 1);
+ PUSH_MTHDl(push, NV10_3D(COLOR_OFFSET), BUFCTX_FB,
s->bo, 0, bo_flags);
}
rt_format |= get_rt_format(s->format);
zeta_pitch = s->pitch;
- nouveau_bo_markl(bctx, celsius, NV10_3D_ZETA_OFFSET,
+ BEGIN_NV04(push, NV10_3D(ZETA_OFFSET), 1);
+ PUSH_MTHDl(push, NV10_3D(ZETA_OFFSET), BUFCTX_FB,
s->bo, 0, bo_flags);
if (context_chipset(ctx) >= 0x17) {
}
}
- BEGIN_RING(chan, celsius, NV10_3D_RT_FORMAT, 2);
- OUT_RING(chan, rt_format);
- OUT_RING(chan, zeta_pitch << 16 | rt_pitch);
+ BEGIN_NV04(push, NV10_3D(RT_FORMAT), 2);
+ PUSH_DATA (push, rt_format);
+ PUSH_DATA (push, zeta_pitch << 16 | rt_pitch);
context_dirty(ctx, VIEWPORT);
context_dirty(ctx, SCISSOR);
void
nv10_emit_scissor(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
int x, y, w, h;
get_scissors(ctx->DrawBuffer, &x, &y, &w, &h);
- BEGIN_RING(chan, celsius, NV10_3D_RT_HORIZ, 2);
- OUT_RING(chan, w << 16 | x);
- OUT_RING(chan, h << 16 | y);
+ BEGIN_NV04(push, NV10_3D(RT_HORIZ), 2);
+ PUSH_DATA (push, w << 16 | x);
+ PUSH_DATA (push, h << 16 | y);
}
void
nv10_emit_viewport(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
struct gl_viewport_attrib *vp = &ctx->Viewport;
struct gl_framebuffer *fb = ctx->DrawBuffer;
float a[4] = {};
if (nv10_use_viewport_zclear(ctx))
a[2] = nv10_transform_depth(ctx, (vp->Far + vp->Near) / 2);
- BEGIN_RING(chan, celsius, NV10_3D_VIEWPORT_TRANSLATE_X, 4);
- OUT_RINGp(chan, a, 4);
+ BEGIN_NV04(push, NV10_3D(VIEWPORT_TRANSLATE_X), 4);
+ PUSH_DATAp(push, a, 4);
- BEGIN_RING(chan, celsius, NV10_3D_VIEWPORT_CLIP_HORIZ(0), 1);
- OUT_RING(chan, (fb->Width - 1) << 16 | 0x08000800);
- BEGIN_RING(chan, celsius, NV10_3D_VIEWPORT_CLIP_VERT(0), 1);
- OUT_RING(chan, (fb->Height - 1) << 16 | 0x08000800);
+ BEGIN_NV04(push, NV10_3D(VIEWPORT_CLIP_HORIZ(0)), 1);
+ PUSH_DATA (push, (fb->Width - 1) << 16 | 0x08000800);
+ BEGIN_NV04(push, NV10_3D(VIEWPORT_CLIP_VERT(0)), 1);
+ PUSH_DATA (push, (fb->Height - 1) << 16 | 0x08000800);
context_dirty(ctx, PROJECTION);
}
nv10_emit_zclear(struct gl_context *ctx, int emit)
{
struct nouveau_context *nctx = to_nouveau_context(ctx);
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
struct nouveau_framebuffer *nfb =
to_nouveau_framebuffer(ctx->DrawBuffer);
if (nfb->hierz.bo) {
- BEGIN_RING(chan, celsius, NV17_3D_ZCLEAR_ENABLE, 2);
- OUT_RINGb(chan, !nctx->hierz.clear_blocked);
- OUT_RING(chan, nfb->hierz.clear_value |
+ BEGIN_NV04(push, NV17_3D(ZCLEAR_ENABLE), 2);
+ PUSH_DATAb(push, !nctx->hierz.clear_blocked);
+ PUSH_DATA (push, nfb->hierz.clear_value |
(nctx->hierz.clear_seq & 0xff));
} else {
- BEGIN_RING(chan, celsius, NV10_3D_DEPTH_RANGE_NEAR, 2);
- OUT_RINGf(chan, nv10_transform_depth(ctx, 0));
- OUT_RINGf(chan, nv10_transform_depth(ctx, 1));
+ BEGIN_NV04(push, NV10_3D(DEPTH_RANGE_NEAR), 2);
+ PUSH_DATAf(push, nv10_transform_depth(ctx, 0));
+ PUSH_DATAf(push, nv10_transform_depth(ctx, 1));
context_dirty(ctx, VIEWPORT);
}
}
nv10_emit_tex_env(struct gl_context *ctx, int emit)
{
const int i = emit - NOUVEAU_STATE_TEX_ENV0;
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
uint32_t a_in, a_out, c_in, c_out, k;
nv10_get_general_combiner(ctx, i, &a_in, &a_out, &c_in, &c_out, &k);
c_out |= 0x3 << 27;
}
- BEGIN_RING(chan, celsius, NV10_3D_RC_IN_ALPHA(i), 1);
- OUT_RING(chan, a_in);
- BEGIN_RING(chan, celsius, NV10_3D_RC_IN_RGB(i), 1);
- OUT_RING(chan, c_in);
- BEGIN_RING(chan, celsius, NV10_3D_RC_COLOR(i), 1);
- OUT_RING(chan, k);
- BEGIN_RING(chan, celsius, NV10_3D_RC_OUT_ALPHA(i), 1);
- OUT_RING(chan, a_out);
- BEGIN_RING(chan, celsius, NV10_3D_RC_OUT_RGB(i), 1);
- OUT_RING(chan, c_out);
+ BEGIN_NV04(push, NV10_3D(RC_IN_ALPHA(i)), 1);
+ PUSH_DATA (push, a_in);
+ BEGIN_NV04(push, NV10_3D(RC_IN_RGB(i)), 1);
+ PUSH_DATA (push, c_in);
+ BEGIN_NV04(push, NV10_3D(RC_COLOR(i)), 1);
+ PUSH_DATA (push, k);
+ BEGIN_NV04(push, NV10_3D(RC_OUT_ALPHA(i)), 1);
+ PUSH_DATA (push, a_out);
+ BEGIN_NV04(push, NV10_3D(RC_OUT_RGB(i)), 1);
+ PUSH_DATA (push, c_out);
context_dirty(ctx, FRAG);
}
void
nv10_emit_frag(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
uint64_t in;
int n;
nv10_get_final_combiner(ctx, &in, &n);
- BEGIN_RING(chan, celsius, NV10_3D_RC_FINAL0, 2);
- OUT_RING(chan, in);
- OUT_RING(chan, in >> 32);
+ BEGIN_NV04(push, NV10_3D(RC_FINAL0), 2);
+ PUSH_DATA (push, in);
+ PUSH_DATA (push, in >> 32);
}
void
nv10_emit_cull_face(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
GLenum mode = ctx->Polygon.CullFaceMode;
- BEGIN_RING(chan, celsius, NV10_3D_CULL_FACE_ENABLE, 1);
- OUT_RINGb(chan, ctx->Polygon.CullFlag);
+ BEGIN_NV04(push, NV10_3D(CULL_FACE_ENABLE), 1);
+ PUSH_DATAb(push, ctx->Polygon.CullFlag);
- BEGIN_RING(chan, celsius, NV10_3D_CULL_FACE, 1);
- OUT_RING(chan, (mode == GL_FRONT ? NV10_3D_CULL_FACE_FRONT :
+ BEGIN_NV04(push, NV10_3D(CULL_FACE), 1);
+ PUSH_DATA (push, (mode == GL_FRONT ? NV10_3D_CULL_FACE_FRONT :
mode == GL_BACK ? NV10_3D_CULL_FACE_BACK :
NV10_3D_CULL_FACE_FRONT_AND_BACK));
}
void
nv10_emit_front_face(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
- BEGIN_RING(chan, celsius, NV10_3D_FRONT_FACE, 1);
- OUT_RING(chan, ctx->Polygon.FrontFace == GL_CW ?
+ BEGIN_NV04(push, NV10_3D(FRONT_FACE), 1);
+ PUSH_DATA (push, ctx->Polygon.FrontFace == GL_CW ?
NV10_3D_FRONT_FACE_CW : NV10_3D_FRONT_FACE_CCW);
}
void
nv10_emit_line_mode(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
GLboolean smooth = ctx->Line.SmoothFlag &&
ctx->Hint.LineSmooth == GL_NICEST;
- BEGIN_RING(chan, celsius, NV10_3D_LINE_WIDTH, 1);
- OUT_RING(chan, MAX2(smooth ? 0 : 1,
+ BEGIN_NV04(push, NV10_3D(LINE_WIDTH), 1);
+ PUSH_DATA (push, MAX2(smooth ? 0 : 1,
ctx->Line.Width) * 8);
- BEGIN_RING(chan, celsius, NV10_3D_LINE_SMOOTH_ENABLE, 1);
- OUT_RINGb(chan, smooth);
+ BEGIN_NV04(push, NV10_3D(LINE_SMOOTH_ENABLE), 1);
+ PUSH_DATAb(push, smooth);
}
void
void
nv10_emit_point_mode(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
- BEGIN_RING(chan, celsius, NV10_3D_POINT_SIZE, 1);
- OUT_RING(chan, (uint32_t)(ctx->Point.Size * 8));
+ BEGIN_NV04(push, NV10_3D(POINT_SIZE), 1);
+ PUSH_DATA (push, (uint32_t)(ctx->Point.Size * 8));
- BEGIN_RING(chan, celsius, NV10_3D_POINT_SMOOTH_ENABLE, 1);
- OUT_RINGb(chan, ctx->Point.SmoothFlag);
+ BEGIN_NV04(push, NV10_3D(POINT_SMOOTH_ENABLE), 1);
+ PUSH_DATAb(push, ctx->Point.SmoothFlag);
}
void
nv10_emit_polygon_mode(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
- BEGIN_RING(chan, celsius, NV10_3D_POLYGON_MODE_FRONT, 2);
- OUT_RING(chan, nvgl_polygon_mode(ctx->Polygon.FrontMode));
- OUT_RING(chan, nvgl_polygon_mode(ctx->Polygon.BackMode));
+ BEGIN_NV04(push, NV10_3D(POLYGON_MODE_FRONT), 2);
+ PUSH_DATA (push, nvgl_polygon_mode(ctx->Polygon.FrontMode));
+ PUSH_DATA (push, nvgl_polygon_mode(ctx->Polygon.BackMode));
- BEGIN_RING(chan, celsius, NV10_3D_POLYGON_SMOOTH_ENABLE, 1);
- OUT_RINGb(chan, ctx->Polygon.SmoothFlag);
+ BEGIN_NV04(push, NV10_3D(POLYGON_SMOOTH_ENABLE), 1);
+ PUSH_DATAb(push, ctx->Polygon.SmoothFlag);
}
void
nv10_emit_polygon_offset(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
- BEGIN_RING(chan, celsius, NV10_3D_POLYGON_OFFSET_POINT_ENABLE, 3);
- OUT_RINGb(chan, ctx->Polygon.OffsetPoint);
- OUT_RINGb(chan, ctx->Polygon.OffsetLine);
- OUT_RINGb(chan, ctx->Polygon.OffsetFill);
+ BEGIN_NV04(push, NV10_3D(POLYGON_OFFSET_POINT_ENABLE), 3);
+ PUSH_DATAb(push, ctx->Polygon.OffsetPoint);
+ PUSH_DATAb(push, ctx->Polygon.OffsetLine);
+ PUSH_DATAb(push, ctx->Polygon.OffsetFill);
- BEGIN_RING(chan, celsius, NV10_3D_POLYGON_OFFSET_FACTOR, 2);
- OUT_RINGf(chan, ctx->Polygon.OffsetFactor);
- OUT_RINGf(chan, ctx->Polygon.OffsetUnits);
+ BEGIN_NV04(push, NV10_3D(POLYGON_OFFSET_FACTOR), 2);
+ PUSH_DATAf(push, ctx->Polygon.OffsetFactor);
+ PUSH_DATAf(push, ctx->Polygon.OffsetUnits);
}
void
void
nv10_emit_alpha_func(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
- BEGIN_RING(chan, celsius, NV10_3D_ALPHA_FUNC_ENABLE, 1);
- OUT_RINGb(chan, ctx->Color.AlphaEnabled);
+ BEGIN_NV04(push, NV10_3D(ALPHA_FUNC_ENABLE), 1);
+ PUSH_DATAb(push, ctx->Color.AlphaEnabled);
- BEGIN_RING(chan, celsius, NV10_3D_ALPHA_FUNC_FUNC, 2);
- OUT_RING(chan, nvgl_comparison_op(ctx->Color.AlphaFunc));
- OUT_RING(chan, FLOAT_TO_UBYTE(ctx->Color.AlphaRef));
+ BEGIN_NV04(push, NV10_3D(ALPHA_FUNC_FUNC), 2);
+ PUSH_DATA (push, nvgl_comparison_op(ctx->Color.AlphaFunc));
+ PUSH_DATA (push, FLOAT_TO_UBYTE(ctx->Color.AlphaRef));
}
void
nv10_emit_blend_color(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
- BEGIN_RING(chan, celsius, NV10_3D_BLEND_COLOR, 1);
- OUT_RING(chan, FLOAT_TO_UBYTE(ctx->Color.BlendColor[3]) << 24 |
+ BEGIN_NV04(push, NV10_3D(BLEND_COLOR), 1);
+ PUSH_DATA (push, FLOAT_TO_UBYTE(ctx->Color.BlendColor[3]) << 24 |
FLOAT_TO_UBYTE(ctx->Color.BlendColor[0]) << 16 |
FLOAT_TO_UBYTE(ctx->Color.BlendColor[1]) << 8 |
FLOAT_TO_UBYTE(ctx->Color.BlendColor[2]) << 0);
void
nv10_emit_blend_equation(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
- BEGIN_RING(chan, celsius, NV10_3D_BLEND_FUNC_ENABLE, 1);
- OUT_RINGb(chan, ctx->Color.BlendEnabled);
+ BEGIN_NV04(push, NV10_3D(BLEND_FUNC_ENABLE), 1);
+ PUSH_DATAb(push, ctx->Color.BlendEnabled);
- BEGIN_RING(chan, celsius, NV10_3D_BLEND_EQUATION, 1);
- OUT_RING(chan, nvgl_blend_eqn(ctx->Color.Blend[0].EquationRGB));
+ BEGIN_NV04(push, NV10_3D(BLEND_EQUATION), 1);
+ PUSH_DATA (push, nvgl_blend_eqn(ctx->Color.Blend[0].EquationRGB));
}
void
nv10_emit_blend_func(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
- BEGIN_RING(chan, celsius, NV10_3D_BLEND_FUNC_SRC, 2);
- OUT_RING(chan, nvgl_blend_func(ctx->Color.Blend[0].SrcRGB));
- OUT_RING(chan, nvgl_blend_func(ctx->Color.Blend[0].DstRGB));
+ BEGIN_NV04(push, NV10_3D(BLEND_FUNC_SRC), 2);
+ PUSH_DATA (push, nvgl_blend_func(ctx->Color.Blend[0].SrcRGB));
+ PUSH_DATA (push, nvgl_blend_func(ctx->Color.Blend[0].DstRGB));
}
void
nv10_emit_color_mask(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
- BEGIN_RING(chan, celsius, NV10_3D_COLOR_MASK, 1);
- OUT_RING(chan, ((ctx->Color.ColorMask[0][3] ? 1 << 24 : 0) |
+ BEGIN_NV04(push, NV10_3D(COLOR_MASK), 1);
+ PUSH_DATA (push, ((ctx->Color.ColorMask[0][3] ? 1 << 24 : 0) |
(ctx->Color.ColorMask[0][0] ? 1 << 16 : 0) |
(ctx->Color.ColorMask[0][1] ? 1 << 8 : 0) |
(ctx->Color.ColorMask[0][2] ? 1 << 0 : 0)));
void
nv10_emit_depth(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
-
- BEGIN_RING(chan, celsius, NV10_3D_DEPTH_TEST_ENABLE, 1);
- OUT_RINGb(chan, ctx->Depth.Test);
- BEGIN_RING(chan, celsius, NV10_3D_DEPTH_WRITE_ENABLE, 1);
- OUT_RINGb(chan, ctx->Depth.Mask);
- BEGIN_RING(chan, celsius, NV10_3D_DEPTH_FUNC, 1);
- OUT_RING(chan, nvgl_comparison_op(ctx->Depth.Func));
+ struct nouveau_pushbuf *push = context_push(ctx);
+
+ BEGIN_NV04(push, NV10_3D(DEPTH_TEST_ENABLE), 1);
+ PUSH_DATAb(push, ctx->Depth.Test);
+ BEGIN_NV04(push, NV10_3D(DEPTH_WRITE_ENABLE), 1);
+ PUSH_DATAb(push, ctx->Depth.Mask);
+ BEGIN_NV04(push, NV10_3D(DEPTH_FUNC), 1);
+ PUSH_DATA (push, nvgl_comparison_op(ctx->Depth.Func));
}
void
nv10_emit_dither(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
- BEGIN_RING(chan, celsius, NV10_3D_DITHER_ENABLE, 1);
- OUT_RINGb(chan, ctx->Color.DitherFlag);
+ BEGIN_NV04(push, NV10_3D(DITHER_ENABLE), 1);
+ PUSH_DATAb(push, ctx->Color.DitherFlag);
}
void
nv10_emit_logic_opcode(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
assert(!ctx->Color.ColorLogicOpEnabled
|| context_chipset(ctx) >= 0x11);
- BEGIN_RING(chan, celsius, NV11_3D_COLOR_LOGIC_OP_ENABLE, 2);
- OUT_RINGb(chan, ctx->Color.ColorLogicOpEnabled);
- OUT_RING(chan, nvgl_logicop_func(ctx->Color.LogicOp));
+ BEGIN_NV04(push, NV11_3D(COLOR_LOGIC_OP_ENABLE), 2);
+ PUSH_DATAb(push, ctx->Color.ColorLogicOpEnabled);
+ PUSH_DATA (push, nvgl_logicop_func(ctx->Color.LogicOp));
}
void
nv10_emit_shade_model(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
- BEGIN_RING(chan, celsius, NV10_3D_SHADE_MODEL, 1);
- OUT_RING(chan, ctx->Light.ShadeModel == GL_SMOOTH ?
+ BEGIN_NV04(push, NV10_3D(SHADE_MODEL), 1);
+ PUSH_DATA (push, ctx->Light.ShadeModel == GL_SMOOTH ?
NV10_3D_SHADE_MODEL_SMOOTH : NV10_3D_SHADE_MODEL_FLAT);
}
void
nv10_emit_stencil_func(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
- BEGIN_RING(chan, celsius, NV10_3D_STENCIL_ENABLE, 1);
- OUT_RINGb(chan, ctx->Stencil.Enabled);
+ BEGIN_NV04(push, NV10_3D(STENCIL_ENABLE), 1);
+ PUSH_DATAb(push, ctx->Stencil.Enabled);
- BEGIN_RING(chan, celsius, NV10_3D_STENCIL_FUNC_FUNC, 3);
- OUT_RING(chan, nvgl_comparison_op(ctx->Stencil.Function[0]));
- OUT_RING(chan, ctx->Stencil.Ref[0]);
- OUT_RING(chan, ctx->Stencil.ValueMask[0]);
+ BEGIN_NV04(push, NV10_3D(STENCIL_FUNC_FUNC), 3);
+ PUSH_DATA (push, nvgl_comparison_op(ctx->Stencil.Function[0]));
+ PUSH_DATA (push, ctx->Stencil.Ref[0]);
+ PUSH_DATA (push, ctx->Stencil.ValueMask[0]);
}
void
nv10_emit_stencil_mask(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
- BEGIN_RING(chan, celsius, NV10_3D_STENCIL_MASK, 1);
- OUT_RING(chan, ctx->Stencil.WriteMask[0]);
+ BEGIN_NV04(push, NV10_3D(STENCIL_MASK), 1);
+ PUSH_DATA (push, ctx->Stencil.WriteMask[0]);
}
void
nv10_emit_stencil_op(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
- BEGIN_RING(chan, celsius, NV10_3D_STENCIL_OP_FAIL, 3);
- OUT_RING(chan, nvgl_stencil_op(ctx->Stencil.FailFunc[0]));
- OUT_RING(chan, nvgl_stencil_op(ctx->Stencil.ZFailFunc[0]));
- OUT_RING(chan, nvgl_stencil_op(ctx->Stencil.ZPassFunc[0]));
+ BEGIN_NV04(push, NV10_3D(STENCIL_OP_FAIL), 3);
+ PUSH_DATA (push, nvgl_stencil_op(ctx->Stencil.FailFunc[0]));
+ PUSH_DATA (push, nvgl_stencil_op(ctx->Stencil.ZFailFunc[0]));
+ PUSH_DATA (push, nvgl_stencil_op(ctx->Stencil.ZPassFunc[0]));
}
{
const int i = emit - NOUVEAU_STATE_TEX_GEN0;
struct nouveau_context *nctx = to_nouveau_context(ctx);
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
struct gl_texture_unit *unit = &ctx->Texture.Unit[i];
int j;
float *k = get_texgen_coeff(coord);
if (k) {
- BEGIN_RING(chan, celsius,
- NV10_3D_TEX_GEN_COEFF(i, j), 4);
- OUT_RINGp(chan, k, 4);
+ BEGIN_NV04(push, NV10_3D(TEX_GEN_COEFF(i, j)), 4);
+ PUSH_DATAp(push, k, 4);
}
- BEGIN_RING(chan, celsius, NV10_3D_TEX_GEN_MODE(i,j), 1);
- OUT_RING(chan, nvgl_texgen_mode(coord->Mode));
+ BEGIN_NV04(push, NV10_3D(TEX_GEN_MODE(i,j)), 1);
+ PUSH_DATA (push, nvgl_texgen_mode(coord->Mode));
} else {
- BEGIN_RING(chan, celsius, NV10_3D_TEX_GEN_MODE(i,j), 1);
- OUT_RING(chan, 0);
+ BEGIN_NV04(push, NV10_3D(TEX_GEN_MODE(i,j)), 1);
+ PUSH_DATA (push, 0);
}
}
{
const int i = emit - NOUVEAU_STATE_TEX_MAT0;
struct nouveau_context *nctx = to_nouveau_context(ctx);
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
if (nctx->fallback == HWTNL &&
((ctx->Texture._TexMatEnabled & 1 << i) ||
ctx->Texture.Unit[i]._GenFlags)) {
- BEGIN_RING(chan, celsius, NV10_3D_TEX_MATRIX_ENABLE(i), 1);
- OUT_RING(chan, 1);
+ BEGIN_NV04(push, NV10_3D(TEX_MATRIX_ENABLE(i)), 1);
+ PUSH_DATA (push, 1);
- BEGIN_RING(chan, celsius, NV10_3D_TEX_MATRIX(i, 0), 16);
- OUT_RINGm(chan, ctx->TextureMatrixStack[i].Top->m);
+ BEGIN_NV04(push, NV10_3D(TEX_MATRIX(i, 0)), 16);
+ PUSH_DATAm(push, ctx->TextureMatrixStack[i].Top->m);
} else {
- BEGIN_RING(chan, celsius, NV10_3D_TEX_MATRIX_ENABLE(i), 1);
- OUT_RING(chan, 0);
+ BEGIN_NV04(push, NV10_3D(TEX_MATRIX_ENABLE(i)), 1);
+ PUSH_DATA (push, 0);
}
}
nv10_emit_tex_obj(struct gl_context *ctx, int emit)
{
const int i = emit - NOUVEAU_STATE_TEX_OBJ0;
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
- struct nouveau_bo_context *bctx = context_bctx_i(ctx, TEXTURE, i);
+ struct nouveau_pushbuf *push = context_push(ctx);
const int bo_flags = NOUVEAU_BO_RD | NOUVEAU_BO_GART | NOUVEAU_BO_VRAM;
struct gl_texture_object *t;
struct nouveau_surface *s;
struct gl_texture_image *ti;
uint32_t tx_format, tx_filter, tx_enable;
+ PUSH_RESET(push, BUFCTX_TEX(i));
+
if (!ctx->Texture.Unit[i]._ReallyEnabled) {
- BEGIN_RING(chan, celsius, NV10_3D_TEX_ENABLE(i), 1);
- OUT_RING(chan, 0);
+ BEGIN_NV04(push, NV10_3D(TEX_ENABLE(i)), 1);
+ PUSH_DATA (push, 0);
return;
}
| log2i(t->Sampler.MaxAnisotropy) << 4;
if (t->Target == GL_TEXTURE_RECTANGLE) {
- BEGIN_RING(chan, celsius, NV10_3D_TEX_NPOT_PITCH(i), 1);
- OUT_RING(chan, s->pitch << 16);
- BEGIN_RING(chan, celsius, NV10_3D_TEX_NPOT_SIZE(i), 1);
- OUT_RING(chan, align(s->width, 2) << 16 | s->height);
+ BEGIN_NV04(push, NV10_3D(TEX_NPOT_PITCH(i)), 1);
+ PUSH_DATA (push, s->pitch << 16);
+ BEGIN_NV04(push, NV10_3D(TEX_NPOT_SIZE(i)), 1);
+ PUSH_DATA (push, align(s->width, 2) << 16 | s->height);
tx_format |= get_tex_format_rect(ti);
} else {
}
/* Write it to the hardware. */
- nouveau_bo_mark(bctx, celsius, NV10_3D_TEX_FORMAT(i),
- s->bo, tx_format, 0,
- NV10_3D_TEX_FORMAT_DMA0,
- NV10_3D_TEX_FORMAT_DMA1,
- bo_flags | NOUVEAU_BO_OR);
-
- nouveau_bo_markl(bctx, celsius, NV10_3D_TEX_OFFSET(i),
+ BEGIN_NV04(push, NV10_3D(TEX_FORMAT(i)), 1);
+ PUSH_MTHD (push, NV10_3D(TEX_FORMAT(i)), BUFCTX_TEX(i),
+ s->bo, tx_format, bo_flags | NOUVEAU_BO_OR,
+ NV10_3D_TEX_FORMAT_DMA0,
+ NV10_3D_TEX_FORMAT_DMA1);
+
+ BEGIN_NV04(push, NV10_3D(TEX_OFFSET(i)), 1);
+ PUSH_MTHDl(push, NV10_3D(TEX_OFFSET(i)), BUFCTX_TEX(i),
s->bo, s->offset, bo_flags);
- BEGIN_RING(chan, celsius, NV10_3D_TEX_FILTER(i), 1);
- OUT_RING(chan, tx_filter);
+ BEGIN_NV04(push, NV10_3D(TEX_FILTER(i)), 1);
+ PUSH_DATA (push, tx_filter);
- BEGIN_RING(chan, celsius, NV10_3D_TEX_ENABLE(i), 1);
- OUT_RING(chan, tx_enable);
+ BEGIN_NV04(push, NV10_3D(TEX_ENABLE(i)), 1);
+ PUSH_DATA (push, tx_enable);
}
void
nv10_emit_color_material(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
unsigned mask = get_material_bitmask(ctx->Light.ColorMaterialBitmask);
- BEGIN_RING(chan, celsius, NV10_3D_COLOR_MATERIAL, 1);
- OUT_RING(chan, ctx->Light.ColorMaterialEnabled ? mask : 0);
+ BEGIN_NV04(push, NV10_3D(COLOR_MATERIAL), 1);
+ PUSH_DATA (push, ctx->Light.ColorMaterialEnabled ? mask : 0);
}
static unsigned
nv10_emit_fog(struct gl_context *ctx, int emit)
{
struct nouveau_context *nctx = to_nouveau_context(ctx);
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
struct gl_fog_attrib *f = &ctx->Fog;
unsigned source = nctx->fallback == HWTNL ?
f->FogCoordinateSource : GL_FOG_COORDINATE_EXT;
nv10_get_fog_coeff(ctx, k);
- BEGIN_RING(chan, celsius, NV10_3D_FOG_MODE, 4);
- OUT_RING(chan, get_fog_mode(f->Mode));
- OUT_RING(chan, get_fog_source(source, f->FogDistanceMode));
- OUT_RINGb(chan, f->Enabled);
- OUT_RING(chan, pack_rgba_f(MESA_FORMAT_RGBA8888_REV, f->Color));
+ BEGIN_NV04(push, NV10_3D(FOG_MODE), 4);
+ PUSH_DATA (push, get_fog_mode(f->Mode));
+ PUSH_DATA (push, get_fog_source(source, f->FogDistanceMode));
+ PUSH_DATAb(push, f->Enabled);
+ PUSH_DATA (push, pack_rgba_f(MESA_FORMAT_RGBA8888_REV, f->Color));
- BEGIN_RING(chan, celsius, NV10_3D_FOG_COEFF(0), 3);
- OUT_RINGp(chan, k, 3);
+ BEGIN_NV04(push, NV10_3D(FOG_COEFF(0)), 3);
+ PUSH_DATAp(push, k, 3);
context_dirty(ctx, FRAG);
}
nv10_emit_light_enable(struct gl_context *ctx, int emit)
{
struct nouveau_context *nctx = to_nouveau_context(ctx);
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
uint32_t en_lights = 0;
int i;
if (nctx->fallback != HWTNL) {
- BEGIN_RING(chan, celsius, NV10_3D_LIGHTING_ENABLE, 1);
- OUT_RING(chan, 0);
+ BEGIN_NV04(push, NV10_3D(LIGHTING_ENABLE), 1);
+ PUSH_DATA (push, 0);
return;
}
for (i = 0; i < MAX_LIGHTS; i++)
en_lights |= get_light_mode(&ctx->Light.Light[i]) << 2 * i;
- BEGIN_RING(chan, celsius, NV10_3D_ENABLED_LIGHTS, 1);
- OUT_RING(chan, en_lights);
- BEGIN_RING(chan, celsius, NV10_3D_LIGHTING_ENABLE, 1);
- OUT_RINGb(chan, ctx->Light.Enabled);
- BEGIN_RING(chan, celsius, NV10_3D_NORMALIZE_ENABLE, 1);
- OUT_RINGb(chan, ctx->Transform.Normalize);
+ BEGIN_NV04(push, NV10_3D(ENABLED_LIGHTS), 1);
+ PUSH_DATA (push, en_lights);
+ BEGIN_NV04(push, NV10_3D(LIGHTING_ENABLE), 1);
+ PUSH_DATAb(push, ctx->Light.Enabled);
+ BEGIN_NV04(push, NV10_3D(NORMALIZE_ENABLE), 1);
+ PUSH_DATAb(push, ctx->Transform.Normalize);
}
void
nv10_emit_light_model(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
struct gl_lightmodel *m = &ctx->Light.Model;
- BEGIN_RING(chan, celsius, NV10_3D_SEPARATE_SPECULAR_ENABLE, 1);
- OUT_RINGb(chan, m->ColorControl == GL_SEPARATE_SPECULAR_COLOR);
+ BEGIN_NV04(push, NV10_3D(SEPARATE_SPECULAR_ENABLE), 1);
+ PUSH_DATAb(push, m->ColorControl == GL_SEPARATE_SPECULAR_COLOR);
- BEGIN_RING(chan, celsius, NV10_3D_LIGHT_MODEL, 1);
- OUT_RING(chan, ((m->LocalViewer ?
+ BEGIN_NV04(push, NV10_3D(LIGHT_MODEL), 1);
+ PUSH_DATA (push, ((m->LocalViewer ?
NV10_3D_LIGHT_MODEL_LOCAL_VIEWER : 0) |
(_mesa_need_secondary_color(ctx) ?
NV10_3D_LIGHT_MODEL_SEPARATE_SPECULAR : 0) |
nv10_emit_light_source(struct gl_context *ctx, int emit)
{
const int i = emit - NOUVEAU_STATE_LIGHT_SOURCE0;
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
struct gl_light *l = &ctx->Light.Light[i];
if (l->_Flags & LIGHT_POSITIONAL) {
- BEGIN_RING(chan, celsius, NV10_3D_LIGHT_POSITION_X(i), 3);
- OUT_RINGp(chan, l->_Position, 3);
+ BEGIN_NV04(push, NV10_3D(LIGHT_POSITION_X(i)), 3);
+ PUSH_DATAp(push, l->_Position, 3);
- BEGIN_RING(chan, celsius,
- NV10_3D_LIGHT_ATTENUATION_CONSTANT(i), 3);
- OUT_RINGf(chan, l->ConstantAttenuation);
- OUT_RINGf(chan, l->LinearAttenuation);
- OUT_RINGf(chan, l->QuadraticAttenuation);
+ BEGIN_NV04(push, NV10_3D(LIGHT_ATTENUATION_CONSTANT(i)), 3);
+ PUSH_DATAf(push, l->ConstantAttenuation);
+ PUSH_DATAf(push, l->LinearAttenuation);
+ PUSH_DATAf(push, l->QuadraticAttenuation);
} else {
- BEGIN_RING(chan, celsius, NV10_3D_LIGHT_DIRECTION_X(i), 3);
- OUT_RINGp(chan, l->_VP_inf_norm, 3);
+ BEGIN_NV04(push, NV10_3D(LIGHT_DIRECTION_X(i)), 3);
+ PUSH_DATAp(push, l->_VP_inf_norm, 3);
- BEGIN_RING(chan, celsius, NV10_3D_LIGHT_HALF_VECTOR_X(i), 3);
- OUT_RINGp(chan, l->_h_inf_norm, 3);
+ BEGIN_NV04(push, NV10_3D(LIGHT_HALF_VECTOR_X(i)), 3);
+ PUSH_DATAp(push, l->_h_inf_norm, 3);
}
if (l->_Flags & LIGHT_SPOT) {
nv10_get_spot_coeff(l, k);
- BEGIN_RING(chan, celsius, NV10_3D_LIGHT_SPOT_CUTOFF(i, 0), 7);
- OUT_RINGp(chan, k, 7);
+ BEGIN_NV04(push, NV10_3D(LIGHT_SPOT_CUTOFF(i, 0)), 7);
+ PUSH_DATAp(push, k, 7);
}
}
void
nv10_emit_material_ambient(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
float (*mat)[4] = ctx->Light.Material.Attrib;
float c_scene[3], c_factor[3];
struct gl_light *l;
ZERO_3V(c_factor);
}
- BEGIN_RING(chan, celsius, NV10_3D_LIGHT_MODEL_AMBIENT_R, 3);
- OUT_RINGp(chan, c_scene, 3);
+ BEGIN_NV04(push, NV10_3D(LIGHT_MODEL_AMBIENT_R), 3);
+ PUSH_DATAp(push, c_scene, 3);
if (ctx->Light.ColorMaterialEnabled) {
- BEGIN_RING(chan, celsius, NV10_3D_MATERIAL_FACTOR_R, 3);
- OUT_RINGp(chan, c_factor, 3);
+ BEGIN_NV04(push, NV10_3D(MATERIAL_FACTOR_R), 3);
+ PUSH_DATAp(push, c_factor, 3);
}
foreach(l, &ctx->Light.EnabledList) {
l->Ambient :
l->_MatAmbient[0]);
- BEGIN_RING(chan, celsius, NV10_3D_LIGHT_AMBIENT_R(i), 3);
- OUT_RINGp(chan, c_light, 3);
+ BEGIN_NV04(push, NV10_3D(LIGHT_AMBIENT_R(i)), 3);
+ PUSH_DATAp(push, c_light, 3);
}
}
void
nv10_emit_material_diffuse(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
GLfloat (*mat)[4] = ctx->Light.Material.Attrib;
struct gl_light *l;
- BEGIN_RING(chan, celsius, NV10_3D_MATERIAL_FACTOR_A, 1);
- OUT_RINGf(chan, mat[MAT_ATTRIB_FRONT_DIFFUSE][3]);
+ BEGIN_NV04(push, NV10_3D(MATERIAL_FACTOR_A), 1);
+ PUSH_DATAf(push, mat[MAT_ATTRIB_FRONT_DIFFUSE][3]);
foreach(l, &ctx->Light.EnabledList) {
const int i = l - ctx->Light.Light;
l->Diffuse :
l->_MatDiffuse[0]);
- BEGIN_RING(chan, celsius, NV10_3D_LIGHT_DIFFUSE_R(i), 3);
- OUT_RINGp(chan, c_light, 3);
+ BEGIN_NV04(push, NV10_3D(LIGHT_DIFFUSE_R(i)), 3);
+ PUSH_DATAp(push, c_light, 3);
}
}
void
nv10_emit_material_specular(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
struct gl_light *l;
foreach(l, &ctx->Light.EnabledList) {
l->Specular :
l->_MatSpecular[0]);
- BEGIN_RING(chan, celsius, NV10_3D_LIGHT_SPECULAR_R(i), 3);
- OUT_RINGp(chan, c_light, 3);
+ BEGIN_NV04(push, NV10_3D(LIGHT_SPECULAR_R(i)), 3);
+ PUSH_DATAp(push, c_light, 3);
}
}
void
nv10_emit_material_shininess(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
float (*mat)[4] = ctx->Light.Material.Attrib;
float k[6];
CLAMP(mat[MAT_ATTRIB_FRONT_SHININESS][0], 0, 1024),
k);
- BEGIN_RING(chan, celsius, NV10_3D_MATERIAL_SHININESS(0), 6);
- OUT_RINGp(chan, k, 6);
+ BEGIN_NV04(push, NV10_3D(MATERIAL_SHININESS(0)), 6);
+ PUSH_DATAp(push, k, 6);
}
void
nv10_emit_modelview(struct gl_context *ctx, int emit)
{
struct nouveau_context *nctx = to_nouveau_context(ctx);
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
GLmatrix *m = ctx->ModelviewMatrixStack.Top;
if (nctx->fallback != HWTNL)
if (ctx->Light._NeedEyeCoords || ctx->Fog.Enabled ||
(ctx->Texture._GenFlags & TEXGEN_NEED_EYE_COORD)) {
- BEGIN_RING(chan, celsius, NV10_3D_MODELVIEW_MATRIX(0, 0), 16);
- OUT_RINGm(chan, m->m);
+ BEGIN_NV04(push, NV10_3D(MODELVIEW_MATRIX(0, 0)), 16);
+ PUSH_DATAm(push, m->m);
}
if (ctx->Light.Enabled ||
(ctx->Texture._GenFlags & TEXGEN_NEED_EYE_COORD)) {
int i, j;
- BEGIN_RING(chan, celsius,
- NV10_3D_INVERSE_MODELVIEW_MATRIX(0, 0), 12);
+ BEGIN_NV04(push, NV10_3D(INVERSE_MODELVIEW_MATRIX(0, 0)), 12);
for (i = 0; i < 3; i++)
for (j = 0; j < 4; j++)
- OUT_RINGf(chan, m->inv[4*i + j]);
+ PUSH_DATAf(push, m->inv[4*i + j]);
}
}
nv10_emit_projection(struct gl_context *ctx, int emit)
{
struct nouveau_context *nctx = to_nouveau_context(ctx);
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *celsius = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
GLmatrix m;
_math_matrix_ctr(&m);
if (nctx->fallback == HWTNL)
_math_matrix_mul_matrix(&m, &m, &ctx->_ModelProjectMatrix);
- BEGIN_RING(chan, celsius, NV10_3D_PROJECTION_MATRIX(0), 16);
- OUT_RINGm(chan, m.m);
+ BEGIN_NV04(push, NV10_3D(PROJECTION_MATRIX(0)), 16);
+ PUSH_DATAm(push, m.m);
_math_matrix_dtr(&m);
}
static void
nv20_clear(struct gl_context *ctx, GLbitfield buffers)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *kelvin = context_eng3d(ctx);
+ struct nouveau_context *nctx = to_nouveau_context(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
struct gl_framebuffer *fb = ctx->DrawBuffer;
uint32_t clear = 0;
nouveau_validate_framebuffer(ctx);
+ nouveau_pushbuf_bufctx(push, nctx->hw.bufctx);
+ if (nouveau_pushbuf_validate(push)) {
+ nouveau_pushbuf_bufctx(push, NULL);
+ return;
+ }
+
if (buffers & BUFFER_BITS_COLOR) {
struct nouveau_surface *s = &to_nouveau_renderbuffer(
fb->_ColorDrawBuffers[0])->surface;
if (ctx->Color.ColorMask[0][ACOMP])
clear |= NV20_3D_CLEAR_BUFFERS_COLOR_A;
- BEGIN_RING(chan, kelvin, NV20_3D_CLEAR_VALUE, 1);
- OUT_RING(chan, pack_rgba_clamp_f(s->format, ctx->Color.ClearColor.f));
+ BEGIN_NV04(push, NV20_3D(CLEAR_VALUE), 1);
+ PUSH_DATA (push, pack_rgba_clamp_f(s->format, ctx->Color.ClearColor.f));
buffers &= ~BUFFER_BITS_COLOR;
}
if (buffers & BUFFER_BIT_STENCIL && ctx->Stencil.WriteMask[0])
clear |= NV20_3D_CLEAR_BUFFERS_STENCIL;
- BEGIN_RING(chan, kelvin, NV20_3D_CLEAR_DEPTH_VALUE, 1);
- OUT_RING(chan, pack_zs_f(s->format, ctx->Depth.Clear,
+ BEGIN_NV04(push, NV20_3D(CLEAR_DEPTH_VALUE), 1);
+ PUSH_DATA (push, pack_zs_f(s->format, ctx->Depth.Clear,
ctx->Stencil.Clear));
buffers &= ~(BUFFER_BIT_DEPTH | BUFFER_BIT_STENCIL);
}
- BEGIN_RING(chan, kelvin, NV20_3D_CLEAR_BUFFERS, 1);
- OUT_RING(chan, clear);
+ BEGIN_NV04(push, NV20_3D(CLEAR_BUFFERS), 1);
+ PUSH_DATA (push, clear);
+ nouveau_pushbuf_bufctx(push, NULL);
nouveau_clear(ctx, buffers);
}
static void
nv20_hwctx_init(struct gl_context *ctx)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *kelvin = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
struct nouveau_hw_state *hw = &to_nouveau_context(ctx)->hw;
+ struct nv04_fifo *fifo = hw->chan->data;
int i;
- BEGIN_RING(chan, kelvin, NV20_3D_DMA_NOTIFY, 1);
- OUT_RING (chan, hw->ntfy->handle);
- BEGIN_RING(chan, kelvin, NV20_3D_DMA_TEXTURE0, 2);
- OUT_RING (chan, chan->vram->handle);
- OUT_RING (chan, chan->gart->handle);
- BEGIN_RING(chan, kelvin, NV20_3D_DMA_COLOR, 2);
- OUT_RING (chan, chan->vram->handle);
- OUT_RING (chan, chan->vram->handle);
- BEGIN_RING(chan, kelvin, NV20_3D_DMA_VTXBUF0, 2);
- OUT_RING(chan, chan->vram->handle);
- OUT_RING(chan, chan->gart->handle);
-
- BEGIN_RING(chan, kelvin, NV20_3D_DMA_QUERY, 1);
- OUT_RING (chan, 0);
-
- BEGIN_RING(chan, kelvin, NV20_3D_RT_HORIZ, 2);
- OUT_RING (chan, 0);
- OUT_RING (chan, 0);
-
- BEGIN_RING(chan, kelvin, NV20_3D_VIEWPORT_CLIP_HORIZ(0), 1);
- OUT_RING (chan, 0xfff << 16 | 0x0);
- BEGIN_RING(chan, kelvin, NV20_3D_VIEWPORT_CLIP_VERT(0), 1);
- OUT_RING (chan, 0xfff << 16 | 0x0);
+ BEGIN_NV04(push, NV01_SUBC(3D, OBJECT), 1);
+ PUSH_DATA (push, hw->eng3d->handle);
+ BEGIN_NV04(push, NV20_3D(DMA_NOTIFY), 1);
+ PUSH_DATA (push, hw->ntfy->handle);
+ BEGIN_NV04(push, NV20_3D(DMA_TEXTURE0), 2);
+ PUSH_DATA (push, fifo->vram);
+ PUSH_DATA (push, fifo->gart);
+ BEGIN_NV04(push, NV20_3D(DMA_COLOR), 2);
+ PUSH_DATA (push, fifo->vram);
+ PUSH_DATA (push, fifo->vram);
+ BEGIN_NV04(push, NV20_3D(DMA_VTXBUF0), 2);
+ PUSH_DATA (push, fifo->vram);
+ PUSH_DATA (push, fifo->gart);
+
+ BEGIN_NV04(push, NV20_3D(DMA_QUERY), 1);
+ PUSH_DATA (push, 0);
+
+ BEGIN_NV04(push, NV20_3D(RT_HORIZ), 2);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0);
+
+ BEGIN_NV04(push, NV20_3D(VIEWPORT_CLIP_HORIZ(0)), 1);
+ PUSH_DATA (push, 0xfff << 16 | 0x0);
+ BEGIN_NV04(push, NV20_3D(VIEWPORT_CLIP_VERT(0)), 1);
+ PUSH_DATA (push, 0xfff << 16 | 0x0);
for (i = 1; i < NV20_3D_VIEWPORT_CLIP_HORIZ__LEN; i++) {
- BEGIN_RING(chan, kelvin, NV20_3D_VIEWPORT_CLIP_HORIZ(i), 1);
- OUT_RING (chan, 0);
- BEGIN_RING(chan, kelvin, NV20_3D_VIEWPORT_CLIP_VERT(i), 1);
- OUT_RING (chan, 0);
+ BEGIN_NV04(push, NV20_3D(VIEWPORT_CLIP_HORIZ(i)), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV20_3D(VIEWPORT_CLIP_VERT(i)), 1);
+ PUSH_DATA (push, 0);
}
- BEGIN_RING(chan, kelvin, NV20_3D_VIEWPORT_CLIP_MODE, 1);
- OUT_RING (chan, 0);
+ BEGIN_NV04(push, NV20_3D(VIEWPORT_CLIP_MODE), 1);
+ PUSH_DATA (push, 0);
- BEGIN_RING(chan, kelvin, 0x17e0, 3);
- OUT_RINGf (chan, 0.0);
- OUT_RINGf (chan, 0.0);
- OUT_RINGf (chan, 1.0);
+ BEGIN_NV04(push, SUBC_3D(0x17e0), 3);
+ PUSH_DATAf(push, 0.0);
+ PUSH_DATAf(push, 0.0);
+ PUSH_DATAf(push, 1.0);
if (context_chipset(ctx) >= 0x25) {
- BEGIN_RING(chan, kelvin, NV20_3D_TEX_RCOMP, 1);
- OUT_RING (chan, NV20_3D_TEX_RCOMP_LEQUAL | 0xdb0);
+ BEGIN_NV04(push, NV20_3D(TEX_RCOMP), 1);
+ PUSH_DATA (push, NV20_3D_TEX_RCOMP_LEQUAL | 0xdb0);
} else {
- BEGIN_RING(chan, kelvin, 0x1e68, 1);
- OUT_RING (chan, 0x4b800000); /* 16777216.000000 */
- BEGIN_RING(chan, kelvin, NV20_3D_TEX_RCOMP, 1);
- OUT_RING (chan, NV20_3D_TEX_RCOMP_LEQUAL);
+ BEGIN_NV04(push, SUBC_3D(0x1e68), 1);
+ PUSH_DATA (push, 0x4b800000); /* 16777216.000000 */
+ BEGIN_NV04(push, NV20_3D(TEX_RCOMP), 1);
+ PUSH_DATA (push, NV20_3D_TEX_RCOMP_LEQUAL);
}
- BEGIN_RING(chan, kelvin, 0x290, 1);
- OUT_RING (chan, 0x10 << 16 | 1);
- BEGIN_RING(chan, kelvin, 0x9fc, 1);
- OUT_RING (chan, 0);
- BEGIN_RING(chan, kelvin, 0x1d80, 1);
- OUT_RING (chan, 1);
- BEGIN_RING(chan, kelvin, 0x9f8, 1);
- OUT_RING (chan, 4);
- BEGIN_RING(chan, kelvin, 0x17ec, 3);
- OUT_RINGf (chan, 0.0);
- OUT_RINGf (chan, 1.0);
- OUT_RINGf (chan, 0.0);
+ BEGIN_NV04(push, SUBC_3D(0x290), 1);
+ PUSH_DATA (push, 0x10 << 16 | 1);
+ BEGIN_NV04(push, SUBC_3D(0x9fc), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, SUBC_3D(0x1d80), 1);
+ PUSH_DATA (push, 1);
+ BEGIN_NV04(push, SUBC_3D(0x9f8), 1);
+ PUSH_DATA (push, 4);
+ BEGIN_NV04(push, SUBC_3D(0x17ec), 3);
+ PUSH_DATAf(push, 0.0);
+ PUSH_DATAf(push, 1.0);
+ PUSH_DATAf(push, 0.0);
if (context_chipset(ctx) >= 0x25) {
- BEGIN_RING(chan, kelvin, 0x1d88, 1);
- OUT_RING (chan, 3);
+ BEGIN_NV04(push, SUBC_3D(0x1d88), 1);
+ PUSH_DATA (push, 3);
- BEGIN_RING(chan, kelvin, NV25_3D_DMA_HIERZ, 1);
- OUT_RING (chan, chan->vram->handle);
- BEGIN_RING(chan, kelvin, NV25_3D_UNK01AC, 1);
- OUT_RING (chan, chan->vram->handle);
+ BEGIN_NV04(push, NV25_3D(DMA_HIERZ), 1);
+ PUSH_DATA (push, fifo->vram);
+ BEGIN_NV04(push, NV25_3D(UNK01AC), 1);
+ PUSH_DATA (push, fifo->vram);
}
- BEGIN_RING(chan, kelvin, NV20_3D_DMA_FENCE, 1);
- OUT_RING (chan, 0);
+ BEGIN_NV04(push, NV20_3D(DMA_FENCE), 1);
+ PUSH_DATA (push, 0);
- BEGIN_RING(chan, kelvin, 0x1e98, 1);
- OUT_RING (chan, 0);
+ BEGIN_NV04(push, SUBC_3D(0x1e98), 1);
+ PUSH_DATA (push, 0);
- BEGIN_RING(chan, kelvin, NV01_GRAPH_NOTIFY, 1);
- OUT_RING (chan, 0);
+ BEGIN_NV04(push, NV04_GRAPH(3D, NOTIFY), 1);
+ PUSH_DATA (push, 0);
- BEGIN_RING(chan, kelvin, 0x120, 3);
- OUT_RING (chan, 0);
- OUT_RING (chan, 1);
- OUT_RING (chan, 2);
+ BEGIN_NV04(push, SUBC_3D(0x120), 3);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 1);
+ PUSH_DATA (push, 2);
if (context_chipset(ctx) >= 0x25) {
- BEGIN_RING(chan, kelvin, 0x1da4, 1);
- OUT_RING (chan, 0);
+ BEGIN_NV04(push, SUBC_3D(0x1da4), 1);
+ PUSH_DATA (push, 0);
}
- BEGIN_RING(chan, kelvin, NV20_3D_RT_HORIZ, 2);
- OUT_RING (chan, 0 << 16 | 0);
- OUT_RING (chan, 0 << 16 | 0);
+ BEGIN_NV04(push, NV20_3D(RT_HORIZ), 2);
+ PUSH_DATA (push, 0 << 16 | 0);
+ PUSH_DATA (push, 0 << 16 | 0);
- BEGIN_RING(chan, kelvin, NV20_3D_ALPHA_FUNC_ENABLE, 1);
- OUT_RING (chan, 0);
- BEGIN_RING(chan, kelvin, NV20_3D_ALPHA_FUNC_FUNC, 2);
- OUT_RING (chan, NV20_3D_ALPHA_FUNC_FUNC_ALWAYS);
- OUT_RING (chan, 0);
+ BEGIN_NV04(push, NV20_3D(ALPHA_FUNC_ENABLE), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV20_3D(ALPHA_FUNC_FUNC), 2);
+ PUSH_DATA (push, NV20_3D_ALPHA_FUNC_FUNC_ALWAYS);
+ PUSH_DATA (push, 0);
for (i = 0; i < NV20_3D_TEX__LEN; i++) {
- BEGIN_RING(chan, kelvin, NV20_3D_TEX_ENABLE(i), 1);
- OUT_RING (chan, 0);
+ BEGIN_NV04(push, NV20_3D(TEX_ENABLE(i)), 1);
+ PUSH_DATA (push, 0);
}
- BEGIN_RING(chan, kelvin, NV20_3D_TEX_SHADER_OP, 1);
- OUT_RING (chan, 0);
- BEGIN_RING(chan, kelvin, NV20_3D_TEX_SHADER_CULL_MODE, 1);
- OUT_RING (chan, 0);
-
- BEGIN_RING(chan, kelvin, NV20_3D_RC_IN_ALPHA(0), 4);
- OUT_RING (chan, 0x30d410d0);
- OUT_RING (chan, 0);
- OUT_RING (chan, 0);
- OUT_RING (chan, 0);
- BEGIN_RING(chan, kelvin, NV20_3D_RC_OUT_RGB(0), 4);
- OUT_RING (chan, 0x00000c00);
- OUT_RING (chan, 0);
- OUT_RING (chan, 0);
- OUT_RING (chan, 0);
- BEGIN_RING(chan, kelvin, NV20_3D_RC_ENABLE, 1);
- OUT_RING (chan, 0x00011101);
- BEGIN_RING(chan, kelvin, NV20_3D_RC_FINAL0, 2);
- OUT_RING (chan, 0x130e0300);
- OUT_RING (chan, 0x0c091c80);
- BEGIN_RING(chan, kelvin, NV20_3D_RC_OUT_ALPHA(0), 4);
- OUT_RING (chan, 0x00000c00);
- OUT_RING (chan, 0);
- OUT_RING (chan, 0);
- OUT_RING (chan, 0);
- BEGIN_RING(chan, kelvin, NV20_3D_RC_IN_RGB(0), 4);
- OUT_RING (chan, 0x20c400c0);
- OUT_RING (chan, 0);
- OUT_RING (chan, 0);
- OUT_RING (chan, 0);
- BEGIN_RING(chan, kelvin, NV20_3D_RC_COLOR0, 2);
- OUT_RING (chan, 0);
- OUT_RING (chan, 0);
- BEGIN_RING(chan, kelvin, NV20_3D_RC_CONSTANT_COLOR0(0), 4);
- OUT_RING (chan, 0x035125a0);
- OUT_RING (chan, 0);
- OUT_RING (chan, 0x40002000);
- OUT_RING (chan, 0);
-
- BEGIN_RING(chan, kelvin, NV20_3D_MULTISAMPLE_CONTROL, 1);
- OUT_RING (chan, 0xffff0000);
- BEGIN_RING(chan, kelvin, NV20_3D_BLEND_FUNC_ENABLE, 1);
- OUT_RING (chan, 0);
- BEGIN_RING(chan, kelvin, NV20_3D_DITHER_ENABLE, 1);
- OUT_RING (chan, 0);
- BEGIN_RING(chan, kelvin, NV20_3D_STENCIL_ENABLE, 1);
- OUT_RING (chan, 0);
- BEGIN_RING(chan, kelvin, NV20_3D_BLEND_FUNC_SRC, 4);
- OUT_RING (chan, NV20_3D_BLEND_FUNC_SRC_ONE);
- OUT_RING (chan, NV20_3D_BLEND_FUNC_DST_ZERO);
- OUT_RING (chan, 0);
- OUT_RING (chan, NV20_3D_BLEND_EQUATION_FUNC_ADD);
- BEGIN_RING(chan, kelvin, NV20_3D_STENCIL_MASK, 7);
- OUT_RING (chan, 0xff);
- OUT_RING (chan, NV20_3D_STENCIL_FUNC_FUNC_ALWAYS);
- OUT_RING (chan, 0);
- OUT_RING (chan, 0xff);
- OUT_RING (chan, NV20_3D_STENCIL_OP_FAIL_KEEP);
- OUT_RING (chan, NV20_3D_STENCIL_OP_ZFAIL_KEEP);
- OUT_RING (chan, NV20_3D_STENCIL_OP_ZPASS_KEEP);
-
- BEGIN_RING(chan, kelvin, NV20_3D_COLOR_LOGIC_OP_ENABLE, 2);
- OUT_RING (chan, 0);
- OUT_RING (chan, NV20_3D_COLOR_LOGIC_OP_OP_COPY);
- BEGIN_RING(chan, kelvin, 0x17cc, 1);
- OUT_RING (chan, 0);
+ BEGIN_NV04(push, NV20_3D(TEX_SHADER_OP), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV20_3D(TEX_SHADER_CULL_MODE), 1);
+ PUSH_DATA (push, 0);
+
+ BEGIN_NV04(push, NV20_3D(RC_IN_ALPHA(0)), 4);
+ PUSH_DATA (push, 0x30d410d0);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV20_3D(RC_OUT_RGB(0)), 4);
+ PUSH_DATA (push, 0x00000c00);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV20_3D(RC_ENABLE), 1);
+ PUSH_DATA (push, 0x00011101);
+ BEGIN_NV04(push, NV20_3D(RC_FINAL0), 2);
+ PUSH_DATA (push, 0x130e0300);
+ PUSH_DATA (push, 0x0c091c80);
+ BEGIN_NV04(push, NV20_3D(RC_OUT_ALPHA(0)), 4);
+ PUSH_DATA (push, 0x00000c00);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV20_3D(RC_IN_RGB(0)), 4);
+ PUSH_DATA (push, 0x20c400c0);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV20_3D(RC_COLOR0), 2);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV20_3D(RC_CONSTANT_COLOR0(0)), 4);
+ PUSH_DATA (push, 0x035125a0);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0x40002000);
+ PUSH_DATA (push, 0);
+
+ BEGIN_NV04(push, NV20_3D(MULTISAMPLE_CONTROL), 1);
+ PUSH_DATA (push, 0xffff0000);
+ BEGIN_NV04(push, NV20_3D(BLEND_FUNC_ENABLE), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV20_3D(DITHER_ENABLE), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV20_3D(STENCIL_ENABLE), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV20_3D(BLEND_FUNC_SRC), 4);
+ PUSH_DATA (push, NV20_3D_BLEND_FUNC_SRC_ONE);
+ PUSH_DATA (push, NV20_3D_BLEND_FUNC_DST_ZERO);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, NV20_3D_BLEND_EQUATION_FUNC_ADD);
+ BEGIN_NV04(push, NV20_3D(STENCIL_MASK), 7);
+ PUSH_DATA (push, 0xff);
+ PUSH_DATA (push, NV20_3D_STENCIL_FUNC_FUNC_ALWAYS);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0xff);
+ PUSH_DATA (push, NV20_3D_STENCIL_OP_FAIL_KEEP);
+ PUSH_DATA (push, NV20_3D_STENCIL_OP_ZFAIL_KEEP);
+ PUSH_DATA (push, NV20_3D_STENCIL_OP_ZPASS_KEEP);
+
+ BEGIN_NV04(push, NV20_3D(COLOR_LOGIC_OP_ENABLE), 2);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, NV20_3D_COLOR_LOGIC_OP_OP_COPY);
+ BEGIN_NV04(push, SUBC_3D(0x17cc), 1);
+ PUSH_DATA (push, 0);
if (context_chipset(ctx) >= 0x25) {
- BEGIN_RING(chan, kelvin, 0x1d84, 1);
- OUT_RING (chan, 1);
+ BEGIN_NV04(push, SUBC_3D(0x1d84), 1);
+ PUSH_DATA (push, 1);
}
- BEGIN_RING(chan, kelvin, NV20_3D_LIGHTING_ENABLE, 1);
- OUT_RING (chan, 0);
- BEGIN_RING(chan, kelvin, NV20_3D_LIGHT_MODEL, 1);
- OUT_RING (chan, NV20_3D_LIGHT_MODEL_VIEWER_NONLOCAL);
- BEGIN_RING(chan, kelvin, NV20_3D_SEPARATE_SPECULAR_ENABLE, 1);
- OUT_RING (chan, 0);
- BEGIN_RING(chan, kelvin, NV20_3D_LIGHT_MODEL_TWO_SIDE_ENABLE, 1);
- OUT_RING (chan, 0);
- BEGIN_RING(chan, kelvin, NV20_3D_ENABLED_LIGHTS, 1);
- OUT_RING (chan, 0);
- BEGIN_RING(chan, kelvin, NV20_3D_NORMALIZE_ENABLE, 1);
- OUT_RING (chan, 0);
- BEGIN_RING(chan, kelvin, NV20_3D_POLYGON_STIPPLE_PATTERN(0),
+ BEGIN_NV04(push, NV20_3D(LIGHTING_ENABLE), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV20_3D(LIGHT_MODEL), 1);
+ PUSH_DATA (push, NV20_3D_LIGHT_MODEL_VIEWER_NONLOCAL);
+ BEGIN_NV04(push, NV20_3D(SEPARATE_SPECULAR_ENABLE), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV20_3D(LIGHT_MODEL_TWO_SIDE_ENABLE), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV20_3D(ENABLED_LIGHTS), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV20_3D(NORMALIZE_ENABLE), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV20_3D(POLYGON_STIPPLE_PATTERN(0)),
NV20_3D_POLYGON_STIPPLE_PATTERN__LEN);
for (i = 0; i < NV20_3D_POLYGON_STIPPLE_PATTERN__LEN; i++) {
- OUT_RING(chan, 0xffffffff);
+ PUSH_DATA (push, 0xffffffff);
}
- BEGIN_RING(chan, kelvin, NV20_3D_POLYGON_OFFSET_POINT_ENABLE, 3);
- OUT_RING (chan, 0);
- OUT_RING (chan, 0);
- OUT_RING (chan, 0);
- BEGIN_RING(chan, kelvin, NV20_3D_DEPTH_FUNC, 1);
- OUT_RING (chan, NV20_3D_DEPTH_FUNC_LESS);
- BEGIN_RING(chan, kelvin, NV20_3D_DEPTH_WRITE_ENABLE, 1);
- OUT_RING (chan, 0);
- BEGIN_RING(chan, kelvin, NV20_3D_DEPTH_TEST_ENABLE, 1);
- OUT_RING (chan, 0);
- BEGIN_RING(chan, kelvin, NV20_3D_POLYGON_OFFSET_FACTOR, 2);
- OUT_RINGf (chan, 0.0);
- OUT_RINGf (chan, 0.0);
- BEGIN_RING(chan, kelvin, NV20_3D_DEPTH_CLAMP, 1);
- OUT_RING (chan, 1);
+ BEGIN_NV04(push, NV20_3D(POLYGON_OFFSET_POINT_ENABLE), 3);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV20_3D(DEPTH_FUNC), 1);
+ PUSH_DATA (push, NV20_3D_DEPTH_FUNC_LESS);
+ BEGIN_NV04(push, NV20_3D(DEPTH_WRITE_ENABLE), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV20_3D(DEPTH_TEST_ENABLE), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV20_3D(POLYGON_OFFSET_FACTOR), 2);
+ PUSH_DATAf(push, 0.0);
+ PUSH_DATAf(push, 0.0);
+ BEGIN_NV04(push, NV20_3D(DEPTH_CLAMP), 1);
+ PUSH_DATA (push, 1);
if (context_chipset(ctx) < 0x25) {
- BEGIN_RING(chan, kelvin, 0x1d84, 1);
- OUT_RING (chan, 3);
+ BEGIN_NV04(push, SUBC_3D(0x1d84), 1);
+ PUSH_DATA (push, 3);
}
- BEGIN_RING(chan, kelvin, NV20_3D_POINT_SIZE, 1);
+ BEGIN_NV04(push, NV20_3D(POINT_SIZE), 1);
if (context_chipset(ctx) >= 0x25)
- OUT_RINGf (chan, 1.0);
+ PUSH_DATAf(push, 1.0);
else
- OUT_RING (chan, 8);
+ PUSH_DATA (push, 8);
if (context_chipset(ctx) >= 0x25) {
- BEGIN_RING(chan, kelvin, NV20_3D_POINT_PARAMETERS_ENABLE, 1);
- OUT_RING (chan, 0);
- BEGIN_RING(chan, kelvin, 0x0a1c, 1);
- OUT_RING (chan, 0x800);
+ BEGIN_NV04(push, NV20_3D(POINT_PARAMETERS_ENABLE), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, SUBC_3D(0x0a1c), 1);
+ PUSH_DATA (push, 0x800);
} else {
- BEGIN_RING(chan, kelvin, NV20_3D_POINT_PARAMETERS_ENABLE, 2);
- OUT_RING (chan, 0);
- OUT_RING (chan, 0);
+ BEGIN_NV04(push, NV20_3D(POINT_PARAMETERS_ENABLE), 2);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0);
}
- BEGIN_RING(chan, kelvin, NV20_3D_LINE_WIDTH, 1);
- OUT_RING (chan, 8);
- BEGIN_RING(chan, kelvin, NV20_3D_LINE_SMOOTH_ENABLE, 1);
- OUT_RING (chan, 0);
- BEGIN_RING(chan, kelvin, NV20_3D_POLYGON_MODE_FRONT, 2);
- OUT_RING (chan, NV20_3D_POLYGON_MODE_FRONT_FILL);
- OUT_RING (chan, NV20_3D_POLYGON_MODE_BACK_FILL);
- BEGIN_RING(chan, kelvin, NV20_3D_CULL_FACE, 2);
- OUT_RING (chan, NV20_3D_CULL_FACE_BACK);
- OUT_RING (chan, NV20_3D_FRONT_FACE_CCW);
- BEGIN_RING(chan, kelvin, NV20_3D_POLYGON_SMOOTH_ENABLE, 1);
- OUT_RING (chan, 0);
- BEGIN_RING(chan, kelvin, NV20_3D_CULL_FACE_ENABLE, 1);
- OUT_RING (chan, 0);
- BEGIN_RING(chan, kelvin, NV20_3D_SHADE_MODEL, 1);
- OUT_RING (chan, NV20_3D_SHADE_MODEL_SMOOTH);
- BEGIN_RING(chan, kelvin, NV20_3D_POLYGON_STIPPLE_ENABLE, 1);
- OUT_RING (chan, 0);
-
- BEGIN_RING(chan, kelvin, NV20_3D_TEX_GEN_MODE(0,0),
+ BEGIN_NV04(push, NV20_3D(LINE_WIDTH), 1);
+ PUSH_DATA (push, 8);
+ BEGIN_NV04(push, NV20_3D(LINE_SMOOTH_ENABLE), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV20_3D(POLYGON_MODE_FRONT), 2);
+ PUSH_DATA (push, NV20_3D_POLYGON_MODE_FRONT_FILL);
+ PUSH_DATA (push, NV20_3D_POLYGON_MODE_BACK_FILL);
+ BEGIN_NV04(push, NV20_3D(CULL_FACE), 2);
+ PUSH_DATA (push, NV20_3D_CULL_FACE_BACK);
+ PUSH_DATA (push, NV20_3D_FRONT_FACE_CCW);
+ BEGIN_NV04(push, NV20_3D(POLYGON_SMOOTH_ENABLE), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV20_3D(CULL_FACE_ENABLE), 1);
+ PUSH_DATA (push, 0);
+ BEGIN_NV04(push, NV20_3D(SHADE_MODEL), 1);
+ PUSH_DATA (push, NV20_3D_SHADE_MODEL_SMOOTH);
+ BEGIN_NV04(push, NV20_3D(POLYGON_STIPPLE_ENABLE), 1);
+ PUSH_DATA (push, 0);
+
+ BEGIN_NV04(push, NV20_3D(TEX_GEN_MODE(0,0)),
4 * NV20_3D_TEX_GEN_MODE__ESIZE);
for (i=0; i < 4 * NV20_3D_TEX_GEN_MODE__LEN; i++)
- OUT_RING(chan, 0);
-
- BEGIN_RING(chan, kelvin, NV20_3D_FOG_COEFF(0), 3);
- OUT_RINGf (chan, 1.5);
- OUT_RINGf (chan, -0.090168);
- OUT_RINGf (chan, 0.0);
- BEGIN_RING(chan, kelvin, NV20_3D_FOG_MODE, 2);
- OUT_RING (chan, NV20_3D_FOG_MODE_EXP_SIGNED);
- OUT_RING (chan, NV20_3D_FOG_COORD_FOG);
- BEGIN_RING(chan, kelvin, NV20_3D_FOG_ENABLE, 2);
- OUT_RING (chan, 0);
- OUT_RING (chan, 0);
-
- BEGIN_RING(chan, kelvin, NV20_3D_ENGINE, 1);
- OUT_RING (chan, NV20_3D_ENGINE_FIXED);
+ PUSH_DATA (push, 0);
+
+ BEGIN_NV04(push, NV20_3D(FOG_COEFF(0)), 3);
+ PUSH_DATAf(push, 1.5);
+ PUSH_DATAf(push, -0.090168);
+ PUSH_DATAf(push, 0.0);
+ BEGIN_NV04(push, NV20_3D(FOG_MODE), 2);
+ PUSH_DATA (push, NV20_3D_FOG_MODE_EXP_SIGNED);
+ PUSH_DATA (push, NV20_3D_FOG_COORD_FOG);
+ BEGIN_NV04(push, NV20_3D(FOG_ENABLE), 2);
+ PUSH_DATA (push, 0);
+ PUSH_DATA (push, 0);
+
+ BEGIN_NV04(push, NV20_3D(ENGINE), 1);
+ PUSH_DATA (push, NV20_3D_ENGINE_FIXED);
for (i = 0; i < NV20_3D_TEX_MATRIX_ENABLE__LEN; i++) {
- BEGIN_RING(chan, kelvin, NV20_3D_TEX_MATRIX_ENABLE(i), 1);
- OUT_RING (chan, 0);
+ BEGIN_NV04(push, NV20_3D(TEX_MATRIX_ENABLE(i)), 1);
+ PUSH_DATA (push, 0);
}
- BEGIN_RING(chan, kelvin, NV20_3D_VERTEX_ATTR_4F_X(1), 4 * 15);
- OUT_RINGf(chan, 1.0);
- OUT_RINGf(chan, 0.0);
- OUT_RINGf(chan, 0.0);
- OUT_RINGf(chan, 1.0);
- OUT_RINGf(chan, 0.0);
- OUT_RINGf(chan, 0.0);
- OUT_RINGf(chan, 1.0);
- OUT_RINGf(chan, 1.0);
- OUT_RINGf(chan, 1.0);
- OUT_RINGf(chan, 1.0);
- OUT_RINGf(chan, 1.0);
- OUT_RINGf(chan, 1.0);
+ BEGIN_NV04(push, NV20_3D(VERTEX_ATTR_4F_X(1)), 4 * 15);
+ PUSH_DATAf(push, 1.0);
+ PUSH_DATAf(push, 0.0);
+ PUSH_DATAf(push, 0.0);
+ PUSH_DATAf(push, 1.0);
+ PUSH_DATAf(push, 0.0);
+ PUSH_DATAf(push, 0.0);
+ PUSH_DATAf(push, 1.0);
+ PUSH_DATAf(push, 1.0);
+ PUSH_DATAf(push, 1.0);
+ PUSH_DATAf(push, 1.0);
+ PUSH_DATAf(push, 1.0);
+ PUSH_DATAf(push, 1.0);
for (i = 0; i < 12; i++) {
- OUT_RINGf(chan, 0.0);
- OUT_RINGf(chan, 0.0);
- OUT_RINGf(chan, 0.0);
- OUT_RINGf(chan, 1.0);
+ PUSH_DATAf(push, 0.0);
+ PUSH_DATAf(push, 0.0);
+ PUSH_DATAf(push, 0.0);
+ PUSH_DATAf(push, 1.0);
}
- BEGIN_RING(chan, kelvin, NV20_3D_EDGEFLAG_ENABLE, 1);
- OUT_RING (chan, 1);
- BEGIN_RING(chan, kelvin, NV20_3D_COLOR_MASK, 1);
- OUT_RING (chan, 0x00010101);
- BEGIN_RING(chan, kelvin, NV20_3D_CLEAR_VALUE, 1);
- OUT_RING (chan, 0);
-
- BEGIN_RING(chan, kelvin, NV20_3D_DEPTH_RANGE_NEAR, 2);
- OUT_RINGf (chan, 0.0);
- OUT_RINGf (chan, 16777216.0);
-
- BEGIN_RING(chan, kelvin, NV20_3D_VIEWPORT_TRANSLATE_X, 4);
- OUT_RINGf (chan, 0.0);
- OUT_RINGf (chan, 0.0);
- OUT_RINGf (chan, 0.0);
- OUT_RINGf (chan, 16777215.0);
-
- BEGIN_RING(chan, kelvin, NV20_3D_VIEWPORT_SCALE_X, 4);
- OUT_RINGf (chan, 0.0);
- OUT_RINGf (chan, 0.0);
- OUT_RINGf (chan, 16777215.0 * 0.5);
- OUT_RINGf (chan, 65535.0);
-
- FIRE_RING(chan);
+ BEGIN_NV04(push, NV20_3D(EDGEFLAG_ENABLE), 1);
+ PUSH_DATA (push, 1);
+ BEGIN_NV04(push, NV20_3D(COLOR_MASK), 1);
+ PUSH_DATA (push, 0x00010101);
+ BEGIN_NV04(push, NV20_3D(CLEAR_VALUE), 1);
+ PUSH_DATA (push, 0);
+
+ BEGIN_NV04(push, NV20_3D(DEPTH_RANGE_NEAR), 2);
+ PUSH_DATAf(push, 0.0);
+ PUSH_DATAf(push, 16777216.0);
+
+ BEGIN_NV04(push, NV20_3D(VIEWPORT_TRANSLATE_X), 4);
+ PUSH_DATAf(push, 0.0);
+ PUSH_DATAf(push, 0.0);
+ PUSH_DATAf(push, 0.0);
+ PUSH_DATAf(push, 16777215.0);
+
+ BEGIN_NV04(push, NV20_3D(VIEWPORT_SCALE_X), 4);
+ PUSH_DATAf(push, 0.0);
+ PUSH_DATAf(push, 0.0);
+ PUSH_DATAf(push, 16777215.0 * 0.5);
+ PUSH_DATAf(push, 65535.0);
+
+ PUSH_KICK (push);
}
static void
nv20_swtnl_destroy(ctx);
nv20_vbo_destroy(ctx);
- nouveau_grobj_free(&nctx->hw.eng3d);
+ nouveau_object_del(&nctx->hw.eng3d);
nouveau_context_deinit(ctx);
FREE(ctx);
/* 3D engine. */
if (context_chipset(ctx) >= 0x25)
- kelvin_class = NV25_3D;
+ kelvin_class = NV25_3D_CLASS;
else
- kelvin_class = NV20_3D;
+ kelvin_class = NV20_3D_CLASS;
- ret = nouveau_grobj_alloc(context_chan(ctx), 0xbeef0001, kelvin_class,
- &nctx->hw.eng3d);
+ ret = nouveau_object_new(context_chan(ctx), 0xbeef0001, kelvin_class,
+ NULL, 0, &nctx->hw.eng3d);
if (ret)
goto fail;
nv20_render_set_format(struct gl_context *ctx)
{
struct nouveau_render_state *render = to_render_state(ctx);
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *kelvin = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
int i, attr, hw_format;
FOR_EACH_ATTR(render, i, attr) {
hw_format = NV20_3D_VTXBUF_FMT_TYPE_FLOAT;
}
- BEGIN_RING(chan, kelvin, NV20_3D_VTXBUF_FMT(i), 1);
- OUT_RING(chan, hw_format);
+ BEGIN_NV04(push, NV20_3D(VTXBUF_FMT(i)), 1);
+ PUSH_DATA (push, hw_format);
}
}
nv20_render_bind_vertices(struct gl_context *ctx)
{
struct nouveau_render_state *render = to_render_state(ctx);
- struct nouveau_bo_context *bctx = context_bctx(ctx, VERTEX);
- struct nouveau_grobj *kelvin = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
int i, attr;
FOR_EACH_BOUND_ATTR(render, i, attr) {
struct nouveau_array *a = &render->attrs[attr];
- nouveau_bo_mark(bctx, kelvin,
- NV20_3D_VTXBUF_OFFSET(i),
- a->bo, a->offset, 0,
- 0, NV20_3D_VTXBUF_OFFSET_DMA1,
- NOUVEAU_BO_LOW | NOUVEAU_BO_OR |
- NOUVEAU_BO_GART | NOUVEAU_BO_RD);
+ BEGIN_NV04(push, NV20_3D(VTXBUF_OFFSET(i)), 1);
+ PUSH_MTHD (push, NV20_3D(VTXBUF_OFFSET(i)), BUFCTX_VTX,
+ a->bo, a->offset, NOUVEAU_BO_LOW |
+ NOUVEAU_BO_OR | NOUVEAU_BO_GART |
+ NOUVEAU_BO_RD, 0,
+ NV20_3D_VTXBUF_OFFSET_DMA1);
}
}
+static void
+nv20_render_release_vertices(struct gl_context *ctx)
+{
+ PUSH_RESET(context_push(ctx), BUFCTX_VTX);
+}
+
/* Vertex array rendering defs. */
-#define RENDER_LOCALS(ctx) \
- struct nouveau_grobj *kelvin = context_eng3d(ctx)
+#define RENDER_LOCALS(ctx)
#define BATCH_VALIDATE() \
- BEGIN_RING(chan, kelvin, NV20_3D_VTXBUF_VALIDATE, 1); \
- OUT_RING(chan, 0)
+ BEGIN_NV04(push, NV20_3D(VTXBUF_VALIDATE), 1); \
+ PUSH_DATA (push, 0)
#define BATCH_BEGIN(prim) \
- BEGIN_RING(chan, kelvin, NV20_3D_VERTEX_BEGIN_END, 1); \
- OUT_RING(chan, prim)
+ BEGIN_NV04(push, NV20_3D(VERTEX_BEGIN_END), 1); \
+ PUSH_DATA (push, prim)
#define BATCH_END() \
- BEGIN_RING(chan, kelvin, NV20_3D_VERTEX_BEGIN_END, 1); \
- OUT_RING(chan, 0)
+ BEGIN_NV04(push, NV20_3D(VERTEX_BEGIN_END), 1); \
+ PUSH_DATA (push, 0)
#define MAX_PACKET 0x400
#define MAX_OUT_L 0x100
#define BATCH_PACKET_L(n) \
- BEGIN_RING_NI(chan, kelvin, NV20_3D_VTXBUF_BATCH, n)
+ BEGIN_NI04(push, NV20_3D(VTXBUF_BATCH), n)
#define BATCH_OUT_L(i, n) \
- OUT_RING(chan, ((n) - 1) << 24 | (i))
+ PUSH_DATA (push, ((n) - 1) << 24 | (i))
#define MAX_OUT_I16 0x2
#define BATCH_PACKET_I16(n) \
- BEGIN_RING_NI(chan, kelvin, NV20_3D_VTXBUF_ELEMENT_U16, n)
+ BEGIN_NI04(push, NV20_3D(VTXBUF_ELEMENT_U16), n)
#define BATCH_OUT_I16(i0, i1) \
- OUT_RING(chan, (i1) << 16 | (i0))
+ PUSH_DATA (push, (i1) << 16 | (i0))
#define MAX_OUT_I32 0x1
#define BATCH_PACKET_I32(n) \
- BEGIN_RING_NI(chan, kelvin, NV20_3D_VTXBUF_ELEMENT_U32, n)
+ BEGIN_NI04(push, NV20_3D(VTXBUF_ELEMENT_U32), n)
#define BATCH_OUT_I32(i) \
- OUT_RING(chan, i)
+ PUSH_DATA (push, i)
#define IMM_PACKET(m, n) \
- BEGIN_RING(chan, kelvin, m, n)
+ BEGIN_NV04(push, SUBC_3D(m), n)
#define IMM_OUT(x) \
- OUT_RINGf(chan, x)
+ PUSH_DATAf(push, x)
#define TAG(x) nv20_##x
#include "nouveau_render_t.c"
static void
setup_hierz_buffer(struct gl_context *ctx)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *kelvin = context_eng3d(ctx);
- struct nouveau_bo_context *bctx = context_bctx(ctx, HIERZ);
+ struct nouveau_pushbuf *push = context_push(ctx);
struct gl_framebuffer *fb = ctx->DrawBuffer;
struct nouveau_framebuffer *nfb = to_nouveau_framebuffer(fb);
unsigned pitch = align(fb->Width, 128),
if (!nfb->hierz.bo || nfb->hierz.bo->size != size) {
nouveau_bo_ref(NULL, &nfb->hierz.bo);
nouveau_bo_new(context_dev(ctx), NOUVEAU_BO_VRAM, 0, size,
- &nfb->hierz.bo);
+ NULL, &nfb->hierz.bo);
}
- BEGIN_RING(chan, kelvin, NV25_3D_HIERZ_PITCH, 1);
- OUT_RING(chan, pitch);
-
- nouveau_bo_markl(bctx, kelvin, NV25_3D_HIERZ_OFFSET, nfb->hierz.bo,
- 0, NOUVEAU_BO_VRAM | NOUVEAU_BO_RDWR);
+ BEGIN_NV04(push, NV25_3D(HIERZ_PITCH), 1);
+ PUSH_DATA (push, pitch);
+ BEGIN_NV04(push, NV25_3D(HIERZ_OFFSET), 1);
+ PUSH_MTHDl(push, NV25_3D(HIERZ_OFFSET), BUFCTX_FB,
+ nfb->hierz.bo, 0, NOUVEAU_BO_VRAM | NOUVEAU_BO_RDWR);
}
void
nv20_emit_framebuffer(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *kelvin = context_eng3d(ctx);
- struct nouveau_bo_context *bctx = context_bctx(ctx, FRAMEBUFFER);
+ struct nouveau_pushbuf *push = context_push(ctx);
struct gl_framebuffer *fb = ctx->DrawBuffer;
struct nouveau_surface *s;
unsigned rt_format = NV20_3D_RT_FORMAT_TYPE_LINEAR;
if (fb->_Status != GL_FRAMEBUFFER_COMPLETE_EXT)
return;
+ PUSH_RESET(push, BUFCTX_FB);
+
/* Render target */
if (fb->_ColorDrawBuffers[0]) {
s = &to_nouveau_renderbuffer(
rt_format |= get_rt_format(s->format);
rt_pitch = s->pitch;
- nouveau_bo_markl(bctx, kelvin, NV20_3D_COLOR_OFFSET,
+ BEGIN_NV04(push, NV20_3D(COLOR_OFFSET), 1);
+ PUSH_MTHDl(push, NV20_3D(COLOR_OFFSET), BUFCTX_FB,
s->bo, 0, bo_flags);
}
rt_format |= get_rt_format(s->format);
zeta_pitch = s->pitch;
- nouveau_bo_markl(bctx, kelvin, NV20_3D_ZETA_OFFSET,
+ BEGIN_NV04(push, NV20_3D(ZETA_OFFSET), 1);
+ PUSH_MTHDl(push, NV20_3D(ZETA_OFFSET), BUFCTX_FB,
s->bo, 0, bo_flags);
if (context_chipset(ctx) >= 0x25)
zeta_pitch = rt_pitch;
}
- BEGIN_RING(chan, kelvin, NV20_3D_RT_FORMAT, 2);
- OUT_RING(chan, rt_format);
- OUT_RING(chan, zeta_pitch << 16 | rt_pitch);
+ BEGIN_NV04(push, NV20_3D(RT_FORMAT), 2);
+ PUSH_DATA (push, rt_format);
+ PUSH_DATA (push, zeta_pitch << 16 | rt_pitch);
/* Recompute the viewport/scissor state. */
context_dirty(ctx, VIEWPORT);
void
nv20_emit_viewport(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *kelvin = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
struct gl_framebuffer *fb = ctx->DrawBuffer;
float a[4] = {};
get_viewport_translate(ctx, a);
- BEGIN_RING(chan, kelvin, NV20_3D_VIEWPORT_TRANSLATE_X, 4);
- OUT_RINGp(chan, a, 4);
+ BEGIN_NV04(push, NV20_3D(VIEWPORT_TRANSLATE_X), 4);
+ PUSH_DATAp(push, a, 4);
- BEGIN_RING(chan, kelvin, NV20_3D_VIEWPORT_CLIP_HORIZ(0), 1);
- OUT_RING(chan, (fb->Width - 1) << 16);
- BEGIN_RING(chan, kelvin, NV20_3D_VIEWPORT_CLIP_VERT(0), 1);
- OUT_RING(chan, (fb->Height - 1) << 16);
+ BEGIN_NV04(push, NV20_3D(VIEWPORT_CLIP_HORIZ(0)), 1);
+ PUSH_DATA (push, (fb->Width - 1) << 16);
+ BEGIN_NV04(push, NV20_3D(VIEWPORT_CLIP_VERT(0)), 1);
+ PUSH_DATA (push, (fb->Height - 1) << 16);
context_dirty(ctx, PROJECTION);
}
nv20_emit_tex_env(struct gl_context *ctx, int emit)
{
const int i = emit - NOUVEAU_STATE_TEX_ENV0;
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *kelvin = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
uint32_t a_in, a_out, c_in, c_out, k;
nv10_get_general_combiner(ctx, i, &a_in, &a_out, &c_in, &c_out, &k);
- BEGIN_RING(chan, kelvin, NV20_3D_RC_IN_ALPHA(i), 1);
- OUT_RING(chan, a_in);
- BEGIN_RING(chan, kelvin, NV20_3D_RC_OUT_ALPHA(i), 1);
- OUT_RING(chan, a_out);
- BEGIN_RING(chan, kelvin, NV20_3D_RC_IN_RGB(i), 1);
- OUT_RING(chan, c_in);
- BEGIN_RING(chan, kelvin, NV20_3D_RC_OUT_RGB(i), 1);
- OUT_RING(chan, c_out);
- BEGIN_RING(chan, kelvin, NV20_3D_RC_CONSTANT_COLOR0(i), 1);
- OUT_RING(chan, k);
+ BEGIN_NV04(push, NV20_3D(RC_IN_ALPHA(i)), 1);
+ PUSH_DATA (push, a_in);
+ BEGIN_NV04(push, NV20_3D(RC_OUT_ALPHA(i)), 1);
+ PUSH_DATA (push, a_out);
+ BEGIN_NV04(push, NV20_3D(RC_IN_RGB(i)), 1);
+ PUSH_DATA (push, c_in);
+ BEGIN_NV04(push, NV20_3D(RC_OUT_RGB(i)), 1);
+ PUSH_DATA (push, c_out);
+ BEGIN_NV04(push, NV20_3D(RC_CONSTANT_COLOR0(i)), 1);
+ PUSH_DATA (push, k);
context_dirty(ctx, FRAG);
}
void
nv20_emit_frag(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *kelvin = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
uint64_t in;
int n;
nv10_get_final_combiner(ctx, &in, &n);
- BEGIN_RING(chan, kelvin, NV20_3D_RC_FINAL0, 2);
- OUT_RING(chan, in);
- OUT_RING(chan, in >> 32);
+ BEGIN_NV04(push, NV20_3D(RC_FINAL0), 2);
+ PUSH_DATA (push, in);
+ PUSH_DATA (push, in >> 32);
- BEGIN_RING(chan, kelvin, NV20_3D_RC_ENABLE, 1);
- OUT_RING(chan, n);
+ BEGIN_NV04(push, NV20_3D(RC_ENABLE), 1);
+ PUSH_DATA (push, n);
}
void
nv20_emit_point_mode(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *kelvin = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
- BEGIN_RING(chan, kelvin, NV20_3D_POINT_SIZE, 1);
+ BEGIN_NV04(push, NV20_3D(POINT_SIZE), 1);
if (context_chipset(ctx) >= 0x25)
- OUT_RINGf(chan, ctx->Point.Size);
+ PUSH_DATAf(push, ctx->Point.Size);
else
- OUT_RING(chan, (uint32_t)(ctx->Point.Size * 8));
+ PUSH_DATA (push, (uint32_t)(ctx->Point.Size * 8));
}
void
nv20_emit_logic_opcode(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *kelvin = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
- BEGIN_RING(chan, kelvin, NV20_3D_COLOR_LOGIC_OP_ENABLE, 2);
- OUT_RINGb(chan, ctx->Color.ColorLogicOpEnabled);
- OUT_RING(chan, nvgl_logicop_func(ctx->Color.LogicOp));
+ BEGIN_NV04(push, NV20_3D(COLOR_LOGIC_OP_ENABLE), 2);
+ PUSH_DATAb(push, ctx->Color.ColorLogicOpEnabled);
+ PUSH_DATA (push, nvgl_logicop_func(ctx->Color.LogicOp));
}
{
const int i = emit - NOUVEAU_STATE_TEX_GEN0;
struct nouveau_context *nctx = to_nouveau_context(ctx);
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *kelvin = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
struct gl_texture_unit *unit = &ctx->Texture.Unit[i];
int j;
float *k = get_texgen_coeff(coord);
if (k) {
- BEGIN_RING(chan, kelvin,
- NV20_3D_TEX_GEN_COEFF(i, j), 4);
- OUT_RINGp(chan, k, 4);
+ BEGIN_NV04(push, NV20_3D(TEX_GEN_COEFF(i, j)), 4);
+ PUSH_DATAp(push, k, 4);
}
- BEGIN_RING(chan, kelvin, NV20_3D_TEX_GEN_MODE(i, j), 1);
- OUT_RING(chan, nvgl_texgen_mode(coord->Mode));
+ BEGIN_NV04(push, NV20_3D(TEX_GEN_MODE(i, j)), 1);
+ PUSH_DATA (push, nvgl_texgen_mode(coord->Mode));
} else {
- BEGIN_RING(chan, kelvin, NV20_3D_TEX_GEN_MODE(i, j), 1);
- OUT_RING(chan, 0);
+ BEGIN_NV04(push, NV20_3D(TEX_GEN_MODE(i, j)), 1);
+ PUSH_DATA (push, 0);
}
}
}
{
const int i = emit - NOUVEAU_STATE_TEX_MAT0;
struct nouveau_context *nctx = to_nouveau_context(ctx);
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *kelvin = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
if (nctx->fallback == HWTNL &&
(ctx->Texture._TexMatEnabled & 1 << i)) {
- BEGIN_RING(chan, kelvin, NV20_3D_TEX_MATRIX_ENABLE(i), 1);
- OUT_RING(chan, 1);
+ BEGIN_NV04(push, NV20_3D(TEX_MATRIX_ENABLE(i)), 1);
+ PUSH_DATA (push, 1);
- BEGIN_RING(chan, kelvin, NV20_3D_TEX_MATRIX(i,0), 16);
- OUT_RINGm(chan, ctx->TextureMatrixStack[i].Top->m);
+ BEGIN_NV04(push, NV20_3D(TEX_MATRIX(i,0)), 16);
+ PUSH_DATAm(push, ctx->TextureMatrixStack[i].Top->m);
} else {
- BEGIN_RING(chan, kelvin, NV20_3D_TEX_MATRIX_ENABLE(i), 1);
- OUT_RING(chan, 0);
+ BEGIN_NV04(push, NV20_3D(TEX_MATRIX_ENABLE(i)), 1);
+ PUSH_DATA (push, 0);
}
}
nv20_emit_tex_obj(struct gl_context *ctx, int emit)
{
const int i = emit - NOUVEAU_STATE_TEX_OBJ0;
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *kelvin = context_eng3d(ctx);
- struct nouveau_bo_context *bctx = context_bctx_i(ctx, TEXTURE, i);
+ struct nouveau_pushbuf *push = context_push(ctx);
const int bo_flags = NOUVEAU_BO_RD | NOUVEAU_BO_GART | NOUVEAU_BO_VRAM;
struct gl_texture_object *t;
struct nouveau_surface *s;
struct gl_texture_image *ti;
uint32_t tx_format, tx_filter, tx_wrap, tx_enable;
+ PUSH_RESET(push, BUFCTX_TEX(i));
+
if (!ctx->Texture.Unit[i]._ReallyEnabled) {
- BEGIN_RING(chan, kelvin, NV20_3D_TEX_ENABLE(i), 1);
- OUT_RING(chan, 0);
+ BEGIN_NV04(push, NV20_3D(TEX_ENABLE(i)), 1);
+ PUSH_DATA (push, 0);
context_dirty(ctx, TEX_SHADER);
return;
| log2i(t->Sampler.MaxAnisotropy) << 4;
if (t->Target == GL_TEXTURE_RECTANGLE) {
- BEGIN_RING(chan, kelvin, NV20_3D_TEX_NPOT_PITCH(i), 1);
- OUT_RING(chan, s->pitch << 16);
- BEGIN_RING(chan, kelvin, NV20_3D_TEX_NPOT_SIZE(i), 1);
- OUT_RING(chan, s->width << 16 | s->height);
+ BEGIN_NV04(push, NV20_3D(TEX_NPOT_PITCH(i)), 1);
+ PUSH_DATA (push, s->pitch << 16);
+ BEGIN_NV04(push, NV20_3D(TEX_NPOT_SIZE(i)), 1);
+ PUSH_DATA (push, s->width << 16 | s->height);
tx_format |= get_tex_format_rect(ti);
} else {
}
/* Write it to the hardware. */
- nouveau_bo_mark(bctx, kelvin, NV20_3D_TEX_FORMAT(i),
- s->bo, tx_format, 0,
- NV20_3D_TEX_FORMAT_DMA0,
- NV20_3D_TEX_FORMAT_DMA1,
- bo_flags | NOUVEAU_BO_OR);
-
- nouveau_bo_markl(bctx, kelvin, NV20_3D_TEX_OFFSET(i),
+ BEGIN_NV04(push, NV20_3D(TEX_FORMAT(i)), 1);
+ PUSH_MTHD (push, NV20_3D(TEX_FORMAT(i)), BUFCTX_TEX(i),
+ s->bo, tx_format, bo_flags | NOUVEAU_BO_OR,
+ NV20_3D_TEX_FORMAT_DMA0,
+ NV20_3D_TEX_FORMAT_DMA1);
+
+ BEGIN_NV04(push, NV20_3D(TEX_OFFSET(i)), 1);
+ PUSH_MTHDl(push, NV20_3D(TEX_OFFSET(i)), BUFCTX_TEX(i),
s->bo, s->offset, bo_flags);
- BEGIN_RING(chan, kelvin, NV20_3D_TEX_WRAP(i), 1);
- OUT_RING(chan, tx_wrap);
+ BEGIN_NV04(push, NV20_3D(TEX_WRAP(i)), 1);
+ PUSH_DATA (push, tx_wrap);
- BEGIN_RING(chan, kelvin, NV20_3D_TEX_FILTER(i), 1);
- OUT_RING(chan, tx_filter);
+ BEGIN_NV04(push, NV20_3D(TEX_FILTER(i)), 1);
+ PUSH_DATA (push, tx_filter);
- BEGIN_RING(chan, kelvin, NV20_3D_TEX_ENABLE(i), 1);
- OUT_RING(chan, tx_enable);
+ BEGIN_NV04(push, NV20_3D(TEX_ENABLE(i)), 1);
+ PUSH_DATA (push, tx_enable);
context_dirty(ctx, TEX_SHADER);
}
void
nv20_emit_tex_shader(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *kelvin = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
uint32_t tx_shader_op = 0;
int i;
tx_shader_op |= NV20_3D_TEX_SHADER_OP_TX0_TEXTURE_2D << 5 * i;
}
- BEGIN_RING(chan, kelvin, NV20_3D_TEX_SHADER_OP, 1);
- OUT_RING(chan, tx_shader_op);
+ BEGIN_NV04(push, NV20_3D(TEX_SHADER_OP), 1);
+ PUSH_DATA (push, tx_shader_op);
}
void
nv20_emit_color_material(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *kelvin = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
unsigned mask = get_material_bitmask(ctx->Light.ColorMaterialBitmask);
- BEGIN_RING(chan, kelvin, NV20_3D_COLOR_MATERIAL, 1);
- OUT_RING(chan, ctx->Light.ColorMaterialEnabled ? mask : 0);
+ BEGIN_NV04(push, NV20_3D(COLOR_MATERIAL), 1);
+ PUSH_DATA (push, ctx->Light.ColorMaterialEnabled ? mask : 0);
}
static unsigned
nv20_emit_fog(struct gl_context *ctx, int emit)
{
struct nouveau_context *nctx = to_nouveau_context(ctx);
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *kelvin = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
struct gl_fog_attrib *f = &ctx->Fog;
unsigned source = nctx->fallback == HWTNL ?
f->FogCoordinateSource : GL_FOG_COORDINATE_EXT;
nv10_get_fog_coeff(ctx, k);
- BEGIN_RING(chan, kelvin, NV20_3D_FOG_MODE, 4);
- OUT_RING(chan, ((source == GL_FRAGMENT_DEPTH_EXT &&
+ BEGIN_NV04(push, NV20_3D(FOG_MODE), 4);
+ PUSH_DATA (push, ((source == GL_FRAGMENT_DEPTH_EXT &&
f->FogDistanceMode == GL_EYE_PLANE_ABSOLUTE_NV) ?
get_fog_mode_unsigned(f->Mode) :
get_fog_mode_signed(f->Mode)));
- OUT_RING(chan, get_fog_source(source, f->FogDistanceMode));
- OUT_RINGb(chan, f->Enabled);
- OUT_RING(chan, pack_rgba_f(MESA_FORMAT_RGBA8888_REV, f->Color));
+ PUSH_DATA (push, get_fog_source(source, f->FogDistanceMode));
+ PUSH_DATAb(push, f->Enabled);
+ PUSH_DATA (push, pack_rgba_f(MESA_FORMAT_RGBA8888_REV, f->Color));
- BEGIN_RING(chan, kelvin, NV20_3D_FOG_COEFF(0), 3);
- OUT_RINGp(chan, k, 3);
+ BEGIN_NV04(push, NV20_3D(FOG_COEFF(0)), 3);
+ PUSH_DATAp(push, k, 3);
}
void
nv20_emit_light_model(struct gl_context *ctx, int emit)
{
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *kelvin = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
struct gl_lightmodel *m = &ctx->Light.Model;
- BEGIN_RING(chan, kelvin, NV20_3D_SEPARATE_SPECULAR_ENABLE, 1);
- OUT_RINGb(chan, m->ColorControl == GL_SEPARATE_SPECULAR_COLOR);
+ BEGIN_NV04(push, NV20_3D(SEPARATE_SPECULAR_ENABLE), 1);
+ PUSH_DATAb(push, m->ColorControl == GL_SEPARATE_SPECULAR_COLOR);
- BEGIN_RING(chan, kelvin, NV20_3D_LIGHT_MODEL, 1);
- OUT_RING(chan, ((m->LocalViewer ?
+ BEGIN_NV04(push, NV20_3D(LIGHT_MODEL), 1);
+ PUSH_DATA (push, ((m->LocalViewer ?
NV20_3D_LIGHT_MODEL_VIEWER_LOCAL :
NV20_3D_LIGHT_MODEL_VIEWER_NONLOCAL) |
(_mesa_need_secondary_color(ctx) ?
NV20_3D_LIGHT_MODEL_SEPARATE_SPECULAR :
0)));
- BEGIN_RING(chan, kelvin, NV20_3D_LIGHT_MODEL_TWO_SIDE_ENABLE, 1);
- OUT_RINGb(chan, ctx->Light.Model.TwoSide);
+ BEGIN_NV04(push, NV20_3D(LIGHT_MODEL_TWO_SIDE_ENABLE), 1);
+ PUSH_DATAb(push, ctx->Light.Model.TwoSide);
}
void
nv20_emit_light_source(struct gl_context *ctx, int emit)
{
const int i = emit - NOUVEAU_STATE_LIGHT_SOURCE0;
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *kelvin = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
struct gl_light *l = &ctx->Light.Light[i];
if (l->_Flags & LIGHT_POSITIONAL) {
- BEGIN_RING(chan, kelvin, NV20_3D_LIGHT_POSITION_X(i), 3);
- OUT_RINGp(chan, l->_Position, 3);
+ BEGIN_NV04(push, NV20_3D(LIGHT_POSITION_X(i)), 3);
+ PUSH_DATAp(push, l->_Position, 3);
- BEGIN_RING(chan, kelvin, NV20_3D_LIGHT_ATTENUATION_CONSTANT(i), 3);
- OUT_RINGf(chan, l->ConstantAttenuation);
- OUT_RINGf(chan, l->LinearAttenuation);
- OUT_RINGf(chan, l->QuadraticAttenuation);
+ BEGIN_NV04(push, NV20_3D(LIGHT_ATTENUATION_CONSTANT(i)), 3);
+ PUSH_DATAf(push, l->ConstantAttenuation);
+ PUSH_DATAf(push, l->LinearAttenuation);
+ PUSH_DATAf(push, l->QuadraticAttenuation);
} else {
- BEGIN_RING(chan, kelvin, NV20_3D_LIGHT_DIRECTION_X(i), 3);
- OUT_RINGp(chan, l->_VP_inf_norm, 3);
+ BEGIN_NV04(push, NV20_3D(LIGHT_DIRECTION_X(i)), 3);
+ PUSH_DATAp(push, l->_VP_inf_norm, 3);
- BEGIN_RING(chan, kelvin, NV20_3D_LIGHT_HALF_VECTOR_X(i), 3);
- OUT_RINGp(chan, l->_h_inf_norm, 3);
+ BEGIN_NV04(push, NV20_3D(LIGHT_HALF_VECTOR_X(i)), 3);
+ PUSH_DATAp(push, l->_h_inf_norm, 3);
}
if (l->_Flags & LIGHT_SPOT) {
nv10_get_spot_coeff(l, k);
- BEGIN_RING(chan, kelvin, NV20_3D_LIGHT_SPOT_CUTOFF(i, 0), 7);
- OUT_RINGp(chan, k, 7);
+ BEGIN_NV04(push, NV20_3D(LIGHT_SPOT_CUTOFF(i, 0)), 7);
+ PUSH_DATAp(push, k, 7);
}
}
nv20_emit_material_ambient(struct gl_context *ctx, int emit)
{
const int side = emit - NOUVEAU_STATE_MATERIAL_FRONT_AMBIENT;
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *kelvin = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
float (*mat)[4] = ctx->Light.Material.Attrib;
float c_scene[3], c_factor[3];
struct gl_light *l;
ZERO_3V(c_factor);
}
- BEGIN_RING(chan, kelvin, LIGHT_MODEL_AMBIENT_R(side), 3);
- OUT_RINGp(chan, c_scene, 3);
+ BEGIN_NV04(push, SUBC_3D(LIGHT_MODEL_AMBIENT_R(side)), 3);
+ PUSH_DATAp(push, c_scene, 3);
if (ctx->Light.ColorMaterialEnabled) {
- BEGIN_RING(chan, kelvin, MATERIAL_FACTOR_R(side), 3);
- OUT_RINGp(chan, c_factor, 3);
+ BEGIN_NV04(push, SUBC_3D(MATERIAL_FACTOR_R(side)), 3);
+ PUSH_DATAp(push, c_factor, 3);
}
foreach(l, &ctx->Light.EnabledList) {
l->Ambient :
l->_MatAmbient[side]);
- BEGIN_RING(chan, kelvin, LIGHT_AMBIENT_R(side, i), 3);
- OUT_RINGp(chan, c_light, 3);
+ BEGIN_NV04(push, SUBC_3D(LIGHT_AMBIENT_R(side, i)), 3);
+ PUSH_DATAp(push, c_light, 3);
}
}
nv20_emit_material_diffuse(struct gl_context *ctx, int emit)
{
const int side = emit - NOUVEAU_STATE_MATERIAL_FRONT_DIFFUSE;
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *kelvin = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
GLfloat (*mat)[4] = ctx->Light.Material.Attrib;
struct gl_light *l;
- BEGIN_RING(chan, kelvin, MATERIAL_FACTOR_A(side), 1);
- OUT_RINGf(chan, mat[MAT_ATTRIB_DIFFUSE(side)][3]);
+ BEGIN_NV04(push, SUBC_3D(MATERIAL_FACTOR_A(side)), 1);
+ PUSH_DATAf(push, mat[MAT_ATTRIB_DIFFUSE(side)][3]);
foreach(l, &ctx->Light.EnabledList) {
const int i = l - ctx->Light.Light;
l->Diffuse :
l->_MatDiffuse[side]);
- BEGIN_RING(chan, kelvin, LIGHT_DIFFUSE_R(side, i), 3);
- OUT_RINGp(chan, c_light, 3);
+ BEGIN_NV04(push, SUBC_3D(LIGHT_DIFFUSE_R(side, i)), 3);
+ PUSH_DATAp(push, c_light, 3);
}
}
nv20_emit_material_specular(struct gl_context *ctx, int emit)
{
const int side = emit - NOUVEAU_STATE_MATERIAL_FRONT_SPECULAR;
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *kelvin = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
struct gl_light *l;
foreach(l, &ctx->Light.EnabledList) {
l->Specular :
l->_MatSpecular[side]);
- BEGIN_RING(chan, kelvin, LIGHT_SPECULAR_R(side, i), 3);
- OUT_RINGp(chan, c_light, 3);
+ BEGIN_NV04(push, SUBC_3D(LIGHT_SPECULAR_R(side, i)), 3);
+ PUSH_DATAp(push, c_light, 3);
}
}
nv20_emit_material_shininess(struct gl_context *ctx, int emit)
{
const int side = emit - NOUVEAU_STATE_MATERIAL_FRONT_SHININESS;
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *kelvin = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
float (*mat)[4] = ctx->Light.Material.Attrib;
float k[6];
CLAMP(mat[MAT_ATTRIB_SHININESS(side)][0], 0, 1024),
k);
- BEGIN_RING(chan, kelvin, MATERIAL_SHININESS(side), 6);
- OUT_RINGp(chan, k, 6);
+ BEGIN_NV04(push, SUBC_3D(MATERIAL_SHININESS(side)), 6);
+ PUSH_DATAp(push, k, 6);
}
void
nv20_emit_modelview(struct gl_context *ctx, int emit)
{
struct nouveau_context *nctx = to_nouveau_context(ctx);
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *kelvin = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
GLmatrix *m = ctx->ModelviewMatrixStack.Top;
if (nctx->fallback != HWTNL)
if (ctx->Light._NeedEyeCoords || ctx->Fog.Enabled ||
(ctx->Texture._GenFlags & TEXGEN_NEED_EYE_COORD)) {
- BEGIN_RING(chan, kelvin, NV20_3D_MODELVIEW_MATRIX(0, 0), 16);
- OUT_RINGm(chan, m->m);
+ BEGIN_NV04(push, NV20_3D(MODELVIEW_MATRIX(0, 0)), 16);
+ PUSH_DATAm(push, m->m);
}
if (ctx->Light.Enabled ||
(ctx->Texture._GenFlags & TEXGEN_NEED_EYE_COORD)) {
int i, j;
- BEGIN_RING(chan, kelvin,
- NV20_3D_INVERSE_MODELVIEW_MATRIX(0, 0), 12);
+ BEGIN_NV04(push, NV20_3D(INVERSE_MODELVIEW_MATRIX(0, 0)), 12);
for (i = 0; i < 3; i++)
for (j = 0; j < 4; j++)
- OUT_RINGf(chan, m->inv[4*i + j]);
+ PUSH_DATAf(push, m->inv[4*i + j]);
}
}
nv20_emit_projection(struct gl_context *ctx, int emit)
{
struct nouveau_context *nctx = to_nouveau_context(ctx);
- struct nouveau_channel *chan = context_chan(ctx);
- struct nouveau_grobj *kelvin = context_eng3d(ctx);
+ struct nouveau_pushbuf *push = context_push(ctx);
GLmatrix m;
_math_matrix_ctr(&m);
if (nctx->fallback == HWTNL)
_math_matrix_mul_matrix(&m, &m, &ctx->_ModelProjectMatrix);
- BEGIN_RING(chan, kelvin, NV20_3D_PROJECTION_MATRIX(0), 16);
- OUT_RINGm(chan, m.m);
+ BEGIN_NV04(push, NV20_3D(PROJECTION_MATRIX(0)), 16);
+ PUSH_DATAm(push, m.m);
_math_matrix_dtr(&m);
}
-#ifndef NV_OBJECT_XML
-#define NV_OBJECT_XML
+#ifndef _HOME_SKEGGSB_GIT_ENVYTOOLS_RNNDB_NV_OBJECT_XML
+#define _HOME_SKEGGSB_GIT_ENVYTOOLS_RNNDB_NV_OBJECT_XML
+
+/* WARNING ABOUT NOT EDITING AUTOGENERATED FILE IGNORED, _CLASS SUFFIX HAS
+ * BEEN ADDED TO ALL THE OBJECT CLASS DEFINITIONS TO AVOID CONFLICTS WITH
+ * THE RING MACROS WE WANT TO USE
+ */
/* Autogenerated file, DO NOT EDIT manually!
git clone git://0x04.net/rules-ng-ng
The rules-ng-ng source files this header was generated from are:
-- nv_object.xml ( 11547 bytes, from 2010-11-13 23:32:57)
-- copyright.xml ( 6452 bytes, from 2010-11-15 15:10:58)
-- nvchipsets.xml ( 3074 bytes, from 2010-11-13 23:32:57)
-- nv_defs.xml ( 4437 bytes, from 2010-11-01 00:28:46)
+- /home/skeggsb/git/envytools/rnndb/nv_object.xml ( 12672 bytes, from 2011-10-22 08:01:09)
+- /home/skeggsb/git/envytools/rnndb/copyright.xml ( 6452 bytes, from 2011-10-22 08:01:09)
+- /home/skeggsb/git/envytools/rnndb/nvchipsets.xml ( 3617 bytes, from 2011-10-22 08:01:09)
+- /home/skeggsb/git/envytools/rnndb/nv_defs.xml ( 4437 bytes, from 2011-10-22 08:01:09)
+- /home/skeggsb/git/envytools/rnndb/nv50_defs.xml ( 5468 bytes, from 2011-10-22 08:01:09)
-Copyright (C) 2006-2010 by the following authors:
+Copyright (C) 2006-2011 by the following authors:
- Artur Huillet <arthur.huillet@free.fr> (ahuillet)
- Ben Skeggs (darktama, darktama_)
- B. R. <koala_br@users.sourceforge.net> (koala_br)
*/
-#define NV01_ROOT 0x00000001
-#define NV01_CONTEXT_DMA 0x00000002
-#define NV01_DEVICE 0x00000003
-#define NV01_TIMER 0x00000004
-#define NV01_NULL 0x00000030
-#define NV01_MEMORY_LOCAL_BANKED 0x0000003d
-#define NV01_MAPPING_SYSTEM 0x0000003e
-#define NV03_MEMORY_LOCAL_CURSOR 0x0000003f
-#define NV01_MEMORY_LOCAL_LINEAR 0x00000040
-#define NV01_MAPPING_LOCAL 0x00000041
-#define NV03_VIDEO_LUT_CURSOR_DAC 0x00000046
-#define NV03_CHANNEL_PIO 0x0000006a
-#define NV03_CHANNEL_DMA 0x0000006b
-#define NV10_VIDEO_DISPLAY 0x0000007c
-#define NV01_CONTEXT_BETA1 0x00000012
-#define NV04_BETA_SOLID 0x00000072
-#define NV01_CONTEXT_COLOR_KEY 0x00000017
-#define NV04_CONTEXT_COLOR_KEY 0x00000057
-#define NV01_CONTEXT_PATTERN 0x00000018
-#define NV01_CONTEXT_CLIP_RECTANGLE 0x00000019
-#define NV03_CONTEXT_ROP 0x00000043
-#define NV04_IMAGE_PATTERN 0x00000044
-#define NV01_RENDER_SOLID_LINE 0x0000001c
-#define NV04_RENDER_SOLID_LINE 0x0000005c
-#define NV30_RENDER_SOLID_LINE 0x0000035c
-#define NV40_RENDER_SOLID_LINE 0x0000305c
-#define NV01_RENDER_SOLID_TRIANGLE 0x0000001d
-#define NV04_RENDER_SOLID_TRIANGLE 0x0000005d
-#define NV01_RENDER_SOLID_RECTANGLE 0x0000001e
-#define NV04_RENDER_SOLID_RECTANGLE 0x0000005e
-#define NV01_IMAGE_BLIT 0x0000001f
-#define NV04_IMAGE_BLIT 0x0000005f
-#define NV11_IMAGE_BLIT 0x0000009f
-#define NV01_IMAGE_FROM_CPU 0x00000021
-#define NV04_IMAGE_FROM_CPU 0x00000061
-#define NV05_IMAGE_FROM_CPU 0x00000065
-#define NV10_IMAGE_FROM_CPU 0x0000008a
-#define NV30_IMAGE_FROM_CPU 0x0000038a
-#define NV40_IMAGE_FROM_CPU 0x0000308a
-#define NV03_STRETCHED_IMAGE_FROM_CPU 0x00000036
-#define NV04_STRETCHED_IMAGE_FROM_CPU 0x00000076
-#define NV05_STRETCHED_IMAGE_FROM_CPU 0x00000066
-#define NV30_STRETCHED_IMAGE_FROM_CPU 0x00000366
-#define NV40_STRETCHED_IMAGE_FROM_CPU 0x00003066
-#define NV03_SCALED_IMAGE_FROM_MEMORY 0x00000037
-#define NV04_SCALED_IMAGE_FROM_MEMORY 0x00000077
-#define NV05_SCALED_IMAGE_FROM_MEMORY 0x00000063
-#define NV10_SCALED_IMAGE_FROM_MEMORY 0x00000089
-#define NV30_SCALED_IMAGE_FROM_MEMORY 0x00000389
-#define NV40_SCALED_IMAGE_FROM_MEMORY 0x00003089
-#define NV50_SCALED_IMAGE_FROM_MEMORY 0x00005089
-#define NV04_DVD_SUBPICTURE 0x00000038
-#define NV10_DVD_SUBPICTURE 0x00000088
-#define NV03_GDI_RECTANGLE_TEXT 0x0000004b
-#define NV04_GDI_RECTANGLE_TEXT 0x0000004a
-#define NV04_SWIZZLED_SURFACE 0x00000052
-#define NV20_SWIZZLED_SURFACE 0x0000009e
-#define NV30_SWIZZLED_SURFACE 0x0000039e
-#define NV40_SWIZZLED_SURFACE 0x0000309e
-#define NV03_CONTEXT_SURFACE_DST 0x00000058
-#define NV03_CONTEXT_SURFACE_SRC 0x00000059
-#define NV04_CONTEXT_SURFACES_2D 0x00000042
-#define NV10_CONTEXT_SURFACES_2D 0x00000062
-#define NV30_CONTEXT_SURFACES_2D 0x00000362
-#define NV40_CONTEXT_SURFACES_2D 0x00003062
-#define NV50_CONTEXT_SURFACES_2D 0x00005062
-#define NV04_INDEXED_IMAGE_FROM_CPU 0x00000060
-#define NV05_INDEXED_IMAGE_FROM_CPU 0x00000064
-#define NV30_INDEXED_IMAGE_FROM_CPU 0x00000364
-#define NV40_INDEXED_IMAGE_FROM_CPU 0x00003064
-#define NV10_TEXTURE_FROM_CPU 0x0000007b
-#define NV30_TEXTURE_FROM_CPU 0x0000037b
-#define NV40_TEXTURE_FROM_CPU 0x0000307b
-#define NV04_M2MF 0x00000039
-#define NV50_M2MF 0x00005039
-#define NVC0_M2MF 0x00009039
-#define NV03_TEXTURED_TRIANGLE 0x00000048
-#define NV04_TEXTURED_TRIANGLE 0x00000054
-#define NV10_TEXTURED_TRIANGLE 0x00000094
-#define NV04_MULTITEX_TRIANGLE 0x00000055
-#define NV10_MULTITEX_TRIANGLE 0x00000095
-#define NV03_CONTEXT_SURFACE_COLOR 0x0000005a
-#define NV03_CONTEXT_SURFACE_ZETA 0x0000005b
-#define NV04_CONTEXT_SURFACES_3D 0x00000053
-#define NV10_CONTEXT_SURFACES_3D 0x00000093
-#define NV10_3D 0x00000056
-#define NV11_3D 0x00000096
-#define NV17_3D 0x00000099
-#define NV20_3D 0x00000097
-#define NV25_3D 0x00000597
-#define NV30_3D 0x00000397
-#define NV35_3D 0x00000497
-#define NV34_3D 0x00000697
-#define NV40_3D 0x00004097
-#define NV44_3D 0x00004497
-#define NV50_3D 0x00005097
-#define NV84_3D 0x00008297
-#define NVA0_3D 0x00008397
-#define NVA3_3D 0x00008597
-#define NVAF_3D 0x00008697
-#define NVC0_3D 0x00009097
-#define NV50_2D 0x0000502d
-#define NVC0_2D 0x0000902d
-#define NV50_COMPUTE 0x000050c0
-#define NVA3_COMPUTE 0x000085c0
-#define NVC0_COMPUTE 0x000090c0
-#define NV84_CRYPT 0x000074c1
-#define NV01_SUBCHAN__SIZE 0x00002000
+#define NV01_DMA_FROM_MEMORY_CLASS 0x00000002
+#define NV01_DMA_TO_MEMORY_CLASS 0x00000003
+#define NV01_NULL_CLASS 0x00000030
+#define NV03_DMA_IN_MEMORY_CLASS 0x0000003d
+#define NV01_OP_CLIP_CLASS 0x00000010
+#define NV01_OP_BLEND_AND_CLASS 0x00000011
+#define NV01_BETA_CLASS 0x00000012
+#define NV04_BETA4_CLASS 0x00000072
+#define NV01_OP_ROP_AND_CLASS 0x00000013
+#define NV01_ROP_CLASS 0x00000014
+#define NV03_ROP_CLASS 0x00000043
+#define NV01_OP_CHROMA_CLASS 0x00000015
+#define NV01_OP_PLANE_SWITCH_CLASS 0x00000016
+#define NV01_CHROMA_CLASS 0x00000017
+#define NV04_CHROMA_CLASS 0x00000057
+#define NV01_PATTERN_CLASS 0x00000018
+#define NV04_PATTERN_CLASS 0x00000044
+#define NV01_CLIP_CLASS 0x00000019
+#define NV01_OP_SRCCOPY_AND_CLASS 0x00000064
+#define NV03_OP_SRCCOPY_CLASS 0x00000065
+#define NV04_OP_SRCCOPY_PREMULT_CLASS 0x00000066
+#define NV04_OP_BLEND_PREMULT_CLASS 0x00000067
+#define NV01_POINT_CLASS 0x0000001a
+#define NV01_LINE_CLASS 0x0000001b
+#define NV01_LIN_CLASS 0x0000001c
+#define NV04_LIN_CLASS 0x0000005c
+#define NV30_LIN_CLASS 0x0000035c
+#define NV40_LIN_CLASS 0x0000305c
+#define NV01_TRI_CLASS 0x0000001d
+#define NV04_TRI_CLASS 0x0000005d
+#define NV01_RECT_CLASS 0x0000001e
+#define NV04_RECT_CLASS 0x0000005e
+#define NV01_BLIT_CLASS 0x0000001f
+#define NV04_BLIT_CLASS 0x0000005f
+#define NV15_BLIT_CLASS 0x0000009f
+#define NV01_IFROMMEM_CLASS 0x00000020
+#define NV01_IFC_CLASS 0x00000021
+#define NV04_IFC_CLASS 0x00000061
+#define NV05_IFC_CLASS 0x00000065
+#define NV10_IFC_CLASS 0x0000008a
+#define NV30_IFC_CLASS 0x0000038a
+#define NV40_IFC_CLASS 0x0000308a
+#define NV01_BITMAP_CLASS 0x00000022
+#define NV01_ITOMEM_CLASS 0x00000025
+#define NV03_SIFC_CLASS 0x00000036
+#define NV04_SIFC_CLASS 0x00000076
+#define NV05_SIFC_CLASS 0x00000066
+#define NV30_SIFC_CLASS 0x00000366
+#define NV40_SIFC_CLASS 0x00003066
+#define NV03_SIFM_CLASS 0x00000037
+#define NV04_SIFM_CLASS 0x00000077
+#define NV05_SIFM_CLASS 0x00000063
+#define NV10_SIFM_CLASS 0x00000089
+#define NV30_SIFM_CLASS 0x00000389
+#define NV40_SIFM_CLASS 0x00003089
+#define NV50_SIFM_CLASS 0x00005089
+#define NV03_SYFM_CLASS 0x00000038
+#define NV03_GDI_CLASS 0x0000004b
+#define NV04_GDI_CLASS 0x0000004a
+#define NV04_SURFACE_SWZ_CLASS 0x00000052
+#define NV20_SURFACE_SWZ_CLASS 0x0000009e
+#define NV30_SURFACE_SWZ_CLASS 0x0000039e
+#define NV40_SURFACE_SWZ_CLASS 0x0000309e
+#define NV03_SURFACE_DST_CLASS 0x00000058
+#define NV03_SURFACE_SRC_CLASS 0x00000059
+#define NV04_SURFACE_2D_CLASS 0x00000042
+#define NV10_SURFACE_2D_CLASS 0x00000062
+#define NV30_SURFACE_2D_CLASS 0x00000362
+#define NV40_SURFACE_2D_CLASS 0x00003062
+#define NV50_SURFACE_2D_CLASS 0x00005062
+#define NV04_INDEX_CLASS 0x00000060
+#define NV05_INDEX_CLASS 0x00000064
+#define NV30_INDEX_CLASS 0x00000364
+#define NV40_INDEX_CLASS 0x00003064
+#define NV10_TEXUPLOAD_CLASS 0x0000007b
+#define NV30_TEXUPLOAD_CLASS 0x0000037b
+#define NV40_TEXUPLOAD_CLASS 0x0000307b
+#define NV04_DVD_SUBPICTURE_CLASS 0x00000038
+#define NV10_DVD_SUBPICTURE_CLASS 0x00000088
+#define NV03_M2MF_CLASS 0x00000039
+#define NV50_M2MF_CLASS 0x00005039
+#define NVC0_M2MF_CLASS 0x00009039
+#define NV03_SURFACE_COLOR_CLASS 0x0000005a
+#define NV03_SURFACE_ZETA_CLASS 0x0000005b
+#define NV03_TEXTURED_TRIANGLE_CLASS 0x00000048
+#define NV04_TEXTURED_TRIANGLE_CLASS 0x00000054
+#define NV10_TEXTURED_TRIANGLE_CLASS 0x00000094
+#define NV04_SURFACE_3D_CLASS 0x00000053
+#define NV10_SURFACE_3D_CLASS 0x00000093
+#define NV04_MULTITEX_TRIANGLE_CLASS 0x00000055
+#define NV10_MULTITEX_TRIANGLE_CLASS 0x00000095
+#define NV10_3D_CLASS 0x00000056
+#define NV15_3D_CLASS 0x00000096
+#define NV11_3D_CLASS 0x00000098
+#define NV17_3D_CLASS 0x00000099
+#define NV20_3D_CLASS 0x00000097
+#define NV25_3D_CLASS 0x00000597
+#define NV30_3D_CLASS 0x00000397
+#define NV35_3D_CLASS 0x00000497
+#define NV34_3D_CLASS 0x00000697
+#define NV40_3D_CLASS 0x00004097
+#define NV44_3D_CLASS 0x00004497
+#define NV50_3D_CLASS 0x00005097
+#define NV84_3D_CLASS 0x00008297
+#define NVA0_3D_CLASS 0x00008397
+#define NVA3_3D_CLASS 0x00008597
+#define NVAF_3D_CLASS 0x00008697
+#define NVC0_3D_CLASS 0x00009097
+#define NVC1_3D_CLASS 0x00009197
+#define NVC8_3D_CLASS 0x00009297
+#define NV50_2D_CLASS 0x0000502d
+#define NVC0_2D_CLASS 0x0000902d
+#define NV50_COMPUTE_CLASS 0x000050c0
+#define NVA3_COMPUTE_CLASS 0x000085c0
+#define NVC0_COMPUTE_CLASS 0x000090c0
+#define NVC8_COMPUTE_CLASS 0x000092c0
+#define NV84_CRYPT_CLASS 0x000074c1
+#define BLOB_NVC0_PCOPY1_CLASS 0x000090b8
+#define BLOB_NVC0_PCOPY0_CLASS 0x000090b5
+#define NV31_MPEG_CLASS 0x00003174
+#define NV84_MPEG_CLASS 0x00008274
+
+#define NV01_SUBCHAN__SIZE 0x00008000
#define NV01_SUBCHAN 0x00000000
#define NV01_SUBCHAN_OBJECT 0x00000000
-#define NV84_SUBCHAN_QUERY_ADDRESS_HIGH 0x00000010
+#define NV84_SUBCHAN_SEMAPHORE_ADDRESS_HIGH 0x00000010
-#define NV84_SUBCHAN_QUERY_ADDRESS_LOW 0x00000014
+#define NV84_SUBCHAN_SEMAPHORE_ADDRESS_LOW 0x00000014
-#define NV84_SUBCHAN_QUERY_COUNTER 0x00000018
+#define NV84_SUBCHAN_SEMAPHORE_SEQUENCE 0x00000018
-#define NV84_SUBCHAN_QUERY_GET 0x0000001c
+#define NV84_SUBCHAN_SEMAPHORE_TRIGGER 0x0000001c
+#define NV84_SUBCHAN_SEMAPHORE_TRIGGER_ACQUIRE_EQUAL 0x00000001
+#define NV84_SUBCHAN_SEMAPHORE_TRIGGER_WRITE_LONG 0x00000002
+#define NV84_SUBCHAN_SEMAPHORE_TRIGGER_ACQUIRE_GEQUAL 0x00000004
-#define NV84_SUBCHAN_QUERY_INTR 0x00000020
+#define NV84_SUBCHAN_NOTIFY_INTR 0x00000020
#define NV84_SUBCHAN_WRCACHE_FLUSH 0x00000024
#define NV04_GRAPH_NOP 0x00000100
-#define NV01_GRAPH_NOTIFY 0x00000104
-#define NV01_GRAPH_NOTIFY_WRITE 0x00000000
-#define NV01_GRAPH_NOTIFY_WRITE_AND_AWAKEN 0x00000001
-
-#define NV50_GRAPH_WAIT_FOR_IDLE 0x00000110
+#define NV04_GRAPH_NOTIFY 0x00000104
+#define NV04_GRAPH_NOTIFY_WRITE 0x00000000
+#define NV04_GRAPH_NOTIFY_WRITE_AND_AWAKEN 0x00000001
-#define NVA3_GRAPH_UNK0120 0x00000120
+#define NVC0_GRAPH_NOTIFY_ADDRESS_HIGH 0x00000104
-#define NVA3_GRAPH_UNK0124 0x00000124
+#define NVC0_GRAPH_NOTIFY_ADDRESS_LOW 0x00000108
-#define NV40_GRAPH_PM_TRIGGER 0x00000140
+#define NVC0_GRAPH_NOTIFY 0x0000010c
+#define NVC0_GRAPH_NOTIFY_WRITE 0x00000000
+#define NVC0_GRAPH_NOTIFY_WRITE_AND_AWAKEN 0x00000001
-#define NVC0_SUBCHAN__SIZE 0x00008000
-#define NVC0_SUBCHAN 0x00000000
+#define NV50_GRAPH_SERIALIZE 0x00000110
-#define NVC0_SUBCHAN_OBJECT 0x00000000
+#define NVC0_GRAPH_MACRO_UPLOAD_POS 0x00000114
+#define NVC0_GRAPH_MACRO_UPLOAD_DATA 0x00000118
-#define NVC0_SUBCHAN_QUERY_ADDRESS_HIGH 0x00000010
+#define NVC0_GRAPH_MACRO_ID 0x0000011c
-#define NVC0_SUBCHAN_QUERY_ADDRESS_LOW 0x00000014
+#define NVC0_GRAPH_MACRO_POS 0x00000120
-#define NVC0_SUBCHAN_QUERY_SEQUENCE 0x00000018
+#define NVA3_GRAPH_UNK0120 0x00000120
-#define NVC0_SUBCHAN_QUERY_GET 0x0000001c
+#define NVA3_GRAPH_UNK0124 0x00000124
-#define NVC0_SUBCHAN_REF_CNT 0x00000050
+#define NVC0_GRAPH_UNK0124 0x00000124
-#define NVC0_GRAPH 0x00000000
+#define NVC0_GRAPH_COND_ADDRESS_HIGH 0x00000130
-#define NVC0_GRAPH_NOP 0x00000100
+#define NVC0_GRAPH_COND_ADDRESS_LOW 0x00000134
-#define NVC0_GRAPH_NOTIFY_ADDRESS_HIGH 0x00000104
+#define NVC0_GRAPH_COND_MODE 0x00000138
+#define NVC0_GRAPH_COND_MODE_NEVER 0x00000000
+#define NVC0_GRAPH_COND_MODE_ALWAYS 0x00000001
+#define NVC0_GRAPH_COND_MODE_RES_NON_ZERO 0x00000002
+#define NVC0_GRAPH_COND_MODE_EQUAL 0x00000003
+#define NVC0_GRAPH_COND_MODE_NOT_EQUAL 0x00000004
-#define NVC0_GRAPH_NOTIFY_ADDRESS_LOW 0x00000108
+#define NVC0_GRAPH_UNK013C 0x0000013c
-#define NVC0_GRAPH_NOTIFY 0x0000010c
-#define NVC0_GRAPH_NOTIFY_WRITE 0x00000000
-#define NVC0_GRAPH_NOTIFY_WRITE_AND_AWAKEN 0x00000001
+#define NV40_GRAPH_PM_TRIGGER 0x00000140
-#define NVC0_GRAPH_SERIALIZE 0x00000110
+#define NVC0_GRAPH_UNK0150 0x00000150
-#define NVC0_GRAPH_MACRO_UPLOAD_POS 0x00000114
+#define NVC0_GRAPH_UNK0154 0x00000154
-#define NVC0_GRAPH_MACRO_UPLOAD_DATA 0x00000118
+#define NVC0_GRAPH_SCRATCH(i0) (0x00003400 + 0x4*(i0))
+#define NVC0_GRAPH_SCRATCH__ESIZE 0x00000004
+#define NVC0_GRAPH_SCRATCH__LEN 0x00000080
-#define NVC0_GRAPH_MACRO_ID 0x0000011c
+#define NVC0_GRAPH_MACRO(i0) (0x00003800 + 0x8*(i0))
+#define NVC0_GRAPH_MACRO__ESIZE 0x00000008
+#define NVC0_GRAPH_MACRO__LEN 0x00000080
-#define NVC0_GRAPH_MACRO_POS 0x00000120
+#define NVC0_GRAPH_MACRO_PARAM(i0) (0x00003804 + 0x8*(i0))
+#define NVC0_GRAPH_MACRO_PARAM__ESIZE 0x00000008
+#define NVC0_GRAPH_MACRO_PARAM__LEN 0x00000080
-#endif /* NV_OBJECT_XML */
+#endif /* _HOME_SKEGGSB_GIT_ENVYTOOLS_RNNDB_NV_OBJECT_XML */
projects / profile / ivi / mesa.git / commitdiff