intel/intel_bufmgr_gem.c

   1 /**************************************************************************
   2  *
   3  * Copyright © 2007 Red Hat Inc.
   4  * Copyright © 2007 Intel Corporation
   5  * Copyright 2006 Tungsten Graphics, Inc., Bismarck, ND., USA
   6  * All Rights Reserved.
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the
  10  * "Software"), to deal in the Software without restriction, including
  11  * without limitation the rights to use, copy, modify, merge, publish,
  12  * distribute, sub license, and/or sell copies of the Software, and to
  13  * permit persons to whom the Software is furnished to do so, subject to
  14  * the following conditions:
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  19  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
  20  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  21  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  22  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  *
  24  * The above copyright notice and this permission notice (including the
  25  * next paragraph) shall be included in all copies or substantial portions
  26  * of the Software.
  27  *
  28  *
  29  **************************************************************************/
  30 /*
  31  * Authors: Thomas Hellström <thomas-at-tungstengraphics-dot-com>
  32  *          Keith Whitwell <keithw-at-tungstengraphics-dot-com>
  33  *          Eric Anholt <eric@anholt.net>
  34  *          Dave Airlie <airlied@linux.ie>
  35  */
  36
  37 #ifdef HAVE_CONFIG_H
  38 #include "config.h"
  39 #endif
  40
  41 #include <xf86drm.h>
  42 #include <fcntl.h>
  43 #include <stdio.h>
  44 #include <stdlib.h>
  45 #include <string.h>
  46 #include <unistd.h>
  47 #include <assert.h>
  48 #include <pthread.h>
  49 #include <sys/ioctl.h>
  50 #include <sys/mman.h>
  51 #include <sys/stat.h>
  52 #include <sys/types.h>
  53
  54 #include "errno.h"
  55 #include "libdrm_lists.h"
  56 #include "intel_atomic.h"
  57 #include "intel_bufmgr.h"
  58 #include "intel_bufmgr_priv.h"
  59 #include "intel_chipset.h"
  60 #include "string.h"
  61
  62 #include "i915_drm.h"
  63
  64 #define DBG(...) do {                                   \
  65         if (bufmgr_gem->bufmgr.debug)                   \
  66                 fprintf(stderr, __VA_ARGS__);           \
  67 } while (0)
  68
  69 typedef struct _drm_intel_bo_gem drm_intel_bo_gem;
  70
  71 struct drm_intel_gem_bo_bucket {
  72         drmMMListHead head;
  73         unsigned long size;
  74 };
  75
  76 /* Only cache objects up to 64MB.  Bigger than that, and the rounding of the
  77  * size makes many operations fail that wouldn't otherwise.
  78  */
  79 #define DRM_INTEL_GEM_BO_BUCKETS        14
  80 typedef struct _drm_intel_bufmgr_gem {
  81         drm_intel_bufmgr bufmgr;
  82
  83         int fd;
  84
  85         int max_relocs;
  86
  87         pthread_mutex_t lock;
  88
  89         struct drm_i915_gem_exec_object *exec_objects;
  90         drm_intel_bo **exec_bos;
  91         int exec_size;
  92         int exec_count;
  93
  94         /** Array of lists of cached gem objects of power-of-two sizes */
  95         struct drm_intel_gem_bo_bucket cache_bucket[DRM_INTEL_GEM_BO_BUCKETS];
  96
  97         uint64_t gtt_size;
  98         int available_fences;
  99         int pci_device;
 100         char bo_reuse;
 101 } drm_intel_bufmgr_gem;
 102
 103 struct _drm_intel_bo_gem {
 104         drm_intel_bo bo;
 105
 106         atomic_t refcount;
 107         uint32_t gem_handle;
 108         const char *name;
 109
 110         /**
 111          * Kenel-assigned global name for this object
 112          */
 113         unsigned int global_name;
 114
 115         /**
 116          * Index of the buffer within the validation list while preparing a
 117          * batchbuffer execution.
 118          */
 119         int validate_index;
 120
 121         /**
 122          * Current tiling mode
 123          */
 124         uint32_t tiling_mode;
 125         uint32_t swizzle_mode;
 126
 127         time_t free_time;
 128
 129         /** Array passed to the DRM containing relocation information. */
 130         struct drm_i915_gem_relocation_entry *relocs;
 131         /** Array of bos corresponding to relocs[i].target_handle */
 132         drm_intel_bo **reloc_target_bo;
 133         /** Number of entries in relocs */
 134         int reloc_count;
 135         /** Mapped address for the buffer, saved across map/unmap cycles */
 136         void *mem_virtual;
 137         /** GTT virtual address for the buffer, saved across map/unmap cycles */
 138         void *gtt_virtual;
 139
 140         /** BO cache list */
 141         drmMMListHead head;
 142
 143         /**
 144          * Boolean of whether this BO and its children have been included in
 145          * the current drm_intel_bufmgr_check_aperture_space() total.
 146          */
 147         char included_in_check_aperture;
 148
 149         /**
 150          * Boolean of whether this buffer has been used as a relocation
 151          * target and had its size accounted for, and thus can't have any
 152          * further relocations added to it.
 153          */
 154         char used_as_reloc_target;
 155
 156         /**
 157          * Boolean of whether we have encountered an error whilst building the relocation tree.
 158          */
 159         char has_error;
 160
 161         /**
 162          * Boolean of whether this buffer can be re-used
 163          */
 164         char reusable;
 165
 166         /**
 167          * Size in bytes of this buffer and its relocation descendents.
 168          *
 169          * Used to avoid costly tree walking in
 170          * drm_intel_bufmgr_check_aperture in the common case.
 171          */
 172         int reloc_tree_size;
 173
 174         /**
 175          * Number of potential fence registers required by this buffer and its
 176          * relocations.
 177          */
 178         int reloc_tree_fences;
 179 };
 180
 181 static unsigned int
 182 drm_intel_gem_estimate_batch_space(drm_intel_bo ** bo_array, int count);
 183
 184 static unsigned int
 185 drm_intel_gem_compute_batch_space(drm_intel_bo ** bo_array, int count);
 186
 187 static int
 188 drm_intel_gem_bo_get_tiling(drm_intel_bo *bo, uint32_t * tiling_mode,
 189                             uint32_t * swizzle_mode);
 190
 191 static int
 192 drm_intel_gem_bo_set_tiling(drm_intel_bo *bo, uint32_t * tiling_mode,
 193                             uint32_t stride);
 194
 195 static void drm_intel_gem_bo_unreference_locked_timed(drm_intel_bo *bo,
 196                                                       time_t time);
 197
 198 static void drm_intel_gem_bo_unreference(drm_intel_bo *bo);
 199
 200 static void drm_intel_gem_bo_free(drm_intel_bo *bo);
 201
 202 static unsigned long
 203 drm_intel_gem_bo_tile_size(drm_intel_bufmgr_gem *bufmgr_gem, unsigned long size,
 204                            uint32_t *tiling_mode)
 205 {
 206         unsigned long min_size, max_size;
 207         unsigned long i;
 208
 209         if (*tiling_mode == I915_TILING_NONE)
 210                 return size;
 211
 212         /* 965+ just need multiples of page size for tiling */
 213         if (IS_I965G(bufmgr_gem))
 214                 return ROUND_UP_TO(size, 4096);
 215
 216         /* Older chips need powers of two, of at least 512k or 1M */
 217         if (IS_I9XX(bufmgr_gem)) {
 218                 min_size = 1024*1024;
 219                 max_size = 128*1024*1024;
 220         } else {
 221                 min_size = 512*1024;
 222                 max_size = 64*1024*1024;
 223         }
 224
 225         if (size > max_size) {
 226                 *tiling_mode = I915_TILING_NONE;
 227                 return size;
 228         }
 229
 230         for (i = min_size; i < size; i <<= 1)
 231                 ;
 232
 233         return i;
 234 }
 235
 236 /*
 237  * Round a given pitch up to the minimum required for X tiling on a
 238  * given chip.  We use 512 as the minimum to allow for a later tiling
 239  * change.
 240  */
 241 static unsigned long
 242 drm_intel_gem_bo_tile_pitch(drm_intel_bufmgr_gem *bufmgr_gem,
 243                             unsigned long pitch, uint32_t tiling_mode)
 244 {
 245         unsigned long tile_width = 512;
 246         unsigned long i;
 247
 248         if (tiling_mode == I915_TILING_NONE)
 249                 return ROUND_UP_TO(pitch, tile_width);
 250
 251         /* 965 is flexible */
 252         if (IS_I965G(bufmgr_gem))
 253                 return ROUND_UP_TO(pitch, tile_width);
 254
 255         /* Pre-965 needs power of two tile width */
 256         for (i = tile_width; i < pitch; i <<= 1)
 257                 ;
 258
 259         return i;
 260 }
 261
 262 static struct drm_intel_gem_bo_bucket *
 263 drm_intel_gem_bo_bucket_for_size(drm_intel_bufmgr_gem *bufmgr_gem,
 264                                  unsigned long size)
 265 {
 266         int i;
 267
 268         for (i = 0; i < DRM_INTEL_GEM_BO_BUCKETS; i++) {
 269                 struct drm_intel_gem_bo_bucket *bucket =
 270                     &bufmgr_gem->cache_bucket[i];
 271                 if (bucket->size >= size) {
 272                         return bucket;
 273                 }
 274         }
 275
 276         return NULL;
 277 }
 278
 279 static void
 280 drm_intel_gem_dump_validation_list(drm_intel_bufmgr_gem *bufmgr_gem)
 281 {
 282         int i, j;
 283
 284         for (i = 0; i < bufmgr_gem->exec_count; i++) {
 285                 drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
 286                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 287
 288                 if (bo_gem->relocs == NULL) {
 289                         DBG("%2d: %d (%s)\n", i, bo_gem->gem_handle,
 290                             bo_gem->name);
 291                         continue;
 292                 }
 293
 294                 for (j = 0; j < bo_gem->reloc_count; j++) {
 295                         drm_intel_bo *target_bo = bo_gem->reloc_target_bo[j];
 296                         drm_intel_bo_gem *target_gem =
 297                             (drm_intel_bo_gem *) target_bo;
 298
 299                         DBG("%2d: %d (%s)@0x%08llx -> "
 300                             "%d (%s)@0x%08lx + 0x%08x\n",
 301                             i,
 302                             bo_gem->gem_handle, bo_gem->name,
 303                             (unsigned long long)bo_gem->relocs[j].offset,
 304                             target_gem->gem_handle,
 305                             target_gem->name,
 306                             target_bo->offset,
 307                             bo_gem->relocs[j].delta);
 308                 }
 309         }
 310 }
 311
 312 static inline void
 313 drm_intel_gem_bo_reference(drm_intel_bo *bo)
 314 {
 315         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 316
 317         assert(atomic_read(&bo_gem->refcount) > 0);
 318         atomic_inc(&bo_gem->refcount);
 319 }
 320
 321 /**
 322  * Adds the given buffer to the list of buffers to be validated (moved into the
 323  * appropriate memory type) with the next batch submission.
 324  *
 325  * If a buffer is validated multiple times in a batch submission, it ends up
 326  * with the intersection of the memory type flags and the union of the
 327  * access flags.
 328  */
 329 static void
 330 drm_intel_add_validate_buffer(drm_intel_bo *bo)
 331 {
 332         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
 333         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 334         int index;
 335
 336         if (bo_gem->validate_index != -1)
 337                 return;
 338
 339         /* Extend the array of validation entries as necessary. */
 340         if (bufmgr_gem->exec_count == bufmgr_gem->exec_size) {
 341                 int new_size = bufmgr_gem->exec_size * 2;
 342
 343                 if (new_size == 0)
 344                         new_size = 5;
 345
 346                 bufmgr_gem->exec_objects =
 347                     realloc(bufmgr_gem->exec_objects,
 348                             sizeof(*bufmgr_gem->exec_objects) * new_size);
 349                 bufmgr_gem->exec_bos =
 350                     realloc(bufmgr_gem->exec_bos,
 351                             sizeof(*bufmgr_gem->exec_bos) * new_size);
 352                 bufmgr_gem->exec_size = new_size;
 353         }
 354
 355         index = bufmgr_gem->exec_count;
 356         bo_gem->validate_index = index;
 357         /* Fill in array entry */
 358         bufmgr_gem->exec_objects[index].handle = bo_gem->gem_handle;
 359         bufmgr_gem->exec_objects[index].relocation_count = bo_gem->reloc_count;
 360         bufmgr_gem->exec_objects[index].relocs_ptr = (uintptr_t) bo_gem->relocs;
 361         bufmgr_gem->exec_objects[index].alignment = 0;
 362         bufmgr_gem->exec_objects[index].offset = 0;
 363         bufmgr_gem->exec_bos[index] = bo;
 364         bufmgr_gem->exec_count++;
 365 }
 366
 367 #define RELOC_BUF_SIZE(x) ((I915_RELOC_HEADER + x * I915_RELOC0_STRIDE) * \
 368         sizeof(uint32_t))
 369
 370 static void
 371 drm_intel_bo_gem_set_in_aperture_size(drm_intel_bufmgr_gem *bufmgr_gem,
 372                                       drm_intel_bo_gem *bo_gem)
 373 {
 374         int size;
 375
 376         assert(!bo_gem->used_as_reloc_target);
 377
 378         /* The older chipsets are far-less flexible in terms of tiling,
 379          * and require tiled buffer to be size aligned in the aperture.
 380          * This means that in the worst possible case we will need a hole
 381          * twice as large as the object in order for it to fit into the
 382          * aperture. Optimal packing is for wimps.
 383          */
 384         size = bo_gem->bo.size;
 385         if (!IS_I965G(bufmgr_gem) && bo_gem->tiling_mode != I915_TILING_NONE)
 386                 size *= 2;
 387
 388         bo_gem->reloc_tree_size = size;
 389 }
 390
 391 static int
 392 drm_intel_setup_reloc_list(drm_intel_bo *bo)
 393 {
 394         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 395         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
 396         unsigned int max_relocs = bufmgr_gem->max_relocs;
 397
 398         if (bo->size / 4 < max_relocs)
 399                 max_relocs = bo->size / 4;
 400
 401         bo_gem->relocs = malloc(max_relocs *
 402                                 sizeof(struct drm_i915_gem_relocation_entry));
 403         bo_gem->reloc_target_bo = malloc(max_relocs * sizeof(drm_intel_bo *));
 404         if (bo_gem->relocs == NULL || bo_gem->reloc_target_bo == NULL) {
 405                 bo_gem->has_error = 1;
 406
 407                 free (bo_gem->relocs);
 408                 bo_gem->relocs = NULL;
 409
 410                 free (bo_gem->reloc_target_bo);
 411                 bo_gem->reloc_target_bo = NULL;
 412
 413                 return 1;
 414         }
 415
 416         return 0;
 417 }
 418
 419 static int
 420 drm_intel_gem_bo_busy(drm_intel_bo *bo)
 421 {
 422         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
 423         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 424         struct drm_i915_gem_busy busy;
 425         int ret;
 426
 427         memset(&busy, 0, sizeof(busy));
 428         busy.handle = bo_gem->gem_handle;
 429
 430         do {
 431                 ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_BUSY, &busy);
 432         } while (ret == -1 && errno == EINTR);
 433
 434         return (ret == 0 && busy.busy);
 435 }
 436
 437 static int
 438 drm_intel_gem_bo_madvise_internal(drm_intel_bufmgr_gem *bufmgr_gem,
 439                                   drm_intel_bo_gem *bo_gem, int state)
 440 {
 441         struct drm_i915_gem_madvise madv;
 442
 443         madv.handle = bo_gem->gem_handle;
 444         madv.madv = state;
 445         madv.retained = 1;
 446         ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_MADVISE, &madv);
 447
 448         return madv.retained;
 449 }
 450
 451 static int
 452 drm_intel_gem_bo_madvise(drm_intel_bo *bo, int madv)
 453 {
 454         return drm_intel_gem_bo_madvise_internal
 455                 ((drm_intel_bufmgr_gem *) bo->bufmgr,
 456                  (drm_intel_bo_gem *) bo,
 457                  madv);
 458 }
 459
 460 /* drop the oldest entries that have been purged by the kernel */
 461 static void
 462 drm_intel_gem_bo_cache_purge_bucket(drm_intel_bufmgr_gem *bufmgr_gem,
 463                                     struct drm_intel_gem_bo_bucket *bucket)
 464 {
 465         while (!DRMLISTEMPTY(&bucket->head)) {
 466                 drm_intel_bo_gem *bo_gem;
 467
 468                 bo_gem = DRMLISTENTRY(drm_intel_bo_gem,
 469                                       bucket->head.next, head);
 470                 if (drm_intel_gem_bo_madvise_internal
 471                     (bufmgr_gem, bo_gem, I915_MADV_DONTNEED))
 472                         break;
 473
 474                 DRMLISTDEL(&bo_gem->head);
 475                 drm_intel_gem_bo_free(&bo_gem->bo);
 476         }
 477 }
 478
 479 static drm_intel_bo *
 480 drm_intel_gem_bo_alloc_internal(drm_intel_bufmgr *bufmgr,
 481                                 const char *name,
 482                                 unsigned long size,
 483                                 unsigned long flags)
 484 {
 485         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
 486         drm_intel_bo_gem *bo_gem;
 487         unsigned int page_size = getpagesize();
 488         int ret;
 489         struct drm_intel_gem_bo_bucket *bucket;
 490         int alloc_from_cache;
 491         unsigned long bo_size;
 492         int for_render = 0;
 493
 494         if (flags & BO_ALLOC_FOR_RENDER)
 495                 for_render = 1;
 496
 497         /* Round the allocated size up to a power of two number of pages. */
 498         bucket = drm_intel_gem_bo_bucket_for_size(bufmgr_gem, size);
 499
 500         /* If we don't have caching at this size, don't actually round the
 501          * allocation up.
 502          */
 503         if (bucket == NULL) {
 504                 bo_size = size;
 505                 if (bo_size < page_size)
 506                         bo_size = page_size;
 507         } else {
 508                 bo_size = bucket->size;
 509         }
 510
 511         pthread_mutex_lock(&bufmgr_gem->lock);
 512         /* Get a buffer out of the cache if available */
 513 retry:
 514         alloc_from_cache = 0;
 515         if (bucket != NULL && !DRMLISTEMPTY(&bucket->head)) {
 516                 if (for_render) {
 517                         /* Allocate new render-target BOs from the tail (MRU)
 518                          * of the list, as it will likely be hot in the GPU
 519                          * cache and in the aperture for us.
 520                          */
 521                         bo_gem = DRMLISTENTRY(drm_intel_bo_gem,
 522                                               bucket->head.prev, head);
 523                         DRMLISTDEL(&bo_gem->head);
 524                         alloc_from_cache = 1;
 525                 } else {
 526                         /* For non-render-target BOs (where we're probably
 527                          * going to map it first thing in order to fill it
 528                          * with data), check if the last BO in the cache is
 529                          * unbusy, and only reuse in that case. Otherwise,
 530                          * allocating a new buffer is probably faster than
 531                          * waiting for the GPU to finish.
 532                          */
 533                         bo_gem = DRMLISTENTRY(drm_intel_bo_gem,
 534                                               bucket->head.next, head);
 535                         if (!drm_intel_gem_bo_busy(&bo_gem->bo)) {
 536                                 alloc_from_cache = 1;
 537                                 DRMLISTDEL(&bo_gem->head);
 538                         }
 539                 }
 540
 541                 if (alloc_from_cache) {
 542                         if (!drm_intel_gem_bo_madvise_internal
 543                             (bufmgr_gem, bo_gem, I915_MADV_WILLNEED)) {
 544                                 drm_intel_gem_bo_free(&bo_gem->bo);
 545                                 drm_intel_gem_bo_cache_purge_bucket(bufmgr_gem,
 546                                                                     bucket);
 547                                 goto retry;
 548                         }
 549                 }
 550         }
 551         pthread_mutex_unlock(&bufmgr_gem->lock);
 552
 553         if (!alloc_from_cache) {
 554                 struct drm_i915_gem_create create;
 555
 556                 bo_gem = calloc(1, sizeof(*bo_gem));
 557                 if (!bo_gem)
 558                         return NULL;
 559
 560                 bo_gem->bo.size = bo_size;
 561                 memset(&create, 0, sizeof(create));
 562                 create.size = bo_size;
 563
 564                 do {
 565                         ret = ioctl(bufmgr_gem->fd,
 566                                     DRM_IOCTL_I915_GEM_CREATE,
 567                                     &create);
 568                 } while (ret == -1 && errno == EINTR);
 569                 bo_gem->gem_handle = create.handle;
 570                 bo_gem->bo.handle = bo_gem->gem_handle;
 571                 if (ret != 0) {
 572                         free(bo_gem);
 573                         return NULL;
 574                 }
 575                 bo_gem->bo.bufmgr = bufmgr;
 576         }
 577
 578         bo_gem->name = name;
 579         atomic_set(&bo_gem->refcount, 1);
 580         bo_gem->validate_index = -1;
 581         bo_gem->reloc_tree_fences = 0;
 582         bo_gem->used_as_reloc_target = 0;
 583         bo_gem->has_error = 0;
 584         bo_gem->tiling_mode = I915_TILING_NONE;
 585         bo_gem->swizzle_mode = I915_BIT_6_SWIZZLE_NONE;
 586         bo_gem->reusable = 1;
 587
 588         drm_intel_bo_gem_set_in_aperture_size(bufmgr_gem, bo_gem);
 589
 590         DBG("bo_create: buf %d (%s) %ldb\n",
 591             bo_gem->gem_handle, bo_gem->name, size);
 592
 593         return &bo_gem->bo;
 594 }
 595
 596 static drm_intel_bo *
 597 drm_intel_gem_bo_alloc_for_render(drm_intel_bufmgr *bufmgr,
 598                                   const char *name,
 599                                   unsigned long size,
 600                                   unsigned int alignment)
 601 {
 602         return drm_intel_gem_bo_alloc_internal(bufmgr, name, size,
 603                                                BO_ALLOC_FOR_RENDER);
 604 }
 605
 606 static drm_intel_bo *
 607 drm_intel_gem_bo_alloc(drm_intel_bufmgr *bufmgr,
 608                        const char *name,
 609                        unsigned long size,
 610                        unsigned int alignment)
 611 {
 612         return drm_intel_gem_bo_alloc_internal(bufmgr, name, size, 0);
 613 }
 614
 615 static drm_intel_bo *
 616 drm_intel_gem_bo_alloc_tiled(drm_intel_bufmgr *bufmgr, const char *name,
 617                              int x, int y, int cpp, uint32_t *tiling_mode,
 618                              unsigned long *pitch, unsigned long flags)
 619 {
 620         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
 621         drm_intel_bo *bo;
 622         unsigned long size, stride, aligned_y = y;
 623         int ret;
 624
 625         if (*tiling_mode == I915_TILING_NONE)
 626                 aligned_y = ALIGN(y, 2);
 627         else if (*tiling_mode == I915_TILING_X)
 628                 aligned_y = ALIGN(y, 8);
 629         else if (*tiling_mode == I915_TILING_Y)
 630                 aligned_y = ALIGN(y, 32);
 631
 632         stride = x * cpp;
 633         stride = drm_intel_gem_bo_tile_pitch(bufmgr_gem, stride, *tiling_mode);
 634         size = stride * aligned_y;
 635         size = drm_intel_gem_bo_tile_size(bufmgr_gem, size, tiling_mode);
 636
 637         bo = drm_intel_gem_bo_alloc_internal(bufmgr, name, size, flags);
 638         if (!bo)
 639                 return NULL;
 640
 641         ret = drm_intel_gem_bo_set_tiling(bo, tiling_mode, stride);
 642         if (ret != 0) {
 643                 drm_intel_gem_bo_unreference(bo);
 644                 return NULL;
 645         }
 646
 647         *pitch = stride;
 648
 649         return bo;
 650 }
 651
 652 /**
 653  * Returns a drm_intel_bo wrapping the given buffer object handle.
 654  *
 655  * This can be used when one application needs to pass a buffer object
 656  * to another.
 657  */
 658 drm_intel_bo *
 659 drm_intel_bo_gem_create_from_name(drm_intel_bufmgr *bufmgr,
 660                                   const char *name,
 661                                   unsigned int handle)
 662 {
 663         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
 664         drm_intel_bo_gem *bo_gem;
 665         int ret;
 666         struct drm_gem_open open_arg;
 667         struct drm_i915_gem_get_tiling get_tiling;
 668
 669         bo_gem = calloc(1, sizeof(*bo_gem));
 670         if (!bo_gem)
 671                 return NULL;
 672
 673         memset(&open_arg, 0, sizeof(open_arg));
 674         open_arg.name = handle;
 675         do {
 676                 ret = ioctl(bufmgr_gem->fd,
 677                             DRM_IOCTL_GEM_OPEN,
 678                             &open_arg);
 679         } while (ret == -1 && errno == EINTR);
 680         if (ret != 0) {
 681                 fprintf(stderr, "Couldn't reference %s handle 0x%08x: %s\n",
 682                         name, handle, strerror(errno));
 683                 free(bo_gem);
 684                 return NULL;
 685         }
 686         bo_gem->bo.size = open_arg.size;
 687         bo_gem->bo.offset = 0;
 688         bo_gem->bo.virtual = NULL;
 689         bo_gem->bo.bufmgr = bufmgr;
 690         bo_gem->name = name;
 691         atomic_set(&bo_gem->refcount, 1);
 692         bo_gem->validate_index = -1;
 693         bo_gem->gem_handle = open_arg.handle;
 694         bo_gem->global_name = handle;
 695         bo_gem->reusable = 0;
 696
 697         memset(&get_tiling, 0, sizeof(get_tiling));
 698         get_tiling.handle = bo_gem->gem_handle;
 699         ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_GET_TILING, &get_tiling);
 700         if (ret != 0) {
 701                 drm_intel_gem_bo_unreference(&bo_gem->bo);
 702                 return NULL;
 703         }
 704         bo_gem->tiling_mode = get_tiling.tiling_mode;
 705         bo_gem->swizzle_mode = get_tiling.swizzle_mode;
 706         if (bo_gem->tiling_mode == I915_TILING_NONE)
 707                 bo_gem->reloc_tree_fences = 0;
 708         else
 709                 bo_gem->reloc_tree_fences = 1;
 710         drm_intel_bo_gem_set_in_aperture_size(bufmgr_gem, bo_gem);
 711
 712         DBG("bo_create_from_handle: %d (%s)\n", handle, bo_gem->name);
 713
 714         return &bo_gem->bo;
 715 }
 716
 717 static void
 718 drm_intel_gem_bo_free(drm_intel_bo *bo)
 719 {
 720         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
 721         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 722         struct drm_gem_close close;
 723         int ret;
 724
 725         if (bo_gem->mem_virtual)
 726                 munmap(bo_gem->mem_virtual, bo_gem->bo.size);
 727         if (bo_gem->gtt_virtual)
 728                 munmap(bo_gem->gtt_virtual, bo_gem->bo.size);
 729
 730         free(bo_gem->reloc_target_bo);
 731         free(bo_gem->relocs);
 732
 733         /* Close this object */
 734         memset(&close, 0, sizeof(close));
 735         close.handle = bo_gem->gem_handle;
 736         ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_GEM_CLOSE, &close);
 737         if (ret != 0) {
 738                 fprintf(stderr,
 739                         "DRM_IOCTL_GEM_CLOSE %d failed (%s): %s\n",
 740                         bo_gem->gem_handle, bo_gem->name, strerror(errno));
 741         }
 742         free(bo);
 743 }
 744
 745 /** Frees all cached buffers significantly older than @time. */
 746 static void
 747 drm_intel_gem_cleanup_bo_cache(drm_intel_bufmgr_gem *bufmgr_gem, time_t time)
 748 {
 749         int i;
 750
 751         for (i = 0; i < DRM_INTEL_GEM_BO_BUCKETS; i++) {
 752                 struct drm_intel_gem_bo_bucket *bucket =
 753                     &bufmgr_gem->cache_bucket[i];
 754
 755                 while (!DRMLISTEMPTY(&bucket->head)) {
 756                         drm_intel_bo_gem *bo_gem;
 757
 758                         bo_gem = DRMLISTENTRY(drm_intel_bo_gem,
 759                                               bucket->head.next, head);
 760                         if (time - bo_gem->free_time <= 1)
 761                                 break;
 762
 763                         DRMLISTDEL(&bo_gem->head);
 764
 765                         drm_intel_gem_bo_free(&bo_gem->bo);
 766                 }
 767         }
 768 }
 769
 770 static void
 771 drm_intel_gem_bo_unreference_final(drm_intel_bo *bo, time_t time)
 772 {
 773         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
 774         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 775         struct drm_intel_gem_bo_bucket *bucket;
 776         uint32_t tiling_mode;
 777         int i;
 778
 779         /* Unreference all the target buffers */
 780         for (i = 0; i < bo_gem->reloc_count; i++) {
 781                 drm_intel_gem_bo_unreference_locked_timed(bo_gem->
 782                                                           reloc_target_bo[i],
 783                                                           time);
 784         }
 785         bo_gem->reloc_count = 0;
 786         bo_gem->used_as_reloc_target = 0;
 787
 788         DBG("bo_unreference final: %d (%s)\n",
 789             bo_gem->gem_handle, bo_gem->name);
 790
 791         bucket = drm_intel_gem_bo_bucket_for_size(bufmgr_gem, bo->size);
 792         /* Put the buffer into our internal cache for reuse if we can. */
 793         tiling_mode = I915_TILING_NONE;
 794         if (bufmgr_gem->bo_reuse && bo_gem->reusable && bucket != NULL &&
 795             drm_intel_gem_bo_set_tiling(bo, &tiling_mode, 0) == 0 &&
 796             drm_intel_gem_bo_madvise_internal(bufmgr_gem, bo_gem,
 797                                               I915_MADV_DONTNEED)) {
 798                 bo_gem->free_time = time;
 799
 800                 bo_gem->name = NULL;
 801                 bo_gem->validate_index = -1;
 802
 803                 DRMLISTADDTAIL(&bo_gem->head, &bucket->head);
 804
 805                 drm_intel_gem_cleanup_bo_cache(bufmgr_gem, time);
 806         } else {
 807                 drm_intel_gem_bo_free(bo);
 808         }
 809 }
 810
 811 static void drm_intel_gem_bo_unreference_locked_timed(drm_intel_bo *bo,
 812                                                       time_t time)
 813 {
 814         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 815
 816         assert(atomic_read(&bo_gem->refcount) > 0);
 817         if (atomic_dec_and_test(&bo_gem->refcount))
 818                 drm_intel_gem_bo_unreference_final(bo, time);
 819 }
 820
 821 static void drm_intel_gem_bo_unreference(drm_intel_bo *bo)
 822 {
 823         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 824
 825         assert(atomic_read(&bo_gem->refcount) > 0);
 826         if (atomic_dec_and_test(&bo_gem->refcount)) {
 827                 drm_intel_bufmgr_gem *bufmgr_gem =
 828                     (drm_intel_bufmgr_gem *) bo->bufmgr;
 829                 struct timespec time;
 830
 831                 clock_gettime(CLOCK_MONOTONIC, &time);
 832
 833                 pthread_mutex_lock(&bufmgr_gem->lock);
 834                 drm_intel_gem_bo_unreference_final(bo, time.tv_sec);
 835                 pthread_mutex_unlock(&bufmgr_gem->lock);
 836         }
 837 }
 838
 839 static int drm_intel_gem_bo_map(drm_intel_bo *bo, int write_enable)
 840 {
 841         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
 842         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 843         struct drm_i915_gem_set_domain set_domain;
 844         int ret;
 845
 846         pthread_mutex_lock(&bufmgr_gem->lock);
 847
 848         /* Allow recursive mapping. Mesa may recursively map buffers with
 849          * nested display loops.
 850          */
 851         if (!bo_gem->mem_virtual) {
 852                 struct drm_i915_gem_mmap mmap_arg;
 853
 854                 DBG("bo_map: %d (%s)\n", bo_gem->gem_handle, bo_gem->name);
 855
 856                 memset(&mmap_arg, 0, sizeof(mmap_arg));
 857                 mmap_arg.handle = bo_gem->gem_handle;
 858                 mmap_arg.offset = 0;
 859                 mmap_arg.size = bo->size;
 860                 do {
 861                         ret = ioctl(bufmgr_gem->fd,
 862                                     DRM_IOCTL_I915_GEM_MMAP,
 863                                     &mmap_arg);
 864                 } while (ret == -1 && errno == EINTR);
 865                 if (ret != 0) {
 866                         ret = -errno;
 867                         fprintf(stderr,
 868                                 "%s:%d: Error mapping buffer %d (%s): %s .\n",
 869                                 __FILE__, __LINE__, bo_gem->gem_handle,
 870                                 bo_gem->name, strerror(errno));
 871                         pthread_mutex_unlock(&bufmgr_gem->lock);
 872                         return ret;
 873                 }
 874                 bo_gem->mem_virtual = (void *)(uintptr_t) mmap_arg.addr_ptr;
 875         }
 876         DBG("bo_map: %d (%s) -> %p\n", bo_gem->gem_handle, bo_gem->name,
 877             bo_gem->mem_virtual);
 878         bo->virtual = bo_gem->mem_virtual;
 879
 880         set_domain.handle = bo_gem->gem_handle;
 881         set_domain.read_domains = I915_GEM_DOMAIN_CPU;
 882         if (write_enable)
 883                 set_domain.write_domain = I915_GEM_DOMAIN_CPU;
 884         else
 885                 set_domain.write_domain = 0;
 886         do {
 887                 ret = ioctl(bufmgr_gem->fd,
 888                             DRM_IOCTL_I915_GEM_SET_DOMAIN,
 889                             &set_domain);
 890         } while (ret == -1 && errno == EINTR);
 891         if (ret != 0) {
 892                 ret = -errno;
 893                 fprintf(stderr, "%s:%d: Error setting to CPU domain %d: %s\n",
 894                         __FILE__, __LINE__, bo_gem->gem_handle,
 895                         strerror(errno));
 896                 pthread_mutex_unlock(&bufmgr_gem->lock);
 897                 return ret;
 898         }
 899
 900         pthread_mutex_unlock(&bufmgr_gem->lock);
 901
 902         return 0;
 903 }
 904
 905 int drm_intel_gem_bo_map_gtt(drm_intel_bo *bo)
 906 {
 907         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
 908         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 909         struct drm_i915_gem_set_domain set_domain;
 910         int ret;
 911
 912         pthread_mutex_lock(&bufmgr_gem->lock);
 913
 914         /* Get a mapping of the buffer if we haven't before. */
 915         if (bo_gem->gtt_virtual == NULL) {
 916                 struct drm_i915_gem_mmap_gtt mmap_arg;
 917
 918                 DBG("bo_map_gtt: mmap %d (%s)\n", bo_gem->gem_handle,
 919                     bo_gem->name);
 920
 921                 memset(&mmap_arg, 0, sizeof(mmap_arg));
 922                 mmap_arg.handle = bo_gem->gem_handle;
 923
 924                 /* Get the fake offset back... */
 925                 do {
 926                         ret = ioctl(bufmgr_gem->fd,
 927                                     DRM_IOCTL_I915_GEM_MMAP_GTT,
 928                                     &mmap_arg);
 929                 } while (ret == -1 && errno == EINTR);
 930                 if (ret != 0) {
 931                         ret = -errno;
 932                         fprintf(stderr,
 933                                 "%s:%d: Error preparing buffer map %d (%s): %s .\n",
 934                                 __FILE__, __LINE__,
 935                                 bo_gem->gem_handle, bo_gem->name,
 936                                 strerror(errno));
 937                         pthread_mutex_unlock(&bufmgr_gem->lock);
 938                         return ret;
 939                 }
 940
 941                 /* and mmap it */
 942                 bo_gem->gtt_virtual = mmap(0, bo->size, PROT_READ | PROT_WRITE,
 943                                            MAP_SHARED, bufmgr_gem->fd,
 944                                            mmap_arg.offset);
 945                 if (bo_gem->gtt_virtual == MAP_FAILED) {
 946                         ret = -errno;
 947                         fprintf(stderr,
 948                                 "%s:%d: Error mapping buffer %d (%s): %s .\n",
 949                                 __FILE__, __LINE__,
 950                                 bo_gem->gem_handle, bo_gem->name,
 951                                 strerror(errno));
 952                         pthread_mutex_unlock(&bufmgr_gem->lock);
 953                         return ret;
 954                 }
 955         }
 956
 957         bo->virtual = bo_gem->gtt_virtual;
 958
 959         DBG("bo_map_gtt: %d (%s) -> %p\n", bo_gem->gem_handle, bo_gem->name,
 960             bo_gem->gtt_virtual);
 961
 962         /* Now move it to the GTT domain so that the CPU caches are flushed */
 963         set_domain.handle = bo_gem->gem_handle;
 964         set_domain.read_domains = I915_GEM_DOMAIN_GTT;
 965         set_domain.write_domain = I915_GEM_DOMAIN_GTT;
 966         do {
 967                 ret = ioctl(bufmgr_gem->fd,
 968                             DRM_IOCTL_I915_GEM_SET_DOMAIN,
 969                             &set_domain);
 970         } while (ret == -1 && errno == EINTR);
 971
 972         if (ret != 0) {
 973                 ret = -errno;
 974                 fprintf(stderr, "%s:%d: Error setting domain %d: %s\n",
 975                         __FILE__, __LINE__, bo_gem->gem_handle,
 976                         strerror(errno));
 977         }
 978
 979         pthread_mutex_unlock(&bufmgr_gem->lock);
 980
 981         return ret;
 982 }
 983
 984 int drm_intel_gem_bo_unmap_gtt(drm_intel_bo *bo)
 985 {
 986         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
 987         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 988         int ret = 0;
 989
 990         if (bo == NULL)
 991                 return 0;
 992
 993         assert(bo_gem->gtt_virtual != NULL);
 994
 995         pthread_mutex_lock(&bufmgr_gem->lock);
 996         bo->virtual = NULL;
 997         pthread_mutex_unlock(&bufmgr_gem->lock);
 998
 999         return ret;
1000 }
1001
1002 static int drm_intel_gem_bo_unmap(drm_intel_bo *bo)
1003 {
1004         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1005         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1006         struct drm_i915_gem_sw_finish sw_finish;
1007         int ret;
1008
1009         if (bo == NULL)
1010                 return 0;
1011
1012         assert(bo_gem->mem_virtual != NULL);
1013
1014         pthread_mutex_lock(&bufmgr_gem->lock);
1015
1016         /* Cause a flush to happen if the buffer's pinned for scanout, so the
1017          * results show up in a timely manner.
1018          */
1019         sw_finish.handle = bo_gem->gem_handle;
1020         do {
1021                 ret = ioctl(bufmgr_gem->fd,
1022                             DRM_IOCTL_I915_GEM_SW_FINISH,
1023                             &sw_finish);
1024         } while (ret == -1 && errno == EINTR);
1025
1026         bo->virtual = NULL;
1027         pthread_mutex_unlock(&bufmgr_gem->lock);
1028         return 0;
1029 }
1030
1031 static int
1032 drm_intel_gem_bo_subdata(drm_intel_bo *bo, unsigned long offset,
1033                          unsigned long size, const void *data)
1034 {
1035         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1036         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1037         struct drm_i915_gem_pwrite pwrite;
1038         int ret;
1039
1040         memset(&pwrite, 0, sizeof(pwrite));
1041         pwrite.handle = bo_gem->gem_handle;
1042         pwrite.offset = offset;
1043         pwrite.size = size;
1044         pwrite.data_ptr = (uint64_t) (uintptr_t) data;
1045         do {
1046                 ret = ioctl(bufmgr_gem->fd,
1047                             DRM_IOCTL_I915_GEM_PWRITE,
1048                             &pwrite);
1049         } while (ret == -1 && errno == EINTR);
1050         if (ret != 0) {
1051                 fprintf(stderr,
1052                         "%s:%d: Error writing data to buffer %d: (%d %d) %s .\n",
1053                         __FILE__, __LINE__, bo_gem->gem_handle, (int)offset,
1054                         (int)size, strerror(errno));
1055         }
1056         return 0;
1057 }
1058
1059 static int
1060 drm_intel_gem_get_pipe_from_crtc_id(drm_intel_bufmgr *bufmgr, int crtc_id)
1061 {
1062         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
1063         struct drm_i915_get_pipe_from_crtc_id get_pipe_from_crtc_id;
1064         int ret;
1065
1066         get_pipe_from_crtc_id.crtc_id = crtc_id;
1067         ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GET_PIPE_FROM_CRTC_ID,
1068                     &get_pipe_from_crtc_id);
1069         if (ret != 0) {
1070                 /* We return -1 here to signal that we don't
1071                  * know which pipe is associated with this crtc.
1072                  * This lets the caller know that this information
1073                  * isn't available; using the wrong pipe for
1074                  * vblank waiting can cause the chipset to lock up
1075                  */
1076                 return -1;
1077         }
1078
1079         return get_pipe_from_crtc_id.pipe;
1080 }
1081
1082 static int
1083 drm_intel_gem_bo_get_subdata(drm_intel_bo *bo, unsigned long offset,
1084                              unsigned long size, void *data)
1085 {
1086         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1087         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1088         struct drm_i915_gem_pread pread;
1089         int ret;
1090
1091         memset(&pread, 0, sizeof(pread));
1092         pread.handle = bo_gem->gem_handle;
1093         pread.offset = offset;
1094         pread.size = size;
1095         pread.data_ptr = (uint64_t) (uintptr_t) data;
1096         do {
1097                 ret = ioctl(bufmgr_gem->fd,
1098                             DRM_IOCTL_I915_GEM_PREAD,
1099                             &pread);
1100         } while (ret == -1 && errno == EINTR);
1101         if (ret != 0) {
1102                 ret = -errno;
1103                 fprintf(stderr,
1104                         "%s:%d: Error reading data from buffer %d: (%d %d) %s .\n",
1105                         __FILE__, __LINE__, bo_gem->gem_handle, (int)offset,
1106                         (int)size, strerror(errno));
1107         }
1108         return ret;
1109 }
1110
1111 /** Waits for all GPU rendering to the object to have completed. */
1112 static void
1113 drm_intel_gem_bo_wait_rendering(drm_intel_bo *bo)
1114 {
1115         drm_intel_gem_bo_start_gtt_access(bo, 0);
1116 }
1117
1118 /**
1119  * Sets the object to the GTT read and possibly write domain, used by the X
1120  * 2D driver in the absence of kernel support to do drm_intel_gem_bo_map_gtt().
1121  *
1122  * In combination with drm_intel_gem_bo_pin() and manual fence management, we
1123  * can do tiled pixmaps this way.
1124  */
1125 void
1126 drm_intel_gem_bo_start_gtt_access(drm_intel_bo *bo, int write_enable)
1127 {
1128         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1129         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1130         struct drm_i915_gem_set_domain set_domain;
1131         int ret;
1132
1133         set_domain.handle = bo_gem->gem_handle;
1134         set_domain.read_domains = I915_GEM_DOMAIN_GTT;
1135         set_domain.write_domain = write_enable ? I915_GEM_DOMAIN_GTT : 0;
1136         do {
1137                 ret = ioctl(bufmgr_gem->fd,
1138                             DRM_IOCTL_I915_GEM_SET_DOMAIN,
1139                             &set_domain);
1140         } while (ret == -1 && errno == EINTR);
1141         if (ret != 0) {
1142                 fprintf(stderr,
1143                         "%s:%d: Error setting memory domains %d (%08x %08x): %s .\n",
1144                         __FILE__, __LINE__, bo_gem->gem_handle,
1145                         set_domain.read_domains, set_domain.write_domain,
1146                         strerror(errno));
1147         }
1148 }
1149
1150 static void
1151 drm_intel_bufmgr_gem_destroy(drm_intel_bufmgr *bufmgr)
1152 {
1153         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
1154         int i;
1155
1156         free(bufmgr_gem->exec_objects);
1157         free(bufmgr_gem->exec_bos);
1158
1159         pthread_mutex_destroy(&bufmgr_gem->lock);
1160
1161         /* Free any cached buffer objects we were going to reuse */
1162         for (i = 0; i < DRM_INTEL_GEM_BO_BUCKETS; i++) {
1163                 struct drm_intel_gem_bo_bucket *bucket =
1164                     &bufmgr_gem->cache_bucket[i];
1165                 drm_intel_bo_gem *bo_gem;
1166
1167                 while (!DRMLISTEMPTY(&bucket->head)) {
1168                         bo_gem = DRMLISTENTRY(drm_intel_bo_gem,
1169                                               bucket->head.next, head);
1170                         DRMLISTDEL(&bo_gem->head);
1171
1172                         drm_intel_gem_bo_free(&bo_gem->bo);
1173                 }
1174         }
1175
1176         free(bufmgr);
1177 }
1178
1179 /**
1180  * Adds the target buffer to the validation list and adds the relocation
1181  * to the reloc_buffer's relocation list.
1182  *
1183  * The relocation entry at the given offset must already contain the
1184  * precomputed relocation value, because the kernel will optimize out
1185  * the relocation entry write when the buffer hasn't moved from the
1186  * last known offset in target_bo.
1187  */
1188 static int
1189 drm_intel_gem_bo_emit_reloc(drm_intel_bo *bo, uint32_t offset,
1190                             drm_intel_bo *target_bo, uint32_t target_offset,
1191                             uint32_t read_domains, uint32_t write_domain)
1192 {
1193         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1194         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1195         drm_intel_bo_gem *target_bo_gem = (drm_intel_bo_gem *) target_bo;
1196
1197         pthread_mutex_lock(&bufmgr_gem->lock);
1198         if (bo_gem->has_error) {
1199                 pthread_mutex_unlock(&bufmgr_gem->lock);
1200                 return -ENOMEM;
1201         }
1202
1203         if (target_bo_gem->has_error) {
1204                 bo_gem->has_error = 1;
1205                 pthread_mutex_unlock(&bufmgr_gem->lock);
1206                 return -ENOMEM;
1207         }
1208
1209         /* Create a new relocation list if needed */
1210         if (bo_gem->relocs == NULL && drm_intel_setup_reloc_list(bo)) {
1211                 pthread_mutex_unlock(&bufmgr_gem->lock);
1212                 return -ENOMEM;
1213         }
1214
1215         /* Check overflow */
1216         assert(bo_gem->reloc_count < bufmgr_gem->max_relocs);
1217
1218         /* Check args */
1219         assert(offset <= bo->size - 4);
1220         assert((write_domain & (write_domain - 1)) == 0);
1221
1222         /* Make sure that we're not adding a reloc to something whose size has
1223          * already been accounted for.
1224          */
1225         assert(!bo_gem->used_as_reloc_target);
1226         bo_gem->reloc_tree_size += target_bo_gem->reloc_tree_size;
1227         bo_gem->reloc_tree_fences += target_bo_gem->reloc_tree_fences;
1228
1229         /* Flag the target to disallow further relocations in it. */
1230         target_bo_gem->used_as_reloc_target = 1;
1231
1232         bo_gem->relocs[bo_gem->reloc_count].offset = offset;
1233         bo_gem->relocs[bo_gem->reloc_count].delta = target_offset;
1234         bo_gem->relocs[bo_gem->reloc_count].target_handle =
1235             target_bo_gem->gem_handle;
1236         bo_gem->relocs[bo_gem->reloc_count].read_domains = read_domains;
1237         bo_gem->relocs[bo_gem->reloc_count].write_domain = write_domain;
1238         bo_gem->relocs[bo_gem->reloc_count].presumed_offset = target_bo->offset;
1239
1240         bo_gem->reloc_target_bo[bo_gem->reloc_count] = target_bo;
1241         drm_intel_gem_bo_reference(target_bo);
1242
1243         bo_gem->reloc_count++;
1244
1245         pthread_mutex_unlock(&bufmgr_gem->lock);
1246
1247         return 0;
1248 }
1249
1250 /**
1251  * Walk the tree of relocations rooted at BO and accumulate the list of
1252  * validations to be performed and update the relocation buffers with
1253  * index values into the validation list.
1254  */
1255 static void
1256 drm_intel_gem_bo_process_reloc(drm_intel_bo *bo)
1257 {
1258         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1259         int i;
1260
1261         if (bo_gem->relocs == NULL)
1262                 return;
1263
1264         for (i = 0; i < bo_gem->reloc_count; i++) {
1265                 drm_intel_bo *target_bo = bo_gem->reloc_target_bo[i];
1266
1267                 /* Continue walking the tree depth-first. */
1268                 drm_intel_gem_bo_process_reloc(target_bo);
1269
1270                 /* Add the target to the validate list */
1271                 drm_intel_add_validate_buffer(target_bo);
1272         }
1273 }
1274
1275 static void
1276 drm_intel_update_buffer_offsets(drm_intel_bufmgr_gem *bufmgr_gem)
1277 {
1278         int i;
1279
1280         for (i = 0; i < bufmgr_gem->exec_count; i++) {
1281                 drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
1282                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1283
1284                 /* Update the buffer offset */
1285                 if (bufmgr_gem->exec_objects[i].offset != bo->offset) {
1286                         DBG("BO %d (%s) migrated: 0x%08lx -> 0x%08llx\n",
1287                             bo_gem->gem_handle, bo_gem->name, bo->offset,
1288                             (unsigned long long)bufmgr_gem->exec_objects[i].
1289                             offset);
1290                         bo->offset = bufmgr_gem->exec_objects[i].offset;
1291                 }
1292         }
1293 }
1294
1295 static int
1296 drm_intel_gem_bo_exec(drm_intel_bo *bo, int used,
1297                       drm_clip_rect_t * cliprects, int num_cliprects, int DR4)
1298 {
1299         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1300         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1301         struct drm_i915_gem_execbuffer execbuf;
1302         int ret, i;
1303
1304         if (bo_gem->has_error)
1305                 return -ENOMEM;
1306
1307         pthread_mutex_lock(&bufmgr_gem->lock);
1308         /* Update indices and set up the validate list. */
1309         drm_intel_gem_bo_process_reloc(bo);
1310
1311         /* Add the batch buffer to the validation list.  There are no
1312          * relocations pointing to it.
1313          */
1314         drm_intel_add_validate_buffer(bo);
1315
1316         execbuf.buffers_ptr = (uintptr_t) bufmgr_gem->exec_objects;
1317         execbuf.buffer_count = bufmgr_gem->exec_count;
1318         execbuf.batch_start_offset = 0;
1319         execbuf.batch_len = used;
1320         execbuf.cliprects_ptr = (uintptr_t) cliprects;
1321         execbuf.num_cliprects = num_cliprects;
1322         execbuf.DR1 = 0;
1323         execbuf.DR4 = DR4;
1324
1325         do {
1326                 ret = ioctl(bufmgr_gem->fd,
1327                             DRM_IOCTL_I915_GEM_EXECBUFFER,
1328                             &execbuf);
1329         } while (ret != 0 && errno == EINTR);
1330
1331         if (ret != 0) {
1332                 ret = -errno;
1333                 if (errno == ENOSPC) {
1334                         fprintf(stderr,
1335                                 "Execbuffer fails to pin. "
1336                                 "Estimate: %u. Actual: %u. Available: %u\n",
1337                                 drm_intel_gem_estimate_batch_space(bufmgr_gem->exec_bos,
1338                                                                    bufmgr_gem->
1339                                                                    exec_count),
1340                                 drm_intel_gem_compute_batch_space(bufmgr_gem->exec_bos,
1341                                                                   bufmgr_gem->
1342                                                                   exec_count),
1343                                 (unsigned int)bufmgr_gem->gtt_size);
1344                 }
1345         }
1346         drm_intel_update_buffer_offsets(bufmgr_gem);
1347
1348         if (bufmgr_gem->bufmgr.debug)
1349                 drm_intel_gem_dump_validation_list(bufmgr_gem);
1350
1351         for (i = 0; i < bufmgr_gem->exec_count; i++) {
1352                 drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
1353                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1354
1355                 /* Disconnect the buffer from the validate list */
1356                 bo_gem->validate_index = -1;
1357                 bufmgr_gem->exec_bos[i] = NULL;
1358         }
1359         bufmgr_gem->exec_count = 0;
1360         pthread_mutex_unlock(&bufmgr_gem->lock);
1361
1362         return ret;
1363 }
1364
1365 static int
1366 drm_intel_gem_bo_pin(drm_intel_bo *bo, uint32_t alignment)
1367 {
1368         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1369         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1370         struct drm_i915_gem_pin pin;
1371         int ret;
1372
1373         memset(&pin, 0, sizeof(pin));
1374         pin.handle = bo_gem->gem_handle;
1375         pin.alignment = alignment;
1376
1377         do {
1378                 ret = ioctl(bufmgr_gem->fd,
1379                             DRM_IOCTL_I915_GEM_PIN,
1380                             &pin);
1381         } while (ret == -1 && errno == EINTR);
1382
1383         if (ret != 0)
1384                 return -errno;
1385
1386         bo->offset = pin.offset;
1387         return 0;
1388 }
1389
1390 static int
1391 drm_intel_gem_bo_unpin(drm_intel_bo *bo)
1392 {
1393         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1394         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1395         struct drm_i915_gem_unpin unpin;
1396         int ret;
1397
1398         memset(&unpin, 0, sizeof(unpin));
1399         unpin.handle = bo_gem->gem_handle;
1400
1401         ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_UNPIN, &unpin);
1402         if (ret != 0)
1403                 return -errno;
1404
1405         return 0;
1406 }
1407
1408 static int
1409 drm_intel_gem_bo_set_tiling(drm_intel_bo *bo, uint32_t * tiling_mode,
1410                             uint32_t stride)
1411 {
1412         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1413         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1414         struct drm_i915_gem_set_tiling set_tiling;
1415         int ret;
1416
1417         if (bo_gem->global_name == 0 && *tiling_mode == bo_gem->tiling_mode)
1418                 return 0;
1419
1420         /* If we're going from non-tiling to tiling, bump fence count */
1421         if (bo_gem->tiling_mode == I915_TILING_NONE)
1422                 bo_gem->reloc_tree_fences++;
1423
1424         memset(&set_tiling, 0, sizeof(set_tiling));
1425         set_tiling.handle = bo_gem->gem_handle;
1426         set_tiling.tiling_mode = *tiling_mode;
1427         set_tiling.stride = stride;
1428
1429         do {
1430                 ret = ioctl(bufmgr_gem->fd,
1431                             DRM_IOCTL_I915_GEM_SET_TILING,
1432                             &set_tiling);
1433         } while (ret == -1 && errno == EINTR);
1434         if (ret != 0) {
1435                 *tiling_mode = bo_gem->tiling_mode;
1436                 return -errno;
1437         }
1438         bo_gem->tiling_mode = set_tiling.tiling_mode;
1439         bo_gem->swizzle_mode = set_tiling.swizzle_mode;
1440
1441         /* If we're going from tiling to non-tiling, drop fence count */
1442         if (bo_gem->tiling_mode == I915_TILING_NONE)
1443                 bo_gem->reloc_tree_fences--;
1444
1445         drm_intel_bo_gem_set_in_aperture_size(bufmgr_gem, bo_gem);
1446
1447         *tiling_mode = bo_gem->tiling_mode;
1448         return 0;
1449 }
1450
1451 static int
1452 drm_intel_gem_bo_get_tiling(drm_intel_bo *bo, uint32_t * tiling_mode,
1453                             uint32_t * swizzle_mode)
1454 {
1455         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1456
1457         *tiling_mode = bo_gem->tiling_mode;
1458         *swizzle_mode = bo_gem->swizzle_mode;
1459         return 0;
1460 }
1461
1462 static int
1463 drm_intel_gem_bo_flink(drm_intel_bo *bo, uint32_t * name)
1464 {
1465         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1466         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1467         struct drm_gem_flink flink;
1468         int ret;
1469
1470         if (!bo_gem->global_name) {
1471                 memset(&flink, 0, sizeof(flink));
1472                 flink.handle = bo_gem->gem_handle;
1473
1474                 ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_GEM_FLINK, &flink);
1475                 if (ret != 0)
1476                         return -errno;
1477                 bo_gem->global_name = flink.name;
1478                 bo_gem->reusable = 0;
1479         }
1480
1481         *name = bo_gem->global_name;
1482         return 0;
1483 }
1484
1485 /**
1486  * Enables unlimited caching of buffer objects for reuse.
1487  *
1488  * This is potentially very memory expensive, as the cache at each bucket
1489  * size is only bounded by how many buffers of that size we've managed to have
1490  * in flight at once.
1491  */
1492 void
1493 drm_intel_bufmgr_gem_enable_reuse(drm_intel_bufmgr *bufmgr)
1494 {
1495         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
1496
1497         bufmgr_gem->bo_reuse = 1;
1498 }
1499
1500 /**
1501  * Return the additional aperture space required by the tree of buffer objects
1502  * rooted at bo.
1503  */
1504 static int
1505 drm_intel_gem_bo_get_aperture_space(drm_intel_bo *bo)
1506 {
1507         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1508         int i;
1509         int total = 0;
1510
1511         if (bo == NULL || bo_gem->included_in_check_aperture)
1512                 return 0;
1513
1514         total += bo->size;
1515         bo_gem->included_in_check_aperture = 1;
1516
1517         for (i = 0; i < bo_gem->reloc_count; i++)
1518                 total +=
1519                     drm_intel_gem_bo_get_aperture_space(bo_gem->
1520                                                         reloc_target_bo[i]);
1521
1522         return total;
1523 }
1524
1525 /**
1526  * Count the number of buffers in this list that need a fence reg
1527  *
1528  * If the count is greater than the number of available regs, we'll have
1529  * to ask the caller to resubmit a batch with fewer tiled buffers.
1530  *
1531  * This function over-counts if the same buffer is used multiple times.
1532  */
1533 static unsigned int
1534 drm_intel_gem_total_fences(drm_intel_bo ** bo_array, int count)
1535 {
1536         int i;
1537         unsigned int total = 0;
1538
1539         for (i = 0; i < count; i++) {
1540                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo_array[i];
1541
1542                 if (bo_gem == NULL)
1543                         continue;
1544
1545                 total += bo_gem->reloc_tree_fences;
1546         }
1547         return total;
1548 }
1549
1550 /**
1551  * Clear the flag set by drm_intel_gem_bo_get_aperture_space() so we're ready
1552  * for the next drm_intel_bufmgr_check_aperture_space() call.
1553  */
1554 static void
1555 drm_intel_gem_bo_clear_aperture_space_flag(drm_intel_bo *bo)
1556 {
1557         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1558         int i;
1559
1560         if (bo == NULL || !bo_gem->included_in_check_aperture)
1561                 return;
1562
1563         bo_gem->included_in_check_aperture = 0;
1564
1565         for (i = 0; i < bo_gem->reloc_count; i++)
1566                 drm_intel_gem_bo_clear_aperture_space_flag(bo_gem->
1567                                                            reloc_target_bo[i]);
1568 }
1569
1570 /**
1571  * Return a conservative estimate for the amount of aperture required
1572  * for a collection of buffers. This may double-count some buffers.
1573  */
1574 static unsigned int
1575 drm_intel_gem_estimate_batch_space(drm_intel_bo **bo_array, int count)
1576 {
1577         int i;
1578         unsigned int total = 0;
1579
1580         for (i = 0; i < count; i++) {
1581                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo_array[i];
1582                 if (bo_gem != NULL)
1583                         total += bo_gem->reloc_tree_size;
1584         }
1585         return total;
1586 }
1587
1588 /**
1589  * Return the amount of aperture needed for a collection of buffers.
1590  * This avoids double counting any buffers, at the cost of looking
1591  * at every buffer in the set.
1592  */
1593 static unsigned int
1594 drm_intel_gem_compute_batch_space(drm_intel_bo **bo_array, int count)
1595 {
1596         int i;
1597         unsigned int total = 0;
1598
1599         for (i = 0; i < count; i++) {
1600                 total += drm_intel_gem_bo_get_aperture_space(bo_array[i]);
1601                 /* For the first buffer object in the array, we get an
1602                  * accurate count back for its reloc_tree size (since nothing
1603                  * had been flagged as being counted yet).  We can save that
1604                  * value out as a more conservative reloc_tree_size that
1605                  * avoids double-counting target buffers.  Since the first
1606                  * buffer happens to usually be the batch buffer in our
1607                  * callers, this can pull us back from doing the tree
1608                  * walk on every new batch emit.
1609                  */
1610                 if (i == 0) {
1611                         drm_intel_bo_gem *bo_gem =
1612                             (drm_intel_bo_gem *) bo_array[i];
1613                         bo_gem->reloc_tree_size = total;
1614                 }
1615         }
1616
1617         for (i = 0; i < count; i++)
1618                 drm_intel_gem_bo_clear_aperture_space_flag(bo_array[i]);
1619         return total;
1620 }
1621
1622 /**
1623  * Return -1 if the batchbuffer should be flushed before attempting to
1624  * emit rendering referencing the buffers pointed to by bo_array.
1625  *
1626  * This is required because if we try to emit a batchbuffer with relocations
1627  * to a tree of buffers that won't simultaneously fit in the aperture,
1628  * the rendering will return an error at a point where the software is not
1629  * prepared to recover from it.
1630  *
1631  * However, we also want to emit the batchbuffer significantly before we reach
1632  * the limit, as a series of batchbuffers each of which references buffers
1633  * covering almost all of the aperture means that at each emit we end up
1634  * waiting to evict a buffer from the last rendering, and we get synchronous
1635  * performance.  By emitting smaller batchbuffers, we eat some CPU overhead to
1636  * get better parallelism.
1637  */
1638 static int
1639 drm_intel_gem_check_aperture_space(drm_intel_bo **bo_array, int count)
1640 {
1641         drm_intel_bufmgr_gem *bufmgr_gem =
1642             (drm_intel_bufmgr_gem *) bo_array[0]->bufmgr;
1643         unsigned int total = 0;
1644         unsigned int threshold = bufmgr_gem->gtt_size * 3 / 4;
1645         int total_fences;
1646
1647         /* Check for fence reg constraints if necessary */
1648         if (bufmgr_gem->available_fences) {
1649                 total_fences = drm_intel_gem_total_fences(bo_array, count);
1650                 if (total_fences > bufmgr_gem->available_fences)
1651                         return -ENOSPC;
1652         }
1653
1654         total = drm_intel_gem_estimate_batch_space(bo_array, count);
1655
1656         if (total > threshold)
1657                 total = drm_intel_gem_compute_batch_space(bo_array, count);
1658
1659         if (total > threshold) {
1660                 DBG("check_space: overflowed available aperture, "
1661                     "%dkb vs %dkb\n",
1662                     total / 1024, (int)bufmgr_gem->gtt_size / 1024);
1663                 return -ENOSPC;
1664         } else {
1665                 DBG("drm_check_space: total %dkb vs bufgr %dkb\n", total / 1024,
1666                     (int)bufmgr_gem->gtt_size / 1024);
1667                 return 0;
1668         }
1669 }
1670
1671 /*
1672  * Disable buffer reuse for objects which are shared with the kernel
1673  * as scanout buffers
1674  */
1675 static int
1676 drm_intel_gem_bo_disable_reuse(drm_intel_bo *bo)
1677 {
1678         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1679
1680         bo_gem->reusable = 0;
1681         return 0;
1682 }
1683
1684 static int
1685 _drm_intel_gem_bo_references(drm_intel_bo *bo, drm_intel_bo *target_bo)
1686 {
1687         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1688         int i;
1689
1690         for (i = 0; i < bo_gem->reloc_count; i++) {
1691                 if (bo_gem->reloc_target_bo[i] == target_bo)
1692                         return 1;
1693                 if (_drm_intel_gem_bo_references(bo_gem->reloc_target_bo[i],
1694                                                 target_bo))
1695                         return 1;
1696         }
1697
1698         return 0;
1699 }
1700
1701 /** Return true if target_bo is referenced by bo's relocation tree. */
1702 static int
1703 drm_intel_gem_bo_references(drm_intel_bo *bo, drm_intel_bo *target_bo)
1704 {
1705         drm_intel_bo_gem *target_bo_gem = (drm_intel_bo_gem *) target_bo;
1706
1707         if (bo == NULL || target_bo == NULL)
1708                 return 0;
1709         if (target_bo_gem->used_as_reloc_target)
1710                 return _drm_intel_gem_bo_references(bo, target_bo);
1711         return 0;
1712 }
1713
1714 /**
1715  * Initializes the GEM buffer manager, which uses the kernel to allocate, map,
1716  * and manage map buffer objections.
1717  *
1718  * \param fd File descriptor of the opened DRM device.
1719  */
1720 drm_intel_bufmgr *
1721 drm_intel_bufmgr_gem_init(int fd, int batch_size)
1722 {
1723         drm_intel_bufmgr_gem *bufmgr_gem;
1724         struct drm_i915_gem_get_aperture aperture;
1725         drm_i915_getparam_t gp;
1726         int ret, i;
1727         unsigned long size;
1728
1729         bufmgr_gem = calloc(1, sizeof(*bufmgr_gem));
1730         bufmgr_gem->fd = fd;
1731
1732         if (pthread_mutex_init(&bufmgr_gem->lock, NULL) != 0) {
1733                 free(bufmgr_gem);
1734                 return NULL;
1735         }
1736
1737         ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_GET_APERTURE, &aperture);
1738
1739         if (ret == 0)
1740                 bufmgr_gem->gtt_size = aperture.aper_available_size;
1741         else {
1742                 fprintf(stderr, "DRM_IOCTL_I915_GEM_APERTURE failed: %s\n",
1743                         strerror(errno));
1744                 bufmgr_gem->gtt_size = 128 * 1024 * 1024;
1745                 fprintf(stderr, "Assuming %dkB available aperture size.\n"
1746                         "May lead to reduced performance or incorrect "
1747                         "rendering.\n",
1748                         (int)bufmgr_gem->gtt_size / 1024);
1749         }
1750
1751         gp.param = I915_PARAM_CHIPSET_ID;
1752         gp.value = &bufmgr_gem->pci_device;
1753         ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
1754         if (ret) {
1755                 fprintf(stderr, "get chip id failed: %d [%d]\n", ret, errno);
1756                 fprintf(stderr, "param: %d, val: %d\n", gp.param, *gp.value);
1757         }
1758
1759         if (!IS_I965G(bufmgr_gem)) {
1760                 gp.param = I915_PARAM_NUM_FENCES_AVAIL;
1761                 gp.value = &bufmgr_gem->available_fences;
1762                 ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
1763                 if (ret) {
1764                         fprintf(stderr, "get fences failed: %d [%d]\n", ret,
1765                                 errno);
1766                         fprintf(stderr, "param: %d, val: %d\n", gp.param,
1767                                 *gp.value);
1768                         bufmgr_gem->available_fences = 0;
1769                 }
1770         }
1771
1772         /* Let's go with one relocation per every 2 dwords (but round down a bit
1773          * since a power of two will mean an extra page allocation for the reloc
1774          * buffer).
1775          *
1776          * Every 4 was too few for the blender benchmark.
1777          */
1778         bufmgr_gem->max_relocs = batch_size / sizeof(uint32_t) / 2 - 2;
1779
1780         bufmgr_gem->bufmgr.bo_alloc = drm_intel_gem_bo_alloc;
1781         bufmgr_gem->bufmgr.bo_alloc_for_render =
1782             drm_intel_gem_bo_alloc_for_render;
1783         bufmgr_gem->bufmgr.bo_alloc_tiled = drm_intel_gem_bo_alloc_tiled;
1784         bufmgr_gem->bufmgr.bo_reference = drm_intel_gem_bo_reference;
1785         bufmgr_gem->bufmgr.bo_unreference = drm_intel_gem_bo_unreference;
1786         bufmgr_gem->bufmgr.bo_map = drm_intel_gem_bo_map;
1787         bufmgr_gem->bufmgr.bo_unmap = drm_intel_gem_bo_unmap;
1788         bufmgr_gem->bufmgr.bo_subdata = drm_intel_gem_bo_subdata;
1789         bufmgr_gem->bufmgr.bo_get_subdata = drm_intel_gem_bo_get_subdata;
1790         bufmgr_gem->bufmgr.bo_wait_rendering = drm_intel_gem_bo_wait_rendering;
1791         bufmgr_gem->bufmgr.bo_emit_reloc = drm_intel_gem_bo_emit_reloc;
1792         bufmgr_gem->bufmgr.bo_pin = drm_intel_gem_bo_pin;
1793         bufmgr_gem->bufmgr.bo_unpin = drm_intel_gem_bo_unpin;
1794         bufmgr_gem->bufmgr.bo_get_tiling = drm_intel_gem_bo_get_tiling;
1795         bufmgr_gem->bufmgr.bo_set_tiling = drm_intel_gem_bo_set_tiling;
1796         bufmgr_gem->bufmgr.bo_flink = drm_intel_gem_bo_flink;
1797         bufmgr_gem->bufmgr.bo_exec = drm_intel_gem_bo_exec;
1798         bufmgr_gem->bufmgr.bo_busy = drm_intel_gem_bo_busy;
1799         bufmgr_gem->bufmgr.bo_madvise = drm_intel_gem_bo_madvise;
1800         bufmgr_gem->bufmgr.destroy = drm_intel_bufmgr_gem_destroy;
1801         bufmgr_gem->bufmgr.debug = 0;
1802         bufmgr_gem->bufmgr.check_aperture_space =
1803             drm_intel_gem_check_aperture_space;
1804         bufmgr_gem->bufmgr.bo_disable_reuse = drm_intel_gem_bo_disable_reuse;
1805         bufmgr_gem->bufmgr.get_pipe_from_crtc_id =
1806             drm_intel_gem_get_pipe_from_crtc_id;
1807         bufmgr_gem->bufmgr.bo_references = drm_intel_gem_bo_references;
1808
1809         /* Initialize the linked lists for BO reuse cache. */
1810         for (i = 0, size = 4096; i < DRM_INTEL_GEM_BO_BUCKETS; i++, size *= 2) {
1811                 DRMINITLISTHEAD(&bufmgr_gem->cache_bucket[i].head);
1812                 bufmgr_gem->cache_bucket[i].size = size;
1813         }
1814
1815         return &bufmgr_gem->bufmgr;
1816 }