intel/intel_bufmgr_fake.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2006 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 /* Originally a fake version of the buffer manager so that we can
  29  * prototype the changes in a driver fairly quickly, has been fleshed
  30  * out to a fully functional interim solution.
  31  *
  32  * Basically wraps the old style memory management in the new
  33  * programming interface, but is more expressive and avoids many of
  34  * the bugs in the old texture manager.
  35  */
  36
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include <assert.h>
  40 #include <errno.h>
  41 #include <strings.h>
  42 #include <xf86drm.h>
  43 #include <pthread.h>
  44 #include "intel_bufmgr.h"
  45 #include "intel_bufmgr_priv.h"
  46 #include "drm.h"
  47 #include "i915_drm.h"
  48 #include "mm.h"
  49 #include "libdrm_macros.h"
  50 #include "libdrm_lists.h"
  51
  52 #define DBG(...) do {                                   \
  53         if (bufmgr_fake->bufmgr.debug)                  \
  54                 drmMsg(__VA_ARGS__);                    \
  55 } while (0)
  56
  57 /* Internal flags:
  58  */
  59 #define BM_NO_BACKING_STORE                     0x00000001
  60 #define BM_NO_FENCE_SUBDATA                     0x00000002
  61 #define BM_PINNED                               0x00000004
  62
  63 /* Wrapper around mm.c's mem_block, which understands that you must
  64  * wait for fences to expire before memory can be freed.  This is
  65  * specific to our use of memcpy for uploads - an upload that was
  66  * processed through the command queue wouldn't need to care about
  67  * fences.
  68  */
  69 #define MAX_RELOCS 4096
  70
  71 struct fake_buffer_reloc {
  72         /** Buffer object that the relocation points at. */
  73         drm_intel_bo *target_buf;
  74         /** Offset of the relocation entry within reloc_buf. */
  75         uint32_t offset;
  76         /**
  77          * Cached value of the offset when we last performed this relocation.
  78          */
  79         uint32_t last_target_offset;
  80         /** Value added to target_buf's offset to get the relocation entry. */
  81         uint32_t delta;
  82         /** Cache domains the target buffer is read into. */
  83         uint32_t read_domains;
  84         /** Cache domain the target buffer will have dirty cachelines in. */
  85         uint32_t write_domain;
  86 };
  87
  88 struct block {
  89         struct block *next, *prev;
  90         struct mem_block *mem;  /* BM_MEM_AGP */
  91
  92         /**
  93          * Marks that the block is currently in the aperture and has yet to be
  94          * fenced.
  95          */
  96         unsigned on_hardware:1;
  97         /**
  98          * Marks that the block is currently fenced (being used by rendering)
  99          * and can't be freed until @fence is passed.
 100          */
 101         unsigned fenced:1;
 102
 103         /** Fence cookie for the block. */
 104         unsigned fence;         /* Split to read_fence, write_fence */
 105
 106         drm_intel_bo *bo;
 107         void *virtual;
 108 };
 109
 110 typedef struct _bufmgr_fake {
 111         drm_intel_bufmgr bufmgr;
 112
 113         pthread_mutex_t lock;
 114
 115         unsigned long low_offset;
 116         unsigned long size;
 117         void *virtual;
 118
 119         struct mem_block *heap;
 120
 121         unsigned buf_nr;        /* for generating ids */
 122
 123         /**
 124          * List of blocks which are currently in the GART but haven't been
 125          * fenced yet.
 126          */
 127         struct block on_hardware;
 128         /**
 129          * List of blocks which are in the GART and have an active fence on
 130          * them.
 131          */
 132         struct block fenced;
 133         /**
 134          * List of blocks which have an expired fence and are ready to be
 135          * evicted.
 136          */
 137         struct block lru;
 138
 139         unsigned int last_fence;
 140
 141         unsigned fail:1;
 142         unsigned need_fence:1;
 143         int thrashing;
 144
 145         /**
 146          * Driver callback to emit a fence, returning the cookie.
 147          *
 148          * This allows the driver to hook in a replacement for the DRM usage in
 149          * bufmgr_fake.
 150          *
 151          * Currently, this also requires that a write flush be emitted before
 152          * emitting the fence, but this should change.
 153          */
 154         unsigned int (*fence_emit) (void *private);
 155         /** Driver callback to wait for a fence cookie to have passed. */
 156         void (*fence_wait) (unsigned int fence, void *private);
 157         void *fence_priv;
 158
 159         /**
 160          * Driver callback to execute a buffer.
 161          *
 162          * This allows the driver to hook in a replacement for the DRM usage in
 163          * bufmgr_fake.
 164          */
 165         int (*exec) (drm_intel_bo *bo, unsigned int used, void *priv);
 166         void *exec_priv;
 167
 168         /** Driver-supplied argument to driver callbacks */
 169         void *driver_priv;
 170         /**
 171          * Pointer to kernel-updated sarea data for the last completed user irq
 172          */
 173         volatile int *last_dispatch;
 174
 175         int fd;
 176
 177         int debug;
 178
 179         int performed_rendering;
 180 } drm_intel_bufmgr_fake;
 181
 182 typedef struct _drm_intel_bo_fake {
 183         drm_intel_bo bo;
 184
 185         unsigned id;            /* debug only */
 186         const char *name;
 187
 188         unsigned dirty:1;
 189         /**
 190          * has the card written to this buffer - we make need to copy it back
 191          */
 192         unsigned card_dirty:1;
 193         unsigned int refcount;
 194         /* Flags may consist of any of the DRM_BO flags, plus
 195          * DRM_BO_NO_BACKING_STORE and BM_NO_FENCE_SUBDATA, which are the
 196          * first two driver private flags.
 197          */
 198         uint64_t flags;
 199         /** Cache domains the target buffer is read into. */
 200         uint32_t read_domains;
 201         /** Cache domain the target buffer will have dirty cachelines in. */
 202         uint32_t write_domain;
 203
 204         unsigned int alignment;
 205         int is_static, validated;
 206         unsigned int map_count;
 207
 208         /** relocation list */
 209         struct fake_buffer_reloc *relocs;
 210         int nr_relocs;
 211         /**
 212          * Total size of the target_bos of this buffer.
 213          *
 214          * Used for estimation in check_aperture.
 215          */
 216         unsigned int child_size;
 217
 218         struct block *block;
 219         void *backing_store;
 220         void (*invalidate_cb) (drm_intel_bo *bo, void *ptr);
 221         void *invalidate_ptr;
 222 } drm_intel_bo_fake;
 223
 224 static int clear_fenced(drm_intel_bufmgr_fake *bufmgr_fake,
 225                         unsigned int fence_cookie);
 226
 227 #define MAXFENCE 0x7fffffff
 228
 229 static int
 230 FENCE_LTE(unsigned a, unsigned b)
 231 {
 232         if (a == b)
 233                 return 1;
 234
 235         if (a < b && b - a < (1 << 24))
 236                 return 1;
 237
 238         if (a > b && MAXFENCE - a + b < (1 << 24))
 239                 return 1;
 240
 241         return 0;
 242 }
 243
 244 drm_public void
 245 drm_intel_bufmgr_fake_set_fence_callback(drm_intel_bufmgr *bufmgr,
 246                                          unsigned int (*emit) (void *priv),
 247                                          void (*wait) (unsigned int fence,
 248                                                        void *priv),
 249                                          void *priv)
 250 {
 251         drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *) bufmgr;
 252
 253         bufmgr_fake->fence_emit = emit;
 254         bufmgr_fake->fence_wait = wait;
 255         bufmgr_fake->fence_priv = priv;
 256 }
 257
 258 static unsigned int
 259 _fence_emit_internal(drm_intel_bufmgr_fake *bufmgr_fake)
 260 {
 261         struct drm_i915_irq_emit ie;
 262         int ret, seq = 1;
 263
 264         if (bufmgr_fake->fence_emit != NULL) {
 265                 seq = bufmgr_fake->fence_emit(bufmgr_fake->fence_priv);
 266                 return seq;
 267         }
 268
 269         ie.irq_seq = &seq;
 270         ret = drmCommandWriteRead(bufmgr_fake->fd, DRM_I915_IRQ_EMIT,
 271                                   &ie, sizeof(ie));
 272         if (ret) {
 273                 drmMsg("%s: drm_i915_irq_emit: %d\n", __func__, ret);
 274                 abort();
 275         }
 276
 277         DBG("emit 0x%08x\n", seq);
 278         return seq;
 279 }
 280
 281 static void
 282 _fence_wait_internal(drm_intel_bufmgr_fake *bufmgr_fake, int seq)
 283 {
 284         struct drm_i915_irq_wait iw;
 285         int hw_seq, busy_count = 0;
 286         int ret;
 287         int kernel_lied;
 288
 289         if (bufmgr_fake->fence_wait != NULL) {
 290                 bufmgr_fake->fence_wait(seq, bufmgr_fake->fence_priv);
 291                 clear_fenced(bufmgr_fake, seq);
 292                 return;
 293         }
 294
 295         iw.irq_seq = seq;
 296
 297         DBG("wait 0x%08x\n", iw.irq_seq);
 298
 299         /* The kernel IRQ_WAIT implementation is all sorts of broken.
 300          * 1) It returns 1 to 0x7fffffff instead of using the full 32-bit
 301          *    unsigned range.
 302          * 2) It returns 0 if hw_seq >= seq, not seq - hw_seq < 0 on the 32-bit
 303          *    signed range.
 304          * 3) It waits if seq < hw_seq, not seq - hw_seq > 0 on the 32-bit
 305          *    signed range.
 306          * 4) It returns -EBUSY in 3 seconds even if the hardware is still
 307          *    successfully chewing through buffers.
 308          *
 309          * Assume that in userland we treat sequence numbers as ints, which
 310          * makes some of the comparisons convenient, since the sequence
 311          * numbers are all positive signed integers.
 312          *
 313          * From this we get several cases we need to handle.  Here's a timeline.
 314          * 0x2   0x7                                    0x7ffffff8   0x7ffffffd
 315          *   |    |                                             |    |
 316          * ------------------------------------------------------------
 317          *
 318          * A) Normal wait for hw to catch up
 319          * hw_seq seq
 320          *   |    |
 321          * ------------------------------------------------------------
 322          * seq - hw_seq = 5.  If we call IRQ_WAIT, it will wait for hw to
 323          * catch up.
 324          *
 325          * B) Normal wait for a sequence number that's already passed.
 326          * seq    hw_seq
 327          *   |    |
 328          * ------------------------------------------------------------
 329          * seq - hw_seq = -5.  If we call IRQ_WAIT, it returns 0 quickly.
 330          *
 331          * C) Hardware has already wrapped around ahead of us
 332          * hw_seq                                                    seq
 333          *   |                                                       |
 334          * ------------------------------------------------------------
 335          * seq - hw_seq = 0x80000000 - 5.  If we called IRQ_WAIT, it would wait
 336          * for hw_seq >= seq, which may never occur.  Thus, we want to catch
 337          * this in userland and return 0.
 338          *
 339          * D) We've wrapped around ahead of the hardware.
 340          * seq                                                      hw_seq
 341          *   |                                                       |
 342          * ------------------------------------------------------------
 343          * seq - hw_seq = -(0x80000000 - 5).  If we called IRQ_WAIT, it would
 344          * return 0 quickly because hw_seq >= seq, even though the hardware
 345          * isn't caught up. Thus, we need to catch this early return in
 346          * userland and bother the kernel until the hardware really does
 347          * catch up.
 348          *
 349          * E) Hardware might wrap after we test in userland.
 350          *                                                  hw_seq  seq
 351          *                                                      |    |
 352          * ------------------------------------------------------------
 353          * seq - hw_seq = 5.  If we call IRQ_WAIT, it will likely see seq >=
 354          * hw_seq and wait.  However, suppose hw_seq wraps before we make it
 355          * into the kernel.  The kernel sees hw_seq >= seq and waits for 3
 356          * seconds then returns -EBUSY.  This is case C).  We should catch
 357          * this and then return successfully.
 358          *
 359          * F) Hardware might take a long time on a buffer.
 360          * hw_seq seq
 361          *   |    |
 362          * -------------------------------------------------------------------
 363          * seq - hw_seq = 5.  If we call IRQ_WAIT, if sequence 2 through 5
 364          * take too long, it will return -EBUSY.  Batchbuffers in the
 365          * gltestperf demo were seen to take up to 7 seconds.  We should
 366          * catch early -EBUSY return and keep trying.
 367          */
 368
 369         do {
 370                 /* Keep a copy of last_dispatch so that if the wait -EBUSYs
 371                  * because the hardware didn't catch up in 3 seconds, we can
 372                  * see if it at least made progress and retry.
 373                  */
 374                 hw_seq = *bufmgr_fake->last_dispatch;
 375
 376                 /* Catch case C */
 377                 if (seq - hw_seq > 0x40000000)
 378                         return;
 379
 380                 ret = drmCommandWrite(bufmgr_fake->fd, DRM_I915_IRQ_WAIT,
 381                                       &iw, sizeof(iw));
 382                 /* Catch case D */
 383                 kernel_lied = (ret == 0) && (seq - *bufmgr_fake->last_dispatch <
 384                                              -0x40000000);
 385
 386                 /* Catch case E */
 387                 if (ret == -EBUSY
 388                     && (seq - *bufmgr_fake->last_dispatch > 0x40000000))
 389                         ret = 0;
 390
 391                 /* Catch case F: Allow up to 15 seconds chewing on one buffer. */
 392                 if ((ret == -EBUSY) && (hw_seq != *bufmgr_fake->last_dispatch))
 393                         busy_count = 0;
 394                 else
 395                         busy_count++;
 396         } while (kernel_lied || ret == -EAGAIN || ret == -EINTR ||
 397                  (ret == -EBUSY && busy_count < 5));
 398
 399         if (ret != 0) {
 400                 drmMsg("%s:%d: Error waiting for fence: %s.\n", __FILE__,
 401                        __LINE__, strerror(-ret));
 402                 abort();
 403         }
 404         clear_fenced(bufmgr_fake, seq);
 405 }
 406
 407 static int
 408 _fence_test(drm_intel_bufmgr_fake *bufmgr_fake, unsigned fence)
 409 {
 410         /* Slight problem with wrap-around:
 411          */
 412         return fence == 0 || FENCE_LTE(fence, bufmgr_fake->last_fence);
 413 }
 414
 415 /**
 416  * Allocate a memory manager block for the buffer.
 417  */
 418 static int
 419 alloc_block(drm_intel_bo *bo)
 420 {
 421         drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *) bo;
 422         drm_intel_bufmgr_fake *bufmgr_fake =
 423             (drm_intel_bufmgr_fake *) bo->bufmgr;
 424         struct block *block = (struct block *)calloc(sizeof *block, 1);
 425         unsigned int align_log2 = ffs(bo_fake->alignment) - 1;
 426         unsigned int sz;
 427
 428         if (!block)
 429                 return 1;
 430
 431         sz = (bo->size + bo_fake->alignment - 1) & ~(bo_fake->alignment - 1);
 432
 433         block->mem = mmAllocMem(bufmgr_fake->heap, sz, align_log2, 0);
 434         if (!block->mem) {
 435                 free(block);
 436                 return 0;
 437         }
 438
 439         DRMINITLISTHEAD(block);
 440
 441         /* Insert at head or at tail??? */
 442         DRMLISTADDTAIL(block, &bufmgr_fake->lru);
 443
 444         block->virtual = (uint8_t *) bufmgr_fake->virtual +
 445             block->mem->ofs - bufmgr_fake->low_offset;
 446         block->bo = bo;
 447
 448         bo_fake->block = block;
 449
 450         return 1;
 451 }
 452
 453 /* Release the card storage associated with buf:
 454  */
 455 static void
 456 free_block(drm_intel_bufmgr_fake *bufmgr_fake, struct block *block,
 457            int skip_dirty_copy)
 458 {
 459         drm_intel_bo_fake *bo_fake;
 460         DBG("free block %p %08x %d %d\n", block, block->mem->ofs,
 461             block->on_hardware, block->fenced);
 462
 463         if (!block)
 464                 return;
 465
 466         bo_fake = (drm_intel_bo_fake *) block->bo;
 467
 468         if (bo_fake->flags & (BM_PINNED | BM_NO_BACKING_STORE))
 469                 skip_dirty_copy = 1;
 470
 471         if (!skip_dirty_copy && (bo_fake->card_dirty == 1)) {
 472                 memcpy(bo_fake->backing_store, block->virtual, block->bo->size);
 473                 bo_fake->card_dirty = 0;
 474                 bo_fake->dirty = 1;
 475         }
 476
 477         if (block->on_hardware) {
 478                 block->bo = NULL;
 479         } else if (block->fenced) {
 480                 block->bo = NULL;
 481         } else {
 482                 DBG("    - free immediately\n");
 483                 DRMLISTDEL(block);
 484
 485                 mmFreeMem(block->mem);
 486                 free(block);
 487         }
 488 }
 489
 490 static void
 491 alloc_backing_store(drm_intel_bo *bo)
 492 {
 493         drm_intel_bufmgr_fake *bufmgr_fake =
 494             (drm_intel_bufmgr_fake *) bo->bufmgr;
 495         drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *) bo;
 496         assert(!bo_fake->backing_store);
 497         assert(!(bo_fake->flags & (BM_PINNED | BM_NO_BACKING_STORE)));
 498
 499         bo_fake->backing_store = malloc(bo->size);
 500
 501         DBG("alloc_backing - buf %d %p %lu\n", bo_fake->id,
 502             bo_fake->backing_store, bo->size);
 503         assert(bo_fake->backing_store);
 504 }
 505
 506 static void
 507 free_backing_store(drm_intel_bo *bo)
 508 {
 509         drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *) bo;
 510
 511         if (bo_fake->backing_store) {
 512                 assert(!(bo_fake->flags & (BM_PINNED | BM_NO_BACKING_STORE)));
 513                 free(bo_fake->backing_store);
 514                 bo_fake->backing_store = NULL;
 515         }
 516 }
 517
 518 static void
 519 set_dirty(drm_intel_bo *bo)
 520 {
 521         drm_intel_bufmgr_fake *bufmgr_fake =
 522             (drm_intel_bufmgr_fake *) bo->bufmgr;
 523         drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *) bo;
 524
 525         if (bo_fake->flags & BM_NO_BACKING_STORE
 526             && bo_fake->invalidate_cb != NULL)
 527                 bo_fake->invalidate_cb(bo, bo_fake->invalidate_ptr);
 528
 529         assert(!(bo_fake->flags & BM_PINNED));
 530
 531         DBG("set_dirty - buf %d\n", bo_fake->id);
 532         bo_fake->dirty = 1;
 533 }
 534
 535 static int
 536 evict_lru(drm_intel_bufmgr_fake *bufmgr_fake, unsigned int max_fence)
 537 {
 538         struct block *block, *tmp;
 539
 540         DBG("%s\n", __func__);
 541
 542         DRMLISTFOREACHSAFE(block, tmp, &bufmgr_fake->lru) {
 543                 drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *) block->bo;
 544
 545                 if (bo_fake != NULL && (bo_fake->flags & BM_NO_FENCE_SUBDATA))
 546                         continue;
 547
 548                 if (block->fence && max_fence && !FENCE_LTE(block->fence,
 549                                                             max_fence))
 550                         return 0;
 551
 552                 set_dirty(&bo_fake->bo);
 553                 bo_fake->block = NULL;
 554
 555                 free_block(bufmgr_fake, block, 0);
 556                 return 1;
 557         }
 558
 559         return 0;
 560 }
 561
 562 static int
 563 evict_mru(drm_intel_bufmgr_fake *bufmgr_fake)
 564 {
 565         struct block *block, *tmp;
 566
 567         DBG("%s\n", __func__);
 568
 569         DRMLISTFOREACHSAFEREVERSE(block, tmp, &bufmgr_fake->lru) {
 570                 drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *) block->bo;
 571
 572                 if (bo_fake && (bo_fake->flags & BM_NO_FENCE_SUBDATA))
 573                         continue;
 574
 575                 set_dirty(&bo_fake->bo);
 576                 bo_fake->block = NULL;
 577
 578                 free_block(bufmgr_fake, block, 0);
 579                 return 1;
 580         }
 581
 582         return 0;
 583 }
 584
 585 /**
 586  * Removes all objects from the fenced list older than the given fence.
 587  */
 588 static int
 589 clear_fenced(drm_intel_bufmgr_fake *bufmgr_fake, unsigned int fence_cookie)
 590 {
 591         struct block *block, *tmp;
 592         int ret = 0;
 593
 594         bufmgr_fake->last_fence = fence_cookie;
 595         DRMLISTFOREACHSAFE(block, tmp, &bufmgr_fake->fenced) {
 596                 assert(block->fenced);
 597
 598                 if (_fence_test(bufmgr_fake, block->fence)) {
 599
 600                         block->fenced = 0;
 601
 602                         if (!block->bo) {
 603                                 DBG("delayed free: offset %x sz %x\n",
 604                                     block->mem->ofs, block->mem->size);
 605                                 DRMLISTDEL(block);
 606                                 mmFreeMem(block->mem);
 607                                 free(block);
 608                         } else {
 609                                 DBG("return to lru: offset %x sz %x\n",
 610                                     block->mem->ofs, block->mem->size);
 611                                 DRMLISTDEL(block);
 612                                 DRMLISTADDTAIL(block, &bufmgr_fake->lru);
 613                         }
 614
 615                         ret = 1;
 616                 } else {
 617                         /* Blocks are ordered by fence, so if one fails, all
 618                          * from here will fail also:
 619                          */
 620                         DBG("fence not passed: offset %x sz %x %d %d \n",
 621                             block->mem->ofs, block->mem->size, block->fence,
 622                             bufmgr_fake->last_fence);
 623                         break;
 624                 }
 625         }
 626
 627         DBG("%s: %d\n", __func__, ret);
 628         return ret;
 629 }
 630
 631 static void
 632 fence_blocks(drm_intel_bufmgr_fake *bufmgr_fake, unsigned fence)
 633 {
 634         struct block *block, *tmp;
 635
 636         DRMLISTFOREACHSAFE(block, tmp, &bufmgr_fake->on_hardware) {
 637                 DBG("Fence block %p (sz 0x%x ofs %x buf %p) with fence %d\n",
 638                     block, block->mem->size, block->mem->ofs, block->bo, fence);
 639                 block->fence = fence;
 640
 641                 block->on_hardware = 0;
 642                 block->fenced = 1;
 643
 644                 /* Move to tail of pending list here
 645                  */
 646                 DRMLISTDEL(block);
 647                 DRMLISTADDTAIL(block, &bufmgr_fake->fenced);
 648         }
 649
 650         assert(DRMLISTEMPTY(&bufmgr_fake->on_hardware));
 651 }
 652
 653 static int
 654 evict_and_alloc_block(drm_intel_bo *bo)
 655 {
 656         drm_intel_bufmgr_fake *bufmgr_fake =
 657             (drm_intel_bufmgr_fake *) bo->bufmgr;
 658         drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *) bo;
 659
 660         assert(bo_fake->block == NULL);
 661
 662         /* Search for already free memory:
 663          */
 664         if (alloc_block(bo))
 665                 return 1;
 666
 667         /* If we're not thrashing, allow lru eviction to dig deeper into
 668          * recently used textures.  We'll probably be thrashing soon:
 669          */
 670         if (!bufmgr_fake->thrashing) {
 671                 while (evict_lru(bufmgr_fake, 0))
 672                         if (alloc_block(bo))
 673                                 return 1;
 674         }
 675
 676         /* Keep thrashing counter alive?
 677          */
 678         if (bufmgr_fake->thrashing)
 679                 bufmgr_fake->thrashing = 20;
 680
 681         /* Wait on any already pending fences - here we are waiting for any
 682          * freed memory that has been submitted to hardware and fenced to
 683          * become available:
 684          */
 685         while (!DRMLISTEMPTY(&bufmgr_fake->fenced)) {
 686                 uint32_t fence = bufmgr_fake->fenced.next->fence;
 687                 _fence_wait_internal(bufmgr_fake, fence);
 688
 689                 if (alloc_block(bo))
 690                         return 1;
 691         }
 692
 693         if (!DRMLISTEMPTY(&bufmgr_fake->on_hardware)) {
 694                 while (!DRMLISTEMPTY(&bufmgr_fake->fenced)) {
 695                         uint32_t fence = bufmgr_fake->fenced.next->fence;
 696                         _fence_wait_internal(bufmgr_fake, fence);
 697                 }
 698
 699                 if (!bufmgr_fake->thrashing) {
 700                         DBG("thrashing\n");
 701                 }
 702                 bufmgr_fake->thrashing = 20;
 703
 704                 if (alloc_block(bo))
 705                         return 1;
 706         }
 707
 708         while (evict_mru(bufmgr_fake))
 709                 if (alloc_block(bo))
 710                         return 1;
 711
 712         DBG("%s 0x%lx bytes failed\n", __func__, bo->size);
 713
 714         return 0;
 715 }
 716
 717 /***********************************************************************
 718  * Public functions
 719  */
 720
 721 /**
 722  * Wait for hardware idle by emitting a fence and waiting for it.
 723  */
 724 static void
 725 drm_intel_bufmgr_fake_wait_idle(drm_intel_bufmgr_fake *bufmgr_fake)
 726 {
 727         unsigned int cookie;
 728
 729         cookie = _fence_emit_internal(bufmgr_fake);
 730         _fence_wait_internal(bufmgr_fake, cookie);
 731 }
 732
 733 /**
 734  * Wait for rendering to a buffer to complete.
 735  *
 736  * It is assumed that the batchbuffer which performed the rendering included
 737  * the necessary flushing.
 738  */
 739 static void
 740 drm_intel_fake_bo_wait_rendering_locked(drm_intel_bo *bo)
 741 {
 742         drm_intel_bufmgr_fake *bufmgr_fake =
 743             (drm_intel_bufmgr_fake *) bo->bufmgr;
 744         drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *) bo;
 745
 746         if (bo_fake->block == NULL || !bo_fake->block->fenced)
 747                 return;
 748
 749         _fence_wait_internal(bufmgr_fake, bo_fake->block->fence);
 750 }
 751
 752 static void
 753 drm_intel_fake_bo_wait_rendering(drm_intel_bo *bo)
 754 {
 755         drm_intel_bufmgr_fake *bufmgr_fake =
 756             (drm_intel_bufmgr_fake *) bo->bufmgr;
 757
 758         pthread_mutex_lock(&bufmgr_fake->lock);
 759         drm_intel_fake_bo_wait_rendering_locked(bo);
 760         pthread_mutex_unlock(&bufmgr_fake->lock);
 761 }
 762
 763 /* Specifically ignore texture memory sharing.
 764  *  -- just evict everything
 765  *  -- and wait for idle
 766  */
 767 drm_public void
 768 drm_intel_bufmgr_fake_contended_lock_take(drm_intel_bufmgr *bufmgr)
 769 {
 770         drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *) bufmgr;
 771         struct block *block, *tmp;
 772
 773         pthread_mutex_lock(&bufmgr_fake->lock);
 774
 775         bufmgr_fake->need_fence = 1;
 776         bufmgr_fake->fail = 0;
 777
 778         /* Wait for hardware idle.  We don't know where acceleration has been
 779          * happening, so we'll need to wait anyway before letting anything get
 780          * put on the card again.
 781          */
 782         drm_intel_bufmgr_fake_wait_idle(bufmgr_fake);
 783
 784         /* Check that we hadn't released the lock without having fenced the last
 785          * set of buffers.
 786          */
 787         assert(DRMLISTEMPTY(&bufmgr_fake->fenced));
 788         assert(DRMLISTEMPTY(&bufmgr_fake->on_hardware));
 789
 790         DRMLISTFOREACHSAFE(block, tmp, &bufmgr_fake->lru) {
 791                 assert(_fence_test(bufmgr_fake, block->fence));
 792                 set_dirty(block->bo);
 793         }
 794
 795         pthread_mutex_unlock(&bufmgr_fake->lock);
 796 }
 797
 798 static drm_intel_bo *
 799 drm_intel_fake_bo_alloc(drm_intel_bufmgr *bufmgr,
 800                         const char *name,
 801                         unsigned long size,
 802                         unsigned int alignment)
 803 {
 804         drm_intel_bufmgr_fake *bufmgr_fake;
 805         drm_intel_bo_fake *bo_fake;
 806
 807         bufmgr_fake = (drm_intel_bufmgr_fake *) bufmgr;
 808
 809         assert(size != 0);
 810
 811         bo_fake = calloc(1, sizeof(*bo_fake));
 812         if (!bo_fake)
 813                 return NULL;
 814
 815         bo_fake->bo.size = size;
 816         bo_fake->bo.offset = -1;
 817         bo_fake->bo.virtual = NULL;
 818         bo_fake->bo.bufmgr = bufmgr;
 819         bo_fake->refcount = 1;
 820
 821         /* Alignment must be a power of two */
 822         assert((alignment & (alignment - 1)) == 0);
 823         if (alignment == 0)
 824                 alignment = 1;
 825         bo_fake->alignment = alignment;
 826         bo_fake->id = ++bufmgr_fake->buf_nr;
 827         bo_fake->name = name;
 828         bo_fake->flags = 0;
 829         bo_fake->is_static = 0;
 830
 831         DBG("drm_bo_alloc: (buf %d: %s, %lu kb)\n", bo_fake->id, bo_fake->name,
 832             bo_fake->bo.size / 1024);
 833
 834         return &bo_fake->bo;
 835 }
 836
 837 static drm_intel_bo *
 838 drm_intel_fake_bo_alloc_tiled(drm_intel_bufmgr * bufmgr,
 839                               const char *name,
 840                               int x, int y, int cpp,
 841                               uint32_t *tiling_mode,
 842                               unsigned long *pitch,
 843                               unsigned long flags)
 844 {
 845         unsigned long stride, aligned_y;
 846
 847         /* No runtime tiling support for fake. */
 848         *tiling_mode = I915_TILING_NONE;
 849
 850         /* Align it for being a render target.  Shouldn't need anything else. */
 851         stride = x * cpp;
 852         stride = ROUND_UP_TO(stride, 64);
 853
 854         /* 965 subspan loading alignment */
 855         aligned_y = ALIGN(y, 2);
 856
 857         *pitch = stride;
 858
 859         return drm_intel_fake_bo_alloc(bufmgr, name, stride * aligned_y,
 860                                        4096);
 861 }
 862
 863 drm_public drm_intel_bo *
 864 drm_intel_bo_fake_alloc_static(drm_intel_bufmgr *bufmgr,
 865                                const char *name,
 866                                unsigned long offset,
 867                                unsigned long size, void *virtual)
 868 {
 869         drm_intel_bufmgr_fake *bufmgr_fake;
 870         drm_intel_bo_fake *bo_fake;
 871
 872         bufmgr_fake = (drm_intel_bufmgr_fake *) bufmgr;
 873
 874         assert(size != 0);
 875
 876         bo_fake = calloc(1, sizeof(*bo_fake));
 877         if (!bo_fake)
 878                 return NULL;
 879
 880         bo_fake->bo.size = size;
 881         bo_fake->bo.offset = offset;
 882         bo_fake->bo.virtual = virtual;
 883         bo_fake->bo.bufmgr = bufmgr;
 884         bo_fake->refcount = 1;
 885         bo_fake->id = ++bufmgr_fake->buf_nr;
 886         bo_fake->name = name;
 887         bo_fake->flags = BM_PINNED;
 888         bo_fake->is_static = 1;
 889
 890         DBG("drm_bo_alloc_static: (buf %d: %s, %lu kb)\n", bo_fake->id,
 891             bo_fake->name, bo_fake->bo.size / 1024);
 892
 893         return &bo_fake->bo;
 894 }
 895
 896 static void
 897 drm_intel_fake_bo_reference(drm_intel_bo *bo)
 898 {
 899         drm_intel_bufmgr_fake *bufmgr_fake =
 900             (drm_intel_bufmgr_fake *) bo->bufmgr;
 901         drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *) bo;
 902
 903         pthread_mutex_lock(&bufmgr_fake->lock);
 904         bo_fake->refcount++;
 905         pthread_mutex_unlock(&bufmgr_fake->lock);
 906 }
 907
 908 static void
 909 drm_intel_fake_bo_reference_locked(drm_intel_bo *bo)
 910 {
 911         drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *) bo;
 912
 913         bo_fake->refcount++;
 914 }
 915
 916 static void
 917 drm_intel_fake_bo_unreference_locked(drm_intel_bo *bo)
 918 {
 919         drm_intel_bufmgr_fake *bufmgr_fake =
 920             (drm_intel_bufmgr_fake *) bo->bufmgr;
 921         drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *) bo;
 922         int i;
 923
 924         if (--bo_fake->refcount == 0) {
 925                 assert(bo_fake->map_count == 0);
 926                 /* No remaining references, so free it */
 927                 if (bo_fake->block)
 928                         free_block(bufmgr_fake, bo_fake->block, 1);
 929                 free_backing_store(bo);
 930
 931                 for (i = 0; i < bo_fake->nr_relocs; i++)
 932                         drm_intel_fake_bo_unreference_locked(bo_fake->relocs[i].
 933                                                              target_buf);
 934
 935                 DBG("drm_bo_unreference: free buf %d %s\n", bo_fake->id,
 936                     bo_fake->name);
 937
 938                 free(bo_fake->relocs);
 939                 free(bo);
 940         }
 941 }
 942
 943 static void
 944 drm_intel_fake_bo_unreference(drm_intel_bo *bo)
 945 {
 946         drm_intel_bufmgr_fake *bufmgr_fake =
 947             (drm_intel_bufmgr_fake *) bo->bufmgr;
 948
 949         pthread_mutex_lock(&bufmgr_fake->lock);
 950         drm_intel_fake_bo_unreference_locked(bo);
 951         pthread_mutex_unlock(&bufmgr_fake->lock);
 952 }
 953
 954 /**
 955  * Set the buffer as not requiring backing store, and instead get the callback
 956  * invoked whenever it would be set dirty.
 957  */
 958 drm_public void
 959 drm_intel_bo_fake_disable_backing_store(drm_intel_bo *bo,
 960                                         void (*invalidate_cb) (drm_intel_bo *bo,
 961                                                                void *ptr),
 962                                         void *ptr)
 963 {
 964         drm_intel_bufmgr_fake *bufmgr_fake =
 965             (drm_intel_bufmgr_fake *) bo->bufmgr;
 966         drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *) bo;
 967
 968         pthread_mutex_lock(&bufmgr_fake->lock);
 969
 970         if (bo_fake->backing_store)
 971                 free_backing_store(bo);
 972
 973         bo_fake->flags |= BM_NO_BACKING_STORE;
 974
 975         DBG("disable_backing_store set buf %d dirty\n", bo_fake->id);
 976         bo_fake->dirty = 1;
 977         bo_fake->invalidate_cb = invalidate_cb;
 978         bo_fake->invalidate_ptr = ptr;
 979
 980         /* Note that it is invalid right from the start.  Also note
 981          * invalidate_cb is called with the bufmgr locked, so cannot
 982          * itself make bufmgr calls.
 983          */
 984         if (invalidate_cb != NULL)
 985                 invalidate_cb(bo, ptr);
 986
 987         pthread_mutex_unlock(&bufmgr_fake->lock);
 988 }
 989
 990 /**
 991  * Map a buffer into bo->virtual, allocating either card memory space (If
 992  * BM_NO_BACKING_STORE or BM_PINNED) or backing store, as necessary.
 993  */
 994 static int
 995  drm_intel_fake_bo_map_locked(drm_intel_bo *bo, int write_enable)
 996 {
 997         drm_intel_bufmgr_fake *bufmgr_fake =
 998             (drm_intel_bufmgr_fake *) bo->bufmgr;
 999         drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *) bo;
1000
1001         /* Static buffers are always mapped. */
1002         if (bo_fake->is_static) {
1003                 if (bo_fake->card_dirty) {
1004                         drm_intel_bufmgr_fake_wait_idle(bufmgr_fake);
1005                         bo_fake->card_dirty = 0;
1006                 }
1007                 return 0;
1008         }
1009
1010         /* Allow recursive mapping.  Mesa may recursively map buffers with
1011          * nested display loops, and it is used internally in bufmgr_fake
1012          * for relocation.
1013          */
1014         if (bo_fake->map_count++ != 0)
1015                 return 0;
1016
1017         {
1018                 DBG("drm_bo_map: (buf %d: %s, %lu kb)\n", bo_fake->id,
1019                     bo_fake->name, bo_fake->bo.size / 1024);
1020
1021                 if (bo->virtual != NULL) {
1022                         drmMsg("%s: already mapped\n", __func__);
1023                         abort();
1024                 } else if (bo_fake->flags & (BM_NO_BACKING_STORE | BM_PINNED)) {
1025
1026                         if (!bo_fake->block && !evict_and_alloc_block(bo)) {
1027                                 DBG("%s: alloc failed\n", __func__);
1028                                 bufmgr_fake->fail = 1;
1029                                 return 1;
1030                         } else {
1031                                 assert(bo_fake->block);
1032                                 bo_fake->dirty = 0;
1033
1034                                 if (!(bo_fake->flags & BM_NO_FENCE_SUBDATA) &&
1035                                     bo_fake->block->fenced) {
1036                                         drm_intel_fake_bo_wait_rendering_locked
1037                                             (bo);
1038                                 }
1039
1040                                 bo->virtual = bo_fake->block->virtual;
1041                         }
1042                 } else {
1043                         if (write_enable)
1044                                 set_dirty(bo);
1045
1046                         if (bo_fake->backing_store == 0)
1047                                 alloc_backing_store(bo);
1048
1049                         if ((bo_fake->card_dirty == 1) && bo_fake->block) {
1050                                 if (bo_fake->block->fenced)
1051                                         drm_intel_fake_bo_wait_rendering_locked
1052                                             (bo);
1053
1054                                 memcpy(bo_fake->backing_store,
1055                                        bo_fake->block->virtual,
1056                                        bo_fake->block->bo->size);
1057                                 bo_fake->card_dirty = 0;
1058                         }
1059
1060                         bo->virtual = bo_fake->backing_store;
1061                 }
1062         }
1063
1064         return 0;
1065 }
1066
1067 static int
1068  drm_intel_fake_bo_map(drm_intel_bo *bo, int write_enable)
1069 {
1070         drm_intel_bufmgr_fake *bufmgr_fake =
1071             (drm_intel_bufmgr_fake *) bo->bufmgr;
1072         int ret;
1073
1074         pthread_mutex_lock(&bufmgr_fake->lock);
1075         ret = drm_intel_fake_bo_map_locked(bo, write_enable);
1076         pthread_mutex_unlock(&bufmgr_fake->lock);
1077
1078         return ret;
1079 }
1080
1081 static int
1082  drm_intel_fake_bo_unmap_locked(drm_intel_bo *bo)
1083 {
1084         drm_intel_bufmgr_fake *bufmgr_fake =
1085             (drm_intel_bufmgr_fake *) bo->bufmgr;
1086         drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *) bo;
1087
1088         /* Static buffers are always mapped. */
1089         if (bo_fake->is_static)
1090                 return 0;
1091
1092         assert(bo_fake->map_count != 0);
1093         if (--bo_fake->map_count != 0)
1094                 return 0;
1095
1096         DBG("drm_bo_unmap: (buf %d: %s, %lu kb)\n", bo_fake->id, bo_fake->name,
1097             bo_fake->bo.size / 1024);
1098
1099         bo->virtual = NULL;
1100
1101         return 0;
1102 }
1103
1104 static int drm_intel_fake_bo_unmap(drm_intel_bo *bo)
1105 {
1106         drm_intel_bufmgr_fake *bufmgr_fake =
1107             (drm_intel_bufmgr_fake *) bo->bufmgr;
1108         int ret;
1109
1110         pthread_mutex_lock(&bufmgr_fake->lock);
1111         ret = drm_intel_fake_bo_unmap_locked(bo);
1112         pthread_mutex_unlock(&bufmgr_fake->lock);
1113
1114         return ret;
1115 }
1116
1117 static int
1118 drm_intel_fake_bo_subdata(drm_intel_bo *bo, unsigned long offset,
1119                           unsigned long size, const void *data)
1120 {
1121         int ret;
1122
1123         if (size == 0 || data == NULL)
1124                 return 0;
1125
1126         ret = drm_intel_bo_map(bo, 1);
1127         if (ret)
1128                 return ret;
1129         memcpy((unsigned char *)bo->virtual + offset, data, size);
1130         drm_intel_bo_unmap(bo);
1131         return 0;
1132 }
1133
1134 static void
1135  drm_intel_fake_kick_all_locked(drm_intel_bufmgr_fake *bufmgr_fake)
1136 {
1137         struct block *block, *tmp;
1138
1139         bufmgr_fake->performed_rendering = 0;
1140         /* okay for ever BO that is on the HW kick it off.
1141            seriously not afraid of the POLICE right now */
1142         DRMLISTFOREACHSAFE(block, tmp, &bufmgr_fake->on_hardware) {
1143                 drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *) block->bo;
1144
1145                 block->on_hardware = 0;
1146                 free_block(bufmgr_fake, block, 0);
1147                 bo_fake->block = NULL;
1148                 bo_fake->validated = 0;
1149                 if (!(bo_fake->flags & BM_NO_BACKING_STORE))
1150                         bo_fake->dirty = 1;
1151         }
1152
1153 }
1154
1155 static int
1156  drm_intel_fake_bo_validate(drm_intel_bo *bo)
1157 {
1158         drm_intel_bufmgr_fake *bufmgr_fake;
1159         drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *) bo;
1160
1161         bufmgr_fake = (drm_intel_bufmgr_fake *) bo->bufmgr;
1162
1163         DBG("drm_bo_validate: (buf %d: %s, %lu kb)\n", bo_fake->id,
1164             bo_fake->name, bo_fake->bo.size / 1024);
1165
1166         /* Sanity check: Buffers should be unmapped before being validated.
1167          * This is not so much of a problem for bufmgr_fake, but TTM refuses,
1168          * and the problem is harder to debug there.
1169          */
1170         assert(bo_fake->map_count == 0);
1171
1172         if (bo_fake->is_static) {
1173                 /* Add it to the needs-fence list */
1174                 bufmgr_fake->need_fence = 1;
1175                 return 0;
1176         }
1177
1178         /* Allocate the card memory */
1179         if (!bo_fake->block && !evict_and_alloc_block(bo)) {
1180                 bufmgr_fake->fail = 1;
1181                 DBG("Failed to validate buf %d:%s\n", bo_fake->id,
1182                     bo_fake->name);
1183                 return -1;
1184         }
1185
1186         assert(bo_fake->block);
1187         assert(bo_fake->block->bo == &bo_fake->bo);
1188
1189         bo->offset = bo_fake->block->mem->ofs;
1190
1191         /* Upload the buffer contents if necessary */
1192         if (bo_fake->dirty) {
1193                 DBG("Upload dirty buf %d:%s, sz %lu offset 0x%x\n", bo_fake->id,
1194                     bo_fake->name, bo->size, bo_fake->block->mem->ofs);
1195
1196                 assert(!(bo_fake->flags & (BM_NO_BACKING_STORE | BM_PINNED)));
1197
1198                 /* Actually, should be able to just wait for a fence on the
1199                  * memory, which we would be tracking when we free it. Waiting
1200                  * for idle is a sufficiently large hammer for now.
1201                  */
1202                 drm_intel_bufmgr_fake_wait_idle(bufmgr_fake);
1203
1204                 /* we may never have mapped this BO so it might not have any
1205                  * backing store if this happens it should be rare, but 0 the
1206                  * card memory in any case */
1207                 if (bo_fake->backing_store)
1208                         memcpy(bo_fake->block->virtual, bo_fake->backing_store,
1209                                bo->size);
1210                 else
1211                         memset(bo_fake->block->virtual, 0, bo->size);
1212
1213                 bo_fake->dirty = 0;
1214         }
1215
1216         bo_fake->block->fenced = 0;
1217         bo_fake->block->on_hardware = 1;
1218         DRMLISTDEL(bo_fake->block);
1219         DRMLISTADDTAIL(bo_fake->block, &bufmgr_fake->on_hardware);
1220
1221         bo_fake->validated = 1;
1222         bufmgr_fake->need_fence = 1;
1223
1224         return 0;
1225 }
1226
1227 static void
1228 drm_intel_fake_fence_validated(drm_intel_bufmgr *bufmgr)
1229 {
1230         drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *) bufmgr;
1231         unsigned int cookie;
1232
1233         cookie = _fence_emit_internal(bufmgr_fake);
1234         fence_blocks(bufmgr_fake, cookie);
1235
1236         DBG("drm_fence_validated: 0x%08x cookie\n", cookie);
1237 }
1238
1239 static void
1240 drm_intel_fake_destroy(drm_intel_bufmgr *bufmgr)
1241 {
1242         drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *) bufmgr;
1243
1244         pthread_mutex_destroy(&bufmgr_fake->lock);
1245         mmDestroy(bufmgr_fake->heap);
1246         free(bufmgr);
1247 }
1248
1249 static int
1250 drm_intel_fake_emit_reloc(drm_intel_bo *bo, uint32_t offset,
1251                           drm_intel_bo *target_bo, uint32_t target_offset,
1252                           uint32_t read_domains, uint32_t write_domain)
1253 {
1254         drm_intel_bufmgr_fake *bufmgr_fake =
1255             (drm_intel_bufmgr_fake *) bo->bufmgr;
1256         struct fake_buffer_reloc *r;
1257         drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *) bo;
1258         drm_intel_bo_fake *target_fake = (drm_intel_bo_fake *) target_bo;
1259         int i;
1260
1261         pthread_mutex_lock(&bufmgr_fake->lock);
1262
1263         assert(bo);
1264         assert(target_bo);
1265
1266         if (bo_fake->relocs == NULL) {
1267                 bo_fake->relocs =
1268                     malloc(sizeof(struct fake_buffer_reloc) * MAX_RELOCS);
1269         }
1270
1271         r = &bo_fake->relocs[bo_fake->nr_relocs++];
1272
1273         assert(bo_fake->nr_relocs <= MAX_RELOCS);
1274
1275         drm_intel_fake_bo_reference_locked(target_bo);
1276
1277         if (!target_fake->is_static) {
1278                 bo_fake->child_size +=
1279                     ALIGN(target_bo->size, target_fake->alignment);
1280                 bo_fake->child_size += target_fake->child_size;
1281         }
1282         r->target_buf = target_bo;
1283         r->offset = offset;
1284         r->last_target_offset = target_bo->offset;
1285         r->delta = target_offset;
1286         r->read_domains = read_domains;
1287         r->write_domain = write_domain;
1288
1289         if (bufmgr_fake->debug) {
1290                 /* Check that a conflicting relocation hasn't already been
1291                  * emitted.
1292                  */
1293                 for (i = 0; i < bo_fake->nr_relocs - 1; i++) {
1294                         struct fake_buffer_reloc *r2 = &bo_fake->relocs[i];
1295
1296                         assert(r->offset != r2->offset);
1297                 }
1298         }
1299
1300         pthread_mutex_unlock(&bufmgr_fake->lock);
1301
1302         return 0;
1303 }
1304
1305 /**
1306  * Incorporates the validation flags associated with each relocation into
1307  * the combined validation flags for the buffer on this batchbuffer submission.
1308  */
1309 static void
1310 drm_intel_fake_calculate_domains(drm_intel_bo *bo)
1311 {
1312         drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *) bo;
1313         int i;
1314
1315         for (i = 0; i < bo_fake->nr_relocs; i++) {
1316                 struct fake_buffer_reloc *r = &bo_fake->relocs[i];
1317                 drm_intel_bo_fake *target_fake =
1318                     (drm_intel_bo_fake *) r->target_buf;
1319
1320                 /* Do the same for the tree of buffers we depend on */
1321                 drm_intel_fake_calculate_domains(r->target_buf);
1322
1323                 target_fake->read_domains |= r->read_domains;
1324                 target_fake->write_domain |= r->write_domain;
1325         }
1326 }
1327
1328 static int
1329 drm_intel_fake_reloc_and_validate_buffer(drm_intel_bo *bo)
1330 {
1331         drm_intel_bufmgr_fake *bufmgr_fake =
1332             (drm_intel_bufmgr_fake *) bo->bufmgr;
1333         drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *) bo;
1334         int i, ret;
1335
1336         assert(bo_fake->map_count == 0);
1337
1338         for (i = 0; i < bo_fake->nr_relocs; i++) {
1339                 struct fake_buffer_reloc *r = &bo_fake->relocs[i];
1340                 drm_intel_bo_fake *target_fake =
1341                     (drm_intel_bo_fake *) r->target_buf;
1342                 uint32_t reloc_data;
1343
1344                 /* Validate the target buffer if that hasn't been done. */
1345                 if (!target_fake->validated) {
1346                         ret =
1347                             drm_intel_fake_reloc_and_validate_buffer(r->target_buf);
1348                         if (ret != 0) {
1349                                 if (bo->virtual != NULL)
1350                                         drm_intel_fake_bo_unmap_locked(bo);
1351                                 return ret;
1352                         }
1353                 }
1354
1355                 /* Calculate the value of the relocation entry. */
1356                 if (r->target_buf->offset != r->last_target_offset) {
1357                         reloc_data = r->target_buf->offset + r->delta;
1358
1359                         if (bo->virtual == NULL)
1360                                 drm_intel_fake_bo_map_locked(bo, 1);
1361
1362                         *(uint32_t *) ((uint8_t *) bo->virtual + r->offset) =
1363                             reloc_data;
1364
1365                         r->last_target_offset = r->target_buf->offset;
1366                 }
1367         }
1368
1369         if (bo->virtual != NULL)
1370                 drm_intel_fake_bo_unmap_locked(bo);
1371
1372         if (bo_fake->write_domain != 0) {
1373                 if (!(bo_fake->flags & (BM_NO_BACKING_STORE | BM_PINNED))) {
1374                         if (bo_fake->backing_store == 0)
1375                                 alloc_backing_store(bo);
1376                 }
1377                 bo_fake->card_dirty = 1;
1378                 bufmgr_fake->performed_rendering = 1;
1379         }
1380
1381         return drm_intel_fake_bo_validate(bo);
1382 }
1383
1384 static void
1385 drm_intel_bo_fake_post_submit(drm_intel_bo *bo)
1386 {
1387         drm_intel_bufmgr_fake *bufmgr_fake =
1388             (drm_intel_bufmgr_fake *) bo->bufmgr;
1389         drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *) bo;
1390         int i;
1391
1392         for (i = 0; i < bo_fake->nr_relocs; i++) {
1393                 struct fake_buffer_reloc *r = &bo_fake->relocs[i];
1394                 drm_intel_bo_fake *target_fake =
1395                     (drm_intel_bo_fake *) r->target_buf;
1396
1397                 if (target_fake->validated)
1398                         drm_intel_bo_fake_post_submit(r->target_buf);
1399
1400                 DBG("%s@0x%08x + 0x%08x -> %s@0x%08x + 0x%08x\n",
1401                     bo_fake->name, (uint32_t) bo->offset, r->offset,
1402                     target_fake->name, (uint32_t) r->target_buf->offset,
1403                     r->delta);
1404         }
1405
1406         assert(bo_fake->map_count == 0);
1407         bo_fake->validated = 0;
1408         bo_fake->read_domains = 0;
1409         bo_fake->write_domain = 0;
1410 }
1411
1412 drm_public void
1413 drm_intel_bufmgr_fake_set_exec_callback(drm_intel_bufmgr *bufmgr,
1414                                              int (*exec) (drm_intel_bo *bo,
1415                                                           unsigned int used,
1416                                                           void *priv),
1417                                              void *priv)
1418 {
1419         drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *) bufmgr;
1420
1421         bufmgr_fake->exec = exec;
1422         bufmgr_fake->exec_priv = priv;
1423 }
1424
1425 static int
1426 drm_intel_fake_bo_exec(drm_intel_bo *bo, int used,
1427                        drm_clip_rect_t * cliprects, int num_cliprects, int DR4)
1428 {
1429         drm_intel_bufmgr_fake *bufmgr_fake =
1430             (drm_intel_bufmgr_fake *) bo->bufmgr;
1431         drm_intel_bo_fake *batch_fake = (drm_intel_bo_fake *) bo;
1432         struct drm_i915_batchbuffer batch;
1433         int ret;
1434         int retry_count = 0;
1435
1436         pthread_mutex_lock(&bufmgr_fake->lock);
1437
1438         bufmgr_fake->performed_rendering = 0;
1439
1440         drm_intel_fake_calculate_domains(bo);
1441
1442         batch_fake->read_domains = I915_GEM_DOMAIN_COMMAND;
1443
1444         /* we've ran out of RAM so blow the whole lot away and retry */
1445 restart:
1446         ret = drm_intel_fake_reloc_and_validate_buffer(bo);
1447         if (bufmgr_fake->fail == 1) {
1448                 if (retry_count == 0) {
1449                         retry_count++;
1450                         drm_intel_fake_kick_all_locked(bufmgr_fake);
1451                         bufmgr_fake->fail = 0;
1452                         goto restart;
1453                 } else          /* dump out the memory here */
1454                         mmDumpMemInfo(bufmgr_fake->heap);
1455         }
1456
1457         assert(ret == 0);
1458
1459         if (bufmgr_fake->exec != NULL) {
1460                 ret = bufmgr_fake->exec(bo, used, bufmgr_fake->exec_priv);
1461                 if (ret != 0) {
1462                         pthread_mutex_unlock(&bufmgr_fake->lock);
1463                         return ret;
1464                 }
1465         } else {
1466                 batch.start = bo->offset;
1467                 batch.used = used;
1468                 batch.cliprects = cliprects;
1469                 batch.num_cliprects = num_cliprects;
1470                 batch.DR1 = 0;
1471                 batch.DR4 = DR4;
1472
1473                 if (drmCommandWrite
1474                     (bufmgr_fake->fd, DRM_I915_BATCHBUFFER, &batch,
1475                      sizeof(batch))) {
1476                         drmMsg("DRM_I915_BATCHBUFFER: %d\n", -errno);
1477                         pthread_mutex_unlock(&bufmgr_fake->lock);
1478                         return -errno;
1479                 }
1480         }
1481
1482         drm_intel_fake_fence_validated(bo->bufmgr);
1483
1484         drm_intel_bo_fake_post_submit(bo);
1485
1486         pthread_mutex_unlock(&bufmgr_fake->lock);
1487
1488         return 0;
1489 }
1490
1491 /**
1492  * Return an error if the list of BOs will exceed the aperture size.
1493  *
1494  * This is a rough guess and likely to fail, as during the validate sequence we
1495  * may place a buffer in an inopportune spot early on and then fail to fit
1496  * a set smaller than the aperture.
1497  */
1498 static int
1499 drm_intel_fake_check_aperture_space(drm_intel_bo ** bo_array, int count)
1500 {
1501         drm_intel_bufmgr_fake *bufmgr_fake =
1502             (drm_intel_bufmgr_fake *) bo_array[0]->bufmgr;
1503         unsigned int sz = 0;
1504         int i;
1505
1506         for (i = 0; i < count; i++) {
1507                 drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *) bo_array[i];
1508
1509                 if (bo_fake == NULL)
1510                         continue;
1511
1512                 if (!bo_fake->is_static)
1513                         sz += ALIGN(bo_array[i]->size, bo_fake->alignment);
1514                 sz += bo_fake->child_size;
1515         }
1516
1517         if (sz > bufmgr_fake->size) {
1518                 DBG("check_space: overflowed bufmgr size, %ukb vs %lukb\n",
1519                     sz / 1024, bufmgr_fake->size / 1024);
1520                 return -1;
1521         }
1522
1523         DBG("drm_check_space: sz %ukb vs bufgr %lukb\n", sz / 1024,
1524             bufmgr_fake->size / 1024);
1525         return 0;
1526 }
1527
1528 /**
1529  * Evicts all buffers, waiting for fences to pass and copying contents out
1530  * as necessary.
1531  *
1532  * Used by the X Server on LeaveVT, when the card memory is no longer our
1533  * own.
1534  */
1535 drm_public void
1536 drm_intel_bufmgr_fake_evict_all(drm_intel_bufmgr *bufmgr)
1537 {
1538         drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *) bufmgr;
1539         struct block *block, *tmp;
1540
1541         pthread_mutex_lock(&bufmgr_fake->lock);
1542
1543         bufmgr_fake->need_fence = 1;
1544         bufmgr_fake->fail = 0;
1545
1546         /* Wait for hardware idle.  We don't know where acceleration has been
1547          * happening, so we'll need to wait anyway before letting anything get
1548          * put on the card again.
1549          */
1550         drm_intel_bufmgr_fake_wait_idle(bufmgr_fake);
1551
1552         /* Check that we hadn't released the lock without having fenced the last
1553          * set of buffers.
1554          */
1555         assert(DRMLISTEMPTY(&bufmgr_fake->fenced));
1556         assert(DRMLISTEMPTY(&bufmgr_fake->on_hardware));
1557
1558         DRMLISTFOREACHSAFE(block, tmp, &bufmgr_fake->lru) {
1559                 drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *) block->bo;
1560                 /* Releases the memory, and memcpys dirty contents out if
1561                  * necessary.
1562                  */
1563                 free_block(bufmgr_fake, block, 0);
1564                 bo_fake->block = NULL;
1565         }
1566
1567         pthread_mutex_unlock(&bufmgr_fake->lock);
1568 }
1569
1570 drm_public void
1571 drm_intel_bufmgr_fake_set_last_dispatch(drm_intel_bufmgr *bufmgr,
1572                                         volatile unsigned int
1573                                         *last_dispatch)
1574 {
1575         drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *) bufmgr;
1576
1577         bufmgr_fake->last_dispatch = (volatile int *)last_dispatch;
1578 }
1579
1580 drm_public drm_intel_bufmgr *
1581 drm_intel_bufmgr_fake_init(int fd, unsigned long low_offset,
1582                            void *low_virtual, unsigned long size,
1583                            volatile unsigned int *last_dispatch)
1584 {
1585         drm_intel_bufmgr_fake *bufmgr_fake;
1586
1587         bufmgr_fake = calloc(1, sizeof(*bufmgr_fake));
1588
1589         if (pthread_mutex_init(&bufmgr_fake->lock, NULL) != 0) {
1590                 free(bufmgr_fake);
1591                 return NULL;
1592         }
1593
1594         /* Initialize allocator */
1595         DRMINITLISTHEAD(&bufmgr_fake->fenced);
1596         DRMINITLISTHEAD(&bufmgr_fake->on_hardware);
1597         DRMINITLISTHEAD(&bufmgr_fake->lru);
1598
1599         bufmgr_fake->low_offset = low_offset;
1600         bufmgr_fake->virtual = low_virtual;
1601         bufmgr_fake->size = size;
1602         bufmgr_fake->heap = mmInit(low_offset, size);
1603
1604         /* Hook in methods */
1605         bufmgr_fake->bufmgr.bo_alloc = drm_intel_fake_bo_alloc;
1606         bufmgr_fake->bufmgr.bo_alloc_for_render = drm_intel_fake_bo_alloc;
1607         bufmgr_fake->bufmgr.bo_alloc_tiled = drm_intel_fake_bo_alloc_tiled;
1608         bufmgr_fake->bufmgr.bo_reference = drm_intel_fake_bo_reference;
1609         bufmgr_fake->bufmgr.bo_unreference = drm_intel_fake_bo_unreference;
1610         bufmgr_fake->bufmgr.bo_map = drm_intel_fake_bo_map;
1611         bufmgr_fake->bufmgr.bo_unmap = drm_intel_fake_bo_unmap;
1612         bufmgr_fake->bufmgr.bo_subdata = drm_intel_fake_bo_subdata;
1613         bufmgr_fake->bufmgr.bo_wait_rendering =
1614             drm_intel_fake_bo_wait_rendering;
1615         bufmgr_fake->bufmgr.bo_emit_reloc = drm_intel_fake_emit_reloc;
1616         bufmgr_fake->bufmgr.destroy = drm_intel_fake_destroy;
1617         bufmgr_fake->bufmgr.bo_exec = drm_intel_fake_bo_exec;
1618         bufmgr_fake->bufmgr.check_aperture_space =
1619             drm_intel_fake_check_aperture_space;
1620         bufmgr_fake->bufmgr.debug = 0;
1621
1622         bufmgr_fake->fd = fd;
1623         bufmgr_fake->last_dispatch = (volatile int *)last_dispatch;
1624
1625         return &bufmgr_fake->bufmgr;
1626 }