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