Subversion Repositories Kolibri OS

Rev

Rev 4397 | Rev 4501 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

  1. /*
  2.  * Copyright (c) 2011 Intel Corporation
  3.  *
  4.  * Permission is hereby granted, free of charge, to any person obtaining a
  5.  * copy of this software and associated documentation files (the "Software"),
  6.  * to deal in the Software without restriction, including without limitation
  7.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  8.  * and/or sell copies of the Software, and to permit persons to whom the
  9.  * Software is furnished to do so, subject to the following conditions:
  10.  *
  11.  * The above copyright notice and this permission notice (including the next
  12.  * paragraph) shall be included in all copies or substantial portions of the
  13.  * Software.
  14.  *
  15.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18.  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20.  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  21.  * SOFTWARE.
  22.  *
  23.  * Authors:
  24.  *    Chris Wilson <chris@chris-wilson.co.uk>
  25.  *
  26.  */
  27.  
  28. #ifdef HAVE_CONFIG_H
  29. #include "config.h"
  30. #endif
  31.  
  32. #include "sna.h"
  33. #include "sna_reg.h"
  34.  
  35. #include <time.h>
  36. #include <errno.h>
  37. #include <fcntl.h>
  38.  
  39. #ifdef HAVE_VALGRIND
  40. #include <valgrind.h>
  41. #include <memcheck.h>
  42. #endif
  43.  
  44. #ifdef HAVE_STRUCT_SYSINFO_TOTALRAM
  45. #include <sys/sysinfo.h>
  46. #endif
  47.  
  48. #include "sna_cpuid.h"
  49.  
  50.  
  51. static struct kgem_bo *
  52. search_linear_cache(struct kgem *kgem, unsigned int num_pages, unsigned flags);
  53.  
  54. static struct kgem_bo *
  55. search_snoop_cache(struct kgem *kgem, unsigned int num_pages, unsigned flags);
  56.  
  57. #define DBG_NO_HW 0
  58. #define DBG_NO_TILING 0
  59. #define DBG_NO_CACHE 0
  60. #define DBG_NO_CACHE_LEVEL 0
  61. #define DBG_NO_CPU 0
  62. #define DBG_NO_CREATE2 1
  63. #define DBG_NO_USERPTR 0
  64. #define DBG_NO_UNSYNCHRONIZED_USERPTR 0
  65. #define DBG_NO_LLC 0
  66. #define DBG_NO_SEMAPHORES 0
  67. #define DBG_NO_MADV 1
  68. #define DBG_NO_UPLOAD_CACHE 0
  69. #define DBG_NO_UPLOAD_ACTIVE 0
  70. #define DBG_NO_MAP_UPLOAD 0
  71. #define DBG_NO_RELAXED_FENCING 0
  72. #define DBG_NO_SECURE_BATCHES 0
  73. #define DBG_NO_PINNED_BATCHES 0
  74. #define DBG_NO_FAST_RELOC 0
  75. #define DBG_NO_HANDLE_LUT 1
  76. #define DBG_NO_WT 0
  77. #define DBG_DUMP 0
  78.  
  79. #define FORCE_MMAP_SYNC 0 /* ((1 << DOMAIN_CPU) | (1 << DOMAIN_GTT)) */
  80.  
  81. #ifndef DEBUG_SYNC
  82. #define DEBUG_SYNC 0
  83. #endif
  84.  
  85.  
  86. #if 0
  87. #define ASSERT_IDLE(kgem__, handle__) assert(!__kgem_busy(kgem__, handle__))
  88. #define ASSERT_MAYBE_IDLE(kgem__, handle__, expect__) assert(!(expect__) || !__kgem_busy(kgem__, handle__))
  89. #else
  90. #define ASSERT_IDLE(kgem__, handle__)
  91. #define ASSERT_MAYBE_IDLE(kgem__, handle__, expect__)
  92. #endif
  93.  
  94. /* Worst case seems to be 965gm where we cannot write within a cacheline that
  95.  * is being simultaneously being read by the GPU, or within the sampler
  96.  * prefetch. In general, the chipsets seem to have a requirement that sampler
  97.  * offsets be aligned to a cacheline (64 bytes).
  98.  */
  99. #define UPLOAD_ALIGNMENT 128
  100.  
  101. #define PAGE_ALIGN(x) ALIGN(x, PAGE_SIZE)
  102. #define NUM_PAGES(x) (((x) + PAGE_SIZE-1) / PAGE_SIZE)
  103.  
  104. #define MAX_GTT_VMA_CACHE 512
  105. #define MAX_CPU_VMA_CACHE INT16_MAX
  106. #define MAP_PRESERVE_TIME 10
  107.  
  108. #define MAKE_CPU_MAP(ptr) ((void*)((uintptr_t)(ptr) | 1))
  109. #define MAKE_USER_MAP(ptr) ((void*)((uintptr_t)(ptr) | 3))
  110. #define IS_USER_MAP(ptr) ((uintptr_t)(ptr) & 2)
  111. #define __MAP_TYPE(ptr) ((uintptr_t)(ptr) & 3)
  112.  
  113. #define MAKE_REQUEST(rq, ring) ((struct kgem_request *)((uintptr_t)(rq) | (ring)))
  114.  
  115. #define LOCAL_I915_PARAM_HAS_BLT                        11
  116. #define LOCAL_I915_PARAM_HAS_RELAXED_FENCING    12
  117. #define LOCAL_I915_PARAM_HAS_RELAXED_DELTA          15
  118. #define LOCAL_I915_PARAM_HAS_SEMAPHORES             20
  119. #define LOCAL_I915_PARAM_HAS_SECURE_BATCHES         23
  120. #define LOCAL_I915_PARAM_HAS_PINNED_BATCHES         24
  121. #define LOCAL_I915_PARAM_HAS_NO_RELOC               25
  122. #define LOCAL_I915_PARAM_HAS_HANDLE_LUT             26
  123. #define LOCAL_I915_PARAM_HAS_WT                 27
  124.  
  125. #define LOCAL_I915_EXEC_IS_PINNED               (1<<10)
  126. #define LOCAL_I915_EXEC_NO_RELOC                (1<<11)
  127. #define LOCAL_I915_EXEC_HANDLE_LUT              (1<<12)
  128. struct local_i915_gem_userptr {
  129.         uint64_t user_ptr;
  130.         uint64_t user_size;
  131.         uint32_t flags;
  132. #define I915_USERPTR_READ_ONLY (1<<0)
  133. #define I915_USERPTR_UNSYNCHRONIZED (1<<31)
  134.         uint32_t handle;
  135. };
  136.  
  137. #define UNCACHED        0
  138. #define SNOOPED         1
  139. #define DISPLAY         2
  140.  
  141. struct local_i915_gem_caching {
  142.         uint32_t handle;
  143.         uint32_t caching;
  144. };
  145.  
  146. #define LOCAL_IOCTL_I915_GEM_SET_CACHING SRV_I915_GEM_SET_CACHING
  147.  
  148. struct local_fbinfo {
  149.         int width;
  150.         int height;
  151.         int pitch;
  152.         int tiling;
  153. };
  154.  
  155. struct kgem_buffer {
  156.         struct kgem_bo base;
  157.         void *mem;
  158.         uint32_t used;
  159.         uint32_t need_io : 1;
  160.         uint32_t write : 2;
  161.         uint32_t mmapped : 1;
  162. };
  163.  
  164. static struct kgem_bo *__kgem_freed_bo;
  165. static struct kgem_request *__kgem_freed_request;
  166. static struct drm_i915_gem_exec_object2 _kgem_dummy_exec;
  167.  
  168. static inline int bytes(struct kgem_bo *bo)
  169. {
  170.         return __kgem_bo_size(bo);
  171. }
  172.  
  173. #define bucket(B) (B)->size.pages.bucket
  174. #define num_pages(B) (B)->size.pages.count
  175.  
  176. #ifdef DEBUG_MEMORY
  177. static void debug_alloc(struct kgem *kgem, size_t size)
  178. {
  179.         kgem->debug_memory.bo_allocs++;
  180.         kgem->debug_memory.bo_bytes += size;
  181. }
  182. static void debug_alloc__bo(struct kgem *kgem, struct kgem_bo *bo)
  183. {
  184.         debug_alloc(kgem, bytes(bo));
  185. }
  186. #else
  187. #define debug_alloc(k, b)
  188. #define debug_alloc__bo(k, b)
  189. #endif
  190.  
  191. #ifndef NDEBUG
  192. static void assert_tiling(struct kgem *kgem, struct kgem_bo *bo)
  193. {
  194.         struct drm_i915_gem_get_tiling tiling;
  195.  
  196.         assert(bo);
  197.  
  198.         VG_CLEAR(tiling);
  199.         tiling.handle = bo->handle;
  200.         tiling.tiling_mode = -1;
  201.         (void)drmIoctl(kgem->fd, DRM_IOCTL_I915_GEM_GET_TILING, &tiling);
  202.         assert(tiling.tiling_mode == bo->tiling);
  203. }
  204. #else
  205. #define assert_tiling(kgem, bo)
  206. #endif
  207.  
  208. static void kgem_sna_reset(struct kgem *kgem)
  209. {
  210.         struct sna *sna = container_of(kgem, struct sna, kgem);
  211.  
  212.         sna->render.reset(sna);
  213.         sna->blt_state.fill_bo = 0;
  214. }
  215.  
  216. static void kgem_sna_flush(struct kgem *kgem)
  217. {
  218.         struct sna *sna = container_of(kgem, struct sna, kgem);
  219.  
  220.         sna->render.flush(sna);
  221.  
  222. //      if (sna->render.solid_cache.dirty)
  223. //              sna_render_flush_solid(sna);
  224. }
  225.  
  226. static bool gem_set_tiling(int fd, uint32_t handle, int tiling, int stride)
  227. {
  228.         struct drm_i915_gem_set_tiling set_tiling;
  229.         int ret;
  230.  
  231.         if (DBG_NO_TILING)
  232.                 return false;
  233.  
  234.         VG_CLEAR(set_tiling);
  235.         do {
  236.                 set_tiling.handle = handle;
  237.                 set_tiling.tiling_mode = tiling;
  238.                 set_tiling.stride = stride;
  239.  
  240.                 ret = drmIoctl(fd, DRM_IOCTL_I915_GEM_SET_TILING, &set_tiling);
  241.         } while (ret != 0);
  242.         return ret == 0;
  243. }
  244.  
  245. static bool gem_set_caching(int fd, uint32_t handle, int caching)
  246. {
  247.         struct local_i915_gem_caching arg;
  248.  
  249.         VG_CLEAR(arg);
  250.         arg.handle = handle;
  251.         arg.caching = caching;
  252.         return drmIoctl(fd, LOCAL_IOCTL_I915_GEM_SET_CACHING, &arg) == 0;
  253. }
  254.  
  255.  
  256.  
  257.  
  258.  
  259. static bool __kgem_throttle_retire(struct kgem *kgem, unsigned flags)
  260. {
  261.         if (flags & CREATE_NO_RETIRE) {
  262.                 DBG(("%s: not retiring per-request\n", __FUNCTION__));
  263.                 return false;
  264.         }
  265.  
  266.         if (!kgem->need_retire) {
  267.                 DBG(("%s: nothing to retire\n", __FUNCTION__));
  268.                 return false;
  269.         }
  270.  
  271.         if (kgem_retire(kgem))
  272.                 return true;
  273.  
  274.         if (flags & CREATE_NO_THROTTLE || !kgem->need_throttle) {
  275.                 DBG(("%s: not throttling\n", __FUNCTION__));
  276.                 return false;
  277.         }
  278.  
  279.         kgem_throttle(kgem);
  280.         return kgem_retire(kgem);
  281. }
  282.  
  283. static void *__kgem_bo_map__gtt(struct kgem *kgem, struct kgem_bo *bo)
  284. {
  285.         struct drm_i915_gem_mmap_gtt mmap_arg;
  286.         void *ptr;
  287.  
  288.         DBG(("%s(handle=%d, size=%d)\n", __FUNCTION__,
  289.              bo->handle, bytes(bo)));
  290.         assert(bo->proxy == NULL);
  291.         assert(!bo->snoop);
  292.         assert(kgem_bo_can_map(kgem, bo));
  293.  
  294. retry_gtt:
  295.         VG_CLEAR(mmap_arg);
  296.         mmap_arg.handle = bo->handle;
  297.         if (drmIoctl(kgem->fd, DRM_IOCTL_I915_GEM_MMAP_GTT, &mmap_arg)) {
  298.  
  299.                 (void)__kgem_throttle_retire(kgem, 0);
  300.                 if (kgem_expire_cache(kgem))
  301.                         goto retry_gtt;
  302.  
  303.                 if (kgem->need_expire) {
  304.                         kgem_cleanup_cache(kgem);
  305.                         goto retry_gtt;
  306.                 }
  307.  
  308.                 printf("%s: failed to retrieve GTT offset for handle=%d\n",
  309.                        __FUNCTION__, bo->handle);
  310.                 return NULL;
  311.         }
  312.  
  313. retry_mmap:
  314.         ptr = (void*)(int)mmap_arg.offset;
  315.         if (ptr == NULL) {
  316.                 ErrorF("%s: failed to mmap handle=%d, %d bytes, into GTT domain\n",
  317.                        __FUNCTION__, bo->handle, bytes(bo));
  318.                 ptr = NULL;
  319.         }
  320.  
  321.         return ptr;
  322. }
  323.  
  324. static int __gem_write(int fd, uint32_t handle,
  325.                        int offset, int length,
  326.                        const void *src)
  327. {
  328.         struct drm_i915_gem_pwrite pwrite;
  329.  
  330.         DBG(("%s(handle=%d, offset=%d, len=%d)\n", __FUNCTION__,
  331.              handle, offset, length));
  332.  
  333.         VG_CLEAR(pwrite);
  334.         pwrite.handle = handle;
  335.         pwrite.offset = offset;
  336.         pwrite.size = length;
  337.         pwrite.data_ptr = (uintptr_t)src;
  338.         return drmIoctl(fd, DRM_IOCTL_I915_GEM_PWRITE, &pwrite);
  339. }
  340.  
  341. static int gem_write(int fd, uint32_t handle,
  342.                      int offset, int length,
  343.                      const void *src)
  344. {
  345.         struct drm_i915_gem_pwrite pwrite;
  346.  
  347.         DBG(("%s(handle=%d, offset=%d, len=%d)\n", __FUNCTION__,
  348.              handle, offset, length));
  349.  
  350.         VG_CLEAR(pwrite);
  351.         pwrite.handle = handle;
  352.         /* align the transfer to cachelines; fortuitously this is safe! */
  353.         if ((offset | length) & 63) {
  354.                 pwrite.offset = offset & ~63;
  355.                 pwrite.size = ALIGN(offset+length, 64) - pwrite.offset;
  356.                 pwrite.data_ptr = (uintptr_t)src + pwrite.offset - offset;
  357.         } else {
  358.                 pwrite.offset = offset;
  359.                 pwrite.size = length;
  360.                 pwrite.data_ptr = (uintptr_t)src;
  361.         }
  362.         return drmIoctl(fd, DRM_IOCTL_I915_GEM_PWRITE, &pwrite);
  363. }
  364.  
  365.  
  366. bool __kgem_busy(struct kgem *kgem, int handle)
  367. {
  368.         struct drm_i915_gem_busy busy;
  369.  
  370.         VG_CLEAR(busy);
  371.         busy.handle = handle;
  372.         busy.busy = !kgem->wedged;
  373.         (void)drmIoctl(kgem->fd, DRM_IOCTL_I915_GEM_BUSY, &busy);
  374.         DBG(("%s: handle=%d, busy=%d, wedged=%d\n",
  375.              __FUNCTION__, handle, busy.busy, kgem->wedged));
  376.  
  377.         return busy.busy;
  378. }
  379.  
  380. static void kgem_bo_retire(struct kgem *kgem, struct kgem_bo *bo)
  381. {
  382.         DBG(("%s: retiring bo handle=%d (needed flush? %d), rq? %d [busy?=%d]\n",
  383.              __FUNCTION__, bo->handle, bo->needs_flush, bo->rq != NULL,
  384.              __kgem_busy(kgem, bo->handle)));
  385.         assert(bo->exec == NULL);
  386.         assert(list_is_empty(&bo->vma));
  387.  
  388.         if (bo->rq) {
  389.                 if (!__kgem_busy(kgem, bo->handle)) {
  390.                         __kgem_bo_clear_busy(bo);
  391.                         kgem_retire(kgem);
  392.                 }
  393.         } else {
  394.                 assert(!bo->needs_flush);
  395.                 ASSERT_IDLE(kgem, bo->handle);
  396.         }
  397. }
  398.  
  399. bool kgem_bo_write(struct kgem *kgem, struct kgem_bo *bo,
  400.                    const void *data, int length)
  401. {
  402.         assert(bo->refcnt);
  403.         assert(!bo->purged);
  404.         assert(bo->proxy == NULL);
  405.         ASSERT_IDLE(kgem, bo->handle);
  406.  
  407.         assert(length <= bytes(bo));
  408.         if (gem_write(kgem->fd, bo->handle, 0, length, data))
  409.                 return false;
  410.  
  411.         DBG(("%s: flush=%d, domain=%d\n", __FUNCTION__, bo->flush, bo->domain));
  412.         if (bo->exec == NULL) {
  413.                 kgem_bo_retire(kgem, bo);
  414.                 bo->domain = DOMAIN_NONE;
  415.         }
  416.         bo->gtt_dirty = true;
  417.         return true;
  418. }
  419.  
  420. static uint32_t gem_create(int fd, int num_pages)
  421. {
  422.         struct drm_i915_gem_create create;
  423.  
  424.         VG_CLEAR(create);
  425.         create.handle = 0;
  426.         create.size = PAGE_SIZE * num_pages;
  427.         (void)drmIoctl(fd, DRM_IOCTL_I915_GEM_CREATE, &create);
  428.  
  429.         return create.handle;
  430. }
  431.  
  432. static bool
  433. kgem_bo_set_purgeable(struct kgem *kgem, struct kgem_bo *bo)
  434. {
  435. #if DBG_NO_MADV
  436.         return true;
  437. #else
  438.         struct drm_i915_gem_madvise madv;
  439.  
  440.         assert(bo->exec == NULL);
  441.         assert(!bo->purged);
  442.  
  443.         VG_CLEAR(madv);
  444.         madv.handle = bo->handle;
  445.         madv.madv = I915_MADV_DONTNEED;
  446.         if (drmIoctl(kgem->fd, DRM_IOCTL_I915_GEM_MADVISE, &madv) == 0) {
  447.                 bo->purged = 1;
  448.                 kgem->need_purge |= !madv.retained && bo->domain == DOMAIN_GPU;
  449.                 return madv.retained;
  450.         }
  451.  
  452.         return true;
  453. #endif
  454. }
  455.  
  456. static bool
  457. kgem_bo_is_retained(struct kgem *kgem, struct kgem_bo *bo)
  458. {
  459. #if DBG_NO_MADV
  460.         return true;
  461. #else
  462.         struct drm_i915_gem_madvise madv;
  463.  
  464.         if (!bo->purged)
  465.                 return true;
  466.  
  467.         VG_CLEAR(madv);
  468.         madv.handle = bo->handle;
  469.         madv.madv = I915_MADV_DONTNEED;
  470.         if (drmIoctl(kgem->fd, DRM_IOCTL_I915_GEM_MADVISE, &madv) == 0)
  471.                 return madv.retained;
  472.  
  473.         return false;
  474. #endif
  475. }
  476.  
  477. static bool
  478. kgem_bo_clear_purgeable(struct kgem *kgem, struct kgem_bo *bo)
  479. {
  480. #if DBG_NO_MADV
  481.         return true;
  482. #else
  483.         struct drm_i915_gem_madvise madv;
  484.  
  485.         assert(bo->purged);
  486.  
  487.         VG_CLEAR(madv);
  488.         madv.handle = bo->handle;
  489.         madv.madv = I915_MADV_WILLNEED;
  490.         if (drmIoctl(kgem->fd, DRM_IOCTL_I915_GEM_MADVISE, &madv) == 0) {
  491.                 bo->purged = !madv.retained;
  492.                 kgem->need_purge |= !madv.retained && bo->domain == DOMAIN_GPU;
  493.                 return madv.retained;
  494.         }
  495.  
  496.         return false;
  497. #endif
  498. }
  499.  
  500. static void gem_close(int fd, uint32_t handle)
  501. {
  502.         struct drm_gem_close close;
  503.  
  504.         VG_CLEAR(close);
  505.         close.handle = handle;
  506.         (void)drmIoctl(fd, DRM_IOCTL_GEM_CLOSE, &close);
  507. }
  508.  
  509. constant inline static unsigned long __fls(unsigned long word)
  510. {
  511. #if defined(__GNUC__) && (defined(__i386__) || defined(__x86__) || defined(__x86_64__))
  512.         asm("bsr %1,%0"
  513.             : "=r" (word)
  514.             : "rm" (word));
  515.         return word;
  516. #else
  517.         unsigned int v = 0;
  518.  
  519.         while (word >>= 1)
  520.                 v++;
  521.  
  522.         return v;
  523. #endif
  524. }
  525.  
  526. constant inline static int cache_bucket(int num_pages)
  527. {
  528.         return __fls(num_pages);
  529. }
  530.  
  531. static struct kgem_bo *__kgem_bo_init(struct kgem_bo *bo,
  532.                                       int handle, int num_pages)
  533. {
  534.         assert(num_pages);
  535.         memset(bo, 0, sizeof(*bo));
  536.  
  537.         bo->refcnt = 1;
  538.         bo->handle = handle;
  539.         bo->target_handle = -1;
  540.         num_pages(bo) = num_pages;
  541.         bucket(bo) = cache_bucket(num_pages);
  542.         bo->reusable = true;
  543.         bo->domain = DOMAIN_CPU;
  544.         list_init(&bo->request);
  545.         list_init(&bo->list);
  546.         list_init(&bo->vma);
  547.  
  548.         return bo;
  549. }
  550.  
  551. static struct kgem_bo *__kgem_bo_alloc(int handle, int num_pages)
  552. {
  553.         struct kgem_bo *bo;
  554.  
  555.         if (__kgem_freed_bo) {
  556.                 bo = __kgem_freed_bo;
  557.                 __kgem_freed_bo = *(struct kgem_bo **)bo;
  558.         } else {
  559.                 bo = malloc(sizeof(*bo));
  560.                 if (bo == NULL)
  561.                         return NULL;
  562.         }
  563.  
  564.         return __kgem_bo_init(bo, handle, num_pages);
  565. }
  566.  
  567. static struct kgem_request *__kgem_request_alloc(struct kgem *kgem)
  568. {
  569.         struct kgem_request *rq;
  570.  
  571.         rq = __kgem_freed_request;
  572.         if (rq) {
  573.                 __kgem_freed_request = *(struct kgem_request **)rq;
  574.         } else {
  575.                 rq = malloc(sizeof(*rq));
  576.                 if (rq == NULL)
  577.                         rq = &kgem->static_request;
  578.         }
  579.  
  580.         list_init(&rq->buffers);
  581.         rq->bo = NULL;
  582.         rq->ring = 0;
  583.  
  584.         return rq;
  585. }
  586.  
  587. static void __kgem_request_free(struct kgem_request *rq)
  588. {
  589.         _list_del(&rq->list);
  590.         *(struct kgem_request **)rq = __kgem_freed_request;
  591.         __kgem_freed_request = rq;
  592. }
  593.  
  594. static struct list *inactive(struct kgem *kgem, int num_pages)
  595. {
  596.         assert(num_pages < MAX_CACHE_SIZE / PAGE_SIZE);
  597.         assert(cache_bucket(num_pages) < NUM_CACHE_BUCKETS);
  598.         return &kgem->inactive[cache_bucket(num_pages)];
  599. }
  600.  
  601. static struct list *active(struct kgem *kgem, int num_pages, int tiling)
  602. {
  603.         assert(num_pages < MAX_CACHE_SIZE / PAGE_SIZE);
  604.         assert(cache_bucket(num_pages) < NUM_CACHE_BUCKETS);
  605.         return &kgem->active[cache_bucket(num_pages)][tiling];
  606. }
  607.  
  608. static size_t
  609. agp_aperture_size(struct pci_device *dev, unsigned gen)
  610. {
  611.         /* XXX assume that only future chipsets are unknown and follow
  612.          * the post gen2 PCI layout.
  613.          */
  614.     return 0;
  615. }
  616.  
  617. static size_t
  618. total_ram_size(void)
  619. {
  620.     uint32_t  data[9];
  621.     size_t    size = 0;
  622.  
  623.     asm volatile("int $0x40"
  624.         : "=a" (size)
  625.         : "a" (18),"b"(20), "c" (data)
  626.         : "memory");
  627.  
  628.     return size != -1 ? size : 0;
  629. }
  630.  
  631. static unsigned
  632. cpu_cache_size__cpuid4(void)
  633. {
  634.         /* Deterministic Cache Parmaeters (Function 04h)":
  635.          *    When EAX is initialized to a value of 4, the CPUID instruction
  636.          *    returns deterministic cache information in the EAX, EBX, ECX
  637.          *    and EDX registers.  This function requires ECX be initialized
  638.          *    with an index which indicates which cache to return information
  639.          *    about. The OS is expected to call this function (CPUID.4) with
  640.          *    ECX = 0, 1, 2, until EAX[4:0] == 0, indicating no more caches.
  641.          *    The order in which the caches are returned is not specified
  642.          *    and may change at Intel's discretion.
  643.          *
  644.          * Calculating the Cache Size in bytes:
  645.          *          = (Ways +1) * (Partitions +1) * (Line Size +1) * (Sets +1)
  646.          */
  647.  
  648.          unsigned int eax, ebx, ecx, edx;
  649.          unsigned int llc_size = 0;
  650.          int cnt = 0;
  651.  
  652.          if (__get_cpuid_max(BASIC_CPUID, NULL) < 4)
  653.                  return 0;
  654.  
  655.          do {
  656.                  unsigned associativity, line_partitions, line_size, sets;
  657.  
  658.                  __cpuid_count(4, cnt++, eax, ebx, ecx, edx);
  659.  
  660.                  if ((eax & 0x1f) == 0)
  661.                          break;
  662.  
  663.                  associativity = ((ebx >> 22) & 0x3ff) + 1;
  664.                  line_partitions = ((ebx >> 12) & 0x3ff) + 1;
  665.                  line_size = (ebx & 0xfff) + 1;
  666.                  sets = ecx + 1;
  667.  
  668.                  llc_size = associativity * line_partitions * line_size * sets;
  669.          } while (1);
  670.  
  671.          return llc_size;
  672. }
  673.  
  674. static int gem_param(struct kgem *kgem, int name)
  675. {
  676.     drm_i915_getparam_t gp;
  677.     int v = -1; /* No param uses the sign bit, reserve it for errors */
  678.  
  679.     VG_CLEAR(gp);
  680.     gp.param = name;
  681.     gp.value = &v;
  682.         if (drmIoctl(kgem->fd, DRM_IOCTL_I915_GETPARAM, &gp))
  683.         return -1;
  684.  
  685.     VG(VALGRIND_MAKE_MEM_DEFINED(&v, sizeof(v)));
  686.     return v;
  687. }
  688.  
  689. static bool test_has_execbuffer2(struct kgem *kgem)
  690. {
  691.         return 1;
  692. }
  693.  
  694. static bool test_has_no_reloc(struct kgem *kgem)
  695. {
  696.         if (DBG_NO_FAST_RELOC)
  697.                 return false;
  698.  
  699.         return gem_param(kgem, LOCAL_I915_PARAM_HAS_NO_RELOC) > 0;
  700. }
  701.  
  702. static bool test_has_handle_lut(struct kgem *kgem)
  703. {
  704.         if (DBG_NO_HANDLE_LUT)
  705.                 return false;
  706.  
  707.         return gem_param(kgem, LOCAL_I915_PARAM_HAS_HANDLE_LUT) > 0;
  708. }
  709.  
  710. static bool test_has_wt(struct kgem *kgem)
  711. {
  712.         if (DBG_NO_WT)
  713.                 return false;
  714.  
  715.         return gem_param(kgem, LOCAL_I915_PARAM_HAS_WT) > 0;
  716. }
  717.  
  718. static bool test_has_semaphores_enabled(struct kgem *kgem)
  719. {
  720.         bool detected = false;
  721.         int ret;
  722.  
  723.         if (DBG_NO_SEMAPHORES)
  724.                 return false;
  725.  
  726.         ret = gem_param(kgem, LOCAL_I915_PARAM_HAS_SEMAPHORES);
  727.         if (ret != -1)
  728.                 return ret > 0;
  729.  
  730.         return detected;
  731. }
  732.  
  733. static bool __kgem_throttle(struct kgem *kgem)
  734. {
  735.         if (drmIoctl(kgem->fd, DRM_IOCTL_I915_GEM_THROTTLE, NULL) == 0)
  736.                 return false;
  737.  
  738.         return errno == EIO;
  739. }
  740.  
  741. static bool is_hw_supported(struct kgem *kgem,
  742.                             struct pci_device *dev)
  743. {
  744.         if (DBG_NO_HW)
  745.                 return false;
  746.  
  747.         if (!test_has_execbuffer2(kgem))
  748.                 return false;
  749.  
  750.         if (kgem->gen == (unsigned)-1) /* unknown chipset, assume future gen */
  751.                 return kgem->has_blt;
  752.  
  753.         /* Although pre-855gm the GMCH is fubar, it works mostly. So
  754.          * let the user decide through "NoAccel" whether or not to risk
  755.          * hw acceleration.
  756.          */
  757.  
  758.         if (kgem->gen == 060 && dev->revision < 8) {
  759.                 /* pre-production SNB with dysfunctional BLT */
  760.                 return false;
  761.         }
  762.  
  763.         if (kgem->gen >= 060) /* Only if the kernel supports the BLT ring */
  764.                 return kgem->has_blt;
  765.  
  766.         return true;
  767. }
  768.  
  769. static bool test_has_relaxed_fencing(struct kgem *kgem)
  770. {
  771.         if (kgem->gen < 040) {
  772.                 if (DBG_NO_RELAXED_FENCING)
  773.                         return false;
  774.  
  775.                 return gem_param(kgem, LOCAL_I915_PARAM_HAS_RELAXED_FENCING) > 0;
  776.         } else
  777.                 return true;
  778. }
  779.  
  780. static bool test_has_llc(struct kgem *kgem)
  781. {
  782.         int has_llc = -1;
  783.  
  784.         if (DBG_NO_LLC)
  785.                 return false;
  786.  
  787. #if defined(I915_PARAM_HAS_LLC) /* Expected in libdrm-2.4.31 */
  788.         has_llc = gem_param(kgem, I915_PARAM_HAS_LLC);
  789. #endif
  790.         if (has_llc == -1) {
  791.                 DBG(("%s: no kernel/drm support for HAS_LLC, assuming support for LLC based on GPU generation\n", __FUNCTION__));
  792.                 has_llc = kgem->gen >= 060;
  793.         }
  794.  
  795.         return has_llc;
  796. }
  797.  
  798. static bool test_has_caching(struct kgem *kgem)
  799. {
  800.         uint32_t handle;
  801.         bool ret;
  802.  
  803.         if (DBG_NO_CACHE_LEVEL)
  804.                 return false;
  805.  
  806.         /* Incoherent blt and sampler hangs the GPU */
  807.         if (kgem->gen == 040)
  808.                 return false;
  809.  
  810.         handle = gem_create(kgem->fd, 1);
  811.         if (handle == 0)
  812.                 return false;
  813.  
  814.         ret = gem_set_caching(kgem->fd, handle, UNCACHED);
  815.         gem_close(kgem->fd, handle);
  816.         return ret;
  817. }
  818.  
  819. static bool test_has_userptr(struct kgem *kgem)
  820. {
  821. #if defined(USE_USERPTR)
  822.         uint32_t handle;
  823.         void *ptr;
  824.  
  825.         if (DBG_NO_USERPTR)
  826.                 return false;
  827.  
  828.         /* Incoherent blt and sampler hangs the GPU */
  829.         if (kgem->gen == 040)
  830.                 return false;
  831.  
  832.         if (posix_memalign(&ptr, PAGE_SIZE, PAGE_SIZE))
  833.                 return false;
  834.  
  835.         handle = gem_userptr(kgem->fd, ptr, PAGE_SIZE, false);
  836.         gem_close(kgem->fd, handle);
  837.         free(ptr);
  838.  
  839.         return handle != 0;
  840. #else
  841.         return false;
  842. #endif
  843. }
  844.  
  845. static bool test_has_create2(struct kgem *kgem)
  846. {
  847. #if defined(USE_CREATE2)
  848.         struct local_i915_gem_create2 args;
  849.  
  850.         if (DBG_NO_CREATE2)
  851.                 return false;
  852.  
  853.         memset(&args, 0, sizeof(args));
  854.         args.size = PAGE_SIZE;
  855.         args.caching = DISPLAY;
  856.         if (drmIoctl(kgem->fd, LOCAL_IOCTL_I915_GEM_CREATE2, &args) == 0)
  857.                 gem_close(kgem->fd, args.handle);
  858.  
  859.         return args.handle != 0;
  860. #else
  861.         return false;
  862. #endif
  863. }
  864.  
  865. static bool test_has_secure_batches(struct kgem *kgem)
  866. {
  867.         if (DBG_NO_SECURE_BATCHES)
  868.                 return false;
  869.  
  870.         return gem_param(kgem, LOCAL_I915_PARAM_HAS_SECURE_BATCHES) > 0;
  871. }
  872.  
  873. static bool test_has_pinned_batches(struct kgem *kgem)
  874. {
  875.         if (DBG_NO_PINNED_BATCHES)
  876.                 return false;
  877.  
  878.         return gem_param(kgem, LOCAL_I915_PARAM_HAS_PINNED_BATCHES) > 0;
  879. }
  880.  
  881.  
  882. static bool kgem_init_pinned_batches(struct kgem *kgem)
  883. {
  884.         int count[2] = { 2, 2 };
  885.         int size[2] = { 1, 2 };
  886.         int n, i;
  887.  
  888.         if (kgem->wedged)
  889.                 return true;
  890.  
  891.         for (n = 0; n < ARRAY_SIZE(count); n++) {
  892.                 for (i = 0; i < count[n]; i++) {
  893.                         struct drm_i915_gem_pin pin;
  894.                         struct kgem_bo *bo;
  895.  
  896.                         VG_CLEAR(pin);
  897.  
  898.                         pin.handle = gem_create(kgem->fd, size[n]);
  899.                         if (pin.handle == 0)
  900.                                 goto err;
  901.  
  902.                         DBG(("%s: new handle=%d, num_pages=%d\n",
  903.                              __FUNCTION__, pin.handle, size[n]));
  904.  
  905.                         bo = __kgem_bo_alloc(pin.handle, size[n]);
  906.                         if (bo == NULL) {
  907.                                 gem_close(kgem->fd, pin.handle);
  908.                                 goto err;
  909.                         }
  910.  
  911.                         pin.alignment = 0;
  912.                         if (drmIoctl(kgem->fd, DRM_IOCTL_I915_GEM_PIN, &pin)) {
  913.                                 gem_close(kgem->fd, pin.handle);
  914.                                 goto err;
  915.                         }
  916.                         bo->presumed_offset = pin.offset;
  917.                         debug_alloc__bo(kgem, bo);
  918.                         list_add(&bo->list, &kgem->pinned_batches[n]);
  919.                 }
  920.         }
  921.  
  922.         return true;
  923.  
  924. err:
  925.         for (n = 0; n < ARRAY_SIZE(kgem->pinned_batches); n++) {
  926.                 while (!list_is_empty(&kgem->pinned_batches[n])) {
  927.                         kgem_bo_destroy(kgem,
  928.                                         list_first_entry(&kgem->pinned_batches[n],
  929.                                                          struct kgem_bo, list));
  930.                 }
  931.         }
  932.  
  933.         /* For simplicity populate the lists with a single unpinned bo */
  934.         for (n = 0; n < ARRAY_SIZE(count); n++) {
  935.                 struct kgem_bo *bo;
  936.                 uint32_t handle;
  937.  
  938.                 handle = gem_create(kgem->fd, size[n]);
  939.                 if (handle == 0)
  940.                         break;
  941.  
  942.                 bo = __kgem_bo_alloc(handle, size[n]);
  943.                 if (bo == NULL) {
  944.                         gem_close(kgem->fd, handle);
  945.                         break;
  946.                 }
  947.  
  948.                 debug_alloc__bo(kgem, bo);
  949.                 list_add(&bo->list, &kgem->pinned_batches[n]);
  950.         }
  951.         return false;
  952. }
  953.  
  954. void kgem_init(struct kgem *kgem, int fd, struct pci_device *dev, unsigned gen)
  955. {
  956.     struct drm_i915_gem_get_aperture aperture;
  957.     size_t totalram;
  958.     unsigned half_gpu_max;
  959.     unsigned int i, j;
  960.  
  961.     DBG(("%s: fd=%d, gen=%d\n", __FUNCTION__, fd, gen));
  962.  
  963.     memset(kgem, 0, sizeof(*kgem));
  964.  
  965.     kgem->fd = fd;
  966.     kgem->gen = gen;
  967.  
  968.     list_init(&kgem->requests[0]);
  969.     list_init(&kgem->requests[1]);
  970.     list_init(&kgem->batch_buffers);
  971.     list_init(&kgem->active_buffers);
  972.     list_init(&kgem->flushing);
  973.     list_init(&kgem->large);
  974.     list_init(&kgem->large_inactive);
  975.     list_init(&kgem->snoop);
  976.     list_init(&kgem->scanout);
  977.     for (i = 0; i < ARRAY_SIZE(kgem->pinned_batches); i++)
  978.         list_init(&kgem->pinned_batches[i]);
  979.     for (i = 0; i < ARRAY_SIZE(kgem->inactive); i++)
  980.         list_init(&kgem->inactive[i]);
  981.     for (i = 0; i < ARRAY_SIZE(kgem->active); i++) {
  982.         for (j = 0; j < ARRAY_SIZE(kgem->active[i]); j++)
  983.             list_init(&kgem->active[i][j]);
  984.     }
  985.     for (i = 0; i < ARRAY_SIZE(kgem->vma); i++) {
  986.         for (j = 0; j < ARRAY_SIZE(kgem->vma[i].inactive); j++)
  987.             list_init(&kgem->vma[i].inactive[j]);
  988.     }
  989.     kgem->vma[MAP_GTT].count = -MAX_GTT_VMA_CACHE;
  990.     kgem->vma[MAP_CPU].count = -MAX_CPU_VMA_CACHE;
  991.  
  992.     kgem->has_blt = gem_param(kgem, LOCAL_I915_PARAM_HAS_BLT) > 0;
  993.     DBG(("%s: has BLT ring? %d\n", __FUNCTION__,
  994.          kgem->has_blt));
  995.  
  996.     kgem->has_relaxed_delta =
  997.         gem_param(kgem, LOCAL_I915_PARAM_HAS_RELAXED_DELTA) > 0;
  998.     DBG(("%s: has relaxed delta? %d\n", __FUNCTION__,
  999.          kgem->has_relaxed_delta));
  1000.  
  1001.     kgem->has_relaxed_fencing = test_has_relaxed_fencing(kgem);
  1002.     DBG(("%s: has relaxed fencing? %d\n", __FUNCTION__,
  1003.          kgem->has_relaxed_fencing));
  1004.  
  1005.     kgem->has_llc = test_has_llc(kgem);
  1006.     DBG(("%s: has shared last-level-cache? %d\n", __FUNCTION__,
  1007.          kgem->has_llc));
  1008.  
  1009.         kgem->has_wt = test_has_wt(kgem);
  1010.         DBG(("%s: has write-through caching for scanouts? %d\n", __FUNCTION__,
  1011.              kgem->has_wt));
  1012.  
  1013.         kgem->has_caching = test_has_caching(kgem);
  1014.     DBG(("%s: has set-cache-level? %d\n", __FUNCTION__,
  1015.              kgem->has_caching));
  1016.  
  1017.     kgem->has_userptr = test_has_userptr(kgem);
  1018.     DBG(("%s: has userptr? %d\n", __FUNCTION__,
  1019.          kgem->has_userptr));
  1020.  
  1021.         kgem->has_create2 = test_has_create2(kgem);
  1022.         kgem->has_create2 = 0;
  1023.         DBG(("%s: has create2? %d\n", __FUNCTION__,
  1024.              kgem->has_create2));
  1025.  
  1026.     kgem->has_no_reloc = test_has_no_reloc(kgem);
  1027.     DBG(("%s: has no-reloc? %d\n", __FUNCTION__,
  1028.          kgem->has_no_reloc));
  1029.  
  1030.     kgem->has_handle_lut = test_has_handle_lut(kgem);
  1031.     kgem->has_handle_lut = 0;
  1032.     DBG(("%s: has handle-lut? %d\n", __FUNCTION__,
  1033.          kgem->has_handle_lut));
  1034.  
  1035.     kgem->has_semaphores = false;
  1036.     if (kgem->has_blt && test_has_semaphores_enabled(kgem))
  1037.         kgem->has_semaphores = true;
  1038.     DBG(("%s: semaphores enabled? %d\n", __FUNCTION__,
  1039.          kgem->has_semaphores));
  1040.  
  1041.     kgem->can_blt_cpu = gen >= 030;
  1042.     DBG(("%s: can blt to cpu? %d\n", __FUNCTION__,
  1043.          kgem->can_blt_cpu));
  1044.  
  1045.     kgem->has_secure_batches = test_has_secure_batches(kgem);
  1046.     DBG(("%s: can use privileged batchbuffers? %d\n", __FUNCTION__,
  1047.          kgem->has_secure_batches));
  1048.  
  1049.     kgem->has_pinned_batches = test_has_pinned_batches(kgem);
  1050.     DBG(("%s: can use pinned batchbuffers (to avoid CS w/a)? %d\n", __FUNCTION__,
  1051.          kgem->has_pinned_batches));
  1052.  
  1053.     if (!is_hw_supported(kgem, dev)) {
  1054.         printf("Detected unsupported/dysfunctional hardware, disabling acceleration.\n");
  1055.         kgem->wedged = 1;
  1056.     } else if (__kgem_throttle(kgem)) {
  1057.         printf("Detected a hung GPU, disabling acceleration.\n");
  1058.         kgem->wedged = 1;
  1059.     }
  1060.  
  1061.     kgem->batch_size = ARRAY_SIZE(kgem->batch);
  1062.     if (gen == 020 && !kgem->has_pinned_batches)
  1063.         /* Limited to what we can pin */
  1064.         kgem->batch_size = 4*1024;
  1065.     if (gen == 022)
  1066.         /* 865g cannot handle a batch spanning multiple pages */
  1067.         kgem->batch_size = PAGE_SIZE / sizeof(uint32_t);
  1068.     if ((gen >> 3) == 7)
  1069.         kgem->batch_size = 16*1024;
  1070.     if (!kgem->has_relaxed_delta && kgem->batch_size > 4*1024)
  1071.         kgem->batch_size = 4*1024;
  1072.  
  1073.     if (!kgem_init_pinned_batches(kgem) && gen == 020) {
  1074.         printf("Unable to reserve memory for GPU, disabling acceleration.\n");
  1075.         kgem->wedged = 1;
  1076.     }
  1077.  
  1078.     DBG(("%s: maximum batch size? %d\n", __FUNCTION__,
  1079.          kgem->batch_size));
  1080.  
  1081.         kgem->min_alignment = 16;
  1082.     if (gen < 040)
  1083.         kgem->min_alignment = 64;
  1084.  
  1085.     kgem->half_cpu_cache_pages = cpu_cache_size() >> 13;
  1086.         DBG(("%s: last-level cache size: %d bytes, threshold in pages: %d\n",
  1087.              __FUNCTION__, cpu_cache_size(), kgem->half_cpu_cache_pages));
  1088.  
  1089.     kgem->next_request = __kgem_request_alloc(kgem);
  1090.  
  1091.     DBG(("%s: cpu bo enabled %d: llc? %d, set-cache-level? %d, userptr? %d\n", __FUNCTION__,
  1092.              !DBG_NO_CPU && (kgem->has_llc | kgem->has_userptr | kgem->has_caching),
  1093.              kgem->has_llc, kgem->has_caching, kgem->has_userptr));
  1094.  
  1095.     VG_CLEAR(aperture);
  1096.     aperture.aper_size = 0;
  1097.         (void)drmIoctl(fd, DRM_IOCTL_I915_GEM_GET_APERTURE, &aperture);
  1098.     if (aperture.aper_size == 0)
  1099.         aperture.aper_size = 64*1024*1024;
  1100.  
  1101.     DBG(("%s: aperture size %lld, available now %lld\n",
  1102.          __FUNCTION__,
  1103.          (long long)aperture.aper_size,
  1104.          (long long)aperture.aper_available_size));
  1105.  
  1106.     kgem->aperture_total = aperture.aper_size;
  1107.     kgem->aperture_high = aperture.aper_size * 3/4;
  1108.     kgem->aperture_low = aperture.aper_size * 1/3;
  1109.     if (gen < 033) {
  1110.         /* Severe alignment penalties */
  1111.         kgem->aperture_high /= 2;
  1112.         kgem->aperture_low /= 2;
  1113.     }
  1114.     DBG(("%s: aperture low=%d [%d], high=%d [%d]\n", __FUNCTION__,
  1115.          kgem->aperture_low, kgem->aperture_low / (1024*1024),
  1116.          kgem->aperture_high, kgem->aperture_high / (1024*1024)));
  1117.  
  1118.     kgem->aperture_mappable = agp_aperture_size(dev, gen);
  1119.     if (kgem->aperture_mappable == 0 ||
  1120.         kgem->aperture_mappable > aperture.aper_size)
  1121.         kgem->aperture_mappable = aperture.aper_size;
  1122.     DBG(("%s: aperture mappable=%d [%d MiB]\n", __FUNCTION__,
  1123.          kgem->aperture_mappable, kgem->aperture_mappable / (1024*1024)));
  1124.  
  1125.     kgem->buffer_size = 64 * 1024;
  1126.     while (kgem->buffer_size < kgem->aperture_mappable >> 10)
  1127.         kgem->buffer_size *= 2;
  1128.     if (kgem->buffer_size >> 12 > kgem->half_cpu_cache_pages)
  1129.         kgem->buffer_size = kgem->half_cpu_cache_pages << 12;
  1130.         kgem->buffer_size = 1 << __fls(kgem->buffer_size);
  1131.     DBG(("%s: buffer size=%d [%d KiB]\n", __FUNCTION__,
  1132.          kgem->buffer_size, kgem->buffer_size / 1024));
  1133.         assert(kgem->buffer_size);
  1134.  
  1135.     kgem->max_object_size = 3 * (kgem->aperture_high >> 12) << 10;
  1136.     kgem->max_gpu_size = kgem->max_object_size;
  1137.         if (!kgem->has_llc && kgem->max_gpu_size > MAX_CACHE_SIZE)
  1138.         kgem->max_gpu_size = MAX_CACHE_SIZE;
  1139.  
  1140.     totalram = total_ram_size();
  1141.     if (totalram == 0) {
  1142.         DBG(("%s: total ram size unknown, assuming maximum of total aperture\n",
  1143.              __FUNCTION__));
  1144.         totalram = kgem->aperture_total;
  1145.     }
  1146.         DBG(("%s: total ram=%ld\n", __FUNCTION__, (long)totalram));
  1147.     if (kgem->max_object_size > totalram / 2)
  1148.         kgem->max_object_size = totalram / 2;
  1149.     if (kgem->max_gpu_size > totalram / 4)
  1150.         kgem->max_gpu_size = totalram / 4;
  1151.  
  1152.     kgem->max_cpu_size = kgem->max_object_size;
  1153.  
  1154.     half_gpu_max = kgem->max_gpu_size / 2;
  1155.     kgem->max_copy_tile_size = (MAX_CACHE_SIZE + 1)/2;
  1156.     if (kgem->max_copy_tile_size > half_gpu_max)
  1157.         kgem->max_copy_tile_size = half_gpu_max;
  1158.  
  1159.     if (kgem->has_llc)
  1160.         kgem->max_upload_tile_size = kgem->max_copy_tile_size;
  1161.     else
  1162.         kgem->max_upload_tile_size = kgem->aperture_mappable / 4;
  1163.     if (kgem->max_upload_tile_size > half_gpu_max)
  1164.         kgem->max_upload_tile_size = half_gpu_max;
  1165.         if (kgem->max_upload_tile_size > kgem->aperture_high/2)
  1166.                 kgem->max_upload_tile_size = kgem->aperture_high/2;
  1167.         if (kgem->max_upload_tile_size > kgem->aperture_low)
  1168.                 kgem->max_upload_tile_size = kgem->aperture_low;
  1169.         if (kgem->max_upload_tile_size < 16*PAGE_SIZE)
  1170.                 kgem->max_upload_tile_size = 16*PAGE_SIZE;
  1171.  
  1172.     kgem->large_object_size = MAX_CACHE_SIZE;
  1173.         if (kgem->large_object_size > half_gpu_max)
  1174.                 kgem->large_object_size = half_gpu_max;
  1175.         if (kgem->max_copy_tile_size > kgem->aperture_high/2)
  1176.                 kgem->max_copy_tile_size = kgem->aperture_high/2;
  1177.         if (kgem->max_copy_tile_size > kgem->aperture_low)
  1178.                 kgem->max_copy_tile_size = kgem->aperture_low;
  1179.         if (kgem->max_copy_tile_size < 16*PAGE_SIZE)
  1180.                 kgem->max_copy_tile_size = 16*PAGE_SIZE;
  1181.  
  1182.         if (kgem->has_llc | kgem->has_caching | kgem->has_userptr) {
  1183.         if (kgem->large_object_size > kgem->max_cpu_size)
  1184.             kgem->large_object_size = kgem->max_cpu_size;
  1185.     } else
  1186.         kgem->max_cpu_size = 0;
  1187.     if (DBG_NO_CPU)
  1188.         kgem->max_cpu_size = 0;
  1189.  
  1190.     DBG(("%s: maximum object size=%d\n",
  1191.          __FUNCTION__, kgem->max_object_size));
  1192.     DBG(("%s: large object thresold=%d\n",
  1193.          __FUNCTION__, kgem->large_object_size));
  1194.     DBG(("%s: max object sizes (gpu=%d, cpu=%d, tile upload=%d, copy=%d)\n",
  1195.          __FUNCTION__,
  1196.          kgem->max_gpu_size, kgem->max_cpu_size,
  1197.          kgem->max_upload_tile_size, kgem->max_copy_tile_size));
  1198.  
  1199.     /* Convert the aperture thresholds to pages */
  1200.     kgem->aperture_low /= PAGE_SIZE;
  1201.     kgem->aperture_high /= PAGE_SIZE;
  1202.  
  1203.     kgem->fence_max = gem_param(kgem, I915_PARAM_NUM_FENCES_AVAIL) - 2;
  1204.     if ((int)kgem->fence_max < 0)
  1205.         kgem->fence_max = 5; /* minimum safe value for all hw */
  1206.     DBG(("%s: max fences=%d\n", __FUNCTION__, kgem->fence_max));
  1207.  
  1208.     kgem->batch_flags_base = 0;
  1209.     if (kgem->has_no_reloc)
  1210.         kgem->batch_flags_base |= LOCAL_I915_EXEC_NO_RELOC;
  1211.     if (kgem->has_handle_lut)
  1212.         kgem->batch_flags_base |= LOCAL_I915_EXEC_HANDLE_LUT;
  1213.     if (kgem->has_pinned_batches)
  1214.         kgem->batch_flags_base |= LOCAL_I915_EXEC_IS_PINNED;
  1215. }
  1216.  
  1217. /* XXX hopefully a good approximation */
  1218. uint32_t kgem_get_unique_id(struct kgem *kgem)
  1219. {
  1220.         uint32_t id;
  1221.         id = ++kgem->unique_id;
  1222.         if (id == 0)
  1223.                 id = ++kgem->unique_id;
  1224.         return id;
  1225. }
  1226.  
  1227. inline static uint32_t kgem_pitch_alignment(struct kgem *kgem, unsigned flags)
  1228. {
  1229.         if (flags & CREATE_PRIME)
  1230.                 return 256;
  1231.         if (flags & CREATE_SCANOUT)
  1232.                 return 64;
  1233.         return kgem->min_alignment;
  1234. }
  1235.  
  1236. void kgem_get_tile_size(struct kgem *kgem, int tiling,
  1237.                         int *tile_width, int *tile_height, int *tile_size)
  1238. {
  1239.         if (kgem->gen <= 030) {
  1240.                 if (tiling) {
  1241.                         if (kgem->gen < 030) {
  1242.                                 *tile_width = 128;
  1243.                                 *tile_height = 16;
  1244.                                 *tile_size = 2048;
  1245.                         } else {
  1246.                                 *tile_width = 512;
  1247.                                 *tile_height = 8;
  1248.                                 *tile_size = 4096;
  1249.                         }
  1250.                 } else {
  1251.                         *tile_width = 1;
  1252.                         *tile_height = 1;
  1253.                         *tile_size = 1;
  1254.                 }
  1255.         } else switch (tiling) {
  1256.         default:
  1257.         case I915_TILING_NONE:
  1258.                 *tile_width = 1;
  1259.                 *tile_height = 1;
  1260.                 *tile_size = 1;
  1261.                 break;
  1262.         case I915_TILING_X:
  1263.                 *tile_width = 512;
  1264.                 *tile_height = 8;
  1265.                 *tile_size = 4096;
  1266.                 break;
  1267.         case I915_TILING_Y:
  1268.                 *tile_width = 128;
  1269.                 *tile_height = 32;
  1270.                 *tile_size = 4096;
  1271.                 break;
  1272.         }
  1273. }
  1274.  
  1275. uint32_t kgem_surface_size(struct kgem *kgem,
  1276.                                   bool relaxed_fencing,
  1277.                                   unsigned flags,
  1278.                                   uint32_t width,
  1279.                                   uint32_t height,
  1280.                                   uint32_t bpp,
  1281.                                   uint32_t tiling,
  1282.                                   uint32_t *pitch)
  1283. {
  1284.         uint32_t tile_width, tile_height;
  1285.         uint32_t size;
  1286.  
  1287.         assert(width <= MAXSHORT);
  1288.         assert(height <= MAXSHORT);
  1289.         assert(bpp >= 8);
  1290.  
  1291.         if (kgem->gen <= 030) {
  1292.                 if (tiling) {
  1293.                         if (kgem->gen < 030) {
  1294.                                 tile_width = 128;
  1295.                                 tile_height = 32;
  1296.                         } else {
  1297.                                 tile_width = 512;
  1298.                                 tile_height = 16;
  1299.                         }
  1300.                 } else {
  1301.                         tile_width = 2 * bpp >> 3;
  1302.                         tile_width = ALIGN(tile_width,
  1303.                                            kgem_pitch_alignment(kgem, flags));
  1304.                         tile_height = 2;
  1305.                 }
  1306.         } else switch (tiling) {
  1307.         default:
  1308.         case I915_TILING_NONE:
  1309.                 tile_width = 2 * bpp >> 3;
  1310.                 tile_width = ALIGN(tile_width,
  1311.                                    kgem_pitch_alignment(kgem, flags));
  1312.                 tile_height = 2;
  1313.                 break;
  1314.  
  1315.                 /* XXX align to an even tile row */
  1316.         case I915_TILING_X:
  1317.                 tile_width = 512;
  1318.                 tile_height = 16;
  1319.                 break;
  1320.         case I915_TILING_Y:
  1321.                 tile_width = 128;
  1322.                 tile_height = 64;
  1323.                 break;
  1324.         }
  1325.  
  1326.         *pitch = ALIGN(width * bpp / 8, tile_width);
  1327.         height = ALIGN(height, tile_height);
  1328.         if (kgem->gen >= 040)
  1329.                 return PAGE_ALIGN(*pitch * height);
  1330.  
  1331.         /* If it is too wide for the blitter, don't even bother.  */
  1332.         if (tiling != I915_TILING_NONE) {
  1333.                 if (*pitch > 8192)
  1334.                         return 0;
  1335.  
  1336.                 for (size = tile_width; size < *pitch; size <<= 1)
  1337.                         ;
  1338.                 *pitch = size;
  1339.         } else {
  1340.                 if (*pitch >= 32768)
  1341.                         return 0;
  1342.         }
  1343.  
  1344.         size = *pitch * height;
  1345.         if (relaxed_fencing || tiling == I915_TILING_NONE)
  1346.                 return PAGE_ALIGN(size);
  1347.  
  1348.         /*  We need to allocate a pot fence region for a tiled buffer. */
  1349.         if (kgem->gen < 030)
  1350.                 tile_width = 512 * 1024;
  1351.         else
  1352.                 tile_width = 1024 * 1024;
  1353.         while (tile_width < size)
  1354.                 tile_width *= 2;
  1355.         return tile_width;
  1356. }
  1357.  
  1358. static uint32_t kgem_aligned_height(struct kgem *kgem,
  1359.                                     uint32_t height, uint32_t tiling)
  1360. {
  1361.         uint32_t tile_height;
  1362.  
  1363.         if (kgem->gen <= 030) {
  1364.                 tile_height = tiling ? kgem->gen < 030 ? 32 : 16 : 1;
  1365.         } else switch (tiling) {
  1366.                 /* XXX align to an even tile row */
  1367.         default:
  1368.         case I915_TILING_NONE:
  1369.                 tile_height = 1;
  1370.                 break;
  1371.         case I915_TILING_X:
  1372.                 tile_height = 16;
  1373.                 break;
  1374.         case I915_TILING_Y:
  1375.                 tile_height = 64;
  1376.                 break;
  1377.         }
  1378.  
  1379.         return ALIGN(height, tile_height);
  1380. }
  1381.  
  1382. static struct drm_i915_gem_exec_object2 *
  1383. kgem_add_handle(struct kgem *kgem, struct kgem_bo *bo)
  1384. {
  1385.         struct drm_i915_gem_exec_object2 *exec;
  1386.  
  1387.         DBG(("%s: handle=%d, index=%d\n",
  1388.              __FUNCTION__, bo->handle, kgem->nexec));
  1389.  
  1390.         assert(kgem->nexec < ARRAY_SIZE(kgem->exec));
  1391.         bo->target_handle = kgem->has_handle_lut ? kgem->nexec : bo->handle;
  1392.         exec = memset(&kgem->exec[kgem->nexec++], 0, sizeof(*exec));
  1393.         exec->handle = bo->handle;
  1394.         exec->offset = bo->presumed_offset;
  1395.  
  1396.         kgem->aperture += num_pages(bo);
  1397.  
  1398.         return exec;
  1399. }
  1400.  
  1401. static void kgem_add_bo(struct kgem *kgem, struct kgem_bo *bo)
  1402. {
  1403.         bo->exec = kgem_add_handle(kgem, bo);
  1404.         bo->rq = MAKE_REQUEST(kgem->next_request, kgem->ring);
  1405.  
  1406.         list_move_tail(&bo->request, &kgem->next_request->buffers);
  1407.  
  1408.         /* XXX is it worth working around gcc here? */
  1409.         kgem->flush |= bo->flush;
  1410. }
  1411.  
  1412. static uint32_t kgem_end_batch(struct kgem *kgem)
  1413. {
  1414.         kgem->batch[kgem->nbatch++] = MI_BATCH_BUFFER_END;
  1415.         if (kgem->nbatch & 1)
  1416.                 kgem->batch[kgem->nbatch++] = MI_NOOP;
  1417.  
  1418.         return kgem->nbatch;
  1419. }
  1420.  
  1421. static void kgem_fixup_self_relocs(struct kgem *kgem, struct kgem_bo *bo)
  1422. {
  1423.         int n;
  1424.  
  1425.         assert(kgem->nreloc__self <= 256);
  1426.         if (kgem->nreloc__self == 0)
  1427.                 return;
  1428.  
  1429.         for (n = 0; n < kgem->nreloc__self; n++) {
  1430.                 int i = kgem->reloc__self[n];
  1431.                 assert(kgem->reloc[i].target_handle == ~0U);
  1432.                 kgem->reloc[i].target_handle = bo->target_handle;
  1433.                 kgem->reloc[i].presumed_offset = bo->presumed_offset;
  1434.                 kgem->batch[kgem->reloc[i].offset/sizeof(kgem->batch[0])] =
  1435.                         kgem->reloc[i].delta + bo->presumed_offset;
  1436.         }
  1437.  
  1438.         if (n == 256) {
  1439.                 for (n = kgem->reloc__self[255]; n < kgem->nreloc; n++) {
  1440.                         if (kgem->reloc[n].target_handle == ~0U) {
  1441.                                 kgem->reloc[n].target_handle = bo->target_handle;
  1442.                                 kgem->reloc[n].presumed_offset = bo->presumed_offset;
  1443.                                 kgem->batch[kgem->reloc[n].offset/sizeof(kgem->batch[0])] =
  1444.                                         kgem->reloc[n].delta + bo->presumed_offset;
  1445.                         }
  1446.                 }
  1447.  
  1448.         }
  1449.  
  1450. }
  1451.  
  1452. static void kgem_bo_binding_free(struct kgem *kgem, struct kgem_bo *bo)
  1453. {
  1454.         struct kgem_bo_binding *b;
  1455.  
  1456.         b = bo->binding.next;
  1457.         while (b) {
  1458.                 struct kgem_bo_binding *next = b->next;
  1459.                 free (b);
  1460.                 b = next;
  1461.         }
  1462. }
  1463.  
  1464. static void kgem_bo_release_map(struct kgem *kgem, struct kgem_bo *bo)
  1465. {
  1466.         int type = IS_CPU_MAP(bo->map);
  1467.  
  1468.         assert(!IS_USER_MAP(bo->map));
  1469.  
  1470.         DBG(("%s: releasing %s vma for handle=%d, count=%d\n",
  1471.              __FUNCTION__, type ? "CPU" : "GTT",
  1472.              bo->handle, kgem->vma[type].count));
  1473.  
  1474.         VG(if (type) VALGRIND_MAKE_MEM_NOACCESS(MAP(bo->map), bytes(bo)));
  1475.         user_free(MAP(bo->map));
  1476.         bo->map = NULL;
  1477.  
  1478.         if (!list_is_empty(&bo->vma)) {
  1479.                 list_del(&bo->vma);
  1480.                 kgem->vma[type].count--;
  1481.         }
  1482. }
  1483.  
  1484. static void kgem_bo_free(struct kgem *kgem, struct kgem_bo *bo)
  1485. {
  1486.         DBG(("%s: handle=%d\n", __FUNCTION__, bo->handle));
  1487.         assert(bo->refcnt == 0);
  1488.         assert(bo->proxy == NULL);
  1489.         assert(bo->exec == NULL);
  1490.         assert(!bo->snoop || bo->rq == NULL);
  1491.  
  1492. #ifdef DEBUG_MEMORY
  1493.         kgem->debug_memory.bo_allocs--;
  1494.         kgem->debug_memory.bo_bytes -= bytes(bo);
  1495. #endif
  1496.  
  1497.         kgem_bo_binding_free(kgem, bo);
  1498.  
  1499.         if (IS_USER_MAP(bo->map)) {
  1500.                 assert(bo->rq == NULL);
  1501.                 assert(!__kgem_busy(kgem, bo->handle));
  1502.                 assert(MAP(bo->map) != bo || bo->io || bo->flush);
  1503.                 if (!(bo->io || bo->flush)) {
  1504.                         DBG(("%s: freeing snooped base\n", __FUNCTION__));
  1505.                         assert(bo != MAP(bo->map));
  1506.                         free(MAP(bo->map));
  1507.                 }
  1508.                 bo->map = NULL;
  1509.         }
  1510.         if (bo->map)
  1511.                 kgem_bo_release_map(kgem, bo);
  1512.         assert(list_is_empty(&bo->vma));
  1513.         assert(bo->map == NULL);
  1514.  
  1515.         _list_del(&bo->list);
  1516.         _list_del(&bo->request);
  1517.         gem_close(kgem->fd, bo->handle);
  1518.  
  1519.         if (!bo->io) {
  1520.                 *(struct kgem_bo **)bo = __kgem_freed_bo;
  1521.                 __kgem_freed_bo = bo;
  1522.         } else
  1523.                 free(bo);
  1524. }
  1525.  
  1526. inline static void kgem_bo_move_to_inactive(struct kgem *kgem,
  1527.                                             struct kgem_bo *bo)
  1528. {
  1529.         DBG(("%s: moving handle=%d to inactive\n", __FUNCTION__, bo->handle));
  1530.  
  1531.         assert(bo->refcnt == 0);
  1532.         assert(bo->reusable);
  1533.         assert(bo->rq == NULL);
  1534.         assert(bo->exec == NULL);
  1535.         assert(bo->domain != DOMAIN_GPU);
  1536.         assert(!bo->proxy);
  1537.         assert(!bo->io);
  1538.         assert(!bo->scanout);
  1539.         assert(!bo->snoop);
  1540.         assert(!bo->flush);
  1541.         assert(!bo->needs_flush);
  1542.         assert(list_is_empty(&bo->vma));
  1543.         assert_tiling(kgem, bo);
  1544.         ASSERT_IDLE(kgem, bo->handle);
  1545.  
  1546.         kgem->need_expire = true;
  1547.  
  1548.         if (bucket(bo) >= NUM_CACHE_BUCKETS) {
  1549.                 list_move(&bo->list, &kgem->large_inactive);
  1550.                 return;
  1551.         }
  1552.  
  1553.         assert(bo->flush == false);
  1554.         list_move(&bo->list, &kgem->inactive[bucket(bo)]);
  1555.         if (bo->map) {
  1556.                 int type = IS_CPU_MAP(bo->map);
  1557.                 if (bucket(bo) >= NUM_CACHE_BUCKETS ||
  1558.                     (!type && !__kgem_bo_is_mappable(kgem, bo))) {
  1559. //                      munmap(MAP(bo->map), bytes(bo));
  1560.                         bo->map = NULL;
  1561.                 }
  1562.                 if (bo->map) {
  1563.                         list_add(&bo->vma, &kgem->vma[type].inactive[bucket(bo)]);
  1564.                         kgem->vma[type].count++;
  1565.                 }
  1566.         }
  1567. }
  1568.  
  1569. static struct kgem_bo *kgem_bo_replace_io(struct kgem_bo *bo)
  1570. {
  1571.         struct kgem_bo *base;
  1572.  
  1573.         if (!bo->io)
  1574.                 return bo;
  1575.  
  1576.         assert(!bo->snoop);
  1577.         base = malloc(sizeof(*base));
  1578.         if (base) {
  1579.                 DBG(("%s: transferring io handle=%d to bo\n",
  1580.                      __FUNCTION__, bo->handle));
  1581.                 /* transfer the handle to a minimum bo */
  1582.                 memcpy(base, bo, sizeof(*base));
  1583.                 base->io = false;
  1584.                 list_init(&base->list);
  1585.                 list_replace(&bo->request, &base->request);
  1586.                 list_replace(&bo->vma, &base->vma);
  1587.                 free(bo);
  1588.                 bo = base;
  1589.         } else
  1590.                 bo->reusable = false;
  1591.  
  1592.         return bo;
  1593. }
  1594.  
  1595. inline static void kgem_bo_remove_from_inactive(struct kgem *kgem,
  1596.                                                 struct kgem_bo *bo)
  1597. {
  1598.         DBG(("%s: removing handle=%d from inactive\n", __FUNCTION__, bo->handle));
  1599.  
  1600.         list_del(&bo->list);
  1601.         assert(bo->rq == NULL);
  1602.         assert(bo->exec == NULL);
  1603.         if (bo->map) {
  1604.                 assert(!list_is_empty(&bo->vma));
  1605.                 list_del(&bo->vma);
  1606.                 kgem->vma[IS_CPU_MAP(bo->map)].count--;
  1607.         }
  1608. }
  1609.  
  1610. inline static void kgem_bo_remove_from_active(struct kgem *kgem,
  1611.                                               struct kgem_bo *bo)
  1612. {
  1613.         DBG(("%s: removing handle=%d from active\n", __FUNCTION__, bo->handle));
  1614.  
  1615.         list_del(&bo->list);
  1616.         assert(bo->rq != NULL);
  1617.         if (bo->rq == (void *)kgem)
  1618.                 list_del(&bo->request);
  1619.         assert(list_is_empty(&bo->vma));
  1620. }
  1621.  
  1622. static void _kgem_bo_delete_buffer(struct kgem *kgem, struct kgem_bo *bo)
  1623. {
  1624.         struct kgem_buffer *io = (struct kgem_buffer *)bo->proxy;
  1625.  
  1626.         DBG(("%s: size=%d, offset=%d, parent used=%d\n",
  1627.              __FUNCTION__, bo->size.bytes, bo->delta, io->used));
  1628.  
  1629.         if (ALIGN(bo->delta + bo->size.bytes, UPLOAD_ALIGNMENT) == io->used)
  1630.                 io->used = bo->delta;
  1631. }
  1632.  
  1633. static void kgem_bo_move_to_scanout(struct kgem *kgem, struct kgem_bo *bo)
  1634. {
  1635.         assert(bo->refcnt == 0);
  1636.         assert(bo->scanout);
  1637.         assert(bo->delta);
  1638.         assert(!bo->flush);
  1639.         assert(!bo->snoop);
  1640.         assert(!bo->io);
  1641.  
  1642.         if (bo->purged) {
  1643.                 DBG(("%s: discarding purged scanout - external name?\n",
  1644.                      __FUNCTION__));
  1645.                 kgem_bo_free(kgem, bo);
  1646.                 return;
  1647.         }
  1648.  
  1649.         DBG(("%s: moving %d [fb %d] to scanout cache, active? %d\n",
  1650.              __FUNCTION__, bo->handle, bo->delta, bo->rq != NULL));
  1651.         if (bo->rq)
  1652.                 list_move_tail(&bo->list, &kgem->scanout);
  1653.         else
  1654.         list_move(&bo->list, &kgem->scanout);
  1655. }
  1656.  
  1657. static void kgem_bo_move_to_snoop(struct kgem *kgem, struct kgem_bo *bo)
  1658. {
  1659.         assert(bo->reusable);
  1660.         assert(!bo->flush);
  1661.         assert(!bo->needs_flush);
  1662.         assert(bo->refcnt == 0);
  1663.         assert(bo->exec == NULL);
  1664.  
  1665.         if (num_pages(bo) > kgem->max_cpu_size >> 13) {
  1666.                 DBG(("%s handle=%d discarding large CPU buffer (%d >%d pages)\n",
  1667.                      __FUNCTION__, bo->handle, num_pages(bo), kgem->max_cpu_size >> 13));
  1668.                 kgem_bo_free(kgem, bo);
  1669.                 return;
  1670.         }
  1671.  
  1672.         assert(bo->tiling == I915_TILING_NONE);
  1673.         assert(bo->rq == NULL);
  1674.  
  1675.         DBG(("%s: moving %d to snoop cachee\n", __FUNCTION__, bo->handle));
  1676.         list_add(&bo->list, &kgem->snoop);
  1677. }
  1678.  
  1679. static struct kgem_bo *
  1680. search_snoop_cache(struct kgem *kgem, unsigned int num_pages, unsigned flags)
  1681. {
  1682.         struct kgem_bo *bo, *first = NULL;
  1683.  
  1684.         DBG(("%s: num_pages=%d, flags=%x\n", __FUNCTION__, num_pages, flags));
  1685.  
  1686.         if ((kgem->has_caching | kgem->has_userptr) == 0)
  1687.                 return NULL;
  1688.  
  1689.         if (list_is_empty(&kgem->snoop)) {
  1690.                 DBG(("%s: inactive and cache empty\n", __FUNCTION__));
  1691.                 if (!__kgem_throttle_retire(kgem, flags)) {
  1692.                         DBG(("%s: nothing retired\n", __FUNCTION__));
  1693.                         return NULL;
  1694.                 }
  1695.         }
  1696.  
  1697.         list_for_each_entry(bo, &kgem->snoop, list) {
  1698.                 assert(bo->refcnt == 0);
  1699.                 assert(bo->snoop);
  1700.                 assert(!bo->scanout);
  1701.                 assert(!bo->purged);
  1702.                 assert(bo->proxy == NULL);
  1703.                 assert(bo->tiling == I915_TILING_NONE);
  1704.                 assert(bo->rq == NULL);
  1705.                 assert(bo->exec == NULL);
  1706.  
  1707.                 if (num_pages > num_pages(bo))
  1708.                         continue;
  1709.  
  1710.                 if (num_pages(bo) > 2*num_pages) {
  1711.                         if (first == NULL)
  1712.                                 first = bo;
  1713.                         continue;
  1714.                 }
  1715.  
  1716.                 list_del(&bo->list);
  1717.                 bo->pitch = 0;
  1718.                 bo->delta = 0;
  1719.  
  1720.                 DBG(("  %s: found handle=%d (num_pages=%d) in snoop cache\n",
  1721.                      __FUNCTION__, bo->handle, num_pages(bo)));
  1722.                 return bo;
  1723.         }
  1724.  
  1725.         if (first) {
  1726.                 list_del(&first->list);
  1727.                 first->pitch = 0;
  1728.                 first->delta = 0;
  1729.  
  1730.                 DBG(("  %s: found handle=%d (num_pages=%d) in snoop cache\n",
  1731.                      __FUNCTION__, first->handle, num_pages(first)));
  1732.                 return first;
  1733.         }
  1734.  
  1735.         return NULL;
  1736. }
  1737.  
  1738. void kgem_bo_undo(struct kgem *kgem, struct kgem_bo *bo)
  1739. {
  1740.         if (kgem->nexec != 1 || bo->exec == NULL)
  1741.                 return;
  1742.  
  1743.         DBG(("%s: only handle in batch, discarding last operations for handle=%d\n",
  1744.              __FUNCTION__, bo->handle));
  1745.  
  1746.         assert(bo->exec == &kgem->exec[0]);
  1747.         assert(kgem->exec[0].handle == bo->handle);
  1748.         assert(RQ(bo->rq) == kgem->next_request);
  1749.  
  1750.         bo->refcnt++;
  1751.         kgem_reset(kgem);
  1752.         bo->refcnt--;
  1753. }
  1754.  
  1755. static void __kgem_bo_destroy(struct kgem *kgem, struct kgem_bo *bo)
  1756. {
  1757.         DBG(("%s: handle=%d\n", __FUNCTION__, bo->handle));
  1758.  
  1759.         assert(list_is_empty(&bo->list));
  1760.         assert(bo->refcnt == 0);
  1761.         assert(!bo->purged || !bo->reusable);
  1762.         assert(bo->proxy == NULL);
  1763.         assert_tiling(kgem, bo);
  1764.  
  1765.         bo->binding.offset = 0;
  1766.  
  1767.         if (DBG_NO_CACHE)
  1768.                 goto destroy;
  1769.  
  1770.         if (bo->snoop && !bo->flush) {
  1771.                 DBG(("%s: handle=%d is snooped\n", __FUNCTION__, bo->handle));
  1772.                 assert(bo->reusable);
  1773.                 assert(list_is_empty(&bo->list));
  1774.                 if (bo->exec == NULL && bo->rq && !__kgem_busy(kgem, bo->handle))
  1775.                         __kgem_bo_clear_busy(bo);
  1776.                 if (bo->rq == NULL)
  1777.                         kgem_bo_move_to_snoop(kgem, bo);
  1778.                 return;
  1779.         }
  1780.         if (!IS_USER_MAP(bo->map))
  1781.                 bo->flush = false;
  1782.  
  1783.         if (bo->scanout) {
  1784.                 kgem_bo_move_to_scanout(kgem, bo);
  1785.                 return;
  1786.         }
  1787.  
  1788.         if (bo->io)
  1789.                 bo = kgem_bo_replace_io(bo);
  1790.         if (!bo->reusable) {
  1791.                 DBG(("%s: handle=%d, not reusable\n",
  1792.                      __FUNCTION__, bo->handle));
  1793.                 goto destroy;
  1794.         }
  1795.  
  1796.         if (!kgem->has_llc && IS_CPU_MAP(bo->map) && bo->domain != DOMAIN_CPU)
  1797.                 kgem_bo_release_map(kgem, bo);
  1798.  
  1799.         assert(list_is_empty(&bo->vma));
  1800.         assert(list_is_empty(&bo->list));
  1801.         assert(bo->flush == false);
  1802.         assert(bo->snoop == false);
  1803.         assert(bo->io == false);
  1804.         assert(bo->scanout == false);
  1805.  
  1806.         kgem_bo_undo(kgem, bo);
  1807.         assert(bo->refcnt == 0);
  1808.  
  1809.         if (bo->rq && bo->exec == NULL && !__kgem_busy(kgem, bo->handle))
  1810.                 __kgem_bo_clear_busy(bo);
  1811.  
  1812.         if (bo->rq) {
  1813.                 struct list *cache;
  1814.  
  1815.                 DBG(("%s: handle=%d -> active\n", __FUNCTION__, bo->handle));
  1816.                 if (bucket(bo) < NUM_CACHE_BUCKETS)
  1817.                         cache = &kgem->active[bucket(bo)][bo->tiling];
  1818.                 else
  1819.                         cache = &kgem->large;
  1820.                 list_add(&bo->list, cache);
  1821.                 return;
  1822.         }
  1823.  
  1824.         assert(bo->exec == NULL);
  1825.         assert(list_is_empty(&bo->request));
  1826.  
  1827.         if (!IS_CPU_MAP(bo->map)) {
  1828.                 if (!kgem_bo_set_purgeable(kgem, bo))
  1829.                         goto destroy;
  1830.  
  1831.                 if (!kgem->has_llc && bo->domain == DOMAIN_CPU)
  1832.                         goto destroy;
  1833.  
  1834.                 DBG(("%s: handle=%d, purged\n",
  1835.                      __FUNCTION__, bo->handle));
  1836.         }
  1837.  
  1838.         kgem_bo_move_to_inactive(kgem, bo);
  1839.         return;
  1840.  
  1841. destroy:
  1842.         if (!bo->exec)
  1843.                 kgem_bo_free(kgem, bo);
  1844. }
  1845.  
  1846. static void kgem_bo_unref(struct kgem *kgem, struct kgem_bo *bo)
  1847. {
  1848.         assert(bo->refcnt);
  1849.         if (--bo->refcnt == 0)
  1850.                 __kgem_bo_destroy(kgem, bo);
  1851. }
  1852.  
  1853. static void kgem_buffer_release(struct kgem *kgem, struct kgem_buffer *bo)
  1854. {
  1855.         while (!list_is_empty(&bo->base.vma)) {
  1856.                 struct kgem_bo *cached;
  1857.  
  1858.                 cached = list_first_entry(&bo->base.vma, struct kgem_bo, vma);
  1859.                 assert(cached->proxy == &bo->base);
  1860.                 list_del(&cached->vma);
  1861.  
  1862.                 assert(*(struct kgem_bo **)cached->map == cached);
  1863.                 *(struct kgem_bo **)cached->map = NULL;
  1864.                 cached->map = NULL;
  1865.  
  1866.                 kgem_bo_destroy(kgem, cached);
  1867.         }
  1868. }
  1869.  
  1870. static bool kgem_retire__buffers(struct kgem *kgem)
  1871. {
  1872.         bool retired = false;
  1873.  
  1874.         while (!list_is_empty(&kgem->active_buffers)) {
  1875.                 struct kgem_buffer *bo =
  1876.                         list_last_entry(&kgem->active_buffers,
  1877.                                         struct kgem_buffer,
  1878.                                         base.list);
  1879.  
  1880.                 if (bo->base.rq)
  1881.                         break;
  1882.  
  1883.                 DBG(("%s: releasing upload cache for handle=%d? %d\n",
  1884.                      __FUNCTION__, bo->base.handle, !list_is_empty(&bo->base.vma)));
  1885.                 list_del(&bo->base.list);
  1886.                 kgem_buffer_release(kgem, bo);
  1887.                 kgem_bo_unref(kgem, &bo->base);
  1888.                 retired = true;
  1889.         }
  1890.  
  1891.         return retired;
  1892. }
  1893.  
  1894. static bool kgem_retire__flushing(struct kgem *kgem)
  1895. {
  1896.         struct kgem_bo *bo, *next;
  1897.         bool retired = false;
  1898.  
  1899.         list_for_each_entry_safe(bo, next, &kgem->flushing, request) {
  1900.                 assert(bo->rq == (void *)kgem);
  1901.                 assert(bo->exec == NULL);
  1902.  
  1903.                 if (__kgem_busy(kgem, bo->handle))
  1904.                         break;
  1905.  
  1906.                 __kgem_bo_clear_busy(bo);
  1907.  
  1908.                 if (bo->refcnt)
  1909.                         continue;
  1910.  
  1911.                 if (bo->snoop) {
  1912.                         kgem_bo_move_to_snoop(kgem, bo);
  1913.                 } else if (bo->scanout) {
  1914.                         kgem_bo_move_to_scanout(kgem, bo);
  1915.                 } else if ((bo = kgem_bo_replace_io(bo))->reusable &&
  1916.                            kgem_bo_set_purgeable(kgem, bo)) {
  1917.                         kgem_bo_move_to_inactive(kgem, bo);
  1918.                         retired = true;
  1919.                 } else
  1920.                         kgem_bo_free(kgem, bo);
  1921.         }
  1922. #if HAS_DEBUG_FULL
  1923.         {
  1924.                 int count = 0;
  1925.                 list_for_each_entry(bo, &kgem->flushing, request)
  1926.                         count++;
  1927.                 ErrorF("%s: %d bo on flushing list\n", __FUNCTION__, count);
  1928.         }
  1929. #endif
  1930.  
  1931.         kgem->need_retire |= !list_is_empty(&kgem->flushing);
  1932.  
  1933.         return retired;
  1934. }
  1935.  
  1936.  
  1937. static bool __kgem_retire_rq(struct kgem *kgem, struct kgem_request *rq)
  1938. {
  1939.         bool retired = false;
  1940.  
  1941.         DBG(("%s: request %d complete\n",
  1942.              __FUNCTION__, rq->bo->handle));
  1943.  
  1944.         while (!list_is_empty(&rq->buffers)) {
  1945.                 struct kgem_bo *bo;
  1946.  
  1947.                 bo = list_first_entry(&rq->buffers,
  1948.                                       struct kgem_bo,
  1949.                                       request);
  1950.  
  1951.                 assert(RQ(bo->rq) == rq);
  1952.                 assert(bo->exec == NULL);
  1953.                 assert(bo->domain == DOMAIN_GPU || bo->domain == DOMAIN_NONE);
  1954.  
  1955.                 list_del(&bo->request);
  1956.  
  1957.                 if (bo->needs_flush)
  1958.                         bo->needs_flush = __kgem_busy(kgem, bo->handle);
  1959.                 if (bo->needs_flush) {
  1960.                         DBG(("%s: moving %d to flushing\n",
  1961.                              __FUNCTION__, bo->handle));
  1962.                         list_add(&bo->request, &kgem->flushing);
  1963.                         bo->rq = (void *)kgem;
  1964.                         continue;
  1965.                 }
  1966.  
  1967.                 bo->domain = DOMAIN_NONE;
  1968.                 bo->rq = NULL;
  1969.                 if (bo->refcnt)
  1970.                         continue;
  1971.  
  1972.                 if (bo->snoop) {
  1973.                         kgem_bo_move_to_snoop(kgem, bo);
  1974.                 } else if (bo->scanout) {
  1975.                         kgem_bo_move_to_scanout(kgem, bo);
  1976.                 } else if ((bo = kgem_bo_replace_io(bo))->reusable &&
  1977.                            kgem_bo_set_purgeable(kgem, bo)) {
  1978.                         kgem_bo_move_to_inactive(kgem, bo);
  1979.                         retired = true;
  1980.                 } else {
  1981.                         DBG(("%s: closing %d\n",
  1982.                              __FUNCTION__, bo->handle));
  1983.                         kgem_bo_free(kgem, bo);
  1984.                 }
  1985.         }
  1986.  
  1987.         assert(rq->bo->rq == NULL);
  1988.         assert(list_is_empty(&rq->bo->request));
  1989.  
  1990.         if (--rq->bo->refcnt == 0) {
  1991.                 if (kgem_bo_set_purgeable(kgem, rq->bo)) {
  1992.                         kgem_bo_move_to_inactive(kgem, rq->bo);
  1993.                         retired = true;
  1994.                 } else {
  1995.                         DBG(("%s: closing %d\n",
  1996.                              __FUNCTION__, rq->bo->handle));
  1997.                         kgem_bo_free(kgem, rq->bo);
  1998.                 }
  1999.         }
  2000.  
  2001.         __kgem_request_free(rq);
  2002.         return retired;
  2003. }
  2004.  
  2005. static bool kgem_retire__requests_ring(struct kgem *kgem, int ring)
  2006. {
  2007.         bool retired = false;
  2008.  
  2009.         while (!list_is_empty(&kgem->requests[ring])) {
  2010.                 struct kgem_request *rq;
  2011.  
  2012.                 rq = list_first_entry(&kgem->requests[ring],
  2013.                                       struct kgem_request,
  2014.                                       list);
  2015.                 if (__kgem_busy(kgem, rq->bo->handle))
  2016.                         break;
  2017.  
  2018.                 retired |= __kgem_retire_rq(kgem, rq);
  2019.         }
  2020.  
  2021. #if HAS_DEBUG_FULL
  2022.         {
  2023.                 struct kgem_bo *bo;
  2024.                 int count = 0;
  2025.  
  2026.                 list_for_each_entry(bo, &kgem->requests[ring], request)
  2027.                         count++;
  2028.  
  2029.                 bo = NULL;
  2030.                 if (!list_is_empty(&kgem->requests[ring]))
  2031.                         bo = list_first_entry(&kgem->requests[ring],
  2032.                                               struct kgem_request,
  2033.                                               list)->bo;
  2034.  
  2035.                 ErrorF("%s: ring=%d, %d outstanding requests, oldest=%d\n",
  2036.                        __FUNCTION__, ring, count, bo ? bo->handle : 0);
  2037.         }
  2038. #endif
  2039.  
  2040.         return retired;
  2041. }
  2042.  
  2043. static bool kgem_retire__requests(struct kgem *kgem)
  2044. {
  2045.         bool retired = false;
  2046.         int n;
  2047.  
  2048.         for (n = 0; n < ARRAY_SIZE(kgem->requests); n++) {
  2049.                 retired |= kgem_retire__requests_ring(kgem, n);
  2050.                 kgem->need_retire |= !list_is_empty(&kgem->requests[n]);
  2051.         }
  2052.  
  2053.         return retired;
  2054. }
  2055.  
  2056. bool kgem_retire(struct kgem *kgem)
  2057. {
  2058.         bool retired = false;
  2059.  
  2060.         DBG(("%s\n", __FUNCTION__));
  2061.  
  2062.         kgem->need_retire = false;
  2063.  
  2064.         retired |= kgem_retire__flushing(kgem);
  2065.         retired |= kgem_retire__requests(kgem);
  2066.         retired |= kgem_retire__buffers(kgem);
  2067.  
  2068.         DBG(("%s -- retired=%d, need_retire=%d\n",
  2069.              __FUNCTION__, retired, kgem->need_retire));
  2070.  
  2071.         kgem->retire(kgem);
  2072.  
  2073.         return retired;
  2074. }
  2075.  
  2076. bool __kgem_ring_is_idle(struct kgem *kgem, int ring)
  2077. {
  2078.         struct kgem_request *rq;
  2079.  
  2080.         assert(!list_is_empty(&kgem->requests[ring]));
  2081.  
  2082.         rq = list_last_entry(&kgem->requests[ring],
  2083.                              struct kgem_request, list);
  2084.         if (__kgem_busy(kgem, rq->bo->handle)) {
  2085.                 DBG(("%s: last requests handle=%d still busy\n",
  2086.                      __FUNCTION__, rq->bo->handle));
  2087.                 return false;
  2088.         }
  2089.  
  2090.         DBG(("%s: ring=%d idle (handle=%d)\n",
  2091.              __FUNCTION__, ring, rq->bo->handle));
  2092.  
  2093.         kgem_retire__requests_ring(kgem, ring);
  2094.         assert(list_is_empty(&kgem->requests[ring]));
  2095.         return true;
  2096. }
  2097.  
  2098. static void kgem_commit(struct kgem *kgem)
  2099. {
  2100.         struct kgem_request *rq = kgem->next_request;
  2101.         struct kgem_bo *bo, *next;
  2102.  
  2103.         list_for_each_entry_safe(bo, next, &rq->buffers, request) {
  2104.                 assert(next->request.prev == &bo->request);
  2105.  
  2106.                 DBG(("%s: release handle=%d (proxy? %d), dirty? %d flush? %d, snoop? %d -> offset=%x\n",
  2107.                      __FUNCTION__, bo->handle, bo->proxy != NULL,
  2108.                      bo->gpu_dirty, bo->needs_flush, bo->snoop,
  2109.                      (unsigned)bo->exec->offset));
  2110.  
  2111.                 assert(bo->exec);
  2112.                 assert(bo->proxy == NULL || bo->exec == &_kgem_dummy_exec);
  2113.                 assert(RQ(bo->rq) == rq || (RQ(bo->proxy->rq) == rq));
  2114.  
  2115.                 bo->presumed_offset = bo->exec->offset;
  2116.                 bo->exec = NULL;
  2117.                 bo->target_handle = -1;
  2118.  
  2119.                 if (!bo->refcnt && !bo->reusable) {
  2120.                         assert(!bo->snoop);
  2121.                         kgem_bo_free(kgem, bo);
  2122.                         continue;
  2123.                 }
  2124.  
  2125.                 bo->binding.offset = 0;
  2126.                 bo->domain = DOMAIN_GPU;
  2127.                 bo->gpu_dirty = false;
  2128.  
  2129.                 if (bo->proxy) {
  2130.                         /* proxies are not used for domain tracking */
  2131.                         bo->exec = NULL;
  2132.                         __kgem_bo_clear_busy(bo);
  2133.                 }
  2134.  
  2135.                 kgem->scanout_busy |= bo->scanout;
  2136.         }
  2137.  
  2138.         if (rq == &kgem->static_request) {
  2139.                 struct drm_i915_gem_set_domain set_domain;
  2140.  
  2141.                 DBG(("%s: syncing due to allocation failure\n", __FUNCTION__));
  2142.  
  2143.                 VG_CLEAR(set_domain);
  2144.                 set_domain.handle = rq->bo->handle;
  2145.                 set_domain.read_domains = I915_GEM_DOMAIN_GTT;
  2146.                 set_domain.write_domain = I915_GEM_DOMAIN_GTT;
  2147.                 if (drmIoctl(kgem->fd, DRM_IOCTL_I915_GEM_SET_DOMAIN, &set_domain)) {
  2148.                         DBG(("%s: sync: GPU hang detected\n", __FUNCTION__));
  2149.                         kgem_throttle(kgem);
  2150.                 }
  2151.  
  2152.                 kgem_retire(kgem);
  2153.                 assert(list_is_empty(&rq->buffers));
  2154.  
  2155.                 assert(rq->bo->map == NULL);
  2156.                 gem_close(kgem->fd, rq->bo->handle);
  2157.                 kgem_cleanup_cache(kgem);
  2158.         } else {
  2159.                 list_add_tail(&rq->list, &kgem->requests[rq->ring]);
  2160.                 kgem->need_throttle = kgem->need_retire = 1;
  2161.         }
  2162.  
  2163.         kgem->next_request = NULL;
  2164. }
  2165.  
  2166. static void kgem_close_list(struct kgem *kgem, struct list *head)
  2167. {
  2168.         while (!list_is_empty(head))
  2169.                 kgem_bo_free(kgem, list_first_entry(head, struct kgem_bo, list));
  2170. }
  2171.  
  2172. static void kgem_close_inactive(struct kgem *kgem)
  2173. {
  2174.         unsigned int i;
  2175.  
  2176.         for (i = 0; i < ARRAY_SIZE(kgem->inactive); i++)
  2177.                 kgem_close_list(kgem, &kgem->inactive[i]);
  2178. }
  2179.  
  2180. static void kgem_finish_buffers(struct kgem *kgem)
  2181. {
  2182.         struct kgem_buffer *bo, *next;
  2183.  
  2184.         list_for_each_entry_safe(bo, next, &kgem->batch_buffers, base.list) {
  2185.                 DBG(("%s: buffer handle=%d, used=%d, exec?=%d, write=%d, mmapped=%s\n",
  2186.                      __FUNCTION__, bo->base.handle, bo->used, bo->base.exec!=NULL,
  2187.                      bo->write, bo->mmapped ? IS_CPU_MAP(bo->base.map) ? "cpu" : "gtt" : "no"));
  2188.  
  2189.                 assert(next->base.list.prev == &bo->base.list);
  2190.                 assert(bo->base.io);
  2191.                 assert(bo->base.refcnt >= 1);
  2192.  
  2193.                 if (!bo->base.exec) {
  2194.                         DBG(("%s: skipping unattached handle=%d, used=%d\n",
  2195.                              __FUNCTION__, bo->base.handle, bo->used));
  2196.                         continue;
  2197.                 }
  2198.  
  2199.                 if (!bo->write) {
  2200.                         assert(bo->base.exec || bo->base.refcnt > 1);
  2201.                         goto decouple;
  2202.                 }
  2203.  
  2204.                 if (bo->mmapped) {
  2205.                         int used;
  2206.  
  2207.                         assert(!bo->need_io);
  2208.  
  2209.                         used = ALIGN(bo->used, PAGE_SIZE);
  2210.                         if (!DBG_NO_UPLOAD_ACTIVE &&
  2211.                             used + PAGE_SIZE <= bytes(&bo->base) &&
  2212.                             (kgem->has_llc || !IS_CPU_MAP(bo->base.map) || bo->base.snoop)) {
  2213.                                 DBG(("%s: retaining upload buffer (%d/%d)\n",
  2214.                                      __FUNCTION__, bo->used, bytes(&bo->base)));
  2215.                                 bo->used = used;
  2216.                                 list_move(&bo->base.list,
  2217.                                           &kgem->active_buffers);
  2218.                                 continue;
  2219.                         }
  2220.                         DBG(("%s: discarding mmapped buffer, used=%d, map type=%d\n",
  2221.                              __FUNCTION__, bo->used, (int)__MAP_TYPE(bo->base.map)));
  2222.                         goto decouple;
  2223.                 }
  2224.  
  2225.                 if (!bo->used) {
  2226.                         /* Unless we replace the handle in the execbuffer,
  2227.                          * then this bo will become active. So decouple it
  2228.                          * from the buffer list and track it in the normal
  2229.                          * manner.
  2230.                          */
  2231.                         goto decouple;
  2232.                 }
  2233.  
  2234.                 assert(bo->need_io);
  2235.                 assert(bo->base.rq == MAKE_REQUEST(kgem->next_request, kgem->ring));
  2236.                 assert(bo->base.domain != DOMAIN_GPU);
  2237.  
  2238.                 if (bo->base.refcnt == 1 &&
  2239.                     bo->base.size.pages.count > 1 &&
  2240.                     bo->used < bytes(&bo->base) / 2) {
  2241.                         struct kgem_bo *shrink;
  2242.                         unsigned alloc = NUM_PAGES(bo->used);
  2243.  
  2244.                         shrink = search_snoop_cache(kgem, alloc,
  2245.                                                     CREATE_INACTIVE | CREATE_NO_RETIRE);
  2246.                         if (shrink) {
  2247.                                 void *map;
  2248.                                 int n;
  2249.  
  2250.                                 DBG(("%s: used=%d, shrinking %d to %d, handle %d to %d\n",
  2251.                                      __FUNCTION__,
  2252.                                      bo->used, bytes(&bo->base), bytes(shrink),
  2253.                                      bo->base.handle, shrink->handle));
  2254.  
  2255.                                 assert(bo->used <= bytes(shrink));
  2256.                                 map = kgem_bo_map__cpu(kgem, shrink);
  2257.                                 if (map) {
  2258.                                         kgem_bo_sync__cpu(kgem, shrink);
  2259.                                         memcpy(map, bo->mem, bo->used);
  2260.  
  2261.                                         shrink->target_handle =
  2262.                                                 kgem->has_handle_lut ? bo->base.target_handle : shrink->handle;
  2263.                                         for (n = 0; n < kgem->nreloc; n++) {
  2264.                                                 if (kgem->reloc[n].target_handle == bo->base.target_handle) {
  2265.                                                         kgem->reloc[n].target_handle = shrink->target_handle;
  2266.                                                         kgem->reloc[n].presumed_offset = shrink->presumed_offset;
  2267.                                                         kgem->batch[kgem->reloc[n].offset/sizeof(kgem->batch[0])] =
  2268.                                                                 kgem->reloc[n].delta + shrink->presumed_offset;
  2269.                                                 }
  2270.                                         }
  2271.  
  2272.                                         bo->base.exec->handle = shrink->handle;
  2273.                                         bo->base.exec->offset = shrink->presumed_offset;
  2274.                                         shrink->exec = bo->base.exec;
  2275.                                         shrink->rq = bo->base.rq;
  2276.                                         list_replace(&bo->base.request,
  2277.                                                      &shrink->request);
  2278.                                         list_init(&bo->base.request);
  2279.                                         shrink->needs_flush = bo->base.gpu_dirty;
  2280.  
  2281.                                         bo->base.exec = NULL;
  2282.                                         bo->base.rq = NULL;
  2283.                                         bo->base.gpu_dirty = false;
  2284.                                         bo->base.needs_flush = false;
  2285.                                         bo->used = 0;
  2286.  
  2287.                                         goto decouple;
  2288.                                 }
  2289.  
  2290.                                 __kgem_bo_destroy(kgem, shrink);
  2291.                         }
  2292.  
  2293.                         shrink = search_linear_cache(kgem, alloc,
  2294.                                                      CREATE_INACTIVE | CREATE_NO_RETIRE);
  2295.                         if (shrink) {
  2296.                                 int n;
  2297.  
  2298.                                 DBG(("%s: used=%d, shrinking %d to %d, handle %d to %d\n",
  2299.                                      __FUNCTION__,
  2300.                                      bo->used, bytes(&bo->base), bytes(shrink),
  2301.                                      bo->base.handle, shrink->handle));
  2302.  
  2303.                                 assert(bo->used <= bytes(shrink));
  2304.                                 if (gem_write(kgem->fd, shrink->handle,
  2305.                                               0, bo->used, bo->mem) == 0) {
  2306.                                         shrink->target_handle =
  2307.                                                 kgem->has_handle_lut ? bo->base.target_handle : shrink->handle;
  2308.                                         for (n = 0; n < kgem->nreloc; n++) {
  2309.                                                 if (kgem->reloc[n].target_handle == bo->base.target_handle) {
  2310.                                                         kgem->reloc[n].target_handle = shrink->target_handle;
  2311.                                                         kgem->reloc[n].presumed_offset = shrink->presumed_offset;
  2312.                                                         kgem->batch[kgem->reloc[n].offset/sizeof(kgem->batch[0])] =
  2313.                                                                 kgem->reloc[n].delta + shrink->presumed_offset;
  2314.                                                 }
  2315.                                         }
  2316.  
  2317.                                         bo->base.exec->handle = shrink->handle;
  2318.                                         bo->base.exec->offset = shrink->presumed_offset;
  2319.                                         shrink->exec = bo->base.exec;
  2320.                                         shrink->rq = bo->base.rq;
  2321.                                         list_replace(&bo->base.request,
  2322.                                                      &shrink->request);
  2323.                                         list_init(&bo->base.request);
  2324.                                         shrink->needs_flush = bo->base.gpu_dirty;
  2325.  
  2326.                                         bo->base.exec = NULL;
  2327.                                         bo->base.rq = NULL;
  2328.                                         bo->base.gpu_dirty = false;
  2329.                                         bo->base.needs_flush = false;
  2330.                                         bo->used = 0;
  2331.  
  2332.                                         goto decouple;
  2333.                                 }
  2334.  
  2335.                                 __kgem_bo_destroy(kgem, shrink);
  2336.                         }
  2337.                 }
  2338.  
  2339.                 DBG(("%s: handle=%d, uploading %d/%d\n",
  2340.                      __FUNCTION__, bo->base.handle, bo->used, bytes(&bo->base)));
  2341.                 ASSERT_IDLE(kgem, bo->base.handle);
  2342.                 assert(bo->used <= bytes(&bo->base));
  2343.                 gem_write(kgem->fd, bo->base.handle,
  2344.                           0, bo->used, bo->mem);
  2345.                 bo->need_io = 0;
  2346.  
  2347. decouple:
  2348.                 DBG(("%s: releasing handle=%d\n",
  2349.                      __FUNCTION__, bo->base.handle));
  2350.                 list_del(&bo->base.list);
  2351.                 kgem_bo_unref(kgem, &bo->base);
  2352.         }
  2353. }
  2354.  
  2355. static void kgem_cleanup(struct kgem *kgem)
  2356. {
  2357.         int n;
  2358.  
  2359.         for (n = 0; n < ARRAY_SIZE(kgem->requests); n++) {
  2360.                 while (!list_is_empty(&kgem->requests[n])) {
  2361.                         struct kgem_request *rq;
  2362.  
  2363.                         rq = list_first_entry(&kgem->requests[n],
  2364.                                               struct kgem_request,
  2365.                                               list);
  2366.                         while (!list_is_empty(&rq->buffers)) {
  2367.                                 struct kgem_bo *bo;
  2368.  
  2369.                                 bo = list_first_entry(&rq->buffers,
  2370.                                                       struct kgem_bo,
  2371.                                                       request);
  2372.  
  2373.                                 bo->exec = NULL;
  2374.                                 bo->gpu_dirty = false;
  2375.                                 __kgem_bo_clear_busy(bo);
  2376.                                 if (bo->refcnt == 0)
  2377.                                         kgem_bo_free(kgem, bo);
  2378.                         }
  2379.  
  2380.                         __kgem_request_free(rq);
  2381.                 }
  2382.         }
  2383.  
  2384.         kgem_close_inactive(kgem);
  2385. }
  2386.  
  2387. static int kgem_batch_write(struct kgem *kgem, uint32_t handle, uint32_t size)
  2388. {
  2389.         int ret;
  2390.  
  2391.         ASSERT_IDLE(kgem, handle);
  2392.  
  2393.         /* If there is no surface data, just upload the batch */
  2394.         if (kgem->surface == kgem->batch_size)
  2395.                 return gem_write(kgem->fd, handle,
  2396.                                  0, sizeof(uint32_t)*kgem->nbatch,
  2397.                                  kgem->batch);
  2398.  
  2399.         /* Are the batch pages conjoint with the surface pages? */
  2400.         if (kgem->surface < kgem->nbatch + PAGE_SIZE/sizeof(uint32_t)) {
  2401.                 assert(size == PAGE_ALIGN(kgem->batch_size*sizeof(uint32_t)));
  2402.                 return gem_write(kgem->fd, handle,
  2403.                                  0, kgem->batch_size*sizeof(uint32_t),
  2404.                                  kgem->batch);
  2405.         }
  2406.  
  2407.         /* Disjoint surface/batch, upload separately */
  2408.         ret = gem_write(kgem->fd, handle,
  2409.                         0, sizeof(uint32_t)*kgem->nbatch,
  2410.                         kgem->batch);
  2411.         if (ret)
  2412.                 return ret;
  2413.  
  2414.         ret = PAGE_ALIGN(sizeof(uint32_t) * kgem->batch_size);
  2415.         ret -= sizeof(uint32_t) * kgem->surface;
  2416.         assert(size-ret >= kgem->nbatch*sizeof(uint32_t));
  2417.         return __gem_write(kgem->fd, handle,
  2418.                         size - ret, (kgem->batch_size - kgem->surface)*sizeof(uint32_t),
  2419.                         kgem->batch + kgem->surface);
  2420. }
  2421.  
  2422. void kgem_reset(struct kgem *kgem)
  2423. {
  2424.         if (kgem->next_request) {
  2425.                 struct kgem_request *rq = kgem->next_request;
  2426.  
  2427.                 while (!list_is_empty(&rq->buffers)) {
  2428.                         struct kgem_bo *bo =
  2429.                                 list_first_entry(&rq->buffers,
  2430.                                                  struct kgem_bo,
  2431.                                                  request);
  2432.                         list_del(&bo->request);
  2433.  
  2434.                         assert(RQ(bo->rq) == rq);
  2435.  
  2436.                         bo->binding.offset = 0;
  2437.                         bo->exec = NULL;
  2438.                         bo->target_handle = -1;
  2439.                         bo->gpu_dirty = false;
  2440.  
  2441.                         if (bo->needs_flush && __kgem_busy(kgem, bo->handle)) {
  2442.                                 assert(bo->domain == DOMAIN_GPU || bo->domain == DOMAIN_NONE);
  2443.                                 list_add(&bo->request, &kgem->flushing);
  2444.                                 bo->rq = (void *)kgem;
  2445.                         } else
  2446.                                 __kgem_bo_clear_busy(bo);
  2447.  
  2448.                         if (bo->refcnt || bo->rq)
  2449.                                 continue;
  2450.  
  2451.                         if (bo->snoop) {
  2452.                                 kgem_bo_move_to_snoop(kgem, bo);
  2453.                         } else if (bo->scanout) {
  2454.                                 kgem_bo_move_to_scanout(kgem, bo);
  2455.                         } else if ((bo = kgem_bo_replace_io(bo))->reusable &&
  2456.                                    kgem_bo_set_purgeable(kgem, bo)) {
  2457.                                 kgem_bo_move_to_inactive(kgem, bo);
  2458.                         } else {
  2459.                                 DBG(("%s: closing %d\n",
  2460.                                      __FUNCTION__, bo->handle));
  2461.                                 kgem_bo_free(kgem, bo);
  2462.                         }
  2463.                 }
  2464.  
  2465.                 if (rq != &kgem->static_request) {
  2466.                         list_init(&rq->list);
  2467.                         __kgem_request_free(rq);
  2468.                 }
  2469.         }
  2470.  
  2471.         kgem->nfence = 0;
  2472.         kgem->nexec = 0;
  2473.         kgem->nreloc = 0;
  2474.         kgem->nreloc__self = 0;
  2475.         kgem->aperture = 0;
  2476.         kgem->aperture_fenced = 0;
  2477.         kgem->nbatch = 0;
  2478.         kgem->surface = kgem->batch_size;
  2479.         kgem->mode = KGEM_NONE;
  2480.         kgem->flush = 0;
  2481.         kgem->batch_flags = kgem->batch_flags_base;
  2482.  
  2483.         kgem->next_request = __kgem_request_alloc(kgem);
  2484.  
  2485.         kgem_sna_reset(kgem);
  2486. }
  2487.  
  2488. static int compact_batch_surface(struct kgem *kgem)
  2489. {
  2490.         int size, shrink, n;
  2491.  
  2492.         if (!kgem->has_relaxed_delta)
  2493.                 return kgem->batch_size;
  2494.  
  2495.         /* See if we can pack the contents into one or two pages */
  2496.         n = ALIGN(kgem->batch_size, 1024);
  2497.         size = n - kgem->surface + kgem->nbatch;
  2498.         size = ALIGN(size, 1024);
  2499.  
  2500.         shrink = n - size;
  2501.         if (shrink) {
  2502.                 DBG(("shrinking from %d to %d\n", kgem->batch_size, size));
  2503.  
  2504.                 shrink *= sizeof(uint32_t);
  2505.                 for (n = 0; n < kgem->nreloc; n++) {
  2506.                         if (kgem->reloc[n].read_domains == I915_GEM_DOMAIN_INSTRUCTION &&
  2507.                             kgem->reloc[n].target_handle == ~0U)
  2508.                                 kgem->reloc[n].delta -= shrink;
  2509.  
  2510.                         if (kgem->reloc[n].offset >= sizeof(uint32_t)*kgem->nbatch)
  2511.                                 kgem->reloc[n].offset -= shrink;
  2512.                 }
  2513.         }
  2514.  
  2515.         return size * sizeof(uint32_t);
  2516. }
  2517.  
  2518. static struct kgem_bo *
  2519. kgem_create_batch(struct kgem *kgem, int size)
  2520. {
  2521.         struct drm_i915_gem_set_domain set_domain;
  2522.         struct kgem_bo *bo;
  2523.  
  2524.         if (size <= 4096) {
  2525.                 bo = list_first_entry(&kgem->pinned_batches[0],
  2526.                                       struct kgem_bo,
  2527.                                       list);
  2528.                 if (!bo->rq) {
  2529. out_4096:
  2530.                         list_move_tail(&bo->list, &kgem->pinned_batches[0]);
  2531.                         return kgem_bo_reference(bo);
  2532.                 }
  2533.  
  2534.                 if (!__kgem_busy(kgem, bo->handle)) {
  2535.                         assert(RQ(bo->rq)->bo == bo);
  2536.                         __kgem_retire_rq(kgem, RQ(bo->rq));
  2537.                         goto out_4096;
  2538.                 }
  2539.         }
  2540.  
  2541.         if (size <= 16384) {
  2542.                 bo = list_first_entry(&kgem->pinned_batches[1],
  2543.                                       struct kgem_bo,
  2544.                                       list);
  2545.                 if (!bo->rq) {
  2546. out_16384:
  2547.                         list_move_tail(&bo->list, &kgem->pinned_batches[1]);
  2548.                         return kgem_bo_reference(bo);
  2549.                 }
  2550.  
  2551.                 if (!__kgem_busy(kgem, bo->handle)) {
  2552.                         assert(RQ(bo->rq)->bo == bo);
  2553.                         __kgem_retire_rq(kgem, RQ(bo->rq));
  2554.                         goto out_16384;
  2555.                 }
  2556.         }
  2557.  
  2558.         if (kgem->gen == 020 && !kgem->has_pinned_batches) {
  2559.                 assert(size <= 16384);
  2560.  
  2561.                 bo = list_first_entry(&kgem->pinned_batches[size > 4096],
  2562.                                       struct kgem_bo,
  2563.                                       list);
  2564.                 list_move_tail(&bo->list, &kgem->pinned_batches[size > 4096]);
  2565.  
  2566.                 DBG(("%s: syncing due to busy batches\n", __FUNCTION__));
  2567.  
  2568.                 VG_CLEAR(set_domain);
  2569.                 set_domain.handle = bo->handle;
  2570.                 set_domain.read_domains = I915_GEM_DOMAIN_GTT;
  2571.                 set_domain.write_domain = I915_GEM_DOMAIN_GTT;
  2572.                 if (drmIoctl(kgem->fd, DRM_IOCTL_I915_GEM_SET_DOMAIN, &set_domain)) {
  2573.                         DBG(("%s: sync: GPU hang detected\n", __FUNCTION__));
  2574.                         kgem_throttle(kgem);
  2575.                         return NULL;
  2576.                 }
  2577.  
  2578.                 kgem_retire(kgem);
  2579.                 assert(bo->rq == NULL);
  2580.                 return kgem_bo_reference(bo);
  2581.         }
  2582.  
  2583.         return kgem_create_linear(kgem, size, CREATE_NO_THROTTLE);
  2584. }
  2585.  
  2586. void _kgem_submit(struct kgem *kgem)
  2587. {
  2588.         struct kgem_request *rq;
  2589.         uint32_t batch_end;
  2590.         int size;
  2591.  
  2592.         assert(!DBG_NO_HW);
  2593.         assert(!kgem->wedged);
  2594.  
  2595.         assert(kgem->nbatch);
  2596.         assert(kgem->nbatch <= KGEM_BATCH_SIZE(kgem));
  2597.         assert(kgem->nbatch <= kgem->surface);
  2598.  
  2599.         batch_end = kgem_end_batch(kgem);
  2600.         kgem_sna_flush(kgem);
  2601.  
  2602.         DBG(("batch[%d/%d, flags=%x]: %d %d %d %d, nreloc=%d, nexec=%d, nfence=%d, aperture=%d\n",
  2603.              kgem->mode, kgem->ring, kgem->batch_flags,
  2604.              batch_end, kgem->nbatch, kgem->surface, kgem->batch_size,
  2605.              kgem->nreloc, kgem->nexec, kgem->nfence, kgem->aperture));
  2606.  
  2607.         assert(kgem->nbatch <= kgem->batch_size);
  2608.         assert(kgem->nbatch <= kgem->surface);
  2609.         assert(kgem->nreloc <= ARRAY_SIZE(kgem->reloc));
  2610.         assert(kgem->nexec < ARRAY_SIZE(kgem->exec));
  2611.         assert(kgem->nfence <= kgem->fence_max);
  2612.  
  2613.         kgem_finish_buffers(kgem);
  2614.  
  2615. #if SHOW_BATCH
  2616.         __kgem_batch_debug(kgem, batch_end);
  2617. #endif
  2618.  
  2619.         rq = kgem->next_request;
  2620.         if (kgem->surface != kgem->batch_size)
  2621.                 size = compact_batch_surface(kgem);
  2622.         else
  2623.                 size = kgem->nbatch * sizeof(kgem->batch[0]);
  2624.         rq->bo = kgem_create_batch(kgem, size);
  2625.         if (rq->bo) {
  2626.                 uint32_t handle = rq->bo->handle;
  2627.                 int i;
  2628.  
  2629.                 assert(!rq->bo->needs_flush);
  2630.  
  2631.                 i = kgem->nexec++;
  2632.                 kgem->exec[i].handle = handle;
  2633.                 kgem->exec[i].relocation_count = kgem->nreloc;
  2634.                 kgem->exec[i].relocs_ptr = (uintptr_t)kgem->reloc;
  2635.                 kgem->exec[i].alignment = 0;
  2636.                 kgem->exec[i].offset = rq->bo->presumed_offset;
  2637.                 kgem->exec[i].flags = 0;
  2638.                 kgem->exec[i].rsvd1</