src/gallium/winsys/svga/drm/vmw_screen_svga.c

   1 /**********************************************************
   2  * Copyright 2009 VMware, Inc.  All rights reserved.
   3  *
   4  * Permission is hereby granted, free of charge, to any person
   5  * obtaining a copy of this software and associated documentation
   6  * files (the "Software"), to deal in the Software without
   7  * restriction, including without limitation the rights to use, copy,
   8  * modify, merge, publish, distribute, sublicense, and/or sell copies
   9  * of the Software, and to permit persons to whom the Software is
  10  * furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be
  13  * included in all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  16  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  18  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  19  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  20  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  21  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22  * SOFTWARE.
  23  *
  24  **********************************************************/
  25
  26 /**
  27  * @file
  28  * This file implements the SVGA interface into this winsys, defined
  29  * in drivers/svga/svga_winsys.h.
  30  *
  31  * @author Keith Whitwell
  32  * @author Jose Fonseca
  33  */
  34
  35
  36 #include "svga_cmd.h"
  37 #include "svga3d_caps.h"
  38
  39 #include "util/u_inlines.h"
  40 #include "util/u_math.h"
  41 #include "util/u_memory.h"
  42 #include "pipebuffer/pb_buffer.h"
  43 #include "pipebuffer/pb_bufmgr.h"
  44 #include "svga_winsys.h"
  45 #include "vmw_context.h"
  46 #include "vmw_screen.h"
  47 #include "vmw_surface.h"
  48 #include "vmw_buffer.h"
  49 #include "vmw_fence.h"
  50
  51
  52 static struct svga_winsys_buffer *
  53 vmw_svga_winsys_buffer_create(struct svga_winsys_screen *sws,
  54                               unsigned alignment,
  55                               unsigned usage,
  56                               unsigned size)
  57 {
  58    struct vmw_winsys_screen *vws = vmw_winsys_screen(sws);
  59    struct pb_desc desc;
  60    struct pb_manager *provider;
  61    struct pb_buffer *buffer;
  62
  63    memset(&desc, 0, sizeof desc);
  64    desc.alignment = alignment;
  65    desc.usage = usage;
  66
  67    if (usage == SVGA_BUFFER_USAGE_PINNED) {
  68       if (vws->pools.query_fenced == NULL && !vmw_query_pools_init(vws))
  69          return NULL;
  70       provider = vws->pools.query_fenced;
  71    } else
  72       provider = vws->pools.gmr_fenced;
  73
  74    assert(provider);
  75    buffer = provider->create_buffer(provider, size, &desc);
  76
  77    if(!buffer && provider == vws->pools.gmr_fenced) {
  78
  79       assert(provider);
  80       provider = vws->pools.gmr_slab_fenced;
  81       buffer = provider->create_buffer(provider, size, &desc);
  82    }
  83
  84    if (!buffer)
  85       return NULL;
  86
  87    return vmw_svga_winsys_buffer(buffer);
  88 }
  89
  90
  91 static void *
  92 vmw_svga_winsys_buffer_map(struct svga_winsys_screen *sws,
  93                            struct svga_winsys_buffer *buf,
  94                            unsigned flags)
  95 {
  96    (void)sws;
  97    return pb_map(vmw_pb_buffer(buf), flags, NULL);
  98 }
  99
 100
 101 static void
 102 vmw_svga_winsys_buffer_unmap(struct svga_winsys_screen *sws,
 103                              struct svga_winsys_buffer *buf)
 104 {
 105    (void)sws;
 106    pb_unmap(vmw_pb_buffer(buf));
 107 }
 108
 109
 110 static void
 111 vmw_svga_winsys_buffer_destroy(struct svga_winsys_screen *sws,
 112                                struct svga_winsys_buffer *buf)
 113 {
 114    struct pb_buffer *pbuf = vmw_pb_buffer(buf);
 115    (void)sws;
 116    pb_reference(&pbuf, NULL);
 117 }
 118
 119
 120 static void
 121 vmw_svga_winsys_fence_reference(struct svga_winsys_screen *sws,
 122                                 struct pipe_fence_handle **pdst,
 123                                 struct pipe_fence_handle *src)
 124 {
 125     struct vmw_winsys_screen *vws = vmw_winsys_screen(sws);
 126
 127     vmw_fence_reference(vws, pdst, src);
 128 }
 129
 130
 131 static int
 132 vmw_svga_winsys_fence_signalled(struct svga_winsys_screen *sws,
 133                                 struct pipe_fence_handle *fence,
 134                                 unsigned flag)
 135 {
 136    struct vmw_winsys_screen *vws = vmw_winsys_screen(sws);
 137
 138    return vmw_fence_signalled(vws, fence, flag);
 139 }
 140
 141
 142 static int
 143 vmw_svga_winsys_fence_finish(struct svga_winsys_screen *sws,
 144                              struct pipe_fence_handle *fence,
 145                              unsigned flag)
 146 {
 147    struct vmw_winsys_screen *vws = vmw_winsys_screen(sws);
 148
 149    return vmw_fence_finish(vws, fence, flag);
 150 }
 151
 152
 153
 154 static struct svga_winsys_surface *
 155 vmw_svga_winsys_surface_create(struct svga_winsys_screen *sws,
 156                                SVGA3dSurfaceFlags flags,
 157                                SVGA3dSurfaceFormat format,
 158                                SVGA3dSize size,
 159                                uint32 numFaces,
 160                                uint32 numMipLevels)
 161 {
 162    struct vmw_winsys_screen *vws = vmw_winsys_screen(sws);
 163    struct vmw_svga_winsys_surface *surface;
 164
 165    surface = CALLOC_STRUCT(vmw_svga_winsys_surface);
 166    if(!surface)
 167       goto no_surface;
 168
 169    pipe_reference_init(&surface->refcnt, 1);
 170    p_atomic_set(&surface->validated, 0);
 171    surface->screen = vws;
 172    surface->sid = vmw_ioctl_surface_create(vws,
 173                                            flags, format, size,
 174                                            numFaces, numMipLevels);
 175    if(surface->sid == SVGA3D_INVALID_ID)
 176       goto no_sid;
 177
 178    return svga_winsys_surface(surface);
 179
 180 no_sid:
 181    FREE(surface);
 182 no_surface:
 183    return NULL;
 184 }
 185
 186
 187 static boolean
 188 vmw_svga_winsys_surface_is_flushed(struct svga_winsys_screen *sws,
 189                                    struct svga_winsys_surface *surface)
 190 {
 191    struct vmw_svga_winsys_surface *vsurf = vmw_svga_winsys_surface(surface);
 192    return (p_atomic_read(&vsurf->validated) == 0);
 193 }
 194
 195
 196 static void
 197 vmw_svga_winsys_surface_ref(struct svga_winsys_screen *sws,
 198                             struct svga_winsys_surface **pDst,
 199                             struct svga_winsys_surface *src)
 200 {
 201    struct vmw_svga_winsys_surface *d_vsurf = vmw_svga_winsys_surface(*pDst);
 202    struct vmw_svga_winsys_surface *s_vsurf = vmw_svga_winsys_surface(src);
 203
 204    vmw_svga_winsys_surface_reference(&d_vsurf, s_vsurf);
 205    *pDst = svga_winsys_surface(d_vsurf);
 206 }
 207
 208
 209 static void
 210 vmw_svga_winsys_destroy(struct svga_winsys_screen *sws)
 211 {
 212    struct vmw_winsys_screen *vws = vmw_winsys_screen(sws);
 213
 214    vmw_winsys_destroy(vws);
 215 }
 216
 217
 218 static SVGA3dHardwareVersion
 219 vmw_svga_winsys_get_hw_version(struct svga_winsys_screen *sws)
 220 {
 221    struct vmw_winsys_screen *vws = vmw_winsys_screen(sws);
 222
 223    return (SVGA3dHardwareVersion) vws->ioctl.hwversion;
 224 }
 225
 226
 227 static boolean
 228 vmw_svga_winsys_get_cap(struct svga_winsys_screen *sws,
 229                         SVGA3dDevCapIndex index,
 230                         SVGA3dDevCapResult *result)
 231 {
 232    struct vmw_winsys_screen *vws = vmw_winsys_screen(sws);
 233    const uint32 *capsBlock;
 234    const SVGA3dCapsRecord *capsRecord = NULL;
 235    uint32 offset;
 236    const SVGA3dCapPair *capArray;
 237    int numCaps, first, last;
 238
 239    if(vws->ioctl.hwversion < SVGA3D_HWVERSION_WS6_B1)
 240       return FALSE;
 241
 242    /*
 243     * Search linearly through the caps block records for the specified type.
 244     */
 245    capsBlock = (const uint32 *)vws->ioctl.buffer;
 246    for (offset = 0; capsBlock[offset] != 0; offset += capsBlock[offset]) {
 247       const SVGA3dCapsRecord *record;
 248       assert(offset < SVGA_FIFO_3D_CAPS_SIZE);
 249       record = (const SVGA3dCapsRecord *) (capsBlock + offset);
 250       if ((record->header.type >= SVGA3DCAPS_RECORD_DEVCAPS_MIN) &&
 251           (record->header.type <= SVGA3DCAPS_RECORD_DEVCAPS_MAX) &&
 252           (!capsRecord || (record->header.type > capsRecord->header.type))) {
 253          capsRecord = record;
 254       }
 255    }
 256
 257    if(!capsRecord)
 258       return FALSE;
 259
 260    /*
 261     * Calculate the number of caps from the size of the record.
 262     */
 263    capArray = (const SVGA3dCapPair *) capsRecord->data;
 264    numCaps = (int) ((capsRecord->header.length * sizeof(uint32) -
 265                      sizeof capsRecord->header) / (2 * sizeof(uint32)));
 266
 267    /*
 268     * Binary-search for the cap with the specified index.
 269     */
 270    for (first = 0, last = numCaps - 1; first <= last; ) {
 271       int mid = (first + last) / 2;
 272
 273       if ((SVGA3dDevCapIndex) capArray[mid][0] == index) {
 274          /*
 275           * Found it.
 276           */
 277          result->u = capArray[mid][1];
 278          return TRUE;
 279       }
 280
 281       /*
 282        * Divide and conquer.
 283        */
 284       if ((SVGA3dDevCapIndex) capArray[mid][0] > index) {
 285          last = mid - 1;
 286       } else {
 287          first = mid + 1;
 288       }
 289    }
 290
 291    return FALSE;
 292 }
 293
 294
 295 boolean
 296 vmw_winsys_screen_init_svga(struct vmw_winsys_screen *vws)
 297 {
 298    vws->base.destroy = vmw_svga_winsys_destroy;
 299    vws->base.get_hw_version = vmw_svga_winsys_get_hw_version;
 300    vws->base.get_cap = vmw_svga_winsys_get_cap;
 301    vws->base.context_create = vmw_svga_winsys_context_create;
 302    vws->base.surface_create = vmw_svga_winsys_surface_create;
 303    vws->base.surface_is_flushed = vmw_svga_winsys_surface_is_flushed;
 304    vws->base.surface_reference = vmw_svga_winsys_surface_ref;
 305    vws->base.buffer_create = vmw_svga_winsys_buffer_create;
 306    vws->base.buffer_map = vmw_svga_winsys_buffer_map;
 307    vws->base.buffer_unmap = vmw_svga_winsys_buffer_unmap;
 308    vws->base.buffer_destroy = vmw_svga_winsys_buffer_destroy;
 309    vws->base.fence_reference = vmw_svga_winsys_fence_reference;
 310    vws->base.fence_signalled = vmw_svga_winsys_fence_signalled;
 311    vws->base.fence_finish = vmw_svga_winsys_fence_finish;
 312
 313    return TRUE;
 314 }
 315
 316