Subversion Repositories Kolibri OS

/*

 * Copyright (c) 2011 Intel Corporation

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the "Software"),

 * to deal in the Software without restriction, including without limitation

 * the rights to use, copy, modify, merge, publish, distribute, sublicense,

 * and/or sell copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice (including the next

 * paragraph) shall be included in all copies or substantial portions of the

 * Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

 * SOFTWARE.

 *

 * Authors:

 *    Chris Wilson 

 *

 */

#ifndef KGEM_H

#define KGEM_H

#define HAS_DEBUG_FULL 0

#include 

#include 

#include 

#include 

#include 

#include "compiler.h"

#include "intel_list.h"

static inline void delay(uint32_t time)

{

    __asm__ __volatile__(

    "int $0x40"

    ::"a"(5), "b"(time)

    :"memory");

};

#undef  DBG

#if HAS_DEBUG_FULL

#define DBG(x) printf x

#else

#define DBG(x)

#endif

struct kgem_bo {

	struct kgem_request *rq;

#define RQ(rq) ((struct kgem_request *)((uintptr_t)(rq) & ~3))

#define RQ_RING(rq) ((uintptr_t)(rq) & 3)

#define RQ_IS_BLT(rq) (RQ_RING(rq) == KGEM_BLT)

	struct drm_i915_gem_exec_object2 *exec;

	struct kgem_bo *proxy;

	struct list list;

	struct list request;

	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)

	struct kgem_bo_binding {

		struct kgem_bo_binding *next;

		uint32_t format;

		uint16_t offset;

	} binding;

	uint32_t unique_id;

	uint32_t refcnt;

	uint32_t handle;

	uint32_t target_handle;

	uint32_t presumed_offset;

	uint32_t delta;

	union {

		struct {

			uint32_t count:27;

#define PAGE_SIZE 4096

            uint32_t bucket:5;

#define NUM_CACHE_BUCKETS 16

#define MAX_CACHE_SIZE (1 << (NUM_CACHE_BUCKETS+12))

		} pages;

		uint32_t bytes;

	} size;

    uint32_t pitch  : 18; /* max 128k */

	uint32_t tiling : 2;

	uint32_t reusable : 1;

    uint32_t 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 scanout : 1;

	uint32_t purged : 1;

};

#define DOMAIN_NONE 0

#define DOMAIN_CPU 1

#define DOMAIN_GTT 2

#define DOMAIN_GPU 3

struct kgem_request {

	struct list list;

	struct kgem_bo *bo;

	struct list buffers;

	int ring;

};

enum {

	MAP_GTT = 0,

	MAP_CPU,

	NUM_MAP_TYPES,

};

struct kgem {

	int fd;

	int wedged;

	unsigned gen;

	uint32_t unique_id;

	enum kgem_mode {

		/* order matches I915_EXEC_RING ordering */

		KGEM_NONE = 0,

		KGEM_RENDER,

		KGEM_BSD,

		KGEM_BLT,

	} mode, ring;

	struct list flushing;

	struct list large;

	struct list large_inactive;

	struct list active[NUM_CACHE_BUCKETS][3];

	struct list inactive[NUM_CACHE_BUCKETS];

	struct list pinned_batches[2];

	struct list snoop;

	struct list scanout;

	struct list batch_buffers, active_buffers;

	struct list requests[2];

	struct kgem_request *next_request;

	struct kgem_request static_request;

	struct {

		struct list inactive[NUM_CACHE_BUCKETS];

		int16_t count;

	} vma[NUM_MAP_TYPES];

	uint32_t batch_flags;

	uint32_t batch_flags_base;

#define I915_EXEC_SECURE (1<<9)

#define LOCAL_EXEC_OBJECT_WRITE (1<<2)

	uint16_t nbatch;

	uint16_t surface;

	uint16_t nexec;

	uint16_t nreloc;

	uint16_t nreloc__self;

	uint16_t nfence;

	uint16_t batch_size;

	uint16_t min_alignment;

	uint32_t flush:1;

	uint32_t need_expire:1;

	uint32_t need_purge:1;

	uint32_t need_retire:1;

	uint32_t need_throttle:1;

	uint32_t scanout_busy:1;

	uint32_t busy: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_llc :1;

	uint32_t has_no_reloc :1;

	uint32_t has_handle_lut :1;

	uint32_t can_blt_cpu :1;

	uint16_t fence_max;

	uint16_t half_cpu_cache_pages;

	uint32_t aperture_total, aperture_high, aperture_low, aperture_mappable;

	uint32_t aperture, aperture_fenced;

	uint32_t max_upload_tile_size, max_copy_tile_size;

	uint32_t max_gpu_size, max_cpu_size;

	uint32_t large_object_size, max_object_size;

	uint32_t buffer_size;

	void (*context_switch)(struct kgem *kgem, int new_mode);

    void (*retire)(struct kgem *kgem);

	void (*expire)(struct kgem *kgem);

	uint32_t batch[64*1024-8];

	struct drm_i915_gem_exec_object2 exec[256];

	struct drm_i915_gem_relocation_entry reloc[4096];

	uint16_t reloc__self[256];

#ifdef DEBUG_MEMORY

	struct {

		int bo_allocs;

		size_t bo_bytes;

	} debug_memory;

#endif

};

#define KGEM_BATCH_RESERVED 1

#define KGEM_RELOC_RESERVED 4

#define KGEM_EXEC_RESERVED 1

#ifndef ARRAY_SIZE

#define ARRAY_SIZE(a) (sizeof(a)/sizeof((a)[0]))

#endif

#define KGEM_BATCH_SIZE(K) ((K)->batch_size-KGEM_BATCH_RESERVED)

#define KGEM_EXEC_SIZE(K) (int)(ARRAY_SIZE((K)->exec)-KGEM_EXEC_RESERVED)

#define KGEM_RELOC_SIZE(K) (int)(ARRAY_SIZE((K)->reloc)-KGEM_RELOC_RESERVED)

void kgem_init(struct kgem *kgem, int fd, struct pci_device *dev, unsigned gen);

void kgem_reset(struct kgem *kgem);

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_linear(struct kgem *kgem, int size, unsigned flags);

struct kgem_bo *kgem_create_proxy(struct kgem *kgem,

				  struct kgem_bo *target,

				  int offset, int length);

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_LARGE	0x4

#define KGEM_CAN_CREATE_GTT	0x8

struct kgem_bo *

kgem_replace_bo(struct kgem *kgem,

		struct kgem_bo *src,

		uint32_t width,

		uint32_t height,

		uint32_t pitch,

		uint32_t bpp);

enum {

	CREATE_EXACT = 0x1,