X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fdrivers%2Fsvga%2Fsvga_resource_buffer.h;h=35ed35d61ddafaab62c79060416bdcbc4ebca78d;hb=00db976905b7fcd615ccee0c13dcbf9dfe29f5ec;hp=d3ec11bfd527af0bef7cc6678c8533b414b88ee3;hpb=b84590994c4261d85485357263146d5e3d8827eb;p=mesa.git diff --git a/src/gallium/drivers/svga/svga_resource_buffer.h b/src/gallium/drivers/svga/svga_resource_buffer.h index d3ec11bfd52..35ed35d61dd 100644 --- a/src/gallium/drivers/svga/svga_resource_buffer.h +++ b/src/gallium/drivers/svga/svga_resource_buffer.h @@ -31,9 +31,10 @@ #include "pipe/p_state.h" #include "util/u_transfer.h" -#include "util/u_double_list.h" - #include "svga_screen_cache.h" +#include "svga_screen.h" +#include "svga_cmd.h" +#include "svga_context.h" /** @@ -42,7 +43,6 @@ #define SVGA_BUFFER_MAX_RANGES 32 -struct svga_screen; struct svga_context; struct svga_winsys_buffer; struct svga_winsys_surface; @@ -56,67 +56,77 @@ struct svga_buffer_range unsigned end; }; +struct svga_3d_update_gb_image; + +/** + * This structure describes the bind flags and cache key associated + * with the host surface. + */ +struct svga_buffer_surface +{ + struct list_head list; + unsigned bind_flags; + struct svga_host_surface_cache_key key; + struct svga_winsys_surface *handle; +}; /** * SVGA pipe buffer. */ -struct svga_buffer +struct svga_buffer { struct u_resource b; + /** This is a superset of b.b.bind */ + unsigned bind_flags; + /** * Regular (non DMA'able) memory. - * + * * Used for user buffers or for buffers which we know before hand that can * never be used by the virtual hardware directly, such as constant buffers. */ void *swbuf; - - /** + + /** * Whether swbuf was created by the user or not. */ boolean user; - + /** * Creation key for the host surface handle. - * - * This structure describes all the host surface characteristics so that it + * + * This structure describes all the host surface characteristics so that it * can be looked up in cache, since creating a host surface is often a slow * operation. */ struct svga_host_surface_cache_key key; - + /** * Host surface handle. - * - * This is a platform independent abstraction for host SID. We create when - * trying to bind + * + * This is a platform independent abstraction for host SID. We create when + * trying to bind. + * + * Only set for non-user buffers. */ struct svga_winsys_surface *handle; + /** + * List of surfaces created for this buffer resource to support + * incompatible bind flags. + */ + struct list_head surfaces; + /** * Information about ongoing and past map operations. */ struct { /** * Number of concurrent mappings. - * - * XXX: It is impossible to guarantee concurrent maps work in all - * circumstances -- pipe_buffers really need transfer objects too. */ unsigned count; - /** - * Whether this buffer is currently mapped for writing. - */ - boolean writing; - - /** - * Whether the application will tell us explicity which ranges it touched - * or not. - */ - boolean flush_explicit; - /** * Dirty ranges. * @@ -141,6 +151,12 @@ struct svga_buffer * is the relative offset within that buffer. */ unsigned offset; + + /** + * Range of user buffer that is uploaded in @buffer at @offset. + */ + unsigned start; + unsigned end; } uploaded; /** @@ -149,6 +165,8 @@ struct svga_buffer * A piece of GMR memory, with the same size of the buffer. It is created * when mapping the buffer, and will be used to upload vertex data to the * host. + * + * Only set for non-user buffers. */ struct svga_winsys_buffer *hwbuf; @@ -171,6 +189,12 @@ struct svga_buffer */ SVGA3dCopyBox *boxes; + /** + * Pointer to the sequence of update commands + * *inside* the command buffer. + */ + struct svga_3d_update_gb_image *updates; + /** * Context that has the pending DMA to this buffer. */ @@ -182,17 +206,30 @@ struct svga_buffer * a context. It is only valid if the dma.pending is set above. */ struct list_head head; + + unsigned size; /**< Approximate size in bytes */ + + boolean dirty; /**< Need to do a readback before mapping? */ + + /** In some cases we try to keep the results of the translate_indices() + * function from svga_draw_elements.c + */ + struct { + enum pipe_prim_type orig_prim, new_prim; + struct pipe_resource *buffer; + unsigned index_size; + unsigned offset; /**< first index */ + unsigned count; /**< num indices */ + } translated_indices; }; -static INLINE struct svga_buffer * -svga_buffer(struct pipe_resource *buffer) +static inline struct svga_buffer * +svga_buffer(struct pipe_resource *resource) { - if (buffer) { - assert(((struct svga_buffer *)buffer)->b.vtbl == &svga_buffer_vtbl); - return (struct svga_buffer *)buffer; - } - return NULL; + struct svga_buffer *buf = (struct svga_buffer *) resource; + assert(buf == NULL || buf->b.vtbl == &svga_buffer_vtbl); + return buf; } @@ -200,24 +237,107 @@ svga_buffer(struct pipe_resource *buffer) * Returns TRUE for user buffers. We may * decide to use an alternate upload path for these buffers. */ -static INLINE boolean -svga_buffer_is_user_buffer( struct pipe_resource *buffer ) +static inline boolean +svga_buffer_is_user_buffer(struct pipe_resource *buffer) { - return svga_buffer(buffer)->user; + if (buffer) { + return svga_buffer(buffer)->user; + } else { + return FALSE; + } +} + +/** + * Returns a pointer to a struct svga_winsys_screen given a + * struct svga_buffer. + */ +static inline struct svga_winsys_screen * +svga_buffer_winsys_screen(struct svga_buffer *sbuf) +{ + return svga_screen(sbuf->b.b.screen)->sws; } +/** + * Returns whether a buffer has hardware storage that is + * visible to the GPU. + */ +static inline boolean +svga_buffer_has_hw_storage(struct svga_buffer *sbuf) +{ + if (svga_buffer_winsys_screen(sbuf)->have_gb_objects) + return (sbuf->handle ? TRUE : FALSE); + else + return (sbuf->hwbuf ? TRUE : FALSE); +} + +/** + * Map the hardware storage of a buffer. + * \param flags bitmask of PIPE_TRANSFER_* flags + */ +static inline void * +svga_buffer_hw_storage_map(struct svga_context *svga, + struct svga_buffer *sbuf, + unsigned flags, boolean *retry) +{ + struct svga_winsys_screen *sws = svga_buffer_winsys_screen(sbuf); + + svga->hud.num_buffers_mapped++; + + if (sws->have_gb_objects) { + return svga->swc->surface_map(svga->swc, sbuf->handle, flags, retry); + } else { + *retry = FALSE; + return sws->buffer_map(sws, sbuf->hwbuf, flags); + } +} + +/** + * Unmap the hardware storage of a buffer. + */ +static inline void +svga_buffer_hw_storage_unmap(struct svga_context *svga, + struct svga_buffer *sbuf) +{ + struct svga_winsys_screen *sws = svga_buffer_winsys_screen(sbuf); + + if (sws->have_gb_objects) { + struct svga_winsys_context *swc = svga->swc; + boolean rebind; + swc->surface_unmap(swc, sbuf->handle, &rebind); + if (rebind) { + enum pipe_error ret; + ret = SVGA3D_BindGBSurface(swc, sbuf->handle); + if (ret != PIPE_OK) { + /* flush and retry */ + svga_context_flush(svga, NULL); + ret = SVGA3D_BindGBSurface(swc, sbuf->handle); + assert(ret == PIPE_OK); + } + if (swc->force_coherent) { + ret = SVGA3D_UpdateGBSurface(swc, sbuf->handle); + if (ret != PIPE_OK) { + /* flush and retry */ + svga_context_flush(svga, NULL); + ret = SVGA3D_UpdateGBSurface(swc, sbuf->handle); + assert(ret == PIPE_OK); + } + } + } + } else + sws->buffer_unmap(sws, sbuf->hwbuf); +} struct pipe_resource * svga_user_buffer_create(struct pipe_screen *screen, void *ptr, unsigned bytes, - unsigned usage); + unsigned usage); struct pipe_resource * svga_buffer_create(struct pipe_screen *screen, - const struct pipe_resource *template); + const struct pipe_resource *template); @@ -232,14 +352,15 @@ svga_buffer_create(struct pipe_screen *screen, */ struct svga_winsys_surface * svga_buffer_handle(struct svga_context *svga, - struct pipe_resource *buf); + struct pipe_resource *buf, + unsigned tobind_flags); void svga_context_flush_buffers(struct svga_context *svga); struct svga_winsys_buffer * svga_winsys_buffer_create(struct svga_context *svga, - unsigned alignment, + unsigned alignment, unsigned usage, unsigned size);