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