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 static void
 926 drm_intel_gem_bo_mark_mmaps_incoherent(drm_intel_bo *bo)
 927 {
 928 #if HAVE_VALGRIND
 929         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 930
 931         if (bo_gem->mem_virtual)
 932                 VALGRIND_MAKE_MEM_NOACCESS(bo_gem->mem_virtual, bo->size);
 933
 934         if (bo_gem->gtt_virtual)
 935                 VALGRIND_MAKE_MEM_NOACCESS(bo_gem->gtt_virtual, bo->size);
 936 #endif
 937 }
 938
 939 /** Frees all cached buffers significantly older than @time. */
 940 static void
 941 drm_intel_gem_cleanup_bo_cache(drm_intel_bufmgr_gem *bufmgr_gem, time_t time)
 942 {
 943         int i;
 944
 945         if (bufmgr_gem->time == time)
 946                 return;
 947
 948         for (i = 0; i < bufmgr_gem->num_buckets; i++) {
 949                 struct drm_intel_gem_bo_bucket *bucket =
 950                     &bufmgr_gem->cache_bucket[i];
 951
 952                 while (!DRMLISTEMPTY(&bucket->head)) {
 953                         drm_intel_bo_gem *bo_gem;
 954
 955                         bo_gem = DRMLISTENTRY(drm_intel_bo_gem,
 956                                               bucket->head.next, head);
 957                         if (time - bo_gem->free_time <= 1)
 958                                 break;
 959
 960                         DRMLISTDEL(&bo_gem->head);
 961
 962                         drm_intel_gem_bo_free(&bo_gem->bo);
 963                 }
 964         }
 965
 966         bufmgr_gem->time = time;
 967 }
 968
 969 static void drm_intel_gem_bo_purge_vma_cache(drm_intel_bufmgr_gem *bufmgr_gem)
 970 {
 971         int limit;
 972
 973         DBG("%s: cached=%d, open=%d, limit=%d\n", __FUNCTION__,
 974             bufmgr_gem->vma_count, bufmgr_gem->vma_open, bufmgr_gem->vma_max);
 975
 976         if (bufmgr_gem->vma_max < 0)
 977                 return;
 978
 979         /* We may need to evict a few entries in order to create new mmaps */
 980         limit = bufmgr_gem->vma_max - 2*bufmgr_gem->vma_open;
 981         if (limit < 0)
 982                 limit = 0;
 983
 984         while (bufmgr_gem->vma_count > limit) {
 985                 drm_intel_bo_gem *bo_gem;
 986
 987                 bo_gem = DRMLISTENTRY(drm_intel_bo_gem,
 988                                       bufmgr_gem->vma_cache.next,
 989                                       vma_list);
 990                 assert(bo_gem->map_count == 0);
 991                 DRMLISTDELINIT(&bo_gem->vma_list);
 992
 993                 if (bo_gem->mem_virtual) {
 994                         munmap(bo_gem->mem_virtual, bo_gem->bo.size);
 995                         bo_gem->mem_virtual = NULL;
 996                         bufmgr_gem->vma_count--;
 997                 }
 998                 if (bo_gem->gtt_virtual) {
 999                         munmap(bo_gem->gtt_virtual, bo_gem->bo.size);
1000                         bo_gem->gtt_virtual = NULL;
1001                         bufmgr_gem->vma_count--;
1002                 }
1003         }
1004 }
1005
1006 static void drm_intel_gem_bo_close_vma(drm_intel_bufmgr_gem *bufmgr_gem,
1007                                        drm_intel_bo_gem *bo_gem)
1008 {
1009         bufmgr_gem->vma_open--;
1010         DRMLISTADDTAIL(&bo_gem->vma_list, &bufmgr_gem->vma_cache);
1011         if (bo_gem->mem_virtual)
1012                 bufmgr_gem->vma_count++;
1013         if (bo_gem->gtt_virtual)
1014                 bufmgr_gem->vma_count++;
1015         drm_intel_gem_bo_purge_vma_cache(bufmgr_gem);
1016 }
1017
1018 static void drm_intel_gem_bo_open_vma(drm_intel_bufmgr_gem *bufmgr_gem,
1019                                       drm_intel_bo_gem *bo_gem)
1020 {
1021         bufmgr_gem->vma_open++;
1022         DRMLISTDEL(&bo_gem->vma_list);
1023         if (bo_gem->mem_virtual)
1024                 bufmgr_gem->vma_count--;
1025         if (bo_gem->gtt_virtual)
1026                 bufmgr_gem->vma_count--;
1027         drm_intel_gem_bo_purge_vma_cache(bufmgr_gem);
1028 }
1029
1030 static void
1031 drm_intel_gem_bo_unreference_final(drm_intel_bo *bo, time_t time)
1032 {
1033         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1034         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1035         struct drm_intel_gem_bo_bucket *bucket;
1036         int i;
1037
1038         /* Unreference all the target buffers */
1039         for (i = 0; i < bo_gem->reloc_count; i++) {
1040                 if (bo_gem->reloc_target_info[i].bo != bo) {
1041                         drm_intel_gem_bo_unreference_locked_timed(bo_gem->
1042                                                                   reloc_target_info[i].bo,
1043                                                                   time);
1044                 }
1045         }
1046         bo_gem->reloc_count = 0;
1047         bo_gem->used_as_reloc_target = false;
1048
1049         DBG("bo_unreference final: %d (%s)\n",
1050             bo_gem->gem_handle, bo_gem->name);
1051
1052         /* release memory associated with this object */
1053         if (bo_gem->reloc_target_info) {
1054                 free(bo_gem->reloc_target_info);
1055                 bo_gem->reloc_target_info = NULL;
1056         }
1057         if (bo_gem->relocs) {
1058                 free(bo_gem->relocs);
1059                 bo_gem->relocs = NULL;
1060         }
1061
1062         /* Clear any left-over mappings */
1063         if (bo_gem->map_count) {
1064                 DBG("bo freed with non-zero map-count %d\n", bo_gem->map_count);
1065                 bo_gem->map_count = 0;
1066                 drm_intel_gem_bo_close_vma(bufmgr_gem, bo_gem);
1067                 drm_intel_gem_bo_mark_mmaps_incoherent(bo);
1068         }
1069
1070         DRMLISTDEL(&bo_gem->name_list);
1071
1072         bucket = drm_intel_gem_bo_bucket_for_size(bufmgr_gem, bo->size);
1073         /* Put the buffer into our internal cache for reuse if we can. */
1074         if (bufmgr_gem->bo_reuse && bo_gem->reusable && bucket != NULL &&
1075             drm_intel_gem_bo_madvise_internal(bufmgr_gem, bo_gem,
1076                                               I915_MADV_DONTNEED)) {
1077                 bo_gem->free_time = time;
1078
1079                 bo_gem->name = NULL;
1080                 bo_gem->validate_index = -1;
1081
1082                 DRMLISTADDTAIL(&bo_gem->head, &bucket->head);
1083         } else {
1084                 drm_intel_gem_bo_free(bo);
1085         }
1086 }
1087
1088 static void drm_intel_gem_bo_unreference_locked_timed(drm_intel_bo *bo,
1089                                                       time_t time)
1090 {
1091         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1092
1093         assert(atomic_read(&bo_gem->refcount) > 0);
1094         if (atomic_dec_and_test(&bo_gem->refcount))
1095                 drm_intel_gem_bo_unreference_final(bo, time);
1096 }
1097
1098 static void drm_intel_gem_bo_unreference(drm_intel_bo *bo)
1099 {
1100         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1101
1102         assert(atomic_read(&bo_gem->refcount) > 0);
1103         if (atomic_dec_and_test(&bo_gem->refcount)) {
1104                 drm_intel_bufmgr_gem *bufmgr_gem =
1105                     (drm_intel_bufmgr_gem *) bo->bufmgr;
1106                 struct timespec time;
1107
1108                 clock_gettime(CLOCK_MONOTONIC, &time);
1109
1110                 pthread_mutex_lock(&bufmgr_gem->lock);
1111                 drm_intel_gem_bo_unreference_final(bo, time.tv_sec);
1112                 drm_intel_gem_cleanup_bo_cache(bufmgr_gem, time.tv_sec);
1113                 pthread_mutex_unlock(&bufmgr_gem->lock);
1114         }
1115 }
1116
1117 static int drm_intel_gem_bo_map(drm_intel_bo *bo, int write_enable)
1118 {
1119         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1120         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1121         struct drm_i915_gem_set_domain set_domain;
1122         int ret;
1123
1124         pthread_mutex_lock(&bufmgr_gem->lock);
1125
1126         if (bo_gem->map_count++ == 0)
1127                 drm_intel_gem_bo_open_vma(bufmgr_gem, bo_gem);
1128
1129         if (!bo_gem->mem_virtual) {
1130                 struct drm_i915_gem_mmap mmap_arg;
1131
1132                 DBG("bo_map: %d (%s), map_count=%d\n",
1133                     bo_gem->gem_handle, bo_gem->name, bo_gem->map_count);
1134
1135                 VG_CLEAR(mmap_arg);
1136                 mmap_arg.handle = bo_gem->gem_handle;
1137                 mmap_arg.offset = 0;
1138                 mmap_arg.size = bo->size;
1139                 ret = drmIoctl(bufmgr_gem->fd,
1140                                DRM_IOCTL_I915_GEM_MMAP,
1141                                &mmap_arg);
1142                 if (ret != 0) {
1143                         ret = -errno;
1144                         DBG("%s:%d: Error mapping buffer %d (%s): %s .\n",
1145                             __FILE__, __LINE__, bo_gem->gem_handle,
1146                             bo_gem->name, strerror(errno));
1147                         if (--bo_gem->map_count == 0)
1148                                 drm_intel_gem_bo_close_vma(bufmgr_gem, bo_gem);
1149                         pthread_mutex_unlock(&bufmgr_gem->lock);
1150                         return ret;
1151                 }
1152                 VG(VALGRIND_MALLOCLIKE_BLOCK(mmap_arg.addr_ptr, mmap_arg.size, 0, 1));
1153                 bo_gem->mem_virtual = (void *)(uintptr_t) mmap_arg.addr_ptr;
1154         }
1155         DBG("bo_map: %d (%s) -> %p\n", bo_gem->gem_handle, bo_gem->name,
1156             bo_gem->mem_virtual);
1157         bo->virtual = bo_gem->mem_virtual;
1158
1159         VG_CLEAR(set_domain);
1160         set_domain.handle = bo_gem->gem_handle;
1161         set_domain.read_domains = I915_GEM_DOMAIN_CPU;
1162         if (write_enable)
1163                 set_domain.write_domain = I915_GEM_DOMAIN_CPU;
1164         else
1165                 set_domain.write_domain = 0;
1166         ret = drmIoctl(bufmgr_gem->fd,
1167                        DRM_IOCTL_I915_GEM_SET_DOMAIN,
1168                        &set_domain);
1169         if (ret != 0) {
1170                 DBG("%s:%d: Error setting to CPU domain %d: %s\n",
1171                     __FILE__, __LINE__, bo_gem->gem_handle,
1172                     strerror(errno));
1173         }
1174
1175         if (write_enable)
1176                 bo_gem->mapped_cpu_write = true;
1177
1178         drm_intel_gem_bo_mark_mmaps_incoherent(bo);
1179         VG(VALGRIND_MAKE_MEM_DEFINED(bo_gem->mem_virtual, bo->size));
1180         pthread_mutex_unlock(&bufmgr_gem->lock);
1181
1182         return 0;
1183 }
1184
1185 int drm_intel_gem_bo_map_gtt(drm_intel_bo *bo)
1186 {
1187         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1188         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1189         struct drm_i915_gem_set_domain set_domain;
1190         int ret;
1191
1192         pthread_mutex_lock(&bufmgr_gem->lock);
1193
1194         if (bo_gem->map_count++ == 0)
1195                 drm_intel_gem_bo_open_vma(bufmgr_gem, bo_gem);
1196
1197         /* Get a mapping of the buffer if we haven't before. */
1198         if (bo_gem->gtt_virtual == NULL) {
1199                 struct drm_i915_gem_mmap_gtt mmap_arg;
1200
1201                 DBG("bo_map_gtt: mmap %d (%s), map_count=%d\n",
1202                     bo_gem->gem_handle, bo_gem->name, bo_gem->map_count);
1203
1204                 VG_CLEAR(mmap_arg);
1205                 mmap_arg.handle = bo_gem->gem_handle;
1206
1207                 /* Get the fake offset back... */
1208                 ret = drmIoctl(bufmgr_gem->fd,
1209                                DRM_IOCTL_I915_GEM_MMAP_GTT,
1210                                &mmap_arg);
1211                 if (ret != 0) {
1212                         ret = -errno;
1213                         DBG("%s:%d: Error preparing buffer map %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                 /* and mmap it */
1224                 bo_gem->gtt_virtual = mmap(0, bo->size, PROT_READ | PROT_WRITE,
1225                                            MAP_SHARED, bufmgr_gem->fd,
1226                                            mmap_arg.offset);
1227                 if (bo_gem->gtt_virtual == MAP_FAILED) {
1228                         bo_gem->gtt_virtual = NULL;
1229                         ret = -errno;
1230                         DBG("%s:%d: Error mapping buffer %d (%s): %s .\n",
1231                             __FILE__, __LINE__,
1232                             bo_gem->gem_handle, bo_gem->name,
1233                             strerror(errno));
1234                         if (--bo_gem->map_count == 0)
1235                                 drm_intel_gem_bo_close_vma(bufmgr_gem, bo_gem);
1236                         pthread_mutex_unlock(&bufmgr_gem->lock);
1237                         return ret;
1238                 }
1239         }
1240
1241         bo->virtual = bo_gem->gtt_virtual;
1242
1243         DBG("bo_map_gtt: %d (%s) -> %p\n", bo_gem->gem_handle, bo_gem->name,
1244             bo_gem->gtt_virtual);
1245
1246         /* Now move it to the GTT domain so that the CPU caches are flushed */
1247         VG_CLEAR(set_domain);
1248         set_domain.handle = bo_gem->gem_handle;
1249         set_domain.read_domains = I915_GEM_DOMAIN_GTT;
1250         set_domain.write_domain = I915_GEM_DOMAIN_GTT;
1251         ret = drmIoctl(bufmgr_gem->fd,
1252                        DRM_IOCTL_I915_GEM_SET_DOMAIN,
1253                        &set_domain);
1254         if (ret != 0) {
1255                 DBG("%s:%d: Error setting domain %d: %s\n",
1256                     __FILE__, __LINE__, bo_gem->gem_handle,
1257                     strerror(errno));
1258         }
1259
1260         drm_intel_gem_bo_mark_mmaps_incoherent(bo);
1261         VG(VALGRIND_MAKE_MEM_DEFINED(bo_gem->gtt_virtual, bo->size));
1262         pthread_mutex_unlock(&bufmgr_gem->lock);
1263
1264         return 0;
1265 }
1266
1267 static int drm_intel_gem_bo_unmap(drm_intel_bo *bo)
1268 {
1269         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1270         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1271         int ret = 0;
1272
1273         if (bo == NULL)
1274                 return 0;
1275
1276         pthread_mutex_lock(&bufmgr_gem->lock);
1277
1278         if (bo_gem->map_count <= 0) {
1279                 DBG("attempted to unmap an unmapped bo\n");
1280                 pthread_mutex_unlock(&bufmgr_gem->lock);
1281                 /* Preserve the old behaviour of just treating this as a
1282                  * no-op rather than reporting the error.
1283                  */
1284                 return 0;
1285         }
1286
1287         if (bo_gem->mapped_cpu_write) {
1288                 struct drm_i915_gem_sw_finish sw_finish;
1289
1290                 /* Cause a flush to happen if the buffer's pinned for
1291                  * scanout, so the results show up in a timely manner.
1292                  * Unlike GTT set domains, this only does work if the
1293                  * buffer should be scanout-related.
1294                  */
1295                 VG_CLEAR(sw_finish);
1296                 sw_finish.handle = bo_gem->gem_handle;
1297                 ret = drmIoctl(bufmgr_gem->fd,
1298                                DRM_IOCTL_I915_GEM_SW_FINISH,
1299                                &sw_finish);
1300                 ret = ret == -1 ? -errno : 0;
1301
1302                 bo_gem->mapped_cpu_write = false;
1303         }
1304
1305         /* We need to unmap after every innovation as we cannot track
1306          * an open vma for every bo as that will exhaasut the system
1307          * limits and cause later failures.
1308          */
1309         if (--bo_gem->map_count == 0) {
1310                 drm_intel_gem_bo_close_vma(bufmgr_gem, bo_gem);
1311                 drm_intel_gem_bo_mark_mmaps_incoherent(bo);
1312                 bo->virtual = NULL;
1313         }
1314         pthread_mutex_unlock(&bufmgr_gem->lock);
1315
1316         return ret;
1317 }
1318
1319 int drm_intel_gem_bo_unmap_gtt(drm_intel_bo *bo)
1320 {
1321         return drm_intel_gem_bo_unmap(bo);
1322 }
1323
1324 static int
1325 drm_intel_gem_bo_subdata(drm_intel_bo *bo, unsigned long offset,
1326                          unsigned long size, const void *data)
1327 {
1328         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1329         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1330         struct drm_i915_gem_pwrite pwrite;
1331         int ret;
1332
1333         VG_CLEAR(pwrite);
1334         pwrite.handle = bo_gem->gem_handle;
1335         pwrite.offset = offset;
1336         pwrite.size = size;
1337         pwrite.data_ptr = (uint64_t) (uintptr_t) data;
1338         ret = drmIoctl(bufmgr_gem->fd,
1339                        DRM_IOCTL_I915_GEM_PWRITE,
1340                        &pwrite);
1341         if (ret != 0) {
1342                 ret = -errno;
1343                 DBG("%s:%d: Error writing data to buffer %d: (%d %d) %s .\n",
1344                     __FILE__, __LINE__, bo_gem->gem_handle, (int)offset,
1345                     (int)size, strerror(errno));
1346         }
1347
1348         return ret;
1349 }
1350
1351 static int
1352 drm_intel_gem_get_pipe_from_crtc_id(drm_intel_bufmgr *bufmgr, int crtc_id)
1353 {
1354         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
1355         struct drm_i915_get_pipe_from_crtc_id get_pipe_from_crtc_id;
1356         int ret;
1357
1358         VG_CLEAR(get_pipe_from_crtc_id);
1359         get_pipe_from_crtc_id.crtc_id = crtc_id;
1360         ret = drmIoctl(bufmgr_gem->fd,
1361                        DRM_IOCTL_I915_GET_PIPE_FROM_CRTC_ID,
1362                        &get_pipe_from_crtc_id);
1363         if (ret != 0) {
1364                 /* We return -1 here to signal that we don't
1365                  * know which pipe is associated with this crtc.
1366                  * This lets the caller know that this information
1367                  * isn't available; using the wrong pipe for
1368                  * vblank waiting can cause the chipset to lock up
1369                  */
1370                 return -1;
1371         }
1372
1373         return get_pipe_from_crtc_id.pipe;
1374 }
1375
1376 static int
1377 drm_intel_gem_bo_get_subdata(drm_intel_bo *bo, unsigned long offset,
1378                              unsigned long size, void *data)
1379 {
1380         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1381         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1382         struct drm_i915_gem_pread pread;
1383         int ret;
1384
1385         VG_CLEAR(pread);
1386         pread.handle = bo_gem->gem_handle;
1387         pread.offset = offset;
1388         pread.size = size;
1389         pread.data_ptr = (uint64_t) (uintptr_t) data;
1390         ret = drmIoctl(bufmgr_gem->fd,
1391                        DRM_IOCTL_I915_GEM_PREAD,
1392                        &pread);
1393         if (ret != 0) {
1394                 ret = -errno;
1395                 DBG("%s:%d: Error reading data from buffer %d: (%d %d) %s .\n",
1396                     __FILE__, __LINE__, bo_gem->gem_handle, (int)offset,
1397                     (int)size, strerror(errno));
1398         }
1399
1400         return ret;
1401 }
1402
1403 /** Waits for all GPU rendering with the object to have completed. */
1404 static void
1405 drm_intel_gem_bo_wait_rendering(drm_intel_bo *bo)
1406 {
1407         drm_intel_gem_bo_start_gtt_access(bo, 1);
1408 }
1409
1410 /**
1411  * Sets the object to the GTT read and possibly write domain, used by the X
1412  * 2D driver in the absence of kernel support to do drm_intel_gem_bo_map_gtt().
1413  *
1414  * In combination with drm_intel_gem_bo_pin() and manual fence management, we
1415  * can do tiled pixmaps this way.
1416  */
1417 void
1418 drm_intel_gem_bo_start_gtt_access(drm_intel_bo *bo, int write_enable)
1419 {
1420         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1421         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1422         struct drm_i915_gem_set_domain set_domain;
1423         int ret;
1424
1425         VG_CLEAR(set_domain);
1426         set_domain.handle = bo_gem->gem_handle;
1427         set_domain.read_domains = I915_GEM_DOMAIN_GTT;
1428         set_domain.write_domain = write_enable ? I915_GEM_DOMAIN_GTT : 0;
1429         ret = drmIoctl(bufmgr_gem->fd,
1430                        DRM_IOCTL_I915_GEM_SET_DOMAIN,
1431                        &set_domain);
1432         if (ret != 0) {
1433                 DBG("%s:%d: Error setting memory domains %d (%08x %08x): %s .\n",
1434                     __FILE__, __LINE__, bo_gem->gem_handle,
1435                     set_domain.read_domains, set_domain.write_domain,
1436                     strerror(errno));
1437         }
1438 }
1439
1440 static void
1441 drm_intel_bufmgr_gem_destroy(drm_intel_bufmgr *bufmgr)
1442 {
1443         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
1444         int i;
1445
1446         free(bufmgr_gem->exec2_objects);
1447         free(bufmgr_gem->exec_objects);
1448         free(bufmgr_gem->exec_bos);
1449
1450         pthread_mutex_destroy(&bufmgr_gem->lock);
1451
1452         /* Free any cached buffer objects we were going to reuse */
1453         for (i = 0; i < bufmgr_gem->num_buckets; i++) {
1454                 struct drm_intel_gem_bo_bucket *bucket =
1455                     &bufmgr_gem->cache_bucket[i];
1456                 drm_intel_bo_gem *bo_gem;
1457
1458                 while (!DRMLISTEMPTY(&bucket->head)) {
1459                         bo_gem = DRMLISTENTRY(drm_intel_bo_gem,
1460                                               bucket->head.next, head);
1461                         DRMLISTDEL(&bo_gem->head);
1462
1463                         drm_intel_gem_bo_free(&bo_gem->bo);
1464                 }
1465         }
1466
1467         free(bufmgr);
1468 }
1469
1470 /**
1471  * Adds the target buffer to the validation list and adds the relocation
1472  * to the reloc_buffer's relocation list.
1473  *
1474  * The relocation entry at the given offset must already contain the
1475  * precomputed relocation value, because the kernel will optimize out
1476  * the relocation entry write when the buffer hasn't moved from the
1477  * last known offset in target_bo.
1478  */
1479 static int
1480 do_bo_emit_reloc(drm_intel_bo *bo, uint32_t offset,
1481                  drm_intel_bo *target_bo, uint32_t target_offset,
1482                  uint32_t read_domains, uint32_t write_domain,
1483                  bool need_fence)
1484 {
1485         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1486         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1487         drm_intel_bo_gem *target_bo_gem = (drm_intel_bo_gem *) target_bo;
1488         bool fenced_command;
1489
1490         if (bo_gem->has_error)
1491                 return -ENOMEM;
1492
1493         if (target_bo_gem->has_error) {
1494                 bo_gem->has_error = true;
1495                 return -ENOMEM;
1496         }
1497
1498         /* We never use HW fences for rendering on 965+ */
1499         if (bufmgr_gem->gen >= 4)
1500                 need_fence = false;
1501
1502         fenced_command = need_fence;
1503         if (target_bo_gem->tiling_mode == I915_TILING_NONE)
1504                 need_fence = false;
1505
1506         /* Create a new relocation list if needed */
1507         if (bo_gem->relocs == NULL && drm_intel_setup_reloc_list(bo))
1508                 return -ENOMEM;
1509
1510         /* Check overflow */
1511         assert(bo_gem->reloc_count < bufmgr_gem->max_relocs);
1512
1513         /* Check args */
1514         assert(offset <= bo->size - 4);
1515         assert((write_domain & (write_domain - 1)) == 0);
1516
1517         /* Make sure that we're not adding a reloc to something whose size has
1518          * already been accounted for.
1519          */
1520         assert(!bo_gem->used_as_reloc_target);
1521         if (target_bo_gem != bo_gem) {
1522                 target_bo_gem->used_as_reloc_target = true;
1523                 bo_gem->reloc_tree_size += target_bo_gem->reloc_tree_size;
1524         }
1525         /* An object needing a fence is a tiled buffer, so it won't have
1526          * relocs to other buffers.
1527          */
1528         if (need_fence)
1529                 target_bo_gem->reloc_tree_fences = 1;
1530         bo_gem->reloc_tree_fences += target_bo_gem->reloc_tree_fences;
1531
1532         bo_gem->relocs[bo_gem->reloc_count].offset = offset;
1533         bo_gem->relocs[bo_gem->reloc_count].delta = target_offset;
1534         bo_gem->relocs[bo_gem->reloc_count].target_handle =
1535             target_bo_gem->gem_handle;
1536         bo_gem->relocs[bo_gem->reloc_count].read_domains = read_domains;
1537         bo_gem->relocs[bo_gem->reloc_count].write_domain = write_domain;
1538         bo_gem->relocs[bo_gem->reloc_count].presumed_offset = target_bo->offset;
1539
1540         bo_gem->reloc_target_info[bo_gem->reloc_count].bo = target_bo;
1541         if (target_bo != bo)
1542                 drm_intel_gem_bo_reference(target_bo);
1543         if (fenced_command)
1544                 bo_gem->reloc_target_info[bo_gem->reloc_count].flags =
1545                         DRM_INTEL_RELOC_FENCE;
1546         else
1547                 bo_gem->reloc_target_info[bo_gem->reloc_count].flags = 0;
1548
1549         bo_gem->reloc_count++;
1550
1551         return 0;
1552 }
1553
1554 static int
1555 drm_intel_gem_bo_emit_reloc(drm_intel_bo *bo, uint32_t offset,
1556                             drm_intel_bo *target_bo, uint32_t target_offset,
1557                             uint32_t read_domains, uint32_t write_domain)
1558 {
1559         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
1560
1561         return do_bo_emit_reloc(bo, offset, target_bo, target_offset,
1562                                 read_domains, write_domain,
1563                                 !bufmgr_gem->fenced_relocs);
1564 }
1565
1566 static int
1567 drm_intel_gem_bo_emit_reloc_fence(drm_intel_bo *bo, uint32_t offset,
1568                                   drm_intel_bo *target_bo,
1569                                   uint32_t target_offset,
1570                                   uint32_t read_domains, uint32_t write_domain)
1571 {
1572         return do_bo_emit_reloc(bo, offset, target_bo, target_offset,
1573                                 read_domains, write_domain, true);
1574 }
1575
1576 int
1577 drm_intel_gem_bo_get_reloc_count(drm_intel_bo *bo)
1578 {
1579         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1580
1581         return bo_gem->reloc_count;
1582 }
1583
1584 /**
1585  * Removes existing relocation entries in the BO after "start".
1586  *
1587  * This allows a user to avoid a two-step process for state setup with
1588  * counting up all the buffer objects and doing a
1589  * drm_intel_bufmgr_check_aperture_space() before emitting any of the
1590  * relocations for the state setup.  Instead, save the state of the
1591  * batchbuffer including drm_intel_gem_get_reloc_count(), emit all the
1592  * state, and then check if it still fits in the aperture.
1593  *
1594  * Any further drm_intel_bufmgr_check_aperture_space() queries
1595  * involving this buffer in the tree are undefined after this call.
1596  */
1597 void
1598 drm_intel_gem_bo_clear_relocs(drm_intel_bo *bo, int start)
1599 {
1600         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1601         int i;
1602         struct timespec time;
1603
1604         clock_gettime(CLOCK_MONOTONIC, &time);
1605
1606         assert(bo_gem->reloc_count >= start);
1607         /* Unreference the cleared target buffers */
1608         for (i = start; i < bo_gem->reloc_count; i++) {
1609                 if (bo_gem->reloc_target_info[i].bo != bo) {
1610                         drm_intel_gem_bo_unreference_locked_timed(bo_gem->
1611                                                                   reloc_target_info[i].bo,
1612                                                                   time.tv_sec);
1613                 }
1614         }
1615         bo_gem->reloc_count = start;
1616 }
1617
1618 /**
1619  * Walk the tree of relocations rooted at BO and accumulate the list of
1620  * validations to be performed and update the relocation buffers with
1621  * index values into the validation list.
1622  */
1623 static void
1624 drm_intel_gem_bo_process_reloc(drm_intel_bo *bo)
1625 {
1626         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1627         int i;
1628
1629         if (bo_gem->relocs == NULL)
1630                 return;
1631
1632         for (i = 0; i < bo_gem->reloc_count; i++) {
1633                 drm_intel_bo *target_bo = bo_gem->reloc_target_info[i].bo;
1634
1635                 if (target_bo == bo)
1636                         continue;
1637
1638                 drm_intel_gem_bo_mark_mmaps_incoherent(bo);
1639
1640                 /* Continue walking the tree depth-first. */
1641                 drm_intel_gem_bo_process_reloc(target_bo);
1642
1643                 /* Add the target to the validate list */
1644                 drm_intel_add_validate_buffer(target_bo);
1645         }
1646 }
1647
1648 static void
1649 drm_intel_gem_bo_process_reloc2(drm_intel_bo *bo)
1650 {
1651         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
1652         int i;
1653
1654         if (bo_gem->relocs == NULL)
1655                 return;
1656
1657         for (i = 0; i < bo_gem->reloc_count; i++) {
1658                 drm_intel_bo *target_bo = bo_gem->reloc_target_info[i].bo;
1659                 int need_fence;
1660
1661                 if (target_bo == bo)
1662                         continue;
1663
1664                 drm_intel_gem_bo_mark_mmaps_incoherent(bo);
1665
1666                 /* Continue walking the tree depth-first. */
1667                 drm_intel_gem_bo_process_reloc2(target_bo);
1668
1669                 need_fence = (bo_gem->reloc_target_info[i].flags &
1670                               DRM_INTEL_RELOC_FENCE);
1671
1672                 /* Add the target to the validate list */
1673                 drm_intel_add_validate_buffer2(target_bo, need_fence);
1674         }
1675 }
1676
1677
1678 static void
1679 drm_intel_update_buffer_offsets(drm_intel_bufmgr_gem *bufmgr_gem)
1680 {
1681         int i;
1682
1683         for (i = 0; i < bufmgr_gem->exec_count; i++) {
1684                 drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
1685                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1686
1687                 /* Update the buffer offset */
1688                 if (bufmgr_gem->exec_objects[i].offset != bo->offset) {
1689                         DBG("BO %d (%s) migrated: 0x%08lx -> 0x%08llx\n",
1690                             bo_gem->gem_handle, bo_gem->name, bo->offset,
1691                             (unsigned long long)bufmgr_gem->exec_objects[i].
1692                             offset);
1693                         bo->offset = bufmgr_gem->exec_objects[i].offset;
1694                 }
1695         }
1696 }
1697
1698 static void
1699 drm_intel_update_buffer_offsets2 (drm_intel_bufmgr_gem *bufmgr_gem)
1700 {
1701         int i;
1702
1703         for (i = 0; i < bufmgr_gem->exec_count; i++) {
1704                 drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
1705                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
1706
1707                 /* Update the buffer offset */
1708                 if (bufmgr_gem->exec2_objects[i].offset != bo->offset) {
1709                         DBG("BO %d (%s) migrated: 0x%08lx -> 0x%08llx\n",
1710                             bo_gem->gem_handle, bo_gem->name, bo->offset,
1711                             (unsigned long long)bufmgr_gem->exec2_objects[i].offset);
1712                         bo->offset = bufmgr_gem->exec2_objects[i].offset;
1713                 }
1714         }
1715 }
1716
1717 static int
1718 drm_intel_gem_bo_exec(drm_intel_bo *bo, int used,
1719                       drm_clip_rect_t * cliprects, int num_cliprects, int DR4)
1720 {
1721         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1722         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1723         struct drm_i915_gem_execbuffer execbuf;
1724         int ret, i;
1725
1726         if (bo_gem->has_error)
1727                 return -ENOMEM;
1728
1729         pthread_mutex_lock(&bufmgr_gem->lock);
1730         /* Update indices and set up the validate list. */
1731         drm_intel_gem_bo_process_reloc(bo);
1732
1733         /* Add the batch buffer to the validation list.  There are no
1734          * relocations pointing to it.
1735          */
1736         drm_intel_add_validate_buffer(bo);
1737
1738         VG_CLEAR(execbuf);
1739         execbuf.buffers_ptr = (uintptr_t) bufmgr_gem->exec_objects;
1740         execbuf.buffer_count = bufmgr_gem->exec_count;
1741         execbuf.batch_start_offset = 0;
1742         execbuf.batch_len = used;
1743         execbuf.cliprects_ptr = (uintptr_t) cliprects;
1744         execbuf.num_cliprects = num_cliprects;
1745         execbuf.DR1 = 0;
1746         execbuf.DR4 = DR4;
1747
1748         ret = drmIoctl(bufmgr_gem->fd,
1749                        DRM_IOCTL_I915_GEM_EXECBUFFER,
1750                        &execbuf);
1751         if (ret != 0) {
1752                 ret = -errno;
1753                 if (errno == ENOSPC) {
1754                         DBG("Execbuffer fails to pin. "
1755                             "Estimate: %u. Actual: %u. Available: %u\n",
1756                             drm_intel_gem_estimate_batch_space(bufmgr_gem->exec_bos,
1757                                                                bufmgr_gem->
1758                                                                exec_count),
1759                             drm_intel_gem_compute_batch_space(bufmgr_gem->exec_bos,
1760                                                               bufmgr_gem->
1761                                                               exec_count),
1762                             (unsigned int)bufmgr_gem->gtt_size);
1763                 }
1764         }
1765         drm_intel_update_buffer_offsets(bufmgr_gem);
1766
1767         if (bufmgr_gem->bufmgr.debug)
1768                 drm_intel_gem_dump_validation_list(bufmgr_gem);
1769
1770         for (i = 0; i < bufmgr_gem->exec_count; i++) {
1771                 drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
1772                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1773
1774                 /* Disconnect the buffer from the validate list */
1775                 bo_gem->validate_index = -1;
1776                 bufmgr_gem->exec_bos[i] = NULL;
1777         }
1778         bufmgr_gem->exec_count = 0;
1779         pthread_mutex_unlock(&bufmgr_gem->lock);
1780
1781         return ret;
1782 }
1783
1784 static int
1785 drm_intel_gem_bo_mrb_exec2(drm_intel_bo *bo, int used,
1786                         drm_clip_rect_t *cliprects, int num_cliprects, int DR4,
1787                         unsigned int flags)
1788 {
1789         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
1790         struct drm_i915_gem_execbuffer2 execbuf;
1791         int ret, i;
1792
1793         switch (flags & 0x7) {
1794         default:
1795                 return -EINVAL;
1796         case I915_EXEC_BLT:
1797                 if (!bufmgr_gem->has_blt)
1798                         return -EINVAL;
1799                 break;
1800         case I915_EXEC_BSD:
1801                 if (!bufmgr_gem->has_bsd)
1802                         return -EINVAL;
1803                 break;
1804         case I915_EXEC_RENDER:
1805         case I915_EXEC_DEFAULT:
1806                 break;
1807         }
1808
1809         pthread_mutex_lock(&bufmgr_gem->lock);
1810         /* Update indices and set up the validate list. */
1811         drm_intel_gem_bo_process_reloc2(bo);
1812
1813         /* Add the batch buffer to the validation list.  There are no relocations
1814          * pointing to it.
1815          */
1816         drm_intel_add_validate_buffer2(bo, 0);
1817
1818         VG_CLEAR(execbuf);
1819         execbuf.buffers_ptr = (uintptr_t)bufmgr_gem->exec2_objects;
1820         execbuf.buffer_count = bufmgr_gem->exec_count;
1821         execbuf.batch_start_offset = 0;
1822         execbuf.batch_len = used;
1823         execbuf.cliprects_ptr = (uintptr_t)cliprects;
1824         execbuf.num_cliprects = num_cliprects;
1825         execbuf.DR1 = 0;
1826         execbuf.DR4 = DR4;
1827         execbuf.flags = flags;
1828         execbuf.rsvd1 = 0;
1829         execbuf.rsvd2 = 0;
1830
1831         ret = drmIoctl(bufmgr_gem->fd,
1832                        DRM_IOCTL_I915_GEM_EXECBUFFER2,
1833                        &execbuf);
1834         if (ret != 0) {
1835                 ret = -errno;
1836                 if (ret == -ENOSPC) {
1837                         DBG("Execbuffer fails to pin. "
1838                             "Estimate: %u. Actual: %u. Available: %u\n",
1839                             drm_intel_gem_estimate_batch_space(bufmgr_gem->exec_bos,
1840                                                                bufmgr_gem->exec_count),
1841                             drm_intel_gem_compute_batch_space(bufmgr_gem->exec_bos,
1842                                                               bufmgr_gem->exec_count),
1843                             (unsigned int) bufmgr_gem->gtt_size);
1844                 }
1845         }
1846         drm_intel_update_buffer_offsets2(bufmgr_gem);
1847
1848         if (bufmgr_gem->bufmgr.debug)
1849                 drm_intel_gem_dump_validation_list(bufmgr_gem);
1850
1851         for (i = 0; i < bufmgr_gem->exec_count; i++) {
1852                 drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
1853                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
1854
1855                 /* Disconnect the buffer from the validate list */
1856                 bo_gem->validate_index = -1;
1857                 bufmgr_gem->exec_bos[i] = NULL;
1858         }
1859         bufmgr_gem->exec_count = 0;
1860         pthread_mutex_unlock(&bufmgr_gem->lock);
1861
1862         return ret;
1863 }
1864
1865 static int
1866 drm_intel_gem_bo_exec2(drm_intel_bo *bo, int used,
1867                        drm_clip_rect_t *cliprects, int num_cliprects,
1868                        int DR4)
1869 {
1870         return drm_intel_gem_bo_mrb_exec2(bo, used,
1871                                         cliprects, num_cliprects, DR4,
1872                                         I915_EXEC_RENDER);
1873 }
1874
1875 static int
1876 drm_intel_gem_bo_pin(drm_intel_bo *bo, uint32_t alignment)
1877 {
1878         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1879         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1880         struct drm_i915_gem_pin pin;
1881         int ret;
1882
1883         VG_CLEAR(pin);
1884         pin.handle = bo_gem->gem_handle;
1885         pin.alignment = alignment;
1886
1887         ret = drmIoctl(bufmgr_gem->fd,
1888                        DRM_IOCTL_I915_GEM_PIN,
1889                        &pin);
1890         if (ret != 0)
1891                 return -errno;
1892
1893         bo->offset = pin.offset;
1894         return 0;
1895 }
1896
1897 static int
1898 drm_intel_gem_bo_unpin(drm_intel_bo *bo)
1899 {
1900         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1901         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1902         struct drm_i915_gem_unpin unpin;
1903         int ret;
1904
1905         VG_CLEAR(unpin);
1906         unpin.handle = bo_gem->gem_handle;
1907
1908         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_UNPIN, &unpin);
1909         if (ret != 0)
1910                 return -errno;
1911
1912         return 0;
1913 }
1914
1915 static int
1916 drm_intel_gem_bo_set_tiling_internal(drm_intel_bo *bo,
1917                                      uint32_t tiling_mode,
1918                                      uint32_t stride)
1919 {
1920         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1921         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1922         struct drm_i915_gem_set_tiling set_tiling;
1923         int ret;
1924
1925         if (bo_gem->global_name == 0 &&
1926             tiling_mode == bo_gem->tiling_mode &&
1927             stride == bo_gem->stride)
1928                 return 0;
1929
1930         memset(&set_tiling, 0, sizeof(set_tiling));
1931         do {
1932                 /* set_tiling is slightly broken and overwrites the
1933                  * input on the error path, so we have to open code
1934                  * rmIoctl.
1935                  */
1936                 set_tiling.handle = bo_gem->gem_handle;
1937                 set_tiling.tiling_mode = tiling_mode;
1938                 set_tiling.stride = stride;
1939
1940                 ret = ioctl(bufmgr_gem->fd,
1941                             DRM_IOCTL_I915_GEM_SET_TILING,
1942                             &set_tiling);
1943         } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
1944         if (ret == -1)
1945                 return -errno;
1946
1947         bo_gem->tiling_mode = set_tiling.tiling_mode;
1948         bo_gem->swizzle_mode = set_tiling.swizzle_mode;
1949         bo_gem->stride = set_tiling.stride;
1950         return 0;
1951 }
1952
1953 static int
1954 drm_intel_gem_bo_set_tiling(drm_intel_bo *bo, uint32_t * tiling_mode,
1955                             uint32_t stride)
1956 {
1957         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1958         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1959         int ret;
1960
1961         /* Linear buffers have no stride. By ensuring that we only ever use
1962          * stride 0 with linear buffers, we simplify our code.
1963          */
1964         if (*tiling_mode == I915_TILING_NONE)
1965                 stride = 0;
1966
1967         ret = drm_intel_gem_bo_set_tiling_internal(bo, *tiling_mode, stride);
1968         if (ret == 0)
1969                 drm_intel_bo_gem_set_in_aperture_size(bufmgr_gem, bo_gem);
1970
1971         *tiling_mode = bo_gem->tiling_mode;
1972         return ret;
1973 }
1974
1975 static int
1976 drm_intel_gem_bo_get_tiling(drm_intel_bo *bo, uint32_t * tiling_mode,
1977                             uint32_t * swizzle_mode)
1978 {
1979         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1980
1981         *tiling_mode = bo_gem->tiling_mode;
1982         *swizzle_mode = bo_gem->swizzle_mode;
1983         return 0;
1984 }
1985
1986 static int
1987 drm_intel_gem_bo_flink(drm_intel_bo *bo, uint32_t * name)
1988 {
1989         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1990         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1991         int ret;
1992
1993         if (!bo_gem->global_name) {
1994                 struct drm_gem_flink flink;
1995
1996                 VG_CLEAR(flink);
1997                 flink.handle = bo_gem->gem_handle;
1998
1999                 ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_GEM_FLINK, &flink);
2000                 if (ret != 0)
2001                         return -errno;
2002
2003                 bo_gem->global_name = flink.name;
2004                 bo_gem->reusable = false;
2005
2006                 DRMLISTADDTAIL(&bo_gem->name_list, &bufmgr_gem->named);
2007         }
2008
2009         *name = bo_gem->global_name;
2010         return 0;
2011 }
2012
2013 /**
2014  * Enables unlimited caching of buffer objects for reuse.
2015  *
2016  * This is potentially very memory expensive, as the cache at each bucket
2017  * size is only bounded by how many buffers of that size we've managed to have
2018  * in flight at once.
2019  */
2020 void
2021 drm_intel_bufmgr_gem_enable_reuse(drm_intel_bufmgr *bufmgr)
2022 {
2023         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
2024
2025         bufmgr_gem->bo_reuse = true;
2026 }
2027
2028 /**
2029  * Enable use of fenced reloc type.
2030  *
2031  * New code should enable this to avoid unnecessary fence register
2032  * allocation.  If this option is not enabled, all relocs will have fence
2033  * register allocated.
2034  */
2035 void
2036 drm_intel_bufmgr_gem_enable_fenced_relocs(drm_intel_bufmgr *bufmgr)
2037 {
2038         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
2039
2040         if (bufmgr_gem->bufmgr.bo_exec == drm_intel_gem_bo_exec2)
2041                 bufmgr_gem->fenced_relocs = true;
2042 }
2043
2044 /**
2045  * Return the additional aperture space required by the tree of buffer objects
2046  * rooted at bo.
2047  */
2048 static int
2049 drm_intel_gem_bo_get_aperture_space(drm_intel_bo *bo)
2050 {
2051         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2052         int i;
2053         int total = 0;
2054
2055         if (bo == NULL || bo_gem->included_in_check_aperture)
2056                 return 0;
2057
2058         total += bo->size;
2059         bo_gem->included_in_check_aperture = true;
2060
2061         for (i = 0; i < bo_gem->reloc_count; i++)
2062                 total +=
2063                     drm_intel_gem_bo_get_aperture_space(bo_gem->
2064                                                         reloc_target_info[i].bo);
2065
2066         return total;
2067 }
2068
2069 /**
2070  * Count the number of buffers in this list that need a fence reg
2071  *
2072  * If the count is greater than the number of available regs, we'll have
2073  * to ask the caller to resubmit a batch with fewer tiled buffers.
2074  *
2075  * This function over-counts if the same buffer is used multiple times.
2076  */
2077 static unsigned int
2078 drm_intel_gem_total_fences(drm_intel_bo ** bo_array, int count)
2079 {
2080         int i;
2081         unsigned int total = 0;
2082
2083         for (i = 0; i < count; i++) {
2084                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo_array[i];
2085
2086                 if (bo_gem == NULL)
2087                         continue;
2088
2089                 total += bo_gem->reloc_tree_fences;
2090         }
2091         return total;
2092 }
2093
2094 /**
2095  * Clear the flag set by drm_intel_gem_bo_get_aperture_space() so we're ready
2096  * for the next drm_intel_bufmgr_check_aperture_space() call.
2097  */
2098 static void
2099 drm_intel_gem_bo_clear_aperture_space_flag(drm_intel_bo *bo)
2100 {
2101         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2102         int i;
2103
2104         if (bo == NULL || !bo_gem->included_in_check_aperture)
2105                 return;
2106
2107         bo_gem->included_in_check_aperture = false;
2108
2109         for (i = 0; i < bo_gem->reloc_count; i++)
2110                 drm_intel_gem_bo_clear_aperture_space_flag(bo_gem->
2111                                                            reloc_target_info[i].bo);
2112 }
2113
2114 /**
2115  * Return a conservative estimate for the amount of aperture required
2116  * for a collection of buffers. This may double-count some buffers.
2117  */
2118 static unsigned int
2119 drm_intel_gem_estimate_batch_space(drm_intel_bo **bo_array, int count)
2120 {
2121         int i;
2122         unsigned int total = 0;
2123
2124         for (i = 0; i < count; i++) {
2125                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo_array[i];
2126                 if (bo_gem != NULL)
2127                         total += bo_gem->reloc_tree_size;
2128         }
2129         return total;
2130 }
2131
2132 /**
2133  * Return the amount of aperture needed for a collection of buffers.
2134  * This avoids double counting any buffers, at the cost of looking
2135  * at every buffer in the set.
2136  */
2137 static unsigned int
2138 drm_intel_gem_compute_batch_space(drm_intel_bo **bo_array, int count)
2139 {
2140         int i;
2141         unsigned int total = 0;
2142
2143         for (i = 0; i < count; i++) {
2144                 total += drm_intel_gem_bo_get_aperture_space(bo_array[i]);
2145                 /* For the first buffer object in the array, we get an
2146                  * accurate count back for its reloc_tree size (since nothing
2147                  * had been flagged as being counted yet).  We can save that
2148                  * value out as a more conservative reloc_tree_size that
2149                  * avoids double-counting target buffers.  Since the first
2150                  * buffer happens to usually be the batch buffer in our
2151                  * callers, this can pull us back from doing the tree
2152                  * walk on every new batch emit.
2153                  */
2154                 if (i == 0) {
2155                         drm_intel_bo_gem *bo_gem =
2156                             (drm_intel_bo_gem *) bo_array[i];
2157                         bo_gem->reloc_tree_size = total;
2158                 }
2159         }
2160
2161         for (i = 0; i < count; i++)
2162                 drm_intel_gem_bo_clear_aperture_space_flag(bo_array[i]);
2163         return total;
2164 }
2165
2166 /**
2167  * Return -1 if the batchbuffer should be flushed before attempting to
2168  * emit rendering referencing the buffers pointed to by bo_array.
2169  *
2170  * This is required because if we try to emit a batchbuffer with relocations
2171  * to a tree of buffers that won't simultaneously fit in the aperture,
2172  * the rendering will return an error at a point where the software is not
2173  * prepared to recover from it.
2174  *
2175  * However, we also want to emit the batchbuffer significantly before we reach
2176  * the limit, as a series of batchbuffers each of which references buffers
2177  * covering almost all of the aperture means that at each emit we end up
2178  * waiting to evict a buffer from the last rendering, and we get synchronous
2179  * performance.  By emitting smaller batchbuffers, we eat some CPU overhead to
2180  * get better parallelism.
2181  */
2182 static int
2183 drm_intel_gem_check_aperture_space(drm_intel_bo **bo_array, int count)
2184 {
2185         drm_intel_bufmgr_gem *bufmgr_gem =
2186             (drm_intel_bufmgr_gem *) bo_array[0]->bufmgr;
2187         unsigned int total = 0;
2188         unsigned int threshold = bufmgr_gem->gtt_size * 3 / 4;
2189         int total_fences;
2190
2191         /* Check for fence reg constraints if necessary */
2192         if (bufmgr_gem->available_fences) {
2193                 total_fences = drm_intel_gem_total_fences(bo_array, count);
2194                 if (total_fences > bufmgr_gem->available_fences)
2195                         return -ENOSPC;
2196         }
2197
2198         total = drm_intel_gem_estimate_batch_space(bo_array, count);
2199
2200         if (total > threshold)
2201                 total = drm_intel_gem_compute_batch_space(bo_array, count);
2202
2203         if (total > threshold) {
2204                 DBG("check_space: overflowed available aperture, "
2205                     "%dkb vs %dkb\n",
2206                     total / 1024, (int)bufmgr_gem->gtt_size / 1024);
2207                 return -ENOSPC;
2208         } else {
2209                 DBG("drm_check_space: total %dkb vs bufgr %dkb\n", total / 1024,
2210                     (int)bufmgr_gem->gtt_size / 1024);
2211                 return 0;
2212         }
2213 }
2214
2215 /*
2216  * Disable buffer reuse for objects which are shared with the kernel
2217  * as scanout buffers
2218  */
2219 static int
2220 drm_intel_gem_bo_disable_reuse(drm_intel_bo *bo)
2221 {
2222         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2223
2224         bo_gem->reusable = false;
2225         return 0;
2226 }
2227
2228 static int
2229 drm_intel_gem_bo_is_reusable(drm_intel_bo *bo)
2230 {
2231         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2232
2233         return bo_gem->reusable;
2234 }
2235
2236 static int
2237 _drm_intel_gem_bo_references(drm_intel_bo *bo, drm_intel_bo *target_bo)
2238 {
2239         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2240         int i;
2241
2242         for (i = 0; i < bo_gem->reloc_count; i++) {
2243                 if (bo_gem->reloc_target_info[i].bo == target_bo)
2244                         return 1;
2245                 if (bo == bo_gem->reloc_target_info[i].bo)
2246                         continue;
2247                 if (_drm_intel_gem_bo_references(bo_gem->reloc_target_info[i].bo,
2248                                                 target_bo))
2249                         return 1;
2250         }
2251
2252         return 0;
2253 }
2254
2255 /** Return true if target_bo is referenced by bo's relocation tree. */
2256 static int
2257 drm_intel_gem_bo_references(drm_intel_bo *bo, drm_intel_bo *target_bo)
2258 {
2259         drm_intel_bo_gem *target_bo_gem = (drm_intel_bo_gem *) target_bo;
2260
2261         if (bo == NULL || target_bo == NULL)
2262                 return 0;
2263         if (target_bo_gem->used_as_reloc_target)
2264                 return _drm_intel_gem_bo_references(bo, target_bo);
2265         return 0;
2266 }
2267
2268 static void
2269 add_bucket(drm_intel_bufmgr_gem *bufmgr_gem, int size)
2270 {
2271         unsigned int i = bufmgr_gem->num_buckets;
2272
2273         assert(i < ARRAY_SIZE(bufmgr_gem->cache_bucket));
2274
2275         DRMINITLISTHEAD(&bufmgr_gem->cache_bucket[i].head);
2276         bufmgr_gem->cache_bucket[i].size = size;
2277         bufmgr_gem->num_buckets++;
2278 }
2279
2280 static void
2281 init_cache_buckets(drm_intel_bufmgr_gem *bufmgr_gem)
2282 {
2283         unsigned long size, cache_max_size = 64 * 1024 * 1024;
2284
2285         /* OK, so power of two buckets was too wasteful of memory.
2286          * Give 3 other sizes between each power of two, to hopefully
2287          * cover things accurately enough.  (The alternative is
2288          * probably to just go for exact matching of sizes, and assume
2289          * that for things like composited window resize the tiled
2290          * width/height alignment and rounding of sizes to pages will
2291          * get us useful cache hit rates anyway)
2292          */
2293         add_bucket(bufmgr_gem, 4096);
2294         add_bucket(bufmgr_gem, 4096 * 2);
2295         add_bucket(bufmgr_gem, 4096 * 3);
2296
2297         /* Initialize the linked lists for BO reuse cache. */
2298         for (size = 4 * 4096; size <= cache_max_size; size *= 2) {
2299                 add_bucket(bufmgr_gem, size);
2300
2301                 add_bucket(bufmgr_gem, size + size * 1 / 4);
2302                 add_bucket(bufmgr_gem, size + size * 2 / 4);
2303                 add_bucket(bufmgr_gem, size + size * 3 / 4);
2304         }
2305 }
2306
2307 void
2308 drm_intel_bufmgr_gem_set_vma_cache_size(drm_intel_bufmgr *bufmgr, int limit)
2309 {
2310         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
2311
2312         bufmgr_gem->vma_max = limit;
2313
2314         drm_intel_gem_bo_purge_vma_cache(bufmgr_gem);
2315 }
2316
2317 /**
2318  * Initializes the GEM buffer manager, which uses the kernel to allocate, map,
2319  * and manage map buffer objections.
2320  *
2321  * \param fd File descriptor of the opened DRM device.
2322  */
2323 drm_intel_bufmgr *
2324 drm_intel_bufmgr_gem_init(int fd, int batch_size)
2325 {
2326         drm_intel_bufmgr_gem *bufmgr_gem;
2327         struct drm_i915_gem_get_aperture aperture;
2328         drm_i915_getparam_t gp;
2329         int ret, tmp;
2330         bool exec2 = false;
2331
2332         bufmgr_gem = calloc(1, sizeof(*bufmgr_gem));
2333         if (bufmgr_gem == NULL)
2334                 return NULL;
2335
2336         bufmgr_gem->fd = fd;
2337
2338         if (pthread_mutex_init(&bufmgr_gem->lock, NULL) != 0) {
2339                 free(bufmgr_gem);
2340                 return NULL;
2341         }
2342
2343         ret = drmIoctl(bufmgr_gem->fd,
2344                        DRM_IOCTL_I915_GEM_GET_APERTURE,
2345                        &aperture);
2346
2347         if (ret == 0)
2348                 bufmgr_gem->gtt_size = aperture.aper_available_size;
2349         else {
2350                 fprintf(stderr, "DRM_IOCTL_I915_GEM_APERTURE failed: %s\n",
2351                         strerror(errno));
2352                 bufmgr_gem->gtt_size = 128 * 1024 * 1024;
2353                 fprintf(stderr, "Assuming %dkB available aperture size.\n"
2354                         "May lead to reduced performance or incorrect "
2355                         "rendering.\n",
2356                         (int)bufmgr_gem->gtt_size / 1024);
2357         }
2358
2359         VG_CLEAR(gp);
2360         gp.param = I915_PARAM_CHIPSET_ID;
2361         gp.value = &bufmgr_gem->pci_device;
2362         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
2363         if (ret) {
2364                 fprintf(stderr, "get chip id failed: %d [%d]\n", ret, errno);
2365                 fprintf(stderr, "param: %d, val: %d\n", gp.param, *gp.value);
2366         }
2367
2368         if (IS_GEN2(bufmgr_gem->pci_device))
2369                 bufmgr_gem->gen = 2;
2370         else if (IS_GEN3(bufmgr_gem->pci_device))
2371                 bufmgr_gem->gen = 3;
2372         else if (IS_GEN4(bufmgr_gem->pci_device))
2373                 bufmgr_gem->gen = 4;
2374         else if (IS_GEN5(bufmgr_gem->pci_device))
2375                 bufmgr_gem->gen = 5;
2376         else if (IS_GEN6(bufmgr_gem->pci_device))
2377                 bufmgr_gem->gen = 6;
2378         else if (IS_GEN7(bufmgr_gem->pci_device))
2379                 bufmgr_gem->gen = 7;
2380         else
2381                 assert(0);
2382
2383         if (IS_GEN3(bufmgr_gem->pci_device) &&
2384             bufmgr_gem->gtt_size > 256*1024*1024) {
2385                 /* The unmappable part of gtt on gen 3 (i.e. above 256MB) can't
2386                  * be used for tiled blits. To simplify the accounting, just
2387                  * substract the unmappable part (fixed to 256MB on all known
2388                  * gen3 devices) if the kernel advertises it. */
2389                 bufmgr_gem->gtt_size -= 256*1024*1024;
2390         }
2391
2392         gp.value = &tmp;
2393
2394         gp.param = I915_PARAM_HAS_EXECBUF2;
2395         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
2396         if (!ret)
2397                 exec2 = true;
2398
2399         gp.param = I915_PARAM_HAS_BSD;
2400         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
2401         bufmgr_gem->has_bsd = ret == 0;
2402
2403         gp.param = I915_PARAM_HAS_BLT;
2404         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
2405         bufmgr_gem->has_blt = ret == 0;
2406
2407         gp.param = I915_PARAM_HAS_RELAXED_FENCING;
2408         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
2409         bufmgr_gem->has_relaxed_fencing = ret == 0;
2410
2411         gp.param = I915_PARAM_HAS_LLC;
2412         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
2413         if (ret == -EINVAL) {
2414                 /* Kernel does not supports HAS_LLC query, fallback to GPU
2415                  * generation detection and assume that we have LLC on GEN6/7
2416                  */
2417                 bufmgr_gem->has_llc = (IS_GEN6(bufmgr_gem->pci_device) |
2418                                 IS_GEN7(bufmgr_gem->pci_device));
2419         } else
2420                 bufmgr_gem->has_llc = ret == 0;
2421
2422         if (bufmgr_gem->gen < 4) {
2423                 gp.param = I915_PARAM_NUM_FENCES_AVAIL;
2424                 gp.value = &bufmgr_gem->available_fences;
2425                 ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
2426                 if (ret) {
2427                         fprintf(stderr, "get fences failed: %d [%d]\n", ret,
2428                                 errno);
2429                         fprintf(stderr, "param: %d, val: %d\n", gp.param,
2430                                 *gp.value);
2431                         bufmgr_gem->available_fences = 0;
2432                 } else {
2433                         /* XXX The kernel reports the total number of fences,
2434                          * including any that may be pinned.
2435                          *
2436                          * We presume that there will be at least one pinned
2437                          * fence for the scanout buffer, but there may be more
2438                          * than one scanout and the user may be manually
2439                          * pinning buffers. Let's move to execbuffer2 and
2440                          * thereby forget the insanity of using fences...
2441                          */
2442                         bufmgr_gem->available_fences -= 2;
2443                         if (bufmgr_gem->available_fences < 0)
2444                                 bufmgr_gem->available_fences = 0;
2445                 }
2446         }
2447
2448         /* Let's go with one relocation per every 2 dwords (but round down a bit
2449          * since a power of two will mean an extra page allocation for the reloc
2450          * buffer).
2451          *
2452          * Every 4 was too few for the blender benchmark.
2453          */
2454         bufmgr_gem->max_relocs = batch_size / sizeof(uint32_t) / 2 - 2;
2455
2456         bufmgr_gem->bufmgr.bo_alloc = drm_intel_gem_bo_alloc;
2457         bufmgr_gem->bufmgr.bo_alloc_for_render =
2458             drm_intel_gem_bo_alloc_for_render;
2459         bufmgr_gem->bufmgr.bo_alloc_tiled = drm_intel_gem_bo_alloc_tiled;
2460         bufmgr_gem->bufmgr.bo_reference = drm_intel_gem_bo_reference;
2461         bufmgr_gem->bufmgr.bo_unreference = drm_intel_gem_bo_unreference;
2462         bufmgr_gem->bufmgr.bo_map = drm_intel_gem_bo_map;
2463         bufmgr_gem->bufmgr.bo_unmap = drm_intel_gem_bo_unmap;
2464         bufmgr_gem->bufmgr.bo_subdata = drm_intel_gem_bo_subdata;
2465         bufmgr_gem->bufmgr.bo_get_subdata = drm_intel_gem_bo_get_subdata;
2466         bufmgr_gem->bufmgr.bo_wait_rendering = drm_intel_gem_bo_wait_rendering;
2467         bufmgr_gem->bufmgr.bo_emit_reloc = drm_intel_gem_bo_emit_reloc;
2468         bufmgr_gem->bufmgr.bo_emit_reloc_fence = drm_intel_gem_bo_emit_reloc_fence;
2469         bufmgr_gem->bufmgr.bo_pin = drm_intel_gem_bo_pin;
2470         bufmgr_gem->bufmgr.bo_unpin = drm_intel_gem_bo_unpin;
2471         bufmgr_gem->bufmgr.bo_get_tiling = drm_intel_gem_bo_get_tiling;
2472         bufmgr_gem->bufmgr.bo_set_tiling = drm_intel_gem_bo_set_tiling;
2473         bufmgr_gem->bufmgr.bo_flink = drm_intel_gem_bo_flink;
2474         /* Use the new one if available */
2475         if (exec2) {
2476                 bufmgr_gem->bufmgr.bo_exec = drm_intel_gem_bo_exec2;
2477                 bufmgr_gem->bufmgr.bo_mrb_exec = drm_intel_gem_bo_mrb_exec2;
2478         } else
2479                 bufmgr_gem->bufmgr.bo_exec = drm_intel_gem_bo_exec;
2480         bufmgr_gem->bufmgr.bo_busy = drm_intel_gem_bo_busy;
2481         bufmgr_gem->bufmgr.bo_madvise = drm_intel_gem_bo_madvise;
2482         bufmgr_gem->bufmgr.destroy = drm_intel_bufmgr_gem_destroy;
2483         bufmgr_gem->bufmgr.debug = 0;
2484         bufmgr_gem->bufmgr.check_aperture_space =
2485             drm_intel_gem_check_aperture_space;
2486         bufmgr_gem->bufmgr.bo_disable_reuse = drm_intel_gem_bo_disable_reuse;
2487         bufmgr_gem->bufmgr.bo_is_reusable = drm_intel_gem_bo_is_reusable;
2488         bufmgr_gem->bufmgr.get_pipe_from_crtc_id =
2489             drm_intel_gem_get_pipe_from_crtc_id;
2490         bufmgr_gem->bufmgr.bo_references = drm_intel_gem_bo_references;
2491
2492         DRMINITLISTHEAD(&bufmgr_gem->named);
2493         init_cache_buckets(bufmgr_gem);
2494
2495         DRMINITLISTHEAD(&bufmgr_gem->vma_cache);
2496         bufmgr_gem->vma_max = -1; /* unlimited by default */
2497
2498         return &bufmgr_gem->bufmgr;
2499 }