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