WebSVN – Kolibri OS – Diff – /drivers/video/Intel-2D/kgem.h

  */
 #ifndef KGEM_H
-#define KGEM_H
-#define HAS_DEBUG_FULL 1
+#define KGEM_H
 #include
 #include
-#include
 #include
 #include
+#include
+#include "compiler.h"
+#include "intel_list.h"
+#include
+#if !defined(MAXSHORT) || !defined(MINSHORT) || \
+    !defined(MAXINT) || !defined(MININT)
+/*
+ * Some implementations #define these through , so preclude
+ * #include'ing it later.
+ */
 #include
+#undef MAXSHORT
+#define MAXSHORT SHRT_MAX
+#undef MINSHORT
-#include "compiler.h"
-#include "intel_list.h"
-#undef  DBG
+#define MINSHORT SHRT_MIN
 #undef MAXINT
-#if HAS_DEBUG_FULL
+#define MAXINT INT_MAX
-#define DBG(x) printf x
+#undef MININT
 	struct list vma;
     void     *map;
 #define IS_CPU_MAP(ptr) ((uintptr_t)(ptr) & 1)
+#define IS_GTT_MAP(ptr) (ptr && ((uintptr_t)(ptr) & 1) == 0)
-#define IS_GTT_MAP(ptr) (ptr && ((uintptr_t)(ptr) & 1) == 0)
+#define MAP(ptr) ((void*)((uintptr_t)(ptr) & ~3))
 	struct kgem_bo_binding {
 		struct kgem_bo_binding *next;
 		uint32_t bytes;
 	} size;
     uint32_t pitch  : 18; /* max 128k */
 	uint32_t tiling : 2;
 	uint32_t reusable : 1;
+	uint32_t gpu_dirty : 1;
-    uint32_t dirty  : 1;
+	uint32_t gtt_dirty : 1;
 	uint32_t domain : 2;
 	uint32_t needs_flush : 1;
 	uint32_t snoop : 1;
     uint32_t io     : 1;
     uint32_t flush  : 1;
 	uint32_t need_retire:1;
 	uint32_t need_throttle:1;
 	uint32_t scanout_busy:1;
 	uint32_t busy:1;
 	uint32_t has_create2 :1;
 	uint32_t has_userptr :1;
 	uint32_t has_blt :1;
 	uint32_t has_relaxed_fencing :1;
 	uint32_t has_relaxed_delta :1;
 	uint32_t has_semaphores :1;
 	uint32_t has_secure_batches :1;
 	uint32_t has_pinned_batches :1;
-	uint32_t has_cacheing :1;
+	uint32_t has_caching :1;
+	uint32_t has_llc :1;
-	uint32_t has_llc :1;
+	uint32_t has_wt :1;
 	uint32_t has_no_reloc :1;
 	uint32_t has_handle_lut :1;
 	void (*context_switch)(struct kgem *kgem, int new_mode);
     void (*retire)(struct kgem *kgem);
+	void (*expire)(struct kgem *kgem);
+#if 0
+	void (*memcpy_to_tiled_x)(const void *src, void *dst, int bpp,
-	void (*expire)(struct kgem *kgem);
+				  int32_t src_stride, int32_t dst_stride,
+				  int16_t src_x, int16_t src_y,
+				  int16_t dst_x, int16_t dst_y,
+				  uint16_t width, uint16_t height);
+	void (*memcpy_from_tiled_x)(const void *src, void *dst, int bpp,
+				    int32_t src_stride, int32_t dst_stride,
-	uint32_t batch[64*1024-8];
+				    int16_t src_x, int16_t src_y,
+				    int16_t dst_x, int16_t dst_y,
+				    uint16_t width, uint16_t height);
-	struct drm_i915_gem_exec_object2 exec[256];
+#endif
+	uint16_t reloc__self[256];
+	uint32_t batch[64*1024-8] page_aligned;
-	struct drm_i915_gem_relocation_entry reloc[4096];
+	struct drm_i915_gem_exec_object2 exec[384] page_aligned;
-	uint16_t reloc__self[256];
+	struct drm_i915_gem_relocation_entry reloc[8192] page_aligned;
 #ifdef DEBUG_MEMORY
 	struct {
 		int bo_allocs;
 		size_t bo_bytes;
+	} debug_memory;
+#endif
-	} debug_memory;
+};
-#endif
-};
+#define KGEM_MAX_DEFERRED_VBO 16
 #define KGEM_BATCH_RESERVED 1
-#define KGEM_RELOC_RESERVED 4
+#define KGEM_RELOC_RESERVED (KGEM_MAX_DEFERRED_VBO)
 struct kgem_bo *kgem_create_map(struct kgem *kgem,
 				void *ptr, uint32_t size,
 				bool read_only);
+struct kgem_bo *kgem_create_for_name(struct kgem *kgem, uint32_t name);
+struct kgem_bo *kgem_create_for_prime(struct kgem *kgem, int name, uint32_t size);
-struct kgem_bo *kgem_create_for_name(struct kgem *kgem, uint32_t name);
+int kgem_bo_export_to_prime(struct kgem *kgem, struct kgem_bo *bo);
 struct kgem_bo *kgem_create_linear(struct kgem *kgem, int size, unsigned flags);
 struct kgem_bo *kgem_create_proxy(struct kgem *kgem,
+				  struct kgem_bo *target,
-				  struct kgem_bo *target,
+				  int offset, int length);
 				  int offset, int length);
 void kgem_proxy_bo_attach(struct kgem_bo *bo, struct kgem_bo **ptr);
 int kgem_choose_tiling(struct kgem *kgem,
 		       int tiling, int width, int height, int bpp);
 unsigned kgem_can_create_2d(struct kgem *kgem, int width, int height, int depth);
+#define KGEM_CAN_CREATE_GPU     0x1
+#define KGEM_CAN_CREATE_CPU     0x2
-#define KGEM_CAN_CREATE_GPU     0x1
+#define KGEM_CAN_CREATE_LARGE	0x4
-#define KGEM_CAN_CREATE_CPU     0x2
+#define KGEM_CAN_CREATE_GTT	0x8
 #define KGEM_CAN_CREATE_LARGE	0x4
-#define KGEM_CAN_CREATE_GTT	0x8
+uint32_t kgem_get_unique_id(struct kgem *kgem);
 				   int bpp,
 				   uint32_t flags);
 uint32_t kgem_bo_get_binding(struct kgem_bo *bo, uint32_t format);
-void kgem_bo_set_binding(struct kgem_bo *bo, uint32_t format, uint16_t offset);
-int kgem_bo_get_swizzling(struct kgem *kgem, struct kgem_bo *bo);
+void kgem_bo_set_binding(struct kgem_bo *bo, uint32_t format, uint16_t offset);
 bool kgem_retire(struct kgem *kgem);
 		return true;
 	return kgem_ring_is_idle(kgem, kgem->ring);
+}
+static inline bool __kgem_ring_empty(struct kgem *kgem)
+{
+	return list_is_empty(&kgem->requests[kgem->ring == KGEM_BLT]);
+}
 void _kgem_submit(struct kgem *kgem);
 static inline void kgem_submit(struct kgem *kgem)
+{
+{
 	if (bo->exec)
 		_kgem_submit(kgem);
+}
-void __kgem_flush(struct kgem *kgem, struct kgem_bo *bo);
-static inline void kgem_bo_flush(struct kgem *kgem, struct kgem_bo *bo)
-{
-	kgem_bo_submit(kgem, bo);
-	if (!bo->needs_flush)
-		return;
-	/* If the kernel fails to emit the flush, then it will be forced when
-	 * we assume direct access. And as the useual failure is EIO, we do
-	 * not actualy care.
-	 */
-	__kgem_flush(kgem, bo);
 void kgem_scanout_flush(struct kgem *kgem, struct kgem_bo *bo);
 static inline struct kgem_bo *kgem_bo_reference(struct kgem_bo *bo)
+{
 #if DEBUG_FLUSH_BATCH
 	kgem_submit(kgem);
+#endif
+	if (kgem->nreloc && bo->exec == NULL && kgem_ring_is_idle(kgem, kgem->ring))
-#endif
+		_kgem_submit(kgem);
 	if (kgem->mode == mode)
 		return;
 		kgem_check_exec(kgem, num_surfaces);
+}
 static inline uint32_t *kgem_get_batch(struct kgem *kgem)
+{
+	if (kgem->nreloc) {
+		unsigned mode = kgem->mode;
+		_kgem_submit(kgem);
+		_kgem_set_mode(kgem, mode);
+	}
 	return kgem->batch + kgem->nbatch;
 	if (kgem->gen < 040 && bo->tiling &&
 	    bo->presumed_offset & (kgem_bo_fenced_size(kgem, bo) - 1))
+		return false;
+	if (kgem->gen == 021 && bo->tiling == I915_TILING_Y)
+		return false;
+	if (kgem->has_llc && bo->tiling == I915_TILING_NONE)
-		return false;
+		return true;
 	if (!bo->presumed_offset)
 		return kgem_bo_size(bo) <= kgem->aperture_mappable / 4;
 static inline bool kgem_bo_can_map(struct kgem *kgem, struct kgem_bo *bo)
+{
 	if (kgem_bo_mapped(kgem, bo))
 		return true;
-	if (!bo->tiling && kgem->has_llc)
+	if (!bo->tiling && (kgem->has_llc || bo->domain == DOMAIN_CPU))
 		return true;
 	if (kgem->gen == 021 && bo->tiling == I915_TILING_Y)
 		return false;
+	return kgem_bo_size(bo) <= kgem->aperture_mappable / 4;
+}
+static inline bool kgem_bo_can_map__cpu(struct kgem *kgem,
+					struct kgem_bo *bo,
+					bool write)
+{
+	if (bo->purged || (bo->scanout && write))
+		return false;
+	if (kgem->has_llc)
+		return true;
+	if (bo->domain != DOMAIN_CPU)
+		return false;
-	return kgem_bo_size(bo) <= kgem->aperture_mappable / 4;
+	return !write || bo->exec == NULL;
+}
 static inline bool kgem_bo_is_snoop(struct kgem_bo *bo)
+{
 	assert(bo->refcnt);
+	while (bo->proxy)
+		bo = bo->proxy;
-	while (bo->proxy)
+	return bo->snoop;
 		bo = bo->proxy;
 	return bo->snoop;
 void kgem_bo_undo(struct kgem *kgem, struct kgem_bo *bo);
 bool __kgem_busy(struct kgem *kgem, int handle);
-static inline void kgem_bo_mark_busy(struct kgem_bo *bo, int ring)
-{
-	bo->rq = (struct kgem_request *)((uintptr_t)bo->rq | ring);
+static inline void kgem_bo_mark_busy(struct kgem_bo *bo, int ring)
+{
+	bo->rq = (struct kgem_request *)((uintptr_t)bo->rq | ring);
+}
+inline static void __kgem_bo_clear_busy(struct kgem_bo *bo)
+{
-inline static void __kgem_bo_clear_busy(struct kgem_bo *bo)
+	bo->rq = NULL;
 	list_del(&bo->request);
 	bo->needs_flush = false;
-	list_del(&bo->request);
+	bo->domain = DOMAIN_NONE;
-	bo->rq = NULL;
+	bo->needs_flush = false;
-	bo->domain = DOMAIN_NONE;
+	bo->gtt_dirty = false;
+}
-static inline bool kgem_bo_is_busy(struct kgem_bo *bo)
-	DBG(("%s: handle=%d, domain: %d exec? %d, rq? %d\n", __FUNCTION__,
+static inline bool kgem_bo_is_busy(struct kgem_bo *bo)
 	     bo->handle, bo->domain, bo->exec != NULL, bo->rq != NULL));
-	assert(bo->refcnt);
+	DBG(("%s: handle=%d, domain: %d exec? %d, rq? %d\n", __FUNCTION__,
-	return bo->rq;
+	     bo->handle, bo->domain, bo->exec != NULL, bo->rq != NULL));
 		__kgem_bo_clear_busy(bo);
 	return kgem_bo_is_busy(bo);
+}
+static inline bool kgem_bo_is_render(struct kgem_bo *bo)
+{
+	DBG(("%s: handle=%d, rq? %d [%d]\n", __FUNCTION__,
+	     bo->handle, bo->rq != NULL, (int)RQ_RING(bo->rq)));
+	assert(bo->refcnt);
+	return bo->rq && RQ_RING(bo->rq) == I915_EXEC_RENDER;
+}
+static inline void kgem_bo_mark_unreusable(struct kgem_bo *bo)
+{
+	while (bo->proxy) {
-}
+		bo->flush = true;
+		bo = bo->proxy;
+	}
+	bo->flush = true;
 	bo->reusable = false;
 */
 static inline bool kgem_bo_is_dirty(struct kgem_bo *bo)
+{
 	if (bo == NULL)
 		return false;
 	assert(bo->refcnt);
-	return bo->dirty;
+	return bo->gpu_dirty;
+{
 	DBG(("%s: handle=%d (proxy? %d)\n", __FUNCTION__,
 	     bo->handle, bo->proxy != NULL));
 	bo->exec->flags |= LOCAL_EXEC_OBJECT_WRITE;
-	bo->needs_flush = bo->dirty = true;
+	bo->needs_flush = bo->gpu_dirty = true;
 	list_move(&bo->request, &RQ(bo->rq)->buffers);
+}
 static inline void kgem_bo_mark_dirty(struct kgem_bo *bo)
+{
 	assert(bo->refcnt);
 	do {
 		assert(bo->exec);
 		assert(bo->rq);
-		if (bo->dirty)
+		if (bo->gpu_dirty)
 			return;
 #define MAX_INACTIVE_TIME 10
 bool kgem_expire_cache(struct kgem *kgem);
 void kgem_purge_cache(struct kgem *kgem);
 void kgem_cleanup_cache(struct kgem *kgem);
+void kgem_clean_scanout_cache(struct kgem *kgem);
+void kgem_clean_large_cache(struct kgem *kgem);
 #if HAS_DEBUG_FULL
 void __kgem_batch_debug(struct kgem *kgem, uint32_t nbatch);
 #else
 static inline void __kgem_batch_debug(struct kgem *kgem, uint32_t nbatch)

Subversion Repositories Kolibri OS

(root)/drivers/video/Intel-2D/kgem.h – Rev 4245 → 4251