X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fdrivers%2Fnouveau%2Fnv50%2Fnv50_context.c;h=7867c2df7f38d6730b4f5f07a5831b9752185dcd;hb=d68226087cf5f2f686d6c8f3377c5a1dec3d8bc4;hp=8183b01cbfbe31ecaf990c131a0d20969c73f213;hpb=6a53b81086bd80ad5a5e79939e0aeb208253026a;p=mesa.git diff --git a/src/gallium/drivers/nouveau/nv50/nv50_context.c b/src/gallium/drivers/nouveau/nv50/nv50_context.c index 8183b01cbfb..7867c2df7f3 100644 --- a/src/gallium/drivers/nouveau/nv50/nv50_context.c +++ b/src/gallium/drivers/nouveau/nv50/nv50_context.c @@ -23,10 +23,6 @@ #include "pipe/p_defines.h" #include "util/u_framebuffer.h" -#ifdef NV50_WITH_DRAW_MODULE -#include "draw/draw_context.h" -#endif - #include "nv50/nv50_context.h" #include "nv50/nv50_screen.h" #include "nv50/nv50_resource.h" @@ -57,6 +53,46 @@ nv50_texture_barrier(struct pipe_context *pipe) PUSH_DATA (push, 0x20); } +static void +nv50_memory_barrier(struct pipe_context *pipe, unsigned flags) +{ + struct nv50_context *nv50 = nv50_context(pipe); + int i, s; + + if (flags & PIPE_BARRIER_MAPPED_BUFFER) { + for (i = 0; i < nv50->num_vtxbufs; ++i) { + if (!nv50->vtxbuf[i].buffer) + continue; + if (nv50->vtxbuf[i].buffer->flags & PIPE_RESOURCE_FLAG_MAP_PERSISTENT) + nv50->base.vbo_dirty = true; + } + + if (nv50->idxbuf.buffer && + nv50->idxbuf.buffer->flags & PIPE_RESOURCE_FLAG_MAP_PERSISTENT) + nv50->base.vbo_dirty = true; + + for (s = 0; s < 3 && !nv50->cb_dirty; ++s) { + uint32_t valid = nv50->constbuf_valid[s]; + + while (valid && !nv50->cb_dirty) { + const unsigned i = ffs(valid) - 1; + struct pipe_resource *res; + + valid &= ~(1 << i); + if (nv50->constbuf[s][i].user) + continue; + + res = nv50->constbuf[s][i].u.buf; + if (!res) + continue; + + if (res->flags & PIPE_RESOURCE_FLAG_MAP_PERSISTENT) + nv50->cb_dirty = true; + } + } + } +} + void nv50_default_kick_notify(struct nouveau_pushbuf *push) { @@ -64,9 +100,9 @@ nv50_default_kick_notify(struct nouveau_pushbuf *push) if (screen) { nouveau_fence_next(&screen->base); - nouveau_fence_update(&screen->base, TRUE); + nouveau_fence_update(&screen->base, true); if (screen->cur_ctx) - screen->cur_ctx->state.flushed = TRUE; + screen->cur_ctx->state.flushed = true; } } @@ -102,20 +138,16 @@ nv50_destroy(struct pipe_context *pipe) { struct nv50_context *nv50 = nv50_context(pipe); - if (nv50_context_screen(nv50)->cur_ctx == nv50) { - nv50->base.pushbuf->kick_notify = NULL; - nv50_context_screen(nv50)->cur_ctx = NULL; - nouveau_pushbuf_bufctx(nv50->base.pushbuf, NULL); + if (nv50->screen->cur_ctx == nv50) { + nv50->screen->cur_ctx = NULL; + /* Save off the state in case another context gets created */ + nv50->screen->save_state = nv50->state; } - /* need to flush before destroying the bufctx */ + nouveau_pushbuf_bufctx(nv50->base.pushbuf, NULL); nouveau_pushbuf_kick(nv50->base.pushbuf, nv50->base.pushbuf->channel); nv50_context_unreference_resources(nv50); -#ifdef NV50_WITH_DRAW_MODULE - draw_destroy(nv50->draw); -#endif - FREE(nv50->blit); nouveau_context_destroy(&nv50->base); @@ -130,6 +162,7 @@ nv50_invalidate_resource_storage(struct nouveau_context *ctx, unsigned s, i; if (res->bind & PIPE_BIND_RENDER_TARGET) { + assert(nv50->framebuffer.nr_cbufs <= PIPE_MAX_COLOR_BUFS); for (i = 0; i < nv50->framebuffer.nr_cbufs; ++i) { if (nv50->framebuffer.cbufs[i] && nv50->framebuffer.cbufs[i]->texture == res) { @@ -150,7 +183,12 @@ nv50_invalidate_resource_storage(struct nouveau_context *ctx, } } - if (res->bind & PIPE_BIND_VERTEX_BUFFER) { + if (res->bind & (PIPE_BIND_VERTEX_BUFFER | + PIPE_BIND_INDEX_BUFFER | + PIPE_BIND_CONSTANT_BUFFER | + PIPE_BIND_STREAM_OUTPUT | + PIPE_BIND_SAMPLER_VIEW)) { + assert(nv50->num_vtxbufs <= PIPE_MAX_ATTRIBS); for (i = 0; i < nv50->num_vtxbufs; ++i) { if (nv50->vtxbuf[i].buffer == res) { @@ -160,14 +198,15 @@ nv50_invalidate_resource_storage(struct nouveau_context *ctx, return ref; } } - } - if (res->bind & PIPE_BIND_INDEX_BUFFER) { - if (nv50->idxbuf.buffer == res) + + if (nv50->idxbuf.buffer == res) { + /* Just rebind to the bufctx as there is no separate dirty bit */ + nouveau_bufctx_reset(nv50->bufctx_3d, NV50_BIND_INDEX); + BCTX_REFN(nv50->bufctx_3d, INDEX, nv04_resource(res), RD); if (!--ref) return ref; - } + } - if (res->bind & PIPE_BIND_SAMPLER_VIEW) { for (s = 0; s < 3; ++s) { assert(nv50->num_textures[s] <= PIPE_MAX_SAMPLERS); for (i = 0; i < nv50->num_textures[s]; ++i) { @@ -180,12 +219,11 @@ nv50_invalidate_resource_storage(struct nouveau_context *ctx, } } } - } - if (res->bind & PIPE_BIND_CONSTANT_BUFFER) { for (s = 0; s < 3; ++s) { - assert(nv50->num_vtxbufs <= NV50_MAX_PIPE_CONSTBUFS); - for (i = 0; i < nv50->num_vtxbufs; ++i) { + for (i = 0; i < NV50_MAX_PIPE_CONSTBUFS; ++i) { + if (!(nv50->constbuf_valid[s] & (1 << i))) + continue; if (!nv50->constbuf[s][i].user && nv50->constbuf[s][i].u.buf == res) { nv50->dirty |= NV50_NEW_CONSTBUF; @@ -201,8 +239,12 @@ nv50_invalidate_resource_storage(struct nouveau_context *ctx, return ref; } +static void +nv50_context_get_sample_position(struct pipe_context *, unsigned, unsigned, + float *); + struct pipe_context * -nv50_create(struct pipe_screen *pscreen, void *priv) +nv50_create(struct pipe_screen *pscreen, void *priv, unsigned ctxflags) { struct nv50_screen *screen = nv50_screen(pscreen); struct nv50_context *nv50; @@ -231,7 +273,14 @@ nv50_create(struct pipe_screen *pscreen, void *priv) nv50->base.screen = &screen->base; nv50->base.copy_data = nv50_m2mf_copy_linear; nv50->base.push_data = nv50_sifc_linear_u8; + /* FIXME: Make it possible to use this again. The problem is that there is + * some clever logic in the card that allows for multiple renders to happen + * when there are only constbuf changes. However that relies on the + * constbuf updates happening to the right constbuf slots. Currently + * implementation just makes it go through a separate slot which doesn't + * properly update the right constbuf data. nv50->base.push_cb = nv50_cb_push; + */ nv50->screen = screen; pipe->screen = pscreen; @@ -244,13 +293,20 @@ nv50_create(struct pipe_screen *pscreen, void *priv) pipe->flush = nv50_flush; pipe->texture_barrier = nv50_texture_barrier; + pipe->memory_barrier = nv50_memory_barrier; + pipe->get_sample_position = nv50_context_get_sample_position; if (!screen->cur_ctx) { + /* Restore the last context's state here, normally handled during + * context switch + */ + nv50->state = screen->save_state; screen->cur_ctx = nv50; nouveau_pushbuf_bufctx(screen->base.pushbuf, nv50->bufctx); } nv50->base.pushbuf->kick_notify = nv50_default_kick_notify; + nouveau_context_init(&nv50->base); nv50_init_query_functions(nv50); nv50_init_surface_functions(nv50); nv50_init_state_functions(nv50); @@ -258,15 +314,8 @@ nv50_create(struct pipe_screen *pscreen, void *priv) nv50->base.invalidate_resource_storage = nv50_invalidate_resource_storage; -#ifdef NV50_WITH_DRAW_MODULE - /* no software fallbacks implemented */ - nv50->draw = draw_create(pipe); - assert(nv50->draw); - draw_set_rasterize_stage(nv50->draw, nv50_draw_render_stage(nv50)); -#endif - if (screen->base.device->chipset < 0x84 || - debug_get_bool_option("NOUVEAU_PMPEG", FALSE)) { + debug_get_bool_option("NOUVEAU_PMPEG", false)) { /* PMPEG */ nouveau_context_init_vdec(&nv50->base); } else if (screen->base.device->chipset < 0x98 || @@ -297,20 +346,17 @@ nv50_create(struct pipe_screen *pscreen, void *priv) return pipe; out_err: - if (nv50) { - if (nv50->bufctx_3d) - nouveau_bufctx_del(&nv50->bufctx_3d); - if (nv50->bufctx) - nouveau_bufctx_del(&nv50->bufctx); - if (nv50->blit) - FREE(nv50->blit); - FREE(nv50); - } + if (nv50->bufctx_3d) + nouveau_bufctx_del(&nv50->bufctx_3d); + if (nv50->bufctx) + nouveau_bufctx_del(&nv50->bufctx); + FREE(nv50->blit); + FREE(nv50); return NULL; } void -nv50_bufctx_fence(struct nouveau_bufctx *bufctx, boolean on_flush) +nv50_bufctx_fence(struct nouveau_bufctx *bufctx, bool on_flush) { struct nouveau_list *list = on_flush ? &bufctx->current : &bufctx->pending; struct nouveau_list *it; @@ -322,3 +368,44 @@ nv50_bufctx_fence(struct nouveau_bufctx *bufctx, boolean on_flush) nv50_resource_validate(res, (unsigned)ref->priv_data); } } + +static void +nv50_context_get_sample_position(struct pipe_context *pipe, + unsigned sample_count, unsigned sample_index, + float *xy) +{ + static const uint8_t ms1[1][2] = { { 0x8, 0x8 } }; + static const uint8_t ms2[2][2] = { + { 0x4, 0x4 }, { 0xc, 0xc } }; /* surface coords (0,0), (1,0) */ + static const uint8_t ms4[4][2] = { + { 0x6, 0x2 }, { 0xe, 0x6 }, /* (0,0), (1,0) */ + { 0x2, 0xa }, { 0xa, 0xe } }; /* (0,1), (1,1) */ + static const uint8_t ms8[8][2] = { + { 0x1, 0x7 }, { 0x5, 0x3 }, /* (0,0), (1,0) */ + { 0x3, 0xd }, { 0x7, 0xb }, /* (0,1), (1,1) */ + { 0x9, 0x5 }, { 0xf, 0x1 }, /* (2,0), (3,0) */ + { 0xb, 0xf }, { 0xd, 0x9 } }; /* (2,1), (3,1) */ +#if 0 + /* NOTE: there are alternative modes for MS2 and MS8, currently not used */ + static const uint8_t ms8_alt[8][2] = { + { 0x9, 0x5 }, { 0x7, 0xb }, /* (2,0), (1,1) */ + { 0xd, 0x9 }, { 0x5, 0x3 }, /* (3,1), (1,0) */ + { 0x3, 0xd }, { 0x1, 0x7 }, /* (0,1), (0,0) */ + { 0xb, 0xf }, { 0xf, 0x1 } }; /* (2,1), (3,0) */ +#endif + + const uint8_t (*ptr)[2]; + + switch (sample_count) { + case 0: + case 1: ptr = ms1; break; + case 2: ptr = ms2; break; + case 4: ptr = ms4; break; + case 8: ptr = ms8; break; + default: + assert(0); + return; /* bad sample count -> undefined locations */ + } + xy[0] = ptr[sample_index][0] * 0.0625f; + xy[1] = ptr[sample_index][1] * 0.0625f; +}