radeon/radeon_bo_gem.c

   1 /*
   2  * Copyright © 2008 Dave Airlie
   3  * Copyright © 2008 Jérôme Glisse
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining
   7  * a copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  15  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  16  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  17  * NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS, AUTHORS
  18  * AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  20  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  21  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  22  *
  23  * The above copyright notice and this permission notice (including the
  24  * next paragraph) shall be included in all copies or substantial portions
  25  * of the Software.
  26  */
  27 /*
  28  * Authors:
  29  *      Dave Airlie
  30  *      Jérôme Glisse <glisse@freedesktop.org>
  31  */
  32 #ifdef HAVE_CONFIG_H
  33 #include <config.h>
  34 #endif
  35 #include <stdio.h>
  36 #include <stdint.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include <sys/mman.h>
  40 #include <errno.h>
  41 #include "xf86drm.h"
  42 #include "drm.h"
  43 #include "radeon_drm.h"
  44 #include "radeon_bo.h"
  45 #include "radeon_bo_gem.h"
  46
  47 struct radeon_bo_gem {
  48     struct radeon_bo    base;
  49     uint32_t            name;
  50     int                 map_count;
  51     void *priv_ptr;
  52 };
  53
  54 struct bo_manager_gem {
  55     struct radeon_bo_manager    base;
  56 };
  57
  58 static int bo_wait(struct radeon_bo *bo);
  59
  60 static struct radeon_bo *bo_open(struct radeon_bo_manager *bom,
  61                                  uint32_t handle,
  62                                  uint32_t size,
  63                                  uint32_t alignment,
  64                                  uint32_t domains,
  65                                  uint32_t flags)
  66 {
  67     struct radeon_bo_gem *bo;
  68     int r;
  69
  70     bo = (struct radeon_bo_gem*)calloc(1, sizeof(struct radeon_bo_gem));
  71     if (bo == NULL) {
  72         return NULL;
  73     }
  74
  75     bo->base.bom = bom;
  76     bo->base.handle = 0;
  77     bo->base.size = size;
  78     bo->base.alignment = alignment;
  79     bo->base.domains = domains;
  80     bo->base.flags = flags;
  81     bo->base.ptr = NULL;
  82     bo->map_count = 0;
  83     if (handle) {
  84         struct drm_gem_open open_arg;
  85
  86         memset(&open_arg, 0, sizeof(open_arg));
  87         open_arg.name = handle;
  88         r = drmIoctl(bom->fd, DRM_IOCTL_GEM_OPEN, &open_arg);
  89         if (r != 0) {
  90             free(bo);
  91             return NULL;
  92         }
  93         bo->base.handle = open_arg.handle;
  94         bo->base.size = open_arg.size;
  95         bo->name = handle;
  96     } else {
  97         struct drm_radeon_gem_create args;
  98
  99         args.size = size;
 100         args.alignment = alignment;
 101         args.initial_domain = bo->base.domains;
 102         args.flags = 0;
 103         args.handle = 0;
 104         r = drmCommandWriteRead(bom->fd, DRM_RADEON_GEM_CREATE,
 105                                 &args, sizeof(args));
 106         bo->base.handle = args.handle;
 107         if (r) {
 108             fprintf(stderr, "Failed to allocate :\n");
 109             fprintf(stderr, "   size      : %d bytes\n", size);
 110             fprintf(stderr, "   alignment : %d bytes\n", alignment);
 111             fprintf(stderr, "   domains   : %d\n", bo->base.domains);
 112             free(bo);
 113             return NULL;
 114         }
 115     }
 116     radeon_bo_ref((struct radeon_bo*)bo);
 117     return (struct radeon_bo*)bo;
 118 }
 119
 120 static void bo_ref(struct radeon_bo *bo)
 121 {
 122 }
 123
 124 static struct radeon_bo *bo_unref(struct radeon_bo *bo)
 125 {
 126     struct radeon_bo_gem *bo_gem = (struct radeon_bo_gem*)bo;
 127     struct drm_gem_close args;
 128
 129     if (bo == NULL) {
 130         return NULL;
 131     }
 132     if (bo->cref) {
 133         return bo;
 134     }
 135     if (bo_gem->priv_ptr) {
 136         munmap(bo_gem->priv_ptr, bo->size);
 137     }
 138
 139     /* Zero out args to make valgrind happy */
 140     memset(&args, 0, sizeof(args));
 141
 142     /* close object */
 143     args.handle = bo->handle;
 144     drmIoctl(bo->bom->fd, DRM_IOCTL_GEM_CLOSE, &args);
 145     memset(bo_gem, 0, sizeof(struct radeon_bo_gem));
 146     free(bo_gem);
 147     return NULL;
 148 }
 149
 150 static int bo_map(struct radeon_bo *bo, int write)
 151 {
 152     struct radeon_bo_gem *bo_gem = (struct radeon_bo_gem*)bo;
 153     struct drm_radeon_gem_mmap args;
 154     int r;
 155     void *ptr;
 156
 157     if (bo_gem->map_count++ != 0) {
 158         return 0;
 159     }
 160     if (bo_gem->priv_ptr) {
 161         goto wait;
 162     }
 163
 164     bo->ptr = NULL;
 165
 166     /* Zero out args to make valgrind happy */
 167     memset(&args, 0, sizeof(args));
 168     args.handle = bo->handle;
 169     args.offset = 0;
 170     args.size = (uint64_t)bo->size;
 171     r = drmCommandWriteRead(bo->bom->fd,
 172                             DRM_RADEON_GEM_MMAP,
 173                             &args,
 174                             sizeof(args));
 175     if (r) {
 176         fprintf(stderr, "error mapping %p 0x%08X (error = %d)\n",
 177                 bo, bo->handle, r);
 178         return r;
 179     }
 180     ptr = mmap(0, args.size, PROT_READ|PROT_WRITE, MAP_SHARED, bo->bom->fd, args.addr_ptr);
 181     if (ptr == MAP_FAILED)
 182         return -errno;
 183     bo_gem->priv_ptr = ptr;
 184 wait:
 185     bo->ptr = bo_gem->priv_ptr;
 186     r = bo_wait(bo);
 187     if (r)
 188         return r;
 189     return 0;
 190 }
 191
 192 static int bo_unmap(struct radeon_bo *bo)
 193 {
 194     struct radeon_bo_gem *bo_gem = (struct radeon_bo_gem*)bo;
 195
 196     if (--bo_gem->map_count > 0) {
 197         return 0;
 198     }
 199     //munmap(bo->ptr, bo->size);
 200     bo->ptr = NULL;
 201     return 0;
 202 }
 203
 204 static int bo_wait(struct radeon_bo *bo)
 205 {
 206     struct drm_radeon_gem_wait_idle args;
 207     int ret;
 208
 209     /* Zero out args to make valgrind happy */
 210     memset(&args, 0, sizeof(args));
 211     args.handle = bo->handle;
 212     do {
 213         ret = drmCommandWriteRead(bo->bom->fd, DRM_RADEON_GEM_WAIT_IDLE,
 214                                   &args, sizeof(args));
 215     } while (ret == -EBUSY);
 216     return ret;
 217 }
 218
 219 static int bo_is_busy(struct radeon_bo *bo, uint32_t *domain)
 220 {
 221     struct drm_radeon_gem_busy args;
 222     int ret;
 223
 224     args.handle = bo->handle;
 225     args.domain = 0;
 226
 227     ret = drmCommandWriteRead(bo->bom->fd, DRM_RADEON_GEM_BUSY,
 228             &args, sizeof(args));
 229
 230     *domain = args.domain;
 231     return ret;
 232 }
 233
 234 static int bo_set_tiling(struct radeon_bo *bo, uint32_t tiling_flags,
 235                                  uint32_t pitch)
 236 {
 237     struct drm_radeon_gem_set_tiling args;
 238     int r;
 239
 240     args.handle = bo->handle;
 241     args.tiling_flags = tiling_flags;
 242     args.pitch = pitch;
 243
 244     r = drmCommandWriteRead(bo->bom->fd,
 245                             DRM_RADEON_GEM_SET_TILING,
 246                             &args,
 247                             sizeof(args));
 248     return r;
 249 }
 250
 251 static int bo_get_tiling(struct radeon_bo *bo, uint32_t *tiling_flags,
 252                                  uint32_t *pitch)
 253 {
 254     struct drm_radeon_gem_set_tiling args;
 255     int r;
 256
 257     args.handle = bo->handle;
 258
 259     r = drmCommandWriteRead(bo->bom->fd,
 260                             DRM_RADEON_GEM_GET_TILING,
 261                             &args,
 262                             sizeof(args));
 263
 264     if (r)
 265         return r;
 266
 267     *tiling_flags = args.tiling_flags;
 268     *pitch = args.pitch;
 269     return r;
 270 }
 271
 272 static struct radeon_bo_funcs bo_gem_funcs = {
 273     bo_open,
 274     bo_ref,
 275     bo_unref,
 276     bo_map,
 277     bo_unmap,
 278     bo_wait,
 279     NULL,
 280     bo_set_tiling,
 281     bo_get_tiling,
 282     bo_is_busy,
 283 };
 284
 285 struct radeon_bo_manager *radeon_bo_manager_gem_ctor(int fd)
 286 {
 287     struct bo_manager_gem *bomg;
 288
 289     bomg = (struct bo_manager_gem*)calloc(1, sizeof(struct bo_manager_gem));
 290     if (bomg == NULL) {
 291         return NULL;
 292     }
 293     bomg->base.funcs = &bo_gem_funcs;
 294     bomg->base.fd = fd;
 295     return (struct radeon_bo_manager*)bomg;
 296 }
 297
 298 void radeon_bo_manager_gem_dtor(struct radeon_bo_manager *bom)
 299 {
 300     struct bo_manager_gem *bomg = (struct bo_manager_gem*)bom;
 301
 302     if (bom == NULL) {
 303         return;
 304     }
 305     free(bomg);
 306 }
 307
 308 uint32_t radeon_gem_name_bo(struct radeon_bo *bo)
 309 {
 310     struct radeon_bo_gem *bo_gem = (struct radeon_bo_gem*)bo;
 311     return bo_gem->name;
 312 }
 313
 314 int radeon_gem_get_kernel_name(struct radeon_bo *bo, uint32_t *name)
 315 {
 316     struct drm_gem_flink flink;
 317     int r;
 318
 319     flink.handle = bo->handle;
 320     r = drmIoctl(bo->bom->fd, DRM_IOCTL_GEM_FLINK, &flink);
 321     if (r) {
 322         return r;
 323     }
 324     *name = flink.name;
 325     return 0;
 326 }
 327
 328 int radeon_gem_set_domain(struct radeon_bo *bo, uint32_t read_domains, uint32_t write_domain)
 329 {
 330     struct drm_radeon_gem_set_domain args;
 331     int r;
 332
 333     args.handle = bo->handle;
 334     args.read_domains = read_domains;
 335     args.write_domain = write_domain;
 336
 337     r = drmCommandWriteRead(bo->bom->fd,
 338                             DRM_RADEON_GEM_SET_DOMAIN,
 339                             &args,
 340                             sizeof(args));
 341     return r;
 342 }