src/mesa/drivers/dri/nouveau/nouveau_bufferobj.c

   1 /*
   2  * Copyright (C) 2009 Francisco Jerez.
   3  * All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining
   6  * a copy of this software and associated documentation files (the
   7  * "Software"), to deal in the Software without restriction, including
   8  * without limitation the rights to use, copy, modify, merge, publish,
   9  * distribute, sublicense, and/or sell copies of the Software, and to
  10  * permit persons to whom the Software is furnished to do so, subject to
  11  * the following conditions:
  12  *
  13  * The above copyright notice and this permission notice (including the
  14  * next paragraph) shall be included in all copies or substantial
  15  * portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  18  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  20  * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  21  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  22  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  23  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24  *
  25  */
  26
  27 #include "nouveau_driver.h"
  28 #include "nouveau_bufferobj.h"
  29 #include "nouveau_context.h"
  30
  31 #include "main/bufferobj.h"
  32
  33 static inline char *
  34 get_bufferobj_map(struct gl_buffer_object *obj, unsigned flags)
  35 {
  36         struct nouveau_bufferobj *nbo = to_nouveau_bufferobj(obj);
  37         void *map = NULL;
  38
  39         if (nbo->sys) {
  40                 map = nbo->sys;
  41         } else if (nbo->bo) {
  42                 nouveau_bo_map(nbo->bo, flags);
  43                 map = nbo->bo->map;
  44                 nouveau_bo_unmap(nbo->bo);
  45         }
  46
  47         return map;
  48 }
  49
  50 static struct gl_buffer_object *
  51 nouveau_bufferobj_new(struct gl_context *ctx, GLuint buffer, GLenum target)
  52 {
  53         struct nouveau_bufferobj *nbo;
  54
  55         nbo = CALLOC_STRUCT(nouveau_bufferobj);
  56         if (!nbo)
  57                 return NULL;
  58
  59         _mesa_initialize_buffer_object(&nbo->base, buffer, target);
  60
  61         return &nbo->base;
  62 }
  63
  64 static void
  65 nouveau_bufferobj_del(struct gl_context *ctx, struct gl_buffer_object *obj)
  66 {
  67         struct nouveau_bufferobj *nbo = to_nouveau_bufferobj(obj);
  68
  69         nouveau_bo_ref(NULL, &nbo->bo);
  70         FREE(nbo->sys);
  71         FREE(nbo);
  72 }
  73
  74 static GLboolean
  75 nouveau_bufferobj_data(struct gl_context *ctx, GLenum target, GLsizeiptrARB size,
  76                        const GLvoid *data, GLenum usage,
  77                        struct gl_buffer_object *obj)
  78 {
  79         struct nouveau_bufferobj *nbo = to_nouveau_bufferobj(obj);
  80         int ret;
  81
  82         obj->Size = size;
  83         obj->Usage = usage;
  84
  85         /* Free previous storage */
  86         nouveau_bo_ref(NULL, &nbo->bo);
  87         FREE(nbo->sys);
  88
  89         if (target == GL_ELEMENT_ARRAY_BUFFER_ARB ||
  90             (size < 512 && usage == GL_DYNAMIC_DRAW_ARB) ||
  91             context_chipset(ctx) < 0x10) {
  92                 /* Heuristic: keep it in system ram */
  93                 nbo->sys = MALLOC(size);
  94
  95         } else {
  96                 /* Get a hardware BO */
  97                 ret = nouveau_bo_new(context_dev(ctx),
  98                                      NOUVEAU_BO_GART | NOUVEAU_BO_MAP, 0,
  99                                      size, &nbo->bo);
 100                 assert(!ret);
 101         }
 102
 103         if (data)
 104                 memcpy(get_bufferobj_map(obj, NOUVEAU_BO_WR), data, size);
 105
 106         return GL_TRUE;
 107 }
 108
 109 static void
 110 nouveau_bufferobj_subdata(struct gl_context *ctx, GLenum target, GLintptrARB offset,
 111                           GLsizeiptrARB size, const GLvoid *data,
 112                           struct gl_buffer_object *obj)
 113 {
 114         memcpy(get_bufferobj_map(obj, NOUVEAU_BO_WR) + offset, data, size);
 115 }
 116
 117 static void
 118 nouveau_bufferobj_get_subdata(struct gl_context *ctx, GLenum target, GLintptrARB offset,
 119                            GLsizeiptrARB size, GLvoid *data,
 120                            struct gl_buffer_object *obj)
 121 {
 122         memcpy(data, get_bufferobj_map(obj, NOUVEAU_BO_RD) + offset, size);
 123 }
 124
 125 static void *
 126 nouveau_bufferobj_map(struct gl_context *ctx, GLenum target, GLenum access,
 127                    struct gl_buffer_object *obj)
 128 {
 129         unsigned flags = 0;
 130
 131         if (access == GL_READ_ONLY_ARB ||
 132             access == GL_READ_WRITE_ARB)
 133                 flags |= GL_MAP_READ_BIT;
 134         if (access == GL_WRITE_ONLY_ARB ||
 135             access == GL_READ_WRITE_ARB)
 136                 flags |= GL_MAP_WRITE_BIT;
 137
 138         return ctx->Driver.MapBufferRange(ctx, target, 0, obj->Size, flags,
 139                                           obj);
 140 }
 141
 142 static void *
 143 nouveau_bufferobj_map_range(struct gl_context *ctx, GLenum target, GLintptr offset,
 144                             GLsizeiptr length, GLbitfield access,
 145                             struct gl_buffer_object *obj)
 146 {
 147         unsigned flags = 0;
 148         char *map;
 149
 150         assert(!obj->Pointer);
 151
 152         if (access & GL_MAP_READ_BIT)
 153                 flags |= NOUVEAU_BO_RD;
 154         if (access & GL_MAP_WRITE_BIT)
 155                 flags |= NOUVEAU_BO_WR;
 156         if (access & GL_MAP_UNSYNCHRONIZED_BIT)
 157                 flags |= NOUVEAU_BO_NOSYNC;
 158
 159         map = get_bufferobj_map(obj, flags);
 160         if (!map)
 161                 return NULL;
 162
 163         obj->Pointer = map + offset;
 164         obj->Offset = offset;
 165         obj->Length = length;
 166         obj->AccessFlags = access;
 167
 168         return obj->Pointer;
 169 }
 170
 171 static GLboolean
 172 nouveau_bufferobj_unmap(struct gl_context *ctx, GLenum target, struct gl_buffer_object *obj)
 173 {
 174         assert(obj->Pointer);
 175
 176         obj->Pointer = NULL;
 177         obj->Offset = 0;
 178         obj->Length = 0;
 179         obj->AccessFlags = 0;
 180
 181         return GL_TRUE;
 182 }
 183
 184 void
 185 nouveau_bufferobj_functions_init(struct dd_function_table *functions)
 186 {
 187         functions->NewBufferObject = nouveau_bufferobj_new;
 188         functions->DeleteBuffer = nouveau_bufferobj_del;
 189         functions->BufferData = nouveau_bufferobj_data;
 190         functions->BufferSubData = nouveau_bufferobj_subdata;
 191         functions->GetBufferSubData = nouveau_bufferobj_get_subdata;
 192         functions->MapBuffer = nouveau_bufferobj_map;
 193         functions->MapBufferRange = nouveau_bufferobj_map_range;
 194         functions->UnmapBuffer = nouveau_bufferobj_unmap;
 195 }