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 <xf86atomic.h>
  43 #include <fcntl.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47 #include <unistd.h>
  48 #include <assert.h>
  49 #include <pthread.h>
  50 #include <sys/ioctl.h>
  51 #include <sys/mman.h>
  52 #include <sys/stat.h>
  53 #include <sys/types.h>
  54
  55 #include "errno.h"
  56 #include "libdrm_lists.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 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
  70
  71 typedef struct _drm_intel_bo_gem drm_intel_bo_gem;
  72
  73 struct drm_intel_gem_bo_bucket {
  74         drmMMListHead head;
  75         unsigned long size;
  76 };
  77
  78 typedef struct _drm_intel_bufmgr_gem {
  79         drm_intel_bufmgr bufmgr;
  80
  81         int fd;
  82
  83         int max_relocs;
  84
  85         pthread_mutex_t lock;
  86
  87         struct drm_i915_gem_exec_object *exec_objects;
  88         struct drm_i915_gem_exec_object2 *exec2_objects;
  89         drm_intel_bo **exec_bos;
  90         int exec_size;
  91         int exec_count;
  92
  93         /** Array of lists of cached gem objects of power-of-two sizes */
  94         struct drm_intel_gem_bo_bucket cache_bucket[14 * 4];
  95         int num_buckets;
  96
  97         uint64_t gtt_size;
  98         int available_fences;
  99         int pci_device;
 100         int gen;
 101         char bo_reuse;
 102         char fenced_relocs;
 103 } drm_intel_bufmgr_gem;
 104
 105 #define DRM_INTEL_RELOC_FENCE (1<<0)
 106
 107 typedef struct _drm_intel_reloc_target_info {
 108         drm_intel_bo *bo;
 109         int flags;
 110 } drm_intel_reloc_target;
 111
 112 struct _drm_intel_bo_gem {
 113         drm_intel_bo bo;
 114
 115         atomic_t refcount;
 116         uint32_t gem_handle;
 117         const char *name;
 118
 119         /**
 120          * Kenel-assigned global name for this object
 121          */
 122         unsigned int global_name;
 123
 124         /**
 125          * Index of the buffer within the validation list while preparing a
 126          * batchbuffer execution.
 127          */
 128         int validate_index;
 129
 130         /**
 131          * Current tiling mode
 132          */
 133         uint32_t tiling_mode;
 134         uint32_t swizzle_mode;
 135
 136         time_t free_time;
 137
 138         /** Array passed to the DRM containing relocation information. */
 139         struct drm_i915_gem_relocation_entry *relocs;
 140         /**
 141          * Array of info structs corresponding to relocs[i].target_handle etc
 142          */
 143         drm_intel_reloc_target *reloc_target_info;
 144         /** Number of entries in relocs */
 145         int reloc_count;
 146         /** Mapped address for the buffer, saved across map/unmap cycles */
 147         void *mem_virtual;
 148         /** GTT virtual address for the buffer, saved across map/unmap cycles */
 149         void *gtt_virtual;
 150
 151         /** BO cache list */
 152         drmMMListHead head;
 153
 154         /**
 155          * Boolean of whether this BO and its children have been included in
 156          * the current drm_intel_bufmgr_check_aperture_space() total.
 157          */
 158         char included_in_check_aperture;
 159
 160         /**
 161          * Boolean of whether this buffer has been used as a relocation
 162          * target and had its size accounted for, and thus can't have any
 163          * further relocations added to it.
 164          */
 165         char used_as_reloc_target;
 166
 167         /**
 168          * Boolean of whether we have encountered an error whilst building the relocation tree.
 169          */
 170         char has_error;
 171
 172         /**
 173          * Boolean of whether this buffer can be re-used
 174          */
 175         char reusable;
 176
 177         /**
 178          * Size in bytes of this buffer and its relocation descendents.
 179          *
 180          * Used to avoid costly tree walking in
 181          * drm_intel_bufmgr_check_aperture in the common case.
 182          */
 183         int reloc_tree_size;
 184
 185         /**
 186          * Number of potential fence registers required by this buffer and its
 187          * relocations.
 188          */
 189         int reloc_tree_fences;
 190 };
 191
 192 static unsigned int
 193 drm_intel_gem_estimate_batch_space(drm_intel_bo ** bo_array, int count);
 194
 195 static unsigned int
 196 drm_intel_gem_compute_batch_space(drm_intel_bo ** bo_array, int count);
 197
 198 static int
 199 drm_intel_gem_bo_get_tiling(drm_intel_bo *bo, uint32_t * tiling_mode,
 200                             uint32_t * swizzle_mode);
 201
 202 static int
 203 drm_intel_gem_bo_set_tiling(drm_intel_bo *bo, uint32_t * tiling_mode,
 204                             uint32_t stride);
 205
 206 static void drm_intel_gem_bo_unreference_locked_timed(drm_intel_bo *bo,
 207                                                       time_t time);
 208
 209 static void drm_intel_gem_bo_unreference(drm_intel_bo *bo);
 210
 211 static void drm_intel_gem_bo_free(drm_intel_bo *bo);
 212
 213 static unsigned long
 214 drm_intel_gem_bo_tile_size(drm_intel_bufmgr_gem *bufmgr_gem, unsigned long size,
 215                            uint32_t *tiling_mode)
 216 {
 217         unsigned long min_size, max_size;
 218         unsigned long i;
 219
 220         if (*tiling_mode == I915_TILING_NONE)
 221                 return size;
 222
 223         /* 965+ just need multiples of page size for tiling */
 224         if (bufmgr_gem->gen >= 4)
 225                 return ROUND_UP_TO(size, 4096);
 226
 227         /* Older chips need powers of two, of at least 512k or 1M */
 228         if (bufmgr_gem->gen == 3) {
 229                 min_size = 1024*1024;
 230                 max_size = 128*1024*1024;
 231         } else {
 232                 min_size = 512*1024;
 233                 max_size = 64*1024*1024;
 234         }
 235
 236         if (size > max_size) {
 237                 *tiling_mode = I915_TILING_NONE;
 238                 return size;
 239         }
 240
 241         for (i = min_size; i < size; i <<= 1)
 242                 ;
 243
 244         return i;
 245 }
 246
 247 /*
 248  * Round a given pitch up to the minimum required for X tiling on a
 249  * given chip.  We use 512 as the minimum to allow for a later tiling
 250  * change.
 251  */
 252 static unsigned long
 253 drm_intel_gem_bo_tile_pitch(drm_intel_bufmgr_gem *bufmgr_gem,
 254                             unsigned long pitch, uint32_t tiling_mode)
 255 {
 256         unsigned long tile_width;
 257         unsigned long i;
 258
 259         /* If untiled, then just align it so that we can do rendering
 260          * to it with the 3D engine.
 261          */
 262         if (tiling_mode == I915_TILING_NONE)
 263                 return ALIGN(pitch, 64);
 264
 265         if (tiling_mode == I915_TILING_X)
 266                 tile_width = 512;
 267         else
 268                 tile_width = 128;
 269
 270         /* 965 is flexible */
 271         if (bufmgr_gem->gen >= 4)
 272                 return ROUND_UP_TO(pitch, tile_width);
 273
 274         /* Pre-965 needs power of two tile width */
 275         for (i = tile_width; i < pitch; i <<= 1)
 276                 ;
 277
 278         return i;
 279 }
 280
 281 static struct drm_intel_gem_bo_bucket *
 282 drm_intel_gem_bo_bucket_for_size(drm_intel_bufmgr_gem *bufmgr_gem,
 283                                  unsigned long size)
 284 {
 285         int i;
 286
 287         for (i = 0; i < bufmgr_gem->num_buckets; i++) {
 288                 struct drm_intel_gem_bo_bucket *bucket =
 289                     &bufmgr_gem->cache_bucket[i];
 290                 if (bucket->size >= size) {
 291                         return bucket;
 292                 }
 293         }
 294
 295         return NULL;
 296 }
 297
 298 static void
 299 drm_intel_gem_dump_validation_list(drm_intel_bufmgr_gem *bufmgr_gem)
 300 {
 301         int i, j;
 302
 303         for (i = 0; i < bufmgr_gem->exec_count; i++) {
 304                 drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
 305                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 306
 307                 if (bo_gem->relocs == NULL) {
 308                         DBG("%2d: %d (%s)\n", i, bo_gem->gem_handle,
 309                             bo_gem->name);
 310                         continue;
 311                 }
 312
 313                 for (j = 0; j < bo_gem->reloc_count; j++) {
 314                         drm_intel_bo *target_bo = bo_gem->reloc_target_info[j].bo;
 315                         drm_intel_bo_gem *target_gem =
 316                             (drm_intel_bo_gem *) target_bo;
 317
 318                         DBG("%2d: %d (%s)@0x%08llx -> "
 319                             "%d (%s)@0x%08lx + 0x%08x\n",
 320                             i,
 321                             bo_gem->gem_handle, bo_gem->name,
 322                             (unsigned long long)bo_gem->relocs[j].offset,
 323                             target_gem->gem_handle,
 324                             target_gem->name,
 325                             target_bo->offset,
 326                             bo_gem->relocs[j].delta);
 327                 }
 328         }
 329 }
 330
 331 static inline void
 332 drm_intel_gem_bo_reference(drm_intel_bo *bo)
 333 {
 334         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 335
 336         assert(atomic_read(&bo_gem->refcount) > 0);
 337         atomic_inc(&bo_gem->refcount);
 338 }
 339
 340 /**
 341  * Adds the given buffer to the list of buffers to be validated (moved into the
 342  * appropriate memory type) with the next batch submission.
 343  *
 344  * If a buffer is validated multiple times in a batch submission, it ends up
 345  * with the intersection of the memory type flags and the union of the
 346  * access flags.
 347  */
 348 static void
 349 drm_intel_add_validate_buffer(drm_intel_bo *bo)
 350 {
 351         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
 352         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 353         int index;
 354
 355         if (bo_gem->validate_index != -1)
 356                 return;
 357
 358         /* Extend the array of validation entries as necessary. */
 359         if (bufmgr_gem->exec_count == bufmgr_gem->exec_size) {
 360                 int new_size = bufmgr_gem->exec_size * 2;
 361
 362                 if (new_size == 0)
 363                         new_size = 5;
 364
 365                 bufmgr_gem->exec_objects =
 366                     realloc(bufmgr_gem->exec_objects,
 367                             sizeof(*bufmgr_gem->exec_objects) * new_size);
 368                 bufmgr_gem->exec_bos =
 369                     realloc(bufmgr_gem->exec_bos,
 370                             sizeof(*bufmgr_gem->exec_bos) * new_size);
 371                 bufmgr_gem->exec_size = new_size;
 372         }
 373
 374         index = bufmgr_gem->exec_count;
 375         bo_gem->validate_index = index;
 376         /* Fill in array entry */
 377         bufmgr_gem->exec_objects[index].handle = bo_gem->gem_handle;
 378         bufmgr_gem->exec_objects[index].relocation_count = bo_gem->reloc_count;
 379         bufmgr_gem->exec_objects[index].relocs_ptr = (uintptr_t) bo_gem->relocs;
 380         bufmgr_gem->exec_objects[index].alignment = 0;
 381         bufmgr_gem->exec_objects[index].offset = 0;
 382         bufmgr_gem->exec_bos[index] = bo;
 383         bufmgr_gem->exec_count++;
 384 }
 385
 386 static void
 387 drm_intel_add_validate_buffer2(drm_intel_bo *bo, int need_fence)
 388 {
 389         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
 390         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
 391         int index;
 392
 393         if (bo_gem->validate_index != -1) {
 394                 if (need_fence)
 395                         bufmgr_gem->exec2_objects[bo_gem->validate_index].flags |=
 396                                 EXEC_OBJECT_NEEDS_FENCE;
 397                 return;
 398         }
 399
 400         /* Extend the array of validation entries as necessary. */
 401         if (bufmgr_gem->exec_count == bufmgr_gem->exec_size) {
 402                 int new_size = bufmgr_gem->exec_size * 2;
 403
 404                 if (new_size == 0)
 405                         new_size = 5;
 406
 407                 bufmgr_gem->exec2_objects =
 408                         realloc(bufmgr_gem->exec2_objects,
 409                                 sizeof(*bufmgr_gem->exec2_objects) * new_size);
 410                 bufmgr_gem->exec_bos =
 411                         realloc(bufmgr_gem->exec_bos,
 412                                 sizeof(*bufmgr_gem->exec_bos) * new_size);
 413                 bufmgr_gem->exec_size = new_size;
 414         }
 415
 416         index = bufmgr_gem->exec_count;
 417         bo_gem->validate_index = index;
 418         /* Fill in array entry */
 419         bufmgr_gem->exec2_objects[index].handle = bo_gem->gem_handle;
 420         bufmgr_gem->exec2_objects[index].relocation_count = bo_gem->reloc_count;
 421         bufmgr_gem->exec2_objects[index].relocs_ptr = (uintptr_t)bo_gem->relocs;
 422         bufmgr_gem->exec2_objects[index].alignment = 0;
 423         bufmgr_gem->exec2_objects[index].offset = 0;
 424         bufmgr_gem->exec_bos[index] = bo;
 425         bufmgr_gem->exec2_objects[index].flags = 0;
 426         bufmgr_gem->exec2_objects[index].rsvd1 = 0;
 427         bufmgr_gem->exec2_objects[index].rsvd2 = 0;
 428         if (need_fence) {
 429                 bufmgr_gem->exec2_objects[index].flags |=
 430                         EXEC_OBJECT_NEEDS_FENCE;
 431         }
 432         bufmgr_gem->exec_count++;
 433 }
 434
 435 #define RELOC_BUF_SIZE(x) ((I915_RELOC_HEADER + x * I915_RELOC0_STRIDE) * \
 436         sizeof(uint32_t))
 437
 438 static void
 439 drm_intel_bo_gem_set_in_aperture_size(drm_intel_bufmgr_gem *bufmgr_gem,
 440                                       drm_intel_bo_gem *bo_gem)
 441 {
 442         int size;
 443
 444         assert(!bo_gem->used_as_reloc_target);
 445
 446         /* The older chipsets are far-less flexible in terms of tiling,
 447          * and require tiled buffer to be size aligned in the aperture.
 448          * This means that in the worst possible case we will need a hole
 449          * twice as large as the object in order for it to fit into the
 450          * aperture. Optimal packing is for wimps.
 451          */
 452         size = bo_gem->bo.size;
 453         if (bufmgr_gem->gen < 4 && bo_gem->tiling_mode != I915_TILING_NONE)
 454                 size *= 2;
 455
 456         bo_gem->reloc_tree_size = size;
 457 }
 458
 459 static int
 460 drm_intel_setup_reloc_list(drm_intel_bo *bo)
 461 {
 462         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 463         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
 464         unsigned int max_relocs = bufmgr_gem->max_relocs;
 465
 466         if (bo->size / 4 < max_relocs)
 467                 max_relocs = bo->size / 4;
 468
 469         bo_gem->relocs = malloc(max_relocs *
 470                                 sizeof(struct drm_i915_gem_relocation_entry));
 471         bo_gem->reloc_target_info = malloc(max_relocs *
 472                                            sizeof(drm_intel_reloc_target));
 473         if (bo_gem->relocs == NULL || bo_gem->reloc_target_info == NULL) {
 474                 bo_gem->has_error = 1;
 475
 476                 free (bo_gem->relocs);
 477                 bo_gem->relocs = NULL;
 478
 479                 free (bo_gem->reloc_target_info);
 480                 bo_gem->reloc_target_info = NULL;
 481
 482                 return 1;
 483         }
 484
 485         return 0;
 486 }
 487
 488 static int
 489 drm_intel_gem_bo_busy(drm_intel_bo *bo)
 490 {
 491         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
 492         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 493         struct drm_i915_gem_busy busy;
 494         int ret;
 495
 496         memset(&busy, 0, sizeof(busy));
 497         busy.handle = bo_gem->gem_handle;
 498
 499         do {
 500                 ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_BUSY, &busy);
 501         } while (ret == -1 && errno == EINTR);
 502
 503         return (ret == 0 && busy.busy);
 504 }
 505
 506 static int
 507 drm_intel_gem_bo_madvise_internal(drm_intel_bufmgr_gem *bufmgr_gem,
 508                                   drm_intel_bo_gem *bo_gem, int state)
 509 {
 510         struct drm_i915_gem_madvise madv;
 511
 512         madv.handle = bo_gem->gem_handle;
 513         madv.madv = state;
 514         madv.retained = 1;
 515         ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_MADVISE, &madv);
 516
 517         return madv.retained;
 518 }
 519
 520 static int
 521 drm_intel_gem_bo_madvise(drm_intel_bo *bo, int madv)
 522 {
 523         return drm_intel_gem_bo_madvise_internal
 524                 ((drm_intel_bufmgr_gem *) bo->bufmgr,
 525                  (drm_intel_bo_gem *) bo,
 526                  madv);
 527 }
 528
 529 /* drop the oldest entries that have been purged by the kernel */
 530 static void
 531 drm_intel_gem_bo_cache_purge_bucket(drm_intel_bufmgr_gem *bufmgr_gem,
 532                                     struct drm_intel_gem_bo_bucket *bucket)
 533 {
 534         while (!DRMLISTEMPTY(&bucket->head)) {
 535                 drm_intel_bo_gem *bo_gem;
 536
 537                 bo_gem = DRMLISTENTRY(drm_intel_bo_gem,
 538                                       bucket->head.next, head);
 539                 if (drm_intel_gem_bo_madvise_internal
 540                     (bufmgr_gem, bo_gem, I915_MADV_DONTNEED))
 541                         break;
 542
 543                 DRMLISTDEL(&bo_gem->head);
 544                 drm_intel_gem_bo_free(&bo_gem->bo);
 545         }
 546 }
 547
 548 static drm_intel_bo *
 549 drm_intel_gem_bo_alloc_internal(drm_intel_bufmgr *bufmgr,
 550                                 const char *name,
 551                                 unsigned long size,
 552                                 unsigned long flags)
 553 {
 554         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
 555         drm_intel_bo_gem *bo_gem;
 556         unsigned int page_size = getpagesize();
 557         int ret;
 558         struct drm_intel_gem_bo_bucket *bucket;
 559         int alloc_from_cache;
 560         unsigned long bo_size;
 561         int for_render = 0;
 562
 563         if (flags & BO_ALLOC_FOR_RENDER)
 564                 for_render = 1;
 565
 566         /* Round the allocated size up to a power of two number of pages. */
 567         bucket = drm_intel_gem_bo_bucket_for_size(bufmgr_gem, size);
 568
 569         /* If we don't have caching at this size, don't actually round the
 570          * allocation up.
 571          */
 572         if (bucket == NULL) {
 573                 bo_size = size;
 574                 if (bo_size < page_size)
 575                         bo_size = page_size;
 576         } else {
 577                 bo_size = bucket->size;
 578         }
 579
 580         pthread_mutex_lock(&bufmgr_gem->lock);
 581         /* Get a buffer out of the cache if available */
 582 retry:
 583         alloc_from_cache = 0;
 584         if (bucket != NULL && !DRMLISTEMPTY(&bucket->head)) {
 585                 if (for_render) {
 586                         /* Allocate new render-target BOs from the tail (MRU)
 587                          * of the list, as it will likely be hot in the GPU
 588                          * cache and in the aperture for us.
 589                          */
 590                         bo_gem = DRMLISTENTRY(drm_intel_bo_gem,
 591                                               bucket->head.prev, head);
 592                         DRMLISTDEL(&bo_gem->head);
 593                         alloc_from_cache = 1;
 594                 } else {
 595                         /* For non-render-target BOs (where we're probably
 596                          * going to map it first thing in order to fill it
 597                          * with data), check if the last BO in the cache is
 598                          * unbusy, and only reuse in that case. Otherwise,
 599                          * allocating a new buffer is probably faster than
 600                          * waiting for the GPU to finish.
 601                          */
 602                         bo_gem = DRMLISTENTRY(drm_intel_bo_gem,
 603                                               bucket->head.next, head);
 604                         if (!drm_intel_gem_bo_busy(&bo_gem->bo)) {
 605                                 alloc_from_cache = 1;
 606                                 DRMLISTDEL(&bo_gem->head);
 607                         }
 608                 }
 609
 610                 if (alloc_from_cache) {
 611                         if (!drm_intel_gem_bo_madvise_internal
 612                             (bufmgr_gem, bo_gem, I915_MADV_WILLNEED)) {
 613                                 drm_intel_gem_bo_free(&bo_gem->bo);
 614                                 drm_intel_gem_bo_cache_purge_bucket(bufmgr_gem,
 615                                                                     bucket);
 616                                 goto retry;
 617                         }
 618                 }
 619         }
 620         pthread_mutex_unlock(&bufmgr_gem->lock);
 621
 622         if (!alloc_from_cache) {
 623                 struct drm_i915_gem_create create;
 624
 625                 bo_gem = calloc(1, sizeof(*bo_gem));
 626                 if (!bo_gem)
 627                         return NULL;
 628
 629                 bo_gem->bo.size = bo_size;
 630                 memset(&create, 0, sizeof(create));
 631                 create.size = bo_size;
 632
 633                 do {
 634                         ret = ioctl(bufmgr_gem->fd,
 635                                     DRM_IOCTL_I915_GEM_CREATE,
 636                                     &create);
 637                 } while (ret == -1 && errno == EINTR);
 638                 bo_gem->gem_handle = create.handle;
 639                 bo_gem->bo.handle = bo_gem->gem_handle;
 640                 if (ret != 0) {
 641                         free(bo_gem);
 642                         return NULL;
 643                 }
 644                 bo_gem->bo.bufmgr = bufmgr;
 645         }
 646
 647         bo_gem->name = name;
 648         atomic_set(&bo_gem->refcount, 1);
 649         bo_gem->validate_index = -1;
 650         bo_gem->reloc_tree_fences = 0;
 651         bo_gem->used_as_reloc_target = 0;
 652         bo_gem->has_error = 0;
 653         bo_gem->tiling_mode = I915_TILING_NONE;
 654         bo_gem->swizzle_mode = I915_BIT_6_SWIZZLE_NONE;
 655         bo_gem->reusable = 1;
 656
 657         drm_intel_bo_gem_set_in_aperture_size(bufmgr_gem, bo_gem);
 658
 659         DBG("bo_create: buf %d (%s) %ldb\n",
 660             bo_gem->gem_handle, bo_gem->name, size);
 661
 662         return &bo_gem->bo;
 663 }
 664
 665 static drm_intel_bo *
 666 drm_intel_gem_bo_alloc_for_render(drm_intel_bufmgr *bufmgr,
 667                                   const char *name,
 668                                   unsigned long size,
 669                                   unsigned int alignment)
 670 {
 671         return drm_intel_gem_bo_alloc_internal(bufmgr, name, size,
 672                                                BO_ALLOC_FOR_RENDER);
 673 }
 674
 675 static drm_intel_bo *
 676 drm_intel_gem_bo_alloc(drm_intel_bufmgr *bufmgr,
 677                        const char *name,
 678                        unsigned long size,
 679                        unsigned int alignment)
 680 {
 681         return drm_intel_gem_bo_alloc_internal(bufmgr, name, size, 0);
 682 }
 683
 684 static drm_intel_bo *
 685 drm_intel_gem_bo_alloc_tiled(drm_intel_bufmgr *bufmgr, const char *name,
 686                              int x, int y, int cpp, uint32_t *tiling_mode,
 687                              unsigned long *pitch, unsigned long flags)
 688 {
 689         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
 690         drm_intel_bo *bo;
 691         unsigned long size, stride;
 692         uint32_t tiling;
 693         int ret;
 694
 695         do {
 696                 unsigned long aligned_y;
 697
 698                 tiling = *tiling_mode;
 699
 700                 /* If we're tiled, our allocations are in 8 or 32-row blocks,
 701                  * so failure to align our height means that we won't allocate
 702                  * enough pages.
 703                  *
 704                  * If we're untiled, we still have to align to 2 rows high
 705                  * because the data port accesses 2x2 blocks even if the
 706                  * bottom row isn't to be rendered, so failure to align means
 707                  * we could walk off the end of the GTT and fault.  This is
 708                  * documented on 965, and may be the case on older chipsets
 709                  * too so we try to be careful.
 710                  */
 711                 aligned_y = y;
 712                 if (tiling == I915_TILING_NONE)
 713                         aligned_y = ALIGN(y, 2);
 714                 else if (tiling == I915_TILING_X)
 715                         aligned_y = ALIGN(y, 8);
 716                 else if (tiling == I915_TILING_Y)
 717                         aligned_y = ALIGN(y, 32);
 718
 719                 stride = x * cpp;
 720                 stride = drm_intel_gem_bo_tile_pitch(bufmgr_gem, stride, tiling);
 721                 size = stride * aligned_y;
 722                 size = drm_intel_gem_bo_tile_size(bufmgr_gem, size, tiling_mode);
 723         } while (*tiling_mode != tiling);
 724
 725         bo = drm_intel_gem_bo_alloc_internal(bufmgr, name, size, flags);
 726         if (!bo)
 727                 return NULL;
 728
 729         ret = drm_intel_gem_bo_set_tiling(bo, tiling_mode, stride);
 730         if (ret != 0) {
 731                 drm_intel_gem_bo_unreference(bo);
 732                 return NULL;
 733         }
 734
 735         *pitch = stride;
 736
 737         return bo;
 738 }
 739
 740 /**
 741  * Returns a drm_intel_bo wrapping the given buffer object handle.
 742  *
 743  * This can be used when one application needs to pass a buffer object
 744  * to another.
 745  */
 746 drm_intel_bo *
 747 drm_intel_bo_gem_create_from_name(drm_intel_bufmgr *bufmgr,
 748                                   const char *name,
 749                                   unsigned int handle)
 750 {
 751         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
 752         drm_intel_bo_gem *bo_gem;
 753         int ret;
 754         struct drm_gem_open open_arg;
 755         struct drm_i915_gem_get_tiling get_tiling;
 756
 757         bo_gem = calloc(1, sizeof(*bo_gem));
 758         if (!bo_gem)
 759                 return NULL;
 760
 761         memset(&open_arg, 0, sizeof(open_arg));
 762         open_arg.name = handle;
 763         do {
 764                 ret = ioctl(bufmgr_gem->fd,
 765                             DRM_IOCTL_GEM_OPEN,
 766                             &open_arg);
 767         } while (ret == -1 && errno == EINTR);
 768         if (ret != 0) {
 769                 fprintf(stderr, "Couldn't reference %s handle 0x%08x: %s\n",
 770                         name, handle, strerror(errno));
 771                 free(bo_gem);
 772                 return NULL;
 773         }
 774         bo_gem->bo.size = open_arg.size;
 775         bo_gem->bo.offset = 0;
 776         bo_gem->bo.virtual = NULL;
 777         bo_gem->bo.bufmgr = bufmgr;
 778         bo_gem->name = name;
 779         atomic_set(&bo_gem->refcount, 1);
 780         bo_gem->validate_index = -1;
 781         bo_gem->gem_handle = open_arg.handle;
 782         bo_gem->global_name = handle;
 783         bo_gem->reusable = 0;
 784
 785         memset(&get_tiling, 0, sizeof(get_tiling));
 786         get_tiling.handle = bo_gem->gem_handle;
 787         ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_GET_TILING, &get_tiling);
 788         if (ret != 0) {
 789                 drm_intel_gem_bo_unreference(&bo_gem->bo);
 790                 return NULL;
 791         }
 792         bo_gem->tiling_mode = get_tiling.tiling_mode;
 793         bo_gem->swizzle_mode = get_tiling.swizzle_mode;
 794         drm_intel_bo_gem_set_in_aperture_size(bufmgr_gem, bo_gem);
 795
 796         DBG("bo_create_from_handle: %d (%s)\n", handle, bo_gem->name);
 797
 798         return &bo_gem->bo;
 799 }
 800
 801 static void
 802 drm_intel_gem_bo_free(drm_intel_bo *bo)
 803 {
 804         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
 805         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 806         struct drm_gem_close close;
 807         int ret;
 808
 809         if (bo_gem->mem_virtual)
 810                 munmap(bo_gem->mem_virtual, bo_gem->bo.size);
 811         if (bo_gem->gtt_virtual)
 812                 munmap(bo_gem->gtt_virtual, bo_gem->bo.size);
 813
 814         /* Close this object */
 815         memset(&close, 0, sizeof(close));
 816         close.handle = bo_gem->gem_handle;
 817         ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_GEM_CLOSE, &close);
 818         if (ret != 0) {
 819                 fprintf(stderr,
 820                         "DRM_IOCTL_GEM_CLOSE %d failed (%s): %s\n",
 821                         bo_gem->gem_handle, bo_gem->name, strerror(errno));
 822         }
 823         free(bo);
 824 }
 825
 826 /** Frees all cached buffers significantly older than @time. */
 827 static void
 828 drm_intel_gem_cleanup_bo_cache(drm_intel_bufmgr_gem *bufmgr_gem, time_t time)
 829 {
 830         int i;
 831
 832         for (i = 0; i < bufmgr_gem->num_buckets; i++) {
 833                 struct drm_intel_gem_bo_bucket *bucket =
 834                     &bufmgr_gem->cache_bucket[i];
 835
 836                 while (!DRMLISTEMPTY(&bucket->head)) {
 837                         drm_intel_bo_gem *bo_gem;
 838
 839                         bo_gem = DRMLISTENTRY(drm_intel_bo_gem,
 840                                               bucket->head.next, head);
 841                         if (time - bo_gem->free_time <= 1)
 842                                 break;
 843
 844                         DRMLISTDEL(&bo_gem->head);
 845
 846                         drm_intel_gem_bo_free(&bo_gem->bo);
 847                 }
 848         }
 849 }
 850
 851 static void
 852 drm_intel_gem_bo_unreference_final(drm_intel_bo *bo, time_t time)
 853 {
 854         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
 855         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 856         struct drm_intel_gem_bo_bucket *bucket;
 857         uint32_t tiling_mode;
 858         int i;
 859
 860         /* Unreference all the target buffers */
 861         for (i = 0; i < bo_gem->reloc_count; i++) {
 862                 drm_intel_gem_bo_unreference_locked_timed(bo_gem->
 863                                                           reloc_target_info[i].bo,
 864                                                           time);
 865         }
 866         bo_gem->reloc_count = 0;
 867         bo_gem->used_as_reloc_target = 0;
 868
 869         DBG("bo_unreference final: %d (%s)\n",
 870             bo_gem->gem_handle, bo_gem->name);
 871
 872         /* release memory associated with this object */
 873         if (bo_gem->reloc_target_info) {
 874                 free(bo_gem->reloc_target_info);
 875                 bo_gem->reloc_target_info = NULL;
 876         }
 877         if (bo_gem->relocs) {
 878                 free(bo_gem->relocs);
 879                 bo_gem->relocs = NULL;
 880         }
 881
 882         bucket = drm_intel_gem_bo_bucket_for_size(bufmgr_gem, bo->size);
 883         /* Put the buffer into our internal cache for reuse if we can. */
 884         tiling_mode = I915_TILING_NONE;
 885         if (bufmgr_gem->bo_reuse && bo_gem->reusable && bucket != NULL &&
 886             drm_intel_gem_bo_set_tiling(bo, &tiling_mode, 0) == 0 &&
 887             drm_intel_gem_bo_madvise_internal(bufmgr_gem, bo_gem,
 888                                               I915_MADV_DONTNEED)) {
 889                 bo_gem->free_time = time;
 890
 891                 bo_gem->name = NULL;
 892                 bo_gem->validate_index = -1;
 893
 894                 DRMLISTADDTAIL(&bo_gem->head, &bucket->head);
 895
 896                 drm_intel_gem_cleanup_bo_cache(bufmgr_gem, time);
 897         } else {
 898                 drm_intel_gem_bo_free(bo);
 899         }
 900 }
 901
 902 static void drm_intel_gem_bo_unreference_locked_timed(drm_intel_bo *bo,
 903                                                       time_t time)
 904 {
 905         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 906
 907         assert(atomic_read(&bo_gem->refcount) > 0);
 908         if (atomic_dec_and_test(&bo_gem->refcount))
 909                 drm_intel_gem_bo_unreference_final(bo, time);
 910 }
 911
 912 static void drm_intel_gem_bo_unreference(drm_intel_bo *bo)
 913 {
 914         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 915
 916         assert(atomic_read(&bo_gem->refcount) > 0);
 917         if (atomic_dec_and_test(&bo_gem->refcount)) {
 918                 drm_intel_bufmgr_gem *bufmgr_gem =
 919                     (drm_intel_bufmgr_gem *) bo->bufmgr;
 920                 struct timespec time;
 921
 922                 clock_gettime(CLOCK_MONOTONIC, &time);
 923
 924                 pthread_mutex_lock(&bufmgr_gem->lock);
 925                 drm_intel_gem_bo_unreference_final(bo, time.tv_sec);
 926                 pthread_mutex_unlock(&bufmgr_gem->lock);
 927         }
 928 }
 929
 930 static int drm_intel_gem_bo_map(drm_intel_bo *bo, int write_enable)
 931 {
 932         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
 933         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 934         struct drm_i915_gem_set_domain set_domain;
 935         int ret;
 936
 937         pthread_mutex_lock(&bufmgr_gem->lock);
 938
 939         /* Allow recursive mapping. Mesa may recursively map buffers with
 940          * nested display loops.
 941          */
 942         if (!bo_gem->mem_virtual) {
 943                 struct drm_i915_gem_mmap mmap_arg;
 944
 945                 DBG("bo_map: %d (%s)\n", bo_gem->gem_handle, bo_gem->name);
 946
 947                 memset(&mmap_arg, 0, sizeof(mmap_arg));
 948                 mmap_arg.handle = bo_gem->gem_handle;
 949                 mmap_arg.offset = 0;
 950                 mmap_arg.size = bo->size;
 951                 do {
 952                         ret = ioctl(bufmgr_gem->fd,
 953                                     DRM_IOCTL_I915_GEM_MMAP,
 954                                     &mmap_arg);
 955                 } while (ret == -1 && errno == EINTR);
 956                 if (ret != 0) {
 957                         ret = -errno;
 958                         fprintf(stderr,
 959                                 "%s:%d: Error mapping buffer %d (%s): %s .\n",
 960                                 __FILE__, __LINE__, bo_gem->gem_handle,
 961                                 bo_gem->name, strerror(errno));
 962                         pthread_mutex_unlock(&bufmgr_gem->lock);
 963                         return ret;
 964                 }
 965                 bo_gem->mem_virtual = (void *)(uintptr_t) mmap_arg.addr_ptr;
 966         }
 967         DBG("bo_map: %d (%s) -> %p\n", bo_gem->gem_handle, bo_gem->name,
 968             bo_gem->mem_virtual);
 969         bo->virtual = bo_gem->mem_virtual;
 970
 971         set_domain.handle = bo_gem->gem_handle;
 972         set_domain.read_domains = I915_GEM_DOMAIN_CPU;
 973         if (write_enable)
 974                 set_domain.write_domain = I915_GEM_DOMAIN_CPU;
 975         else
 976                 set_domain.write_domain = 0;
 977         do {
 978                 ret = ioctl(bufmgr_gem->fd,
 979                             DRM_IOCTL_I915_GEM_SET_DOMAIN,
 980                             &set_domain);
 981         } while (ret == -1 && errno == EINTR);
 982         if (ret != 0) {
 983                 ret = -errno;
 984                 fprintf(stderr, "%s:%d: Error setting to CPU domain %d: %s\n",
 985                         __FILE__, __LINE__, bo_gem->gem_handle,
 986                         strerror(errno));
 987                 pthread_mutex_unlock(&bufmgr_gem->lock);
 988                 return ret;
 989         }
 990
 991         pthread_mutex_unlock(&bufmgr_gem->lock);
 992
 993         return 0;
 994 }
 995
 996 int drm_intel_gem_bo_map_gtt(drm_intel_bo *bo)
 997 {
 998         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
 999         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1000         struct drm_i915_gem_set_domain set_domain;
1001         int ret;
1002
1003         pthread_mutex_lock(&bufmgr_gem->lock);
1004
1005         /* Get a mapping of the buffer if we haven't before. */
1006         if (bo_gem->gtt_virtual == NULL) {
1007                 struct drm_i915_gem_mmap_gtt mmap_arg;
1008
1009                 DBG("bo_map_gtt: mmap %d (%s)\n", bo_gem->gem_handle,
1010                     bo_gem->name);
1011
1012                 memset(&mmap_arg, 0, sizeof(mmap_arg));
1013                 mmap_arg.handle = bo_gem->gem_handle;
1014
1015                 /* Get the fake offset back... */
1016                 do {
1017                         ret = ioctl(bufmgr_gem->fd,
1018                                     DRM_IOCTL_I915_GEM_MMAP_GTT,
1019                                     &mmap_arg);
1020                 } while (ret == -1 && errno == EINTR);
1021                 if (ret != 0) {
1022                         ret = -errno;
1023                         fprintf(stderr,
1024                                 "%s:%d: Error preparing buffer map %d (%s): %s .\n",
1025                                 __FILE__, __LINE__,
1026                                 bo_gem->gem_handle, bo_gem->name,
1027                                 strerror(errno));
1028                         pthread_mutex_unlock(&bufmgr_gem->lock);
1029                         return ret;
1030                 }
1031
1032                 /* and mmap it */
1033                 bo_gem->gtt_virtual = mmap(0, bo->size, PROT_READ | PROT_WRITE,
1034                                            MAP_SHARED, bufmgr_gem->fd,
1035                                            mmap_arg.offset);
1036                 if (bo_gem->gtt_virtual == MAP_FAILED) {
1037                         bo_gem->gtt_virtual = NULL;
1038                         ret = -errno;
1039                         fprintf(stderr,
1040                                 "%s:%d: Error mapping buffer %d (%s): %s .\n",
1041                                 __FILE__, __LINE__,
1042                                 bo_gem->gem_handle, bo_gem->name,
1043                                 strerror(errno));
1044                         pthread_mutex_unlock(&bufmgr_gem->lock);
1045                         return ret;
1046                 }
1047         }
1048
1049         bo->virtual = bo_gem->gtt_virtual;
1050
1051         DBG("bo_map_gtt: %d (%s) -> %p\n", bo_gem->gem_handle, bo_gem->name,
1052             bo_gem->gtt_virtual);
1053
1054         /* Now move it to the GTT domain so that the CPU caches are flushed */
1055         set_domain.handle = bo_gem->gem_handle;
1056         set_domain.read_domains = I915_GEM_DOMAIN_GTT;
1057         set_domain.write_domain = I915_GEM_DOMAIN_GTT;
1058         do {
1059                 ret = ioctl(bufmgr_gem->fd,
1060                             DRM_IOCTL_I915_GEM_SET_DOMAIN,
1061                             &set_domain);
1062         } while (ret == -1 && errno == EINTR);
1063
1064         if (ret != 0) {
1065                 ret = -errno;
1066                 fprintf(stderr, "%s:%d: Error setting domain %d: %s\n",
1067                         __FILE__, __LINE__, bo_gem->gem_handle,
1068                         strerror(errno));
1069         }
1070
1071         pthread_mutex_unlock(&bufmgr_gem->lock);
1072
1073         return ret;
1074 }
1075
1076 int drm_intel_gem_bo_unmap_gtt(drm_intel_bo *bo)
1077 {
1078         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1079         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1080         int ret = 0;
1081
1082         if (bo == NULL)
1083                 return 0;
1084
1085         assert(bo_gem->gtt_virtual != NULL);
1086
1087         pthread_mutex_lock(&bufmgr_gem->lock);
1088         bo->virtual = NULL;
1089         pthread_mutex_unlock(&bufmgr_gem->lock);
1090
1091         return ret;
1092 }
1093
1094 static int drm_intel_gem_bo_unmap(drm_intel_bo *bo)
1095 {
1096         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1097         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1098         struct drm_i915_gem_sw_finish sw_finish;
1099         int ret;
1100
1101         if (bo == NULL)
1102                 return 0;
1103
1104         assert(bo_gem->mem_virtual != NULL);
1105
1106         pthread_mutex_lock(&bufmgr_gem->lock);
1107
1108         /* Cause a flush to happen if the buffer's pinned for scanout, so the
1109          * results show up in a timely manner.
1110          */
1111         sw_finish.handle = bo_gem->gem_handle;
1112         do {
1113                 ret = ioctl(bufmgr_gem->fd,
1114                             DRM_IOCTL_I915_GEM_SW_FINISH,
1115                             &sw_finish);
1116         } while (ret == -1 && errno == EINTR);
1117         ret = ret == -1 ? -errno : 0;
1118
1119         bo->virtual = NULL;
1120         pthread_mutex_unlock(&bufmgr_gem->lock);
1121
1122         return ret;
1123 }
1124
1125 static int
1126 drm_intel_gem_bo_subdata(drm_intel_bo *bo, unsigned long offset,
1127                          unsigned long size, const void *data)
1128 {
1129         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1130         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1131         struct drm_i915_gem_pwrite pwrite;
1132         int ret;
1133
1134         memset(&pwrite, 0, sizeof(pwrite));
1135         pwrite.handle = bo_gem->gem_handle;
1136         pwrite.offset = offset;
1137         pwrite.size = size;
1138         pwrite.data_ptr = (uint64_t) (uintptr_t) data;
1139         do {
1140                 ret = ioctl(bufmgr_gem->fd,
1141                             DRM_IOCTL_I915_GEM_PWRITE,
1142                             &pwrite);
1143         } while (ret == -1 && errno == EINTR);
1144         if (ret != 0) {
1145                 ret = -errno;
1146                 fprintf(stderr,
1147                         "%s:%d: Error writing data to buffer %d: (%d %d) %s .\n",
1148                         __FILE__, __LINE__, bo_gem->gem_handle, (int)offset,
1149                         (int)size, strerror(errno));
1150         }
1151
1152         return ret;
1153 }
1154
1155 static int
1156 drm_intel_gem_get_pipe_from_crtc_id(drm_intel_bufmgr *bufmgr, int crtc_id)
1157 {
1158         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
1159         struct drm_i915_get_pipe_from_crtc_id get_pipe_from_crtc_id;
1160         int ret;
1161
1162         get_pipe_from_crtc_id.crtc_id = crtc_id;
1163         ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GET_PIPE_FROM_CRTC_ID,
1164                     &get_pipe_from_crtc_id);
1165         if (ret != 0) {
1166                 /* We return -1 here to signal that we don't
1167                  * know which pipe is associated with this crtc.
1168                  * This lets the caller know that this information
1169                  * isn't available; using the wrong pipe for
1170                  * vblank waiting can cause the chipset to lock up
1171                  */
1172                 return -1;
1173         }
1174
1175         return get_pipe_from_crtc_id.pipe;
1176 }
1177
1178 static int
1179 drm_intel_gem_bo_get_subdata(drm_intel_bo *bo, unsigned long offset,
1180                              unsigned long size, void *data)
1181 {
1182         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1183         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1184         struct drm_i915_gem_pread pread;
1185         int ret;
1186
1187         memset(&pread, 0, sizeof(pread));
1188         pread.handle = bo_gem->gem_handle;
1189         pread.offset = offset;
1190         pread.size = size;
1191         pread.data_ptr = (uint64_t) (uintptr_t) data;
1192         do {
1193                 ret = ioctl(bufmgr_gem->fd,
1194                             DRM_IOCTL_I915_GEM_PREAD,
1195                             &pread);
1196         } while (ret == -1 && errno == EINTR);
1197         if (ret != 0) {
1198                 ret = -errno;
1199                 fprintf(stderr,
1200                         "%s:%d: Error reading data from buffer %d: (%d %d) %s .\n",
1201                         __FILE__, __LINE__, bo_gem->gem_handle, (int)offset,
1202                         (int)size, strerror(errno));
1203         }
1204
1205         return ret;
1206 }
1207
1208 /** Waits for all GPU rendering to the object to have completed. */
1209 static void
1210 drm_intel_gem_bo_wait_rendering(drm_intel_bo *bo)
1211 {
1212         drm_intel_gem_bo_start_gtt_access(bo, 0);
1213 }
1214
1215 /**
1216  * Sets the object to the GTT read and possibly write domain, used by the X
1217  * 2D driver in the absence of kernel support to do drm_intel_gem_bo_map_gtt().
1218  *
1219  * In combination with drm_intel_gem_bo_pin() and manual fence management, we
1220  * can do tiled pixmaps this way.
1221  */
1222 void
1223 drm_intel_gem_bo_start_gtt_access(drm_intel_bo *bo, int write_enable)
1224 {
1225         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1226         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1227         struct drm_i915_gem_set_domain set_domain;
1228         int ret;
1229
1230         set_domain.handle = bo_gem->gem_handle;
1231         set_domain.read_domains = I915_GEM_DOMAIN_GTT;
1232         set_domain.write_domain = write_enable ? I915_GEM_DOMAIN_GTT : 0;
1233         do {
1234                 ret = ioctl(bufmgr_gem->fd,
1235                             DRM_IOCTL_I915_GEM_SET_DOMAIN,
1236                             &set_domain);
1237         } while (ret == -1 && errno == EINTR);
1238         if (ret != 0) {
1239                 fprintf(stderr,
1240                         "%s:%d: Error setting memory domains %d (%08x %08x): %s .\n",
1241                         __FILE__, __LINE__, bo_gem->gem_handle,
1242                         set_domain.read_domains, set_domain.write_domain,
1243                         strerror(errno));
1244         }
1245 }
1246
1247 static void
1248 drm_intel_bufmgr_gem_destroy(drm_intel_bufmgr *bufmgr)
1249 {
1250         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
1251         int i;
1252
1253         free(bufmgr_gem->exec2_objects);
1254         free(bufmgr_gem->exec_objects);
1255         free(bufmgr_gem->exec_bos);
1256
1257         pthread_mutex_destroy(&bufmgr_gem->lock);
1258
1259         /* Free any cached buffer objects we were going to reuse */
1260         for (i = 0; i < bufmgr_gem->num_buckets; i++) {
1261                 struct drm_intel_gem_bo_bucket *bucket =
1262                     &bufmgr_gem->cache_bucket[i];
1263                 drm_intel_bo_gem *bo_gem;
1264
1265                 while (!DRMLISTEMPTY(&bucket->head)) {
1266                         bo_gem = DRMLISTENTRY(drm_intel_bo_gem,
1267                                               bucket->head.next, head);
1268                         DRMLISTDEL(&bo_gem->head);
1269
1270                         drm_intel_gem_bo_free(&bo_gem->bo);
1271                 }
1272         }
1273
1274         free(bufmgr);
1275 }
1276
1277 /**
1278  * Adds the target buffer to the validation list and adds the relocation
1279  * to the reloc_buffer's relocation list.
1280  *
1281  * The relocation entry at the given offset must already contain the
1282  * precomputed relocation value, because the kernel will optimize out
1283  * the relocation entry write when the buffer hasn't moved from the
1284  * last known offset in target_bo.
1285  */
1286 static int
1287 do_bo_emit_reloc(drm_intel_bo *bo, uint32_t offset,
1288                  drm_intel_bo *target_bo, uint32_t target_offset,
1289                  uint32_t read_domains, uint32_t write_domain,
1290                  int need_fence)
1291 {
1292         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1293         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1294         drm_intel_bo_gem *target_bo_gem = (drm_intel_bo_gem *) target_bo;
1295
1296         if (bo_gem->has_error)
1297                 return -ENOMEM;
1298
1299         if (target_bo_gem->has_error) {
1300                 bo_gem->has_error = 1;
1301                 return -ENOMEM;
1302         }
1303
1304         if (target_bo_gem->tiling_mode == I915_TILING_NONE)
1305                 need_fence = 0;
1306
1307         /* We never use HW fences for rendering on 965+ */
1308         if (bufmgr_gem->gen >= 4)
1309                 need_fence = 0;
1310
1311         /* Create a new relocation list if needed */
1312         if (bo_gem->relocs == NULL && drm_intel_setup_reloc_list(bo))
1313                 return -ENOMEM;
1314
1315         /* Check overflow */
1316         assert(bo_gem->reloc_count < bufmgr_gem->max_relocs);
1317
1318         /* Check args */
1319         assert(offset <= bo->size - 4);
1320         assert((write_domain & (write_domain - 1)) == 0);
1321
1322         /* Make sure that we're not adding a reloc to something whose size has
1323          * already been accounted for.
1324          */
1325         assert(!bo_gem->used_as_reloc_target);
1326         if (target_bo_gem != bo_gem) {
1327                 target_bo_gem->used_as_reloc_target = 1;
1328                 bo_gem->reloc_tree_size += target_bo_gem->reloc_tree_size;
1329         }
1330         /* An object needing a fence is a tiled buffer, so it won't have
1331          * relocs to other buffers.
1332          */
1333         if (need_fence)
1334                 target_bo_gem->reloc_tree_fences = 1;
1335         bo_gem->reloc_tree_fences += target_bo_gem->reloc_tree_fences;
1336
1337         /* Flag the target to disallow further relocations in it. */
1338
1339         bo_gem->relocs[bo_gem->reloc_count].offset = offset;
1340         bo_gem->relocs[bo_gem->reloc_count].delta = target_offset;
1341         bo_gem->relocs[bo_gem->reloc_count].target_handle =
1342             target_bo_gem->gem_handle;
1343         bo_gem->relocs[bo_gem->reloc_count].read_domains = read_domains;
1344         bo_gem->relocs[bo_gem->reloc_count].write_domain = write_domain;
1345         bo_gem->relocs[bo_gem->reloc_count].presumed_offset = target_bo->offset;
1346
1347         bo_gem->reloc_target_info[bo_gem->reloc_count].bo = target_bo;
1348         drm_intel_gem_bo_reference(target_bo);
1349         if (need_fence)
1350                 bo_gem->reloc_target_info[bo_gem->reloc_count].flags =
1351                         DRM_INTEL_RELOC_FENCE;
1352         else
1353                 bo_gem->reloc_target_info[bo_gem->reloc_count].flags = 0;
1354
1355         bo_gem->reloc_count++;
1356
1357         return 0;
1358 }
1359
1360 static int
1361 drm_intel_gem_bo_emit_reloc(drm_intel_bo *bo, uint32_t offset,
1362                             drm_intel_bo *target_bo, uint32_t target_offset,
1363                             uint32_t read_domains, uint32_t write_domain)
1364 {
1365         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
1366
1367         return do_bo_emit_reloc(bo, offset, target_bo, target_offset,
1368                                 read_domains, write_domain,
1369                                 !bufmgr_gem->fenced_relocs);
1370 }
1371
1372 static int
1373 drm_intel_gem_bo_emit_reloc_fence(drm_intel_bo *bo, uint32_t offset,
1374                                   drm_intel_bo *target_bo,
1375                                   uint32_t target_offset,
1376                                   uint32_t read_domains, uint32_t write_domain)
1377 {
1378         return do_bo_emit_reloc(bo, offset, target_bo, target_offset,
1379                                 read_domains, write_domain, 1);
1380 }
1381
1382 /**
1383  * Walk the tree of relocations rooted at BO and accumulate the list of
1384  * validations to be performed and update the relocation buffers with
1385  * index values into the validation list.
1386  */
1387 static void
1388 drm_intel_gem_bo_process_reloc(drm_intel_bo *bo)
1389 {
1390         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1391         int i;
1392
1393         if (bo_gem->relocs == NULL)
1394                 return;
1395
1396         for (i = 0; i < bo_gem->reloc_count; i++) {
1397                 drm_intel_bo *target_bo = bo_gem->reloc_target_info[i].bo;
1398
1399                 if (target_bo == bo)
1400                         continue;
1401
1402                 /* Continue walking the tree depth-first. */
1403                 drm_intel_gem_bo_process_reloc(target_bo);
1404
1405                 /* Add the target to the validate list */
1406                 drm_intel_add_validate_buffer(target_bo);
1407         }
1408 }
1409
1410 static void
1411 drm_intel_gem_bo_process_reloc2(drm_intel_bo *bo)
1412 {
1413         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
1414         int i;
1415
1416         if (bo_gem->relocs == NULL)
1417                 return;
1418
1419         for (i = 0; i < bo_gem->reloc_count; i++) {
1420                 drm_intel_bo *target_bo = bo_gem->reloc_target_info[i].bo;
1421                 int need_fence;
1422
1423                 if (target_bo == bo)
1424                         continue;
1425
1426                 /* Continue walking the tree depth-first. */
1427                 drm_intel_gem_bo_process_reloc2(target_bo);
1428
1429                 need_fence = (bo_gem->reloc_target_info[i].flags &
1430                               DRM_INTEL_RELOC_FENCE);
1431
1432                 /* Add the target to the validate list */
1433                 drm_intel_add_validate_buffer2(target_bo, need_fence);
1434         }
1435 }
1436
1437
1438 static void
1439 drm_intel_update_buffer_offsets(drm_intel_bufmgr_gem *bufmgr_gem)
1440 {
1441         int i;
1442
1443         for (i = 0; i < bufmgr_gem->exec_count; i++) {
1444                 drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
1445                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1446
1447                 /* Update the buffer offset */
1448                 if (bufmgr_gem->exec_objects[i].offset != bo->offset) {
1449                         DBG("BO %d (%s) migrated: 0x%08lx -> 0x%08llx\n",
1450                             bo_gem->gem_handle, bo_gem->name, bo->offset,
1451                             (unsigned long long)bufmgr_gem->exec_objects[i].
1452                             offset);
1453                         bo->offset = bufmgr_gem->exec_objects[i].offset;
1454                 }
1455         }
1456 }
1457
1458 static void
1459 drm_intel_update_buffer_offsets2 (drm_intel_bufmgr_gem *bufmgr_gem)
1460 {
1461         int i;
1462
1463         for (i = 0; i < bufmgr_gem->exec_count; i++) {
1464                 drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
1465                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
1466
1467                 /* Update the buffer offset */
1468                 if (bufmgr_gem->exec2_objects[i].offset != bo->offset) {
1469                         DBG("BO %d (%s) migrated: 0x%08lx -> 0x%08llx\n",
1470                             bo_gem->gem_handle, bo_gem->name, bo->offset,
1471                             (unsigned long long)bufmgr_gem->exec2_objects[i].offset);
1472                         bo->offset = bufmgr_gem->exec2_objects[i].offset;
1473                 }
1474         }
1475 }
1476
1477 static int
1478 drm_intel_gem_bo_exec(drm_intel_bo *bo, int used,
1479                       drm_clip_rect_t * cliprects, int num_cliprects, int DR4)
1480 {
1481         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1482         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1483         struct drm_i915_gem_execbuffer execbuf;
1484         int ret, i;
1485
1486         if (bo_gem->has_error)
1487                 return -ENOMEM;
1488
1489         pthread_mutex_lock(&bufmgr_gem->lock);
1490         /* Update indices and set up the validate list. */
1491         drm_intel_gem_bo_process_reloc(bo);
1492
1493         /* Add the batch buffer to the validation list.  There are no
1494          * relocations pointing to it.
1495          */
1496         drm_intel_add_validate_buffer(bo);
1497
1498         execbuf.buffers_ptr = (uintptr_t) bufmgr_gem->exec_objects;
1499         execbuf.buffer_count = bufmgr_gem->exec_count;
1500         execbuf.batch_start_offset = 0;
1501         execbuf.batch_len = used;
1502         execbuf.cliprects_ptr = (uintptr_t) cliprects;
1503         execbuf.num_cliprects = num_cliprects;
1504         execbuf.DR1 = 0;
1505         execbuf.DR4 = DR4;
1506
1507         do {
1508                 ret = ioctl(bufmgr_gem->fd,
1509                             DRM_IOCTL_I915_GEM_EXECBUFFER,
1510                             &execbuf);
1511         } while (ret != 0 && errno == EINTR);
1512
1513         if (ret != 0) {
1514                 ret = -errno;
1515                 if (errno == ENOSPC) {
1516                         fprintf(stderr,
1517                                 "Execbuffer fails to pin. "
1518                                 "Estimate: %u. Actual: %u. Available: %u\n",
1519                                 drm_intel_gem_estimate_batch_space(bufmgr_gem->exec_bos,
1520                                                                    bufmgr_gem->
1521                                                                    exec_count),
1522                                 drm_intel_gem_compute_batch_space(bufmgr_gem->exec_bos,
1523                                                                   bufmgr_gem->
1524                                                                   exec_count),
1525                                 (unsigned int)bufmgr_gem->gtt_size);
1526                 }
1527         }
1528         drm_intel_update_buffer_offsets(bufmgr_gem);
1529
1530         if (bufmgr_gem->bufmgr.debug)
1531                 drm_intel_gem_dump_validation_list(bufmgr_gem);
1532
1533         for (i = 0; i < bufmgr_gem->exec_count; i++) {
1534                 drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
1535                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1536
1537                 /* Disconnect the buffer from the validate list */
1538                 bo_gem->validate_index = -1;
1539                 bufmgr_gem->exec_bos[i] = NULL;
1540         }
1541         bufmgr_gem->exec_count = 0;
1542         pthread_mutex_unlock(&bufmgr_gem->lock);
1543
1544         return ret;
1545 }
1546
1547 static int
1548 drm_intel_gem_bo_mrb_exec2(drm_intel_bo *bo, int used,
1549                         drm_clip_rect_t *cliprects, int num_cliprects, int DR4,
1550                         int ring_flag)
1551 {
1552         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
1553         struct drm_i915_gem_execbuffer2 execbuf;
1554         int ret, i;
1555
1556         if ((ring_flag != I915_EXEC_RENDER) && (ring_flag != I915_EXEC_BSD))
1557                 return -EINVAL;
1558
1559         pthread_mutex_lock(&bufmgr_gem->lock);
1560         /* Update indices and set up the validate list. */
1561         drm_intel_gem_bo_process_reloc2(bo);
1562
1563         /* Add the batch buffer to the validation list.  There are no relocations
1564          * pointing to it.
1565          */
1566         drm_intel_add_validate_buffer2(bo, 0);
1567
1568         execbuf.buffers_ptr = (uintptr_t)bufmgr_gem->exec2_objects;
1569         execbuf.buffer_count = bufmgr_gem->exec_count;
1570         execbuf.batch_start_offset = 0;
1571         execbuf.batch_len = used;
1572         execbuf.cliprects_ptr = (uintptr_t)cliprects;
1573         execbuf.num_cliprects = num_cliprects;
1574         execbuf.DR1 = 0;
1575         execbuf.DR4 = DR4;
1576         execbuf.flags = ring_flag;
1577         execbuf.rsvd1 = 0;
1578         execbuf.rsvd2 = 0;
1579
1580         do {
1581                 ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_EXECBUFFER2,
1582                             &execbuf);
1583         } while (ret != 0 && errno == EINTR);
1584
1585         if (ret != 0) {
1586                 ret = -errno;
1587                 if (ret == -ENOMEM) {
1588                         fprintf(stderr,
1589                                 "Execbuffer fails to pin. "
1590                                 "Estimate: %u. Actual: %u. Available: %u\n",
1591                                 drm_intel_gem_estimate_batch_space(bufmgr_gem->exec_bos,
1592                                                                    bufmgr_gem->exec_count),
1593                                 drm_intel_gem_compute_batch_space(bufmgr_gem->exec_bos,
1594                                                                   bufmgr_gem->exec_count),
1595                                 (unsigned int) bufmgr_gem->gtt_size);
1596                 }
1597         }
1598         drm_intel_update_buffer_offsets2(bufmgr_gem);
1599
1600         if (bufmgr_gem->bufmgr.debug)
1601                 drm_intel_gem_dump_validation_list(bufmgr_gem);
1602
1603         for (i = 0; i < bufmgr_gem->exec_count; i++) {
1604                 drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
1605                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
1606
1607                 /* Disconnect the buffer from the validate list */
1608                 bo_gem->validate_index = -1;
1609                 bufmgr_gem->exec_bos[i] = NULL;
1610         }
1611         bufmgr_gem->exec_count = 0;
1612         pthread_mutex_unlock(&bufmgr_gem->lock);
1613
1614         return ret;
1615 }
1616
1617 static int
1618 drm_intel_gem_bo_exec2(drm_intel_bo *bo, int used,
1619                        drm_clip_rect_t *cliprects, int num_cliprects,
1620                        int DR4)
1621 {
1622         return drm_intel_gem_bo_mrb_exec2(bo, used,
1623                                         cliprects, num_cliprects, DR4,
1624                                         I915_EXEC_RENDER);
1625 }
1626
1627 static int
1628 drm_intel_gem_bo_pin(drm_intel_bo *bo, uint32_t alignment)
1629 {
1630         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1631         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1632         struct drm_i915_gem_pin pin;
1633         int ret;
1634
1635         memset(&pin, 0, sizeof(pin));
1636         pin.handle = bo_gem->gem_handle;
1637         pin.alignment = alignment;
1638
1639         do {
1640                 ret = ioctl(bufmgr_gem->fd,
1641                             DRM_IOCTL_I915_GEM_PIN,
1642                             &pin);
1643         } while (ret == -1 && errno == EINTR);
1644
1645         if (ret != 0)
1646                 return -errno;
1647
1648         bo->offset = pin.offset;
1649         return 0;
1650 }
1651
1652 static int
1653 drm_intel_gem_bo_unpin(drm_intel_bo *bo)
1654 {
1655         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1656         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1657         struct drm_i915_gem_unpin unpin;
1658         int ret;
1659
1660         memset(&unpin, 0, sizeof(unpin));
1661         unpin.handle = bo_gem->gem_handle;
1662
1663         ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_UNPIN, &unpin);
1664         if (ret != 0)
1665                 return -errno;
1666
1667         return 0;
1668 }
1669
1670 static int
1671 drm_intel_gem_bo_set_tiling(drm_intel_bo *bo, uint32_t * tiling_mode,
1672                             uint32_t stride)
1673 {
1674         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1675         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1676         struct drm_i915_gem_set_tiling set_tiling;
1677         int ret;
1678
1679         if (bo_gem->global_name == 0 && *tiling_mode == bo_gem->tiling_mode)
1680                 return 0;
1681
1682         memset(&set_tiling, 0, sizeof(set_tiling));
1683         set_tiling.handle = bo_gem->gem_handle;
1684
1685         do {
1686                 set_tiling.tiling_mode = *tiling_mode;
1687                 set_tiling.stride = stride;
1688
1689                 ret = ioctl(bufmgr_gem->fd,
1690                             DRM_IOCTL_I915_GEM_SET_TILING,
1691                             &set_tiling);
1692         } while (ret == -1 && errno == EINTR);
1693         if (ret == 0) {
1694                 bo_gem->tiling_mode = set_tiling.tiling_mode;
1695                 bo_gem->swizzle_mode = set_tiling.swizzle_mode;
1696                 drm_intel_bo_gem_set_in_aperture_size(bufmgr_gem, bo_gem);
1697         } else
1698                 ret = -errno;
1699
1700         *tiling_mode = bo_gem->tiling_mode;
1701         return ret;
1702 }
1703
1704 static int
1705 drm_intel_gem_bo_get_tiling(drm_intel_bo *bo, uint32_t * tiling_mode,
1706                             uint32_t * swizzle_mode)
1707 {
1708         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1709
1710         *tiling_mode = bo_gem->tiling_mode;
1711         *swizzle_mode = bo_gem->swizzle_mode;
1712         return 0;
1713 }
1714
1715 static int
1716 drm_intel_gem_bo_flink(drm_intel_bo *bo, uint32_t * name)
1717 {
1718         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1719         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1720         struct drm_gem_flink flink;
1721         int ret;
1722
1723         if (!bo_gem->global_name) {
1724                 memset(&flink, 0, sizeof(flink));
1725                 flink.handle = bo_gem->gem_handle;
1726
1727                 ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_GEM_FLINK, &flink);
1728                 if (ret != 0)
1729                         return -errno;
1730                 bo_gem->global_name = flink.name;
1731                 bo_gem->reusable = 0;
1732         }
1733
1734         *name = bo_gem->global_name;
1735         return 0;
1736 }
1737
1738 /**
1739  * Enables unlimited caching of buffer objects for reuse.
1740  *
1741  * This is potentially very memory expensive, as the cache at each bucket
1742  * size is only bounded by how many buffers of that size we've managed to have
1743  * in flight at once.
1744  */
1745 void
1746 drm_intel_bufmgr_gem_enable_reuse(drm_intel_bufmgr *bufmgr)
1747 {
1748         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
1749
1750         bufmgr_gem->bo_reuse = 1;
1751 }
1752
1753 /**
1754  * Enable use of fenced reloc type.
1755  *
1756  * New code should enable this to avoid unnecessary fence register
1757  * allocation.  If this option is not enabled, all relocs will have fence
1758  * register allocated.
1759  */
1760 void
1761 drm_intel_bufmgr_gem_enable_fenced_relocs(drm_intel_bufmgr *bufmgr)
1762 {
1763         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
1764
1765         if (bufmgr_gem->bufmgr.bo_exec == drm_intel_gem_bo_exec2)
1766                 bufmgr_gem->fenced_relocs = 1;
1767 }
1768
1769 /**
1770  * Return the additional aperture space required by the tree of buffer objects
1771  * rooted at bo.
1772  */
1773 static int
1774 drm_intel_gem_bo_get_aperture_space(drm_intel_bo *bo)
1775 {
1776         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1777         int i;
1778         int total = 0;
1779
1780         if (bo == NULL || bo_gem->included_in_check_aperture)
1781                 return 0;
1782
1783         total += bo->size;
1784         bo_gem->included_in_check_aperture = 1;
1785
1786         for (i = 0; i < bo_gem->reloc_count; i++)
1787                 total +=
1788                     drm_intel_gem_bo_get_aperture_space(bo_gem->
1789                                                         reloc_target_info[i].bo);
1790
1791         return total;
1792 }
1793
1794 /**
1795  * Count the number of buffers in this list that need a fence reg
1796  *
1797  * If the count is greater than the number of available regs, we'll have
1798  * to ask the caller to resubmit a batch with fewer tiled buffers.
1799  *
1800  * This function over-counts if the same buffer is used multiple times.
1801  */
1802 static unsigned int
1803 drm_intel_gem_total_fences(drm_intel_bo ** bo_array, int count)
1804 {
1805         int i;
1806         unsigned int total = 0;
1807
1808         for (i = 0; i < count; i++) {
1809                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo_array[i];
1810
1811                 if (bo_gem == NULL)
1812                         continue;
1813
1814                 total += bo_gem->reloc_tree_fences;
1815         }
1816         return total;
1817 }
1818
1819 /**
1820  * Clear the flag set by drm_intel_gem_bo_get_aperture_space() so we're ready
1821  * for the next drm_intel_bufmgr_check_aperture_space() call.
1822  */
1823 static void
1824 drm_intel_gem_bo_clear_aperture_space_flag(drm_intel_bo *bo)
1825 {
1826         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1827         int i;
1828
1829         if (bo == NULL || !bo_gem->included_in_check_aperture)
1830                 return;
1831
1832         bo_gem->included_in_check_aperture = 0;
1833
1834         for (i = 0; i < bo_gem->reloc_count; i++)
1835                 drm_intel_gem_bo_clear_aperture_space_flag(bo_gem->
1836                                                            reloc_target_info[i].bo);
1837 }
1838
1839 /**
1840  * Return a conservative estimate for the amount of aperture required
1841  * for a collection of buffers. This may double-count some buffers.
1842  */
1843 static unsigned int
1844 drm_intel_gem_estimate_batch_space(drm_intel_bo **bo_array, int count)
1845 {
1846         int i;
1847         unsigned int total = 0;
1848
1849         for (i = 0; i < count; i++) {
1850                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo_array[i];
1851                 if (bo_gem != NULL)
1852                         total += bo_gem->reloc_tree_size;
1853         }
1854         return total;
1855 }
1856
1857 /**
1858  * Return the amount of aperture needed for a collection of buffers.
1859  * This avoids double counting any buffers, at the cost of looking
1860  * at every buffer in the set.
1861  */
1862 static unsigned int
1863 drm_intel_gem_compute_batch_space(drm_intel_bo **bo_array, int count)
1864 {
1865         int i;
1866         unsigned int total = 0;
1867
1868         for (i = 0; i < count; i++) {
1869                 total += drm_intel_gem_bo_get_aperture_space(bo_array[i]);
1870                 /* For the first buffer object in the array, we get an
1871                  * accurate count back for its reloc_tree size (since nothing
1872                  * had been flagged as being counted yet).  We can save that
1873                  * value out as a more conservative reloc_tree_size that
1874                  * avoids double-counting target buffers.  Since the first
1875                  * buffer happens to usually be the batch buffer in our
1876                  * callers, this can pull us back from doing the tree
1877                  * walk on every new batch emit.
1878                  */
1879                 if (i == 0) {
1880                         drm_intel_bo_gem *bo_gem =
1881                             (drm_intel_bo_gem *) bo_array[i];
1882                         bo_gem->reloc_tree_size = total;
1883                 }
1884         }
1885
1886         for (i = 0; i < count; i++)
1887                 drm_intel_gem_bo_clear_aperture_space_flag(bo_array[i]);
1888         return total;
1889 }
1890
1891 /**
1892  * Return -1 if the batchbuffer should be flushed before attempting to
1893  * emit rendering referencing the buffers pointed to by bo_array.
1894  *
1895  * This is required because if we try to emit a batchbuffer with relocations
1896  * to a tree of buffers that won't simultaneously fit in the aperture,
1897  * the rendering will return an error at a point where the software is not
1898  * prepared to recover from it.
1899  *
1900  * However, we also want to emit the batchbuffer significantly before we reach
1901  * the limit, as a series of batchbuffers each of which references buffers
1902  * covering almost all of the aperture means that at each emit we end up
1903  * waiting to evict a buffer from the last rendering, and we get synchronous
1904  * performance.  By emitting smaller batchbuffers, we eat some CPU overhead to
1905  * get better parallelism.
1906  */
1907 static int
1908 drm_intel_gem_check_aperture_space(drm_intel_bo **bo_array, int count)
1909 {
1910         drm_intel_bufmgr_gem *bufmgr_gem =
1911             (drm_intel_bufmgr_gem *) bo_array[0]->bufmgr;
1912         unsigned int total = 0;
1913         unsigned int threshold = bufmgr_gem->gtt_size * 3 / 4;
1914         int total_fences;
1915
1916         /* Check for fence reg constraints if necessary */
1917         if (bufmgr_gem->available_fences) {
1918                 total_fences = drm_intel_gem_total_fences(bo_array, count);
1919                 if (total_fences > bufmgr_gem->available_fences)
1920                         return -ENOSPC;
1921         }
1922
1923         total = drm_intel_gem_estimate_batch_space(bo_array, count);
1924
1925         if (total > threshold)
1926                 total = drm_intel_gem_compute_batch_space(bo_array, count);
1927
1928         if (total > threshold) {
1929                 DBG("check_space: overflowed available aperture, "
1930                     "%dkb vs %dkb\n",
1931                     total / 1024, (int)bufmgr_gem->gtt_size / 1024);
1932                 return -ENOSPC;
1933         } else {
1934                 DBG("drm_check_space: total %dkb vs bufgr %dkb\n", total / 1024,
1935                     (int)bufmgr_gem->gtt_size / 1024);
1936                 return 0;
1937         }
1938 }
1939
1940 /*
1941  * Disable buffer reuse for objects which are shared with the kernel
1942  * as scanout buffers
1943  */
1944 static int
1945 drm_intel_gem_bo_disable_reuse(drm_intel_bo *bo)
1946 {
1947         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1948
1949         bo_gem->reusable = 0;
1950         return 0;
1951 }
1952
1953 static int
1954 drm_intel_gem_bo_is_reusable(drm_intel_bo *bo)
1955 {
1956         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1957
1958         return bo_gem->reusable;
1959 }
1960
1961 static int
1962 _drm_intel_gem_bo_references(drm_intel_bo *bo, drm_intel_bo *target_bo)
1963 {
1964         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1965         int i;
1966
1967         for (i = 0; i < bo_gem->reloc_count; i++) {
1968                 if (bo_gem->reloc_target_info[i].bo == target_bo)
1969                         return 1;
1970                 if (_drm_intel_gem_bo_references(bo_gem->reloc_target_info[i].bo,
1971                                                 target_bo))
1972                         return 1;
1973         }
1974
1975         return 0;
1976 }
1977
1978 /** Return true if target_bo is referenced by bo's relocation tree. */
1979 static int
1980 drm_intel_gem_bo_references(drm_intel_bo *bo, drm_intel_bo *target_bo)
1981 {
1982         drm_intel_bo_gem *target_bo_gem = (drm_intel_bo_gem *) target_bo;
1983
1984         if (bo == NULL || target_bo == NULL)
1985                 return 0;
1986         if (target_bo_gem->used_as_reloc_target)
1987                 return _drm_intel_gem_bo_references(bo, target_bo);
1988         return 0;
1989 }
1990
1991 static void
1992 add_bucket(drm_intel_bufmgr_gem *bufmgr_gem, int size)
1993 {
1994         unsigned int i = bufmgr_gem->num_buckets;
1995
1996         assert(i < ARRAY_SIZE(bufmgr_gem->cache_bucket));
1997
1998         DRMINITLISTHEAD(&bufmgr_gem->cache_bucket[i].head);
1999         bufmgr_gem->cache_bucket[i].size = size;
2000         bufmgr_gem->num_buckets++;
2001 }
2002
2003 static void
2004 init_cache_buckets(drm_intel_bufmgr_gem *bufmgr_gem)
2005 {
2006         unsigned long size, cache_max_size = 64 * 1024 * 1024;
2007
2008         /* OK, so power of two buckets was too wasteful of memory.
2009          * Give 3 other sizes between each power of two, to hopefully
2010          * cover things accurately enough.  (The alternative is
2011          * probably to just go for exact matching of sizes, and assume
2012          * that for things like composited window resize the tiled
2013          * width/height alignment and rounding of sizes to pages will
2014          * get us useful cache hit rates anyway)
2015          */
2016         add_bucket(bufmgr_gem, 4096);
2017         add_bucket(bufmgr_gem, 4096 * 2);
2018         add_bucket(bufmgr_gem, 4096 * 3);
2019
2020         /* Initialize the linked lists for BO reuse cache. */
2021         for (size = 4 * 4096; size <= cache_max_size; size *= 2) {
2022                 add_bucket(bufmgr_gem, size);
2023
2024                 add_bucket(bufmgr_gem, size + size * 1 / 4);
2025                 add_bucket(bufmgr_gem, size + size * 2 / 4);
2026                 add_bucket(bufmgr_gem, size + size * 3 / 4);
2027         }
2028 }
2029
2030 /**
2031  * Initializes the GEM buffer manager, which uses the kernel to allocate, map,
2032  * and manage map buffer objections.
2033  *
2034  * \param fd File descriptor of the opened DRM device.
2035  */
2036 drm_intel_bufmgr *
2037 drm_intel_bufmgr_gem_init(int fd, int batch_size)
2038 {
2039         drm_intel_bufmgr_gem *bufmgr_gem;
2040         struct drm_i915_gem_get_aperture aperture;
2041         drm_i915_getparam_t gp;
2042         int ret;
2043         int exec2 = 0, has_bsd = 0;
2044
2045         bufmgr_gem = calloc(1, sizeof(*bufmgr_gem));
2046         if (bufmgr_gem == NULL)
2047                 return NULL;
2048
2049         bufmgr_gem->fd = fd;
2050
2051         if (pthread_mutex_init(&bufmgr_gem->lock, NULL) != 0) {
2052                 free(bufmgr_gem);
2053                 return NULL;
2054         }
2055
2056         ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_GET_APERTURE, &aperture);
2057
2058         if (ret == 0)
2059                 bufmgr_gem->gtt_size = aperture.aper_available_size;
2060         else {
2061                 fprintf(stderr, "DRM_IOCTL_I915_GEM_APERTURE failed: %s\n",
2062                         strerror(errno));
2063                 bufmgr_gem->gtt_size = 128 * 1024 * 1024;
2064                 fprintf(stderr, "Assuming %dkB available aperture size.\n"
2065                         "May lead to reduced performance or incorrect "
2066                         "rendering.\n",
2067                         (int)bufmgr_gem->gtt_size / 1024);
2068         }
2069
2070         gp.param = I915_PARAM_CHIPSET_ID;
2071         gp.value = &bufmgr_gem->pci_device;
2072         ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
2073         if (ret) {
2074                 fprintf(stderr, "get chip id failed: %d [%d]\n", ret, errno);
2075                 fprintf(stderr, "param: %d, val: %d\n", gp.param, *gp.value);
2076         }
2077
2078         if (IS_GEN2(bufmgr_gem))
2079                 bufmgr_gem->gen = 2;
2080         else if (IS_GEN3(bufmgr_gem))
2081                 bufmgr_gem->gen = 3;
2082         else if (IS_GEN4(bufmgr_gem))
2083                 bufmgr_gem->gen = 4;
2084         else
2085                 bufmgr_gem->gen = 6;
2086
2087         gp.param = I915_PARAM_HAS_EXECBUF2;
2088         ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
2089         if (!ret)
2090                 exec2 = 1;
2091
2092         gp.param = I915_PARAM_HAS_BSD;
2093         ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
2094         if (!ret)
2095                 has_bsd = 1;
2096
2097         if (bufmgr_gem->gen < 4) {
2098                 gp.param = I915_PARAM_NUM_FENCES_AVAIL;
2099                 gp.value = &bufmgr_gem->available_fences;
2100                 ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
2101                 if (ret) {
2102                         fprintf(stderr, "get fences failed: %d [%d]\n", ret,
2103                                 errno);
2104                         fprintf(stderr, "param: %d, val: %d\n", gp.param,
2105                                 *gp.value);
2106                         bufmgr_gem->available_fences = 0;
2107                 } else {
2108                         /* XXX The kernel reports the total number of fences,
2109                          * including any that may be pinned.
2110                          *
2111                          * We presume that there will be at least one pinned
2112                          * fence for the scanout buffer, but there may be more
2113                          * than one scanout and the user may be manually
2114                          * pinning buffers. Let's move to execbuffer2 and
2115                          * thereby forget the insanity of using fences...
2116                          */
2117                         bufmgr_gem->available_fences -= 2;
2118                         if (bufmgr_gem->available_fences < 0)
2119                                 bufmgr_gem->available_fences = 0;
2120                 }
2121         }
2122
2123         /* Let's go with one relocation per every 2 dwords (but round down a bit
2124          * since a power of two will mean an extra page allocation for the reloc
2125          * buffer).
2126          *
2127          * Every 4 was too few for the blender benchmark.
2128          */
2129         bufmgr_gem->max_relocs = batch_size / sizeof(uint32_t) / 2 - 2;
2130
2131         bufmgr_gem->bufmgr.bo_alloc = drm_intel_gem_bo_alloc;
2132         bufmgr_gem->bufmgr.bo_alloc_for_render =
2133             drm_intel_gem_bo_alloc_for_render;
2134         bufmgr_gem->bufmgr.bo_alloc_tiled = drm_intel_gem_bo_alloc_tiled;
2135         bufmgr_gem->bufmgr.bo_reference = drm_intel_gem_bo_reference;
2136         bufmgr_gem->bufmgr.bo_unreference = drm_intel_gem_bo_unreference;
2137         bufmgr_gem->bufmgr.bo_map = drm_intel_gem_bo_map;
2138         bufmgr_gem->bufmgr.bo_unmap = drm_intel_gem_bo_unmap;
2139         bufmgr_gem->bufmgr.bo_subdata = drm_intel_gem_bo_subdata;
2140         bufmgr_gem->bufmgr.bo_get_subdata = drm_intel_gem_bo_get_subdata;
2141         bufmgr_gem->bufmgr.bo_wait_rendering = drm_intel_gem_bo_wait_rendering;
2142         bufmgr_gem->bufmgr.bo_emit_reloc = drm_intel_gem_bo_emit_reloc;
2143         bufmgr_gem->bufmgr.bo_emit_reloc_fence = drm_intel_gem_bo_emit_reloc_fence;
2144         bufmgr_gem->bufmgr.bo_pin = drm_intel_gem_bo_pin;
2145         bufmgr_gem->bufmgr.bo_unpin = drm_intel_gem_bo_unpin;
2146         bufmgr_gem->bufmgr.bo_get_tiling = drm_intel_gem_bo_get_tiling;
2147         bufmgr_gem->bufmgr.bo_set_tiling = drm_intel_gem_bo_set_tiling;
2148         bufmgr_gem->bufmgr.bo_flink = drm_intel_gem_bo_flink;
2149         /* Use the new one if available */
2150         if (exec2) {
2151                 bufmgr_gem->bufmgr.bo_exec = drm_intel_gem_bo_exec2;
2152                 if (has_bsd)
2153                         bufmgr_gem->bufmgr.bo_mrb_exec = drm_intel_gem_bo_mrb_exec2;
2154         } else
2155                 bufmgr_gem->bufmgr.bo_exec = drm_intel_gem_bo_exec;
2156         bufmgr_gem->bufmgr.bo_busy = drm_intel_gem_bo_busy;
2157         bufmgr_gem->bufmgr.bo_madvise = drm_intel_gem_bo_madvise;
2158         bufmgr_gem->bufmgr.destroy = drm_intel_bufmgr_gem_destroy;
2159         bufmgr_gem->bufmgr.debug = 0;
2160         bufmgr_gem->bufmgr.check_aperture_space =
2161             drm_intel_gem_check_aperture_space;
2162         bufmgr_gem->bufmgr.bo_disable_reuse = drm_intel_gem_bo_disable_reuse;
2163         bufmgr_gem->bufmgr.bo_is_reusable = drm_intel_gem_bo_is_reusable;
2164         bufmgr_gem->bufmgr.get_pipe_from_crtc_id =
2165             drm_intel_gem_get_pipe_from_crtc_id;
2166         bufmgr_gem->bufmgr.bo_references = drm_intel_gem_bo_references;
2167
2168         init_cache_buckets(bufmgr_gem);
2169
2170         return &bufmgr_gem->bufmgr;
2171 }