/*
 * \brief  Emulation of the Linux kernel API used by DRM
 * \author Norman Feske
 * \date   2015-08-19
 *
 * The content of this file, in particular data structures, is partially
 * derived from Linux-internal headers.
 */

#ifndef _LX_EMUL_H_
#define _LX_EMUL_H_

#include <stdarg.h>
#include <base/fixed_stdint.h>

#include <lx_emul/extern_c_begin.h>

/*****************
 ** asm/param.h **
 *****************/

enum { HZ = 100UL };

#define DEBUG_LINUX_PRINTK 0

#include <lx_emul/compiler.h>
#include <lx_emul/printf.h>
#include <lx_emul/bug.h>
#include <lx_emul/atomic.h>

static inline void atomic_or(int i, atomic_t *v) {
	v->counter = v->counter | i; }
void atomic_andnot(int, atomic_t *);

#define smp_mb__before_atomic_inc() barrier()
#define smp_mb__before_atomic() barrier()

void atomic_set_mask(unsigned int mask, atomic_t *v);
#define atomic_set_release(v, i) atomic_set((v), (i))

#include <lx_emul/barrier.h>
#include <lx_emul/types.h>

typedef unsigned long kernel_ulong_t;
typedef unsigned int  u_int;
typedef long          ptrdiff_t;
typedef unsigned __bitwise slab_flags_t;

#define DECLARE_BITMAP(name,bits) \
	unsigned long name[BITS_TO_LONGS(bits)]


/***************************
 ** asm-generic/barrier.h **
 ***************************/

#define smp_load_acquire(p)     *(p)


/************************
 ** uapi/linux/types.h **
 ************************/

typedef __u16 __le16;
typedef __u16 __be16;
typedef __u32 __le32;
typedef __u32 __be32;
typedef __u64 __le64;
typedef __u64 __be64;

typedef unsigned __poll_t;

/********************
 ** linux/printk.h **
 ********************/

/* needed by drm_edid.c */
enum { DUMP_PREFIX_NONE, };

void print_hex_dump(const char *level, const char *prefix_str,
		int prefix_type, int rowsize, int groupsize,
		const void *buf, size_t len, bool ascii);

#define printk_once(fmt, ...) ({})


/***********************
 ** linux/sync_file.h **
 ***********************/

struct sync_file {
	struct file *file;
};
struct dma_fence;
struct dma_fence *sync_file_get_fence(int);
struct sync_file *sync_file_create(struct dma_fence *);

/*********************
 ** uapi/linux/fb.h **
 *********************/

#define KHZ2PICOS(a) (1000000000UL/(a))



/*******************
 ** linux/ctype.h **
 *******************/

#define isascii(c) (((unsigned char)(c))<=0x7f)
#define isprint(c) (isascii(c) && ((unsigned char)(c) >= 32))



/****************
 ** asm/page.h **
 ****************/

/*
 * For now, hardcoded
 */
#define PAGE_SIZE 4096UL
#define PAGE_MASK (~(PAGE_SIZE-1))


enum {
	PAGE_SHIFT = 12,
};

struct page
{
	atomic_t   _count;
	void      *addr;
	dma_addr_t paddr;
} __attribute((packed));

/* needed for agp/generic.c */
struct page *virt_to_page(const void *addr);

dma_addr_t page_to_phys(struct page *page);

#include <lx_emul/bitops.h>

extern unsigned long find_next_bit(const unsigned long *addr, unsigned long
                                   size, unsigned long offset);
extern unsigned long find_next_zero_bit(const unsigned long *addr, unsigned
                                        long size, unsigned long offset);
#define find_first_bit(addr, size) find_next_bit((addr), (size), 0)
#define find_first_zero_bit(addr, size) find_next_zero_bit((addr), (size), 0)

#define __const_hweight8(w)             \
	( (!!((w) & (1ULL << 0))) +       \
	  (!!((w) & (1ULL << 1))) +       \
	  (!!((w) & (1ULL << 2))) +       \
	  (!!((w) & (1ULL << 3))) +       \
	  (!!((w) & (1ULL << 4))) +       \
	  (!!((w) & (1ULL << 5))) +       \
	  (!!((w) & (1ULL << 6))) +       \
	  (!!((w) & (1ULL << 7))) )
#define hweight8(w)  __const_hweight8(w)
#define hweight16(w) (__const_hweight8(w)  + __const_hweight8((w)  >> 8 ))
#define hweight32(w) (hweight16(w) + hweight16((w) >> 16))
#define hweight64(w) (hweight32(w) + hweight32((w) >> 32))

#define GENMASK(h, l) \
	(((~0UL) << (l)) & (~0UL >> (BITS_PER_LONG - 1 - (h))))

#include <asm-generic/getorder.h>


#include <lx_emul/errno.h>

/* needed by 'virt_to_phys', which is needed by agp/generic.c */
typedef unsigned long phys_addr_t;

#include <lx_emul/string.h>

void *memchr_inv(const void *s, int c, size_t n);

/**********************
 ** linux/compiler.h **
 **********************/

#include <lx_emul/compiler.h>

#define prefetchw(x) __builtin_prefetch(x,1)

static inline void __read_once_size(const volatile void *p, void *res, int size)
{
	switch (size) {
		case 1: *(__u8  *)res = *(volatile __u8  *)p; break;
		case 2: *(__u16 *)res = *(volatile __u16 *)p; break;
		case 4: *(__u32 *)res = *(volatile __u32 *)p; break;
		case 8: *(__u64 *)res = *(volatile __u64 *)p; break;
		default:
			barrier();
			__builtin_memcpy((void *)res, (const void *)p, size);
			barrier();
	}
}

#ifdef __cplusplus
#define READ_ONCE(x) \
({                                               \
	barrier(); \
	x; \
})

#else
#define READ_ONCE(x) \
({                                               \
	union { typeof(x) __val; char __c[1]; } __u; \
	__read_once_size(&(x), __u.__c, sizeof(x));  \
	__u.__val;                                   \
})
#endif

#include <lx_emul/list.h>
#include <lx_emul/kernel.h>

#define SIZE_MAX (~(size_t)0)
#define U64_MAX  ((u64)~0ULL)
#define U16_MAX  ((u16)~0U)

extern long simple_strtol(const char *,char **,unsigned int);
typedef __kernel_time_t time_t;

extern int oops_in_progress;

#define pr_debug(fmt, ...)      printk(KERN_INFO fmt,   ##__VA_ARGS__)
#define pr_info(fmt, ...)       printk(KERN_INFO fmt,   ##__VA_ARGS__)
#define pr_err(fmt, ...)        printk(KERN_ERR fmt,    ##__VA_ARGS__)
#define pr_warn(fmt, ...)       printk(KERN_ERR fmt,    ##__VA_ARGS__)
#define pr_info_once(fmt, ...)  printk(KERN_INFO fmt,   ##__VA_ARGS__)
#define pr_notice(fmt, ...)     printk(KERN_NOTICE fmt, ##__VA_ARGS__)


int sprintf(char *buf, const char *fmt, ...);
int snprintf(char *buf, size_t size, const char *fmt, ...);

int sscanf(const char *, const char *, ...);

int vscnprintf(char *buf, size_t size, const char *fmt, va_list args);

enum { SPRINTF_STR_LEN = 64 };

#define kasprintf(gfp, fmt, ...) ({ \
		void *buf = kmalloc(SPRINTF_STR_LEN, 0); \
		sprintf(buf, fmt, __VA_ARGS__); \
		buf; \
		})

#define DIV_ROUND_UP_ULL(ll,d) \
	({ unsigned long long _tmp = (ll)+(d)-1; do_div(_tmp, d); _tmp; })

#define DIV_ROUND_CLOSEST_ULL(x, divisor)(              \
		{                                               \
		typeof(divisor) __d = divisor;                  \
		unsigned long long _tmp = (x) + (__d) / 2;      \
		do_div(_tmp, __d);                              \
		_tmp;                                           \
		}                                               \
		)

#define mult_frac(x, numer, denom) ({                   \
		typeof(x) quot = (x) / (denom);                 \
		typeof(x) rem  = (x) % (denom);                 \
		(quot * (numer)) + ((rem * (numer)) / (denom)); \
		})

extern int panic_timeout;
extern struct atomic_notifier_head panic_notifier_list;

/* linux/i2c.h */
#define __deprecated

#define rounddown(x, y) (                               \
		{                                               \
		typeof(x) __x = (x);                            \
		__x - (__x % (y));                              \
		}                                               \
		)

/************************
 ** linux/page-flags.h **
 ************************/

/* needed by agp/generic.c */
void SetPageReserved(struct page *page);
void ClearPageReserved(struct page *page);
bool PageSlab(struct page *page);


/********************
 ** linux/printk.h **
 ********************/

int hex_dump_to_buffer(const void *buf, size_t len,
                       int rowsize, int groupsize,
                       char *linebuf, size_t linebuflen, bool ascii);


#include <lx_emul/module.h>

#define MODULE_ALIAS_MISCDEV(x)  /* needed by agp/backend.c */

/* i2c-core.c */
#define postcore_initcall(fn) void postcore_##fn(void) { fn(); }

#define symbol_get(x) ({ extern typeof(x) x __attribute__((weak)); &(x); })
#define symbol_put(x) do { } while (0)


/**************************
 ** linux/preempt_mask.h **
 **************************/

/* needed bu i2c-core.c */
bool in_atomic();
void preempt_enable(void);
void preempt_disable(void);


/**********************
 ** linux/irqflags.h **
 **********************/

/* needed bu i2c-core.c */
bool irqs_disabled();

void local_irq_enable();
void local_irq_disable();


/********************
 ** linux/kernel.h **
 ********************/

#define min3(x, y, z) min((typeof(x))min(x, y), z)

//	typecheck(u64, x); 
#define u64_to_user_ptr(x) ({ \
	(void __user *)(uintptr_t)x; \
})
char *kvasprintf(gfp_t, const char *, va_list);

#define U32_MAX  ((u32)~0U)

#define IS_ALIGNED(x, a) (((x) & ((typeof(x))(a) - 1)) == 0)

#define TAINT_MACHINE_CHECK 4
#define TAINT_WARN          9

/**********************
 ** sched/wait_bit.c **
 **********************/
void wake_up_bit(void *, int);
int wait_on_bit(unsigned long *, int, unsigned);
int wait_on_bit_timeout(unsigned long *, int, unsigned, unsigned long);


/******************
 ** linux/kref.h **
 ******************/

struct kref;
unsigned int kref_read(const struct kref*);



/*********************
 ** linux/jiffies.h **
 *********************/

#include <lx_emul/jiffies.h>

#define time_before(a,b)	time_after(b,a)
#define time_before_eq(a,b)	time_after_eq(b,a)

#define time_in_range(a,b,c) \
	(time_after_eq(a,b) &&   \
	 time_before_eq(a,c))

u64 nsecs_to_jiffies(u64);
extern u64 nsecs_to_jiffies64(u64 n);

static inline u64 get_jiffies_64(void) { return jiffies; }

#include <lx_emul/spinlock.h>
#include <lx_emul/semaphore.h>

#include <lx_emul/mutex.h>

LX_MUTEX_INIT_DECLARE(bridge_lock);
LX_MUTEX_INIT_DECLARE(core_lock);

#define bridge_lock LX_MUTEX(bridge_lock)
#define core_lock   LX_MUTEX(core_lock)


static inline int mutex_lock_interruptible(struct mutex *lock) {
	mutex_lock(lock);
	return 0;
}

void mutex_lock_nest_lock(struct mutex *, struct mutex *);

void might_lock(struct mutex *);


/*********************
 ** linux/rtmutex.h **
 *********************/

#define rt_mutex            mutex
#define rt_mutex_init(m)    mutex_init(m)
#define rt_mutex_lock(m)    mutex_lock(m)
#define rt_mutex_trylock(m) mutex_trylock(m)
#define rt_mutex_unlock(m)  mutex_unlock(m)


/*********************
 ** linux/ww_mutex.h **
 *********************/

struct ww_acquire_ctx { unsigned dummy; };
struct ww_class { int dummy; };
struct ww_mutex {
	bool locked;
	struct ww_acquire_ctx *ctx;
};

#define DEFINE_WW_CLASS(classname) \
	struct ww_class classname;
#define DEFINE_WW_MUTEX(mutexname, ww_class) \
	struct ww_mutex mutexname;


/******************
 ** linux/time.h **
 ******************/

#include <lx_emul/time.h>

void getrawmonotonic(struct timespec *ts);

struct timespec timespec_sub(struct timespec lhs, struct timespec rhs);
bool timespec_valid(const struct timespec *ts);
void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec);
struct timespec ns_to_timespec(const s64 nsec);
s64 timespec_to_ns(const struct timespec *ts);


/*******************
 ** linux/timer.h **
 *******************/

typedef int clockid_t;

#include <lx_emul/timer.h>

#define del_singleshot_timer_sync(t) del_timer_sync(t)

void timer_setup(struct timer_list *, void (*func)(struct timer_list *), unsigned int);

#include <lx_emul/work.h>

extern bool flush_delayed_work(struct delayed_work *dwork);

extern unsigned long timespec_to_jiffies(const struct timespec *value);

#define wait_event_interruptible_timeout wait_event_timeout

#define setup_timer_on_stack setup_timer

unsigned long round_jiffies_up_relative(unsigned long j);

extern int mod_timer_pinned(struct timer_list *timer, unsigned long expires);

#define from_timer(var, callback_timer, timer_fieldname) \
	container_of(callback_timer, typeof(*var), timer_fieldname)

#define TIMER_IRQSAFE 0x00200000

/***********************
 ** linux/workqueue.h **
 ***********************/

enum {
	WORK_STRUCT_PENDING_BIT = 0,
};

#define work_data_bits(work) ((unsigned long *)(&(work)->data))

#define work_pending(work) \
        test_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work))

#define delayed_work_pending(w) \
         work_pending(&(w)->work)

#ifndef CONFIG_DEBUG_OBJECTS_WORK
#define INIT_WORK_ONSTACK(_work, _func) while(0) { }
static inline void destroy_work_on_stack(struct work_struct *work) { }
#endif

void INIT_DELAYED_WORK_ONSTACK(void *, void *);
void destroy_delayed_work_on_stack(struct delayed_work *);

unsigned int work_busy(struct work_struct *);

/*******************
 ** linux/sched.h **
 *******************/

enum { TASK_COMM_LEN = 16 };

enum {
	TASK_RUNNING         = 0x0,
	TASK_INTERRUPTIBLE   = 0x1,
	TASK_UNINTERRUPTIBLE = 0x2,
	TASK_NORMAL          = TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE,
};

#define	MAX_SCHEDULE_TIMEOUT LONG_MAX

struct mm_struct;
struct task_struct {
	struct mm_struct *mm;
	char comm[16]; /* only for debug output */
	unsigned pid;
	int      prio;
	volatile long state;
};

signed long schedule_timeout(signed long timeout);
void __set_current_state(int state);
int signal_pending(struct task_struct *p);
void schedule(void);
int wake_up_process(struct task_struct *tsk);
int wake_up_state(struct task_struct *tsk, unsigned int state);

/* normally declared in linux/smp.h, included by sched.h */
int on_each_cpu(void (*func) (void *info), void *info, int wait);
#define get_cpu() 0
#define put_cpu()
#define smp_processor_id() 0

/* normally defined in asm/current.h, included by sched.h */
extern struct task_struct *current;

void yield(void);

extern signed long schedule_timeout_uninterruptible(signed long timeout);

extern u64 local_clock(void);
extern bool need_resched(void);
extern int signal_pending_state(long state, struct task_struct *p);

struct pid;
extern struct pid *task_pid(struct task_struct *task);

void  cond_resched(void);

void set_current_state(int);
long io_schedule_timeout(long);

struct sched_param {
	int sched_priority;
};

#define SCHED_FIFO 1

int sched_setscheduler_nocheck(struct task_struct *, int, const struct sched_param *);

/************************
 ** linux/completion.h **
 ************************/

#include <lx_emul/completion.h>

struct completion {
	unsigned done;
	void * task;
};

long __wait_completion(struct completion *work, unsigned long);

/*********************
 ** linux/raid/pq.h **
 *********************/

void cpu_relax(void); /* i915_dma.c */
#define cpu_relax_lowlatency() cpu_relax()


/*************************
 ** linux/bottom_half.h **
 *************************/

void local_bh_disable(void);
void local_bh_enable(void);


/*****************
 ** linux/panic **
 *****************/

enum lockdep_ok { LOCKDEP_STILL_OK };
void add_taint(unsigned, enum lockdep_ok);


/*******************
 ** linux/delay.h **
 *******************/

void msleep(unsigned int);
void udelay(unsigned long);
void mdelay(unsigned long);
void ndelay(unsigned long);

void usleep_range(unsigned long min, unsigned long max); /* intel_dp.c */


/*************************
 ** linux/scatterlist.h **
 *************************/

struct scatterlist;

#include <lx_emul/kobject.h>

enum kobject_action {
	KOBJ_CHANGE,
};

int kobject_uevent_env(struct kobject *kobj, enum kobject_action action, char *envp[]);


/************************
 ** asm/memory_model.h **
 ************************/

dma_addr_t page_to_pfn(struct page *page);
struct page * pfn_to_page(dma_addr_t);


/*********************
 ** linux/pagemap.h **
 *********************/

#define page_cache_release(page) put_page(page)

struct address_space {
	unsigned long flags;
	struct page * my_page;
};

gfp_t mapping_gfp_mask(struct address_space * mapping);
void mapping_set_gfp_mask(struct address_space *m, gfp_t mask);

gfp_t mapping_gfp_constraint(struct address_space *mapping, gfp_t gfp_mask);


/******************
 ** linux/swap.h **
 ******************/

void mark_page_accessed(struct page *);


/***************************
 ** linux/pgtable_types.h **
 ***************************/

typedef unsigned long   pgprotval_t;
struct pgprot { pgprotval_t pgprot; };
typedef struct pgprot pgprot_t;

#define PAGE_KERNEL    ((pgprot_t) {0}) /* XXX */
#define PAGE_KERNEL_IO ((pgprot_t) {1}) /* XXX */

extern pgprot_t pgprot_writecombine(pgprot_t prot);
extern pgprot_t pgprot_decrypted(pgprot_t prot);


/*********************
 ** linux/kthread.h **
 *********************/

void kthread_parkme(void);
int kthread_park(struct task_struct *);
void kthread_unpark(struct task_struct *);
bool kthread_should_park(void);
bool kthread_should_stop(void);
int kthread_stop(struct task_struct *k);

struct task_struct *kthread_create_on_node(int (*threadfn)(void *data),
					   void *data,
					   int node,
					   const char namefmt[], ...);

/********************
 ** linux/mmzone.h **
 ********************/

#define MAX_ORDER 11

/**********************
 ** linux/mm_types.h **
 **********************/

struct vm_operations_struct;

struct vm_area_struct {
	unsigned long                      vm_start;
	unsigned long                      vm_end;
	pgprot_t                           vm_page_prot;
	unsigned long                      vm_flags;
	const struct vm_operations_struct *vm_ops;
	unsigned long                      vm_pgoff;
	void                               *vm_private_data;
};

struct mm_struct { struct rw_semaphore mmap_sem; };


/**********************
 ** linux/shrinker.h **
 **********************/

struct shrinker { int DUMMY; };

/****************
 ** linux/mm.h **
 ****************/

enum {
	VM_FAULT_OOM    = 0x001,
	VM_FAULT_SIGBUS = 0x002,
	VM_FAULT_NOPAGE = 0x100,
	VM_PFNMAP       = 0x00000400,
	VM_IO           = 0x00004000,
	VM_DONTEXPAND   = 0x00040000,
	VM_NORESERVE    = 0x00200000,
	VM_DONTDUMP     = 0x04000000,
};

enum { FAULT_FLAG_WRITE = 0x1 };

enum { DEFAULT_SEEKS = 2 };

#define PAGE_ALIGN(addr) ALIGN(addr, PAGE_SIZE)

#define offset_in_page(p) ((unsigned long)(p) & ~PAGE_MASK)

struct vm_fault {
	struct vm_area_struct *vma;
	unsigned int flags;
	unsigned long address;
};

int set_page_dirty(struct page *page);

void get_page(struct page *page);
void put_page(struct page *page);

extern unsigned long totalram_pages;


struct vm_area_struct;

struct vm_operations_struct {
	void (*open)(struct vm_area_struct * area);
	void (*close)(struct vm_area_struct * area);
	int (*fault)(struct vm_fault *vmf);
};

struct file;

extern unsigned long vm_mmap(struct file *, unsigned long,
                             unsigned long, unsigned long,
                             unsigned long, unsigned long);

static inline void *page_address(struct page *page) { return page ? page->addr : 0; };

int is_vmalloc_addr(const void *x);

void free_pages(unsigned long addr, unsigned int order);

extern void kvfree(const void *addr);

extern struct page * nth_page(struct page * page, int n);

extern struct vm_area_struct *find_vma(struct mm_struct *mm, unsigned long addr);

pgprot_t vm_get_page_prot(unsigned long vm_flags);

void *kvmalloc(size_t, gfp_t);
void *kvmalloc_array(size_t, size_t, gfp_t);

void unmap_mapping_range(struct address_space *, loff_t const, loff_t const, int);

unsigned long vma_pages(struct vm_area_struct *);

#include <asm/agp.h>


/***************
 ** asm/smp.h **
 ***************/

static inline void wbinvd() { }
static inline int wbinvd_on_all_cpus() { return 0; }


/**********************************
 ** x86/include/asm/set_memory.h **
 **********************************/

int set_memory_wb(unsigned long addr, int numpages);
int set_memory_uc(unsigned long addr, int numpages);
int set_pages_array_uc(struct page **pages, int addrinarray);

/*********************
 ** linux/vmalloc.h **
 *********************/

/* needed by agp/backend.c */
void *vzalloc(unsigned long size);
void vfree(const void *addr);


/************************
 ** uapi/linux/const.h **
 ************************/

#define _AT(T,X) ((T)(X))


/*************************************************
 ** asm/pgtable_64_types.h, asm/pgtable_types.h **
 *************************************************/

typedef unsigned long pteval_t;


#define _PAGE_BIT_PRESENT	0	/* is present */
#define _PAGE_BIT_RW		1	/* writeable */
#define _PAGE_BIT_PWT		3	/* page write through */
#define _PAGE_BIT_PCD		4	/* page cache disabled */
#define _PAGE_BIT_PAT		7	/* on 4KB pages */

#define _PAGE_PRESENT	(_AT(pteval_t, 1) << _PAGE_BIT_PRESENT)
#define _PAGE_RW	(_AT(pteval_t, 1) << _PAGE_BIT_RW)
#define _PAGE_PWT	(_AT(pteval_t, 1) << _PAGE_BIT_PWT)
#define _PAGE_PCD	(_AT(pteval_t, 1) << _PAGE_BIT_PCD)
#define _PAGE_PAT	(_AT(pteval_t, 1) << _PAGE_BIT_PAT)


/**********************
 ** asm/cacheflush.h **
 **********************/

int set_pages_wb(struct page *page, int numpages);
int set_pages_uc(struct page *page, int numpages);


/******************
 ** linux/slab.h **
 ******************/

enum {
	SLAB_HWCACHE_ALIGN   = 0x00002000ul,
	SLAB_RECLAIM_ACCOUNT = 0x00020000ul,
	SLAB_PANIC           = 0x00040000ul,
	SLAB_TYPESAFE_BY_RCU = 0x00080000ul,
};

void *kzalloc(size_t size, gfp_t flags);
void kfree(const void *);
void *kcalloc(size_t n, size_t size, gfp_t flags);
void *kmalloc(size_t size, gfp_t flags);
void *krealloc(const void *, size_t, gfp_t);
void *kmalloc_array(size_t n, size_t size, gfp_t flags);

struct kmem_cache;
struct kmem_cache *kmem_cache_create(const char *, size_t, size_t, unsigned long, void (*)(void *));
void kmem_cache_destroy(struct kmem_cache *);
void *kmem_cache_zalloc(struct kmem_cache *k, gfp_t flags);
void  kmem_cache_free(struct kmem_cache *, void *);

#define KMEM_CACHE(__struct, __flags) kmem_cache_create(#__struct,\
		sizeof(struct __struct), __alignof__(struct __struct),\
		(__flags), NULL)

void  *kmem_cache_alloc(struct kmem_cache *, gfp_t);


/**********************
 ** linux/kmemleak.h **
 **********************/

#ifndef CONFIG_DEBUG_KMEMLEAK
static inline void kmemleak_update_trace(const void *ptr) { }
static inline void kmemleak_alloc(const void *ptr, size_t size, int min_count,
                                  gfp_t gfp) { }
static inline void kmemleak_free(const void *ptr) { }
#endif

/**********************
 ** linux/byteorder/ **
 **********************/

#include <lx_emul/byteorder.h>


/******************
 ** linux/swab.h **
 ******************/

#define swab16 __swab16


/**********************
 ** linux/highmem.h  **
 **********************/

static inline void *kmap(struct page *page) { return page_address(page); }
static inline void *kmap_atomic(struct page *page) { return kmap(page); }
static inline void  kunmap(struct page *page) { return; }
static inline void  kunmap_atomic(void *addr) { return; }
struct page *kmap_to_page(void *);


#include <lx_emul/gfp.h>

void __free_pages(struct page *page, unsigned int order);

#define __free_page(page) __free_pages((page), 0)

struct page *alloc_pages(gfp_t gfp_mask, unsigned int order);

#define alloc_page(gfp_mask) alloc_pages(gfp_mask, 0)

unsigned long __get_free_pages(gfp_t gfp_mask, unsigned int order);

static inline void flush_kernel_dcache_page(struct page *page) { }

/*************************
 ** linux/percpu-defs.h **
 *************************/

#define DECLARE_PER_CPU(type, name) \
	extern typeof(type) name

#define DEFINE_PER_CPU(type, name) \
	typeof(type) name

#define this_cpu_xchg(pcp, nval) \
({									\
	typeof(pcp) before = pcp; \
	pcp = nval; \
	before; \
})

#define this_cpu_ptr(ptr) ptr
#define this_cpu_read(val) val
#define per_cpu(var, cpu) var

#define this_cpu_cmpxchg(pcp, oval, nval) \
	cmpxchg(&pcp, oval, nval)


#define cpuhp_setup_state_nocalls(a, b, c, d) 0

/******************
 ** linux/gfp.h  **
 ******************/

#define __GFP_BITS_SHIFT (25 + IS_ENABLED(CONFIG_LOCKDEP))
#define __GFP_BITS_MASK ((__force gfp_t)((1 << __GFP_BITS_SHIFT) - 1))

static inline bool gfpflags_allow_blocking(const gfp_t gfp_flags)
{
	return !!(gfp_flags & __GFP_DIRECT_RECLAIM);
}

unsigned long __get_free_pages(gfp_t gfp_mask, unsigned int order);

#define __get_free_page(gfp_mask) \
		__get_free_pages((gfp_mask), 0)

void free_pages(unsigned long addr, unsigned int order);
#define free_page(addr) free_pages((addr), 0)

/**************************************
 ** asm-generic/dma-mapping-common.h **
 **************************************/

struct dma_attrs;
struct device;

enum dma_data_direction { DMA_DATA_DIRECTION_DUMMY };

int dma_map_sg_attrs(struct device *dev, struct scatterlist *sg,
                     int nents, enum dma_data_direction dir,
                     struct dma_attrs *attrs);

#define dma_map_sg(d, s, n, r) dma_map_sg_attrs(d, s, n, r, NULL)


void dma_unmap_sg_attrs(struct device *dev, struct scatterlist *sg,
                        int nents, enum dma_data_direction dir,
                        struct dma_attrs *attrs);

#define dma_unmap_sg(d, s, n, r) dma_unmap_sg_attrs(d, s, n, r, NULL)

extern dma_addr_t dma_map_page(struct device *dev, struct page *page,
                               unsigned long offset, size_t size,
                               enum dma_data_direction direction);
extern void dma_unmap_page(struct device *dev, dma_addr_t dma_address,
                           size_t size, enum dma_data_direction direction);

extern int dma_mapping_error(struct device *dev, dma_addr_t dma_addr);


/*********************
 ** linux/dma-buf.h **
 *********************/

struct dma_buf;
void dma_buf_put(struct dma_buf *);


/********************
 ** linux/pm_qos.h **
 ********************/

enum { PM_QOS_CPU_DMA_LATENCY, };

struct pm_qos_request { int dummy; };

void pm_qos_remove_request(struct pm_qos_request *req);
void pm_qos_update_request(struct pm_qos_request *req, s32 new_value);
void pm_qos_add_request(struct pm_qos_request *req, int pm_qos_class, s32 value);


#define PM_QOS_DEFAULT_VALUE -1


/***********************
 ** linux/pm_wakeup.h **
 ***********************/

bool device_can_wakeup(struct device *dev);
int device_init_wakeup(struct device *dev, bool val);


/*******************
 ** linux/sysfs.h **
 *******************/

struct attribute { int dummy; };

struct attribute_group {
	struct attribute	**attrs;
};

#define __ATTRIBUTE_GROUPS(_name)                               \
	static const struct attribute_group *_name##_groups[] = {   \
		&_name##_group,                                         \
		NULL,                                                   \
	}

#define ATTRIBUTE_GROUPS(_name)                                 \
	static const struct attribute_group _name##_group = {       \
		.attrs = _name##_attrs,                                 \
	};                                                          \
__ATTRIBUTE_GROUPS(_name)

int sysfs_create_link(struct kobject *kobj, struct kobject *target, const char *name);
void sysfs_remove_link(struct kobject *kobj, const char *name);


/****************
 ** linux/pm.h **
 ****************/

#include <lx_emul/pm.h>

enum {
	PM_EVENT_QUIESCE = 0x0008,
	PM_EVENT_PRETHAW = PM_EVENT_QUIESCE,
};

struct dev_pm_domain;

#define SET_RUNTIME_PM_OPS(suspend_fn, resume_fn, idle_fn)
#define DPM_FLAG_NEVER_SKIP	BIT(0)

enum rpm_status {
	RPM_ACTIVE = 0,
	RPM_RESUMING,
	RPM_SUSPENDED,
	RPM_SUSPENDING,
};


/***********************
 ** linux/pm_domain.h **
 ***********************/

static inline int dev_pm_domain_attach(struct device *dev, bool power_on) {
	return -ENODEV; }
static inline void dev_pm_domain_detach(struct device *dev, bool power_off) {}

/********************
 ** linux/device.h **
 ********************/

struct device_driver;
struct subsys_private;

struct bus_type
{
	const char *name;

	int (*match)(struct device *dev, struct device_driver *drv);
	int (*probe)(struct device *dev);
	int (*remove)(struct device *dev);
	void (*shutdown)(struct device *dev);
	int (*suspend)(struct device *dev, pm_message_t state);
	int (*resume)(struct device *dev);

	const struct dev_pm_ops *pm;
	struct subsys_private *p;
};

struct device_type
{
	const struct attribute_group **groups;
	int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
	void (*release)(struct device *dev);
};

struct dev_archdata
{
	struct dma_map_ops *dma_ops;
};

struct fwnode_handle { int dummy; };

struct device {
	struct device            *parent;
	struct kobject            kobj;
	u64                       _dma_mask_buf;
	u64                      *dma_mask;
	u64                       coherent_dma_mask;
	struct device_driver     *driver;
	void                     *drvdata;  /* not in Linux */
	const struct device_type *type;
	void                     *platform_data;
	struct dev_pm_info        power;
	struct dev_archdata       archdata;
	struct bus_type          *bus;
	struct device_node       *of_node;
	struct fwnode_handle     *fwnode;
};

struct device_attribute {
	struct attribute attr;
};

struct lock_class_key { int dummy; };

#define DEVICE_ATTR(_name, _mode, _show, _store) \
	struct device_attribute dev_attr_##_name = { { 0 } }

#define DEVICE_ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store) \
	struct device_attribute dev_attr_##_name = { { 0 } }

#define dev_info(  dev, format, arg...) lx_printf("dev_info: "   format , ## arg)
#define dev_warn(  dev, format, arg...) lx_printf("dev_warn: "   format , ## arg)
#define dev_WARN(  dev, format, arg...) lx_printf("dev_WARN: "   format , ## arg)
#define dev_err(   dev, format, arg...) lx_printf("dev_error: "  format , ## arg)
#define dev_notice(dev, format, arg...) lx_printf("dev_notice: " format , ## arg)
#define dev_crit(  dev, format, arg...) lx_printf("dev_crit: "   format , ## arg)

#define dev_printk(level, dev, format, arg...) \
	lx_printf("dev_printk: " format , ## arg)
#define dev_dbg(dev, format, arg...) \
	lx_printf("dev_dbg: " format, ## arg)

#define dev_err_ratelimited(dev, fmt, ...)                              \
	dev_err(dev, fmt, ##__VA_ARGS__)

struct device_driver
{
	int dummy;
	char const      *name;
	struct bus_type *bus;
	struct module   *owner;
	const struct of_device_id*of_match_table;
	const struct acpi_device_id *acpi_match_table;
	const struct dev_pm_ops *pm;
};

int driver_register(struct device_driver *drv);
void driver_unregister(struct device_driver *drv);

void *dev_get_drvdata(const struct device *dev);
int dev_set_drvdata(struct device *dev, void *data);
int dev_set_name(struct device *dev, const char *name, ...);

int bus_register(struct bus_type *bus);
void bus_unregister(struct bus_type *bus);

struct device *get_device(struct device *dev);
void put_device(struct device *dev);

int device_for_each_child(struct device *dev, void *data, int (*fn)(struct device *dev, void *data));
int device_register(struct device *dev);
void device_unregister(struct device *dev);

const char *dev_name(const struct device *dev);

int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
                     void *data, int (*fn)(struct device_driver *, void *));

int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data,
                     int (*fn)(struct device *dev, void *data));

void dev_pm_set_driver_flags(struct device *, u32);

/* needed by linux/i2c.h */
struct acpi_device;

struct acpi_dev_node { struct acpi_device *companion; };


/*********************
 ** acpi/acpi_bus.h **
 *********************/

typedef char acpi_bus_id[8];
typedef char acpi_device_class[20];

struct acpi_bus_event {
	struct list_head node;
	acpi_device_class device_class;
	acpi_bus_id bus_id;
	u32 type;
	u32 data;
};


/****************
 ** linux/io.h **
 ****************/

enum {
	MEMREMAP_WB = 1 << 0,
};

#define writel(value, addr) (*(volatile uint32_t *)(addr) = (value))
#define readl(addr)         (*(volatile uint32_t *)(addr))

#define writel_relaxed(v, a) writel(v, a)
#define iowrite32(v, addr)	writel((v), (addr))
#define ioread32(addr)		readl(addr)

void outb(u8  value, u32 port);
void outw(u16 value, u32 port);
void outl(u32 value, u32 port);

u8  inb(u32 port);
u16 inw(u32 port);
u32 inl(u32 port);

void  iounmap(volatile void *addr);

void __iomem *ioremap(phys_addr_t offset, unsigned long size);

#define mmiowb() barrier()

/**
 * Map I/O memory write combined
 */
void *ioremap_wc(resource_size_t phys_addr, unsigned long size);

#define ioremap_nocache ioremap_wc

int arch_phys_wc_add(unsigned long base, unsigned long size);
static inline void arch_phys_wc_del(int handle) { }

phys_addr_t virt_to_phys(volatile void *address);

void memset_io(void *s, int c, size_t n);
void memcpy_toio(volatile void __iomem *dst, const void *src, size_t count);
void memcpy_fromio(void *dst, const volatile void __iomem *src, size_t count);


/**************************************
 ** arch/x86/include/asm/string_64.h **
 **************************************/

#ifdef __x86_64__
static inline void *memset64(uint64_t *s, uint64_t v, size_t n)
{
	long d0, d1;
	asm volatile("rep\n\t"
		     "stosq"
		     : "=&c" (d0), "=&D" (d1)
		     : "a" (v), "1" (s), "0" (n)
		     : "memory");
	return s;
}
#else
static inline void *memset64(uint64_t *s, uint64_t v, size_t count)
{
	uint64_t *xs = s;

	while (count--)
		*xs++ = v;
	return s;
}
#endif


/*********************
 ** linux/uaccess.h **
 *********************/

enum { VERIFY_READ = 0, VERIFY_WRITE = 1 };

#define get_user(x, ptr) ({  (x)   = *(ptr); 0; })
#define put_user(x, ptr) ({ *(ptr) =  (x);   0; })

bool access_ok(int access, void *addr, size_t size);

size_t copy_from_user(void *to, void const *from, size_t len);
size_t copy_to_user(void *dst, void const *src, size_t len);

#define __copy_from_user                  copy_from_user
#define __copy_to_user                    copy_to_user
#define __copy_from_user_inatomic         copy_from_user
#define __copy_to_user_inatomic           copy_to_user
#define __copy_from_user_inatomic_nocache copy_from_user

void pagefault_disable(void);
void pagefault_enable(void);

/*************************
 ** linux/dma-mapping.h **
 *************************/

#define DMA_BIT_MASK(n) (((n) == 64) ? ~0ULL : ((1ULL<<(n))-1))

int dma_set_coherent_mask(struct device *dev, u64 mask);


/************************
 ** linux/io-mapping.h **
 ************************/

#define pgprot_noncached(prot) prot

#include <lx_emul/mmio.h>


/********************
 ** linux/random.h **
 ********************/

unsigned int get_random_int(void);
unsigned long get_random_long(void);


/********************
 ** linux/ioport.h **
 ********************/

#include <lx_emul/ioport.h>

extern struct resource iomem_resource;

int request_resource(struct resource *root, struct resource *); /* intel-gtt.c */

int release_resource(struct resource *r);  /* i915_dma.c */

unsigned long resource_type(const struct resource *);

#define IORESOURCE_ROM_SHADOW (1<<1)
#define IORESOURCE_BITS 0x000000ff

/*****************
 ** linux/pci.h **
 *****************/

enum {
	PCI_STD_RESOURCE_END = 5,
	PCI_ROM_RESOURCE,
	PCI_NUM_RESOURCES,
	DEVICE_COUNT_RESOURCE = PCI_NUM_RESOURCES,
};

struct pci_dev {
	unsigned int devfn;
	unsigned int irq;
	struct resource resource[DEVICE_COUNT_RESOURCE];
	struct pci_bus *bus; /* i915_dma.c */
	unsigned short vendor;  /* intel-agp.c */
	unsigned short device;
	u8 hdr_type;
	bool msi_enabled;
	struct device dev; /* intel-agp.c */
	unsigned short subsystem_vendor; /* intel_display.c */
	unsigned short subsystem_device;
	u8 revision; /* i915_gem.c */
	u8 pcie_cap;
	u16 pcie_flags_reg;
	unsigned int class;
};

struct pci_device_id {
	u32 vendor, device, subvendor, subdevice, class, class_mask;
	unsigned long driver_data;
};

#include <lx_emul/pci.h>

struct pci_dev *pci_get_bus_and_slot(unsigned int bus, unsigned int devfn);
int pci_bus_alloc_resource(struct pci_bus *bus,
                           struct resource *res, resource_size_t size,
                           resource_size_t align, resource_size_t min,
                           unsigned int type_mask,
                           resource_size_t (*alignf)(void *,
                                                     const struct resource *,
                                                     resource_size_t,
                                                     resource_size_t),
                           void *alignf_data);
resource_size_t pcibios_align_resource(void *, const struct resource *,
                                       resource_size_t,
                                       resource_size_t);
int pci_set_power_state(struct pci_dev *dev, pci_power_t state);
struct pci_dev *pci_get_class(unsigned int device_class, struct pci_dev *from);
int pci_save_state(struct pci_dev *dev);

enum { PCIBIOS_MIN_MEM = 0UL };


static inline void pci_set_drvdata(struct pci_dev *pdev, void *data)
{
	pdev->dev.drvdata = data;
}

static inline int pci_set_dma_mask(struct pci_dev *dev, u64 mask)
{
	*dev->dev.dma_mask = mask;
	return 0;
}

static inline int pci_set_consistent_dma_mask(struct pci_dev *dev, u64 mask)
{
	dev->dev.coherent_dma_mask = mask;
	return 0;
}

/* agp/generic.c */
#define for_each_pci_dev(d) while ((d = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, d)) != NULL)

static inline dma_addr_t pci_bus_address(struct pci_dev *pdev, int bar)
{
	lx_printf("pci_bus_address called\n");
	return (dma_addr_t)pci_resource_start(pdev, bar);
}

struct pci_dev *pci_dev_get(struct pci_dev *dev);

void __iomem __must_check *pci_map_rom(struct pci_dev *pdev, size_t *size);
void pci_unmap_rom(struct pci_dev *pdev, void __iomem *rom);


/**********************************
 ** asm-generic/pci-dma-compat.h **
 **********************************/

void pci_unmap_page(struct pci_dev *hwdev, dma_addr_t dma_address, size_t size, int direction);

dma_addr_t pci_map_page(struct pci_dev *hwdev, struct page *page, unsigned long offset, size_t size, int direction);

int pci_dma_mapping_error(struct pci_dev *pdev, dma_addr_t dma_addr);

int pci_map_sg(struct pci_dev *hwdev, struct scatterlist *sg, int nents, int direction);
void pci_unmap_sg(struct pci_dev *hwdev, struct scatterlist *sg, int nents, int direction);


/*****************************
 ** asm-generic/pci_iomap.h **
 *****************************/

void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long max);
void pci_iounmap(struct pci_dev *dev, void __iomem *p);


/***********************
 ** linux/irqreturn.h **
 ***********************/

#include <lx_emul/irq.h>

/********************
 ** linux/of_irq.h **
 ********************/

extern int of_irq_get(struct device_node *dev, int index);
extern int of_irq_get_byname(struct device_node *dev, const char *name);
struct irq_data *irq_get_irq_data(unsigned int);


/**********************
 ** linux/irq_work.h **
 **********************/

struct irq_work { int DUMMY; };
bool irq_work_queue(struct irq_work *work);
void init_irq_work(struct irq_work *work, void (*func)(struct irq_work *));

/*********************
 ** linux/hardirq.h **
 *********************/

extern void synchronize_irq(unsigned int irq);

/*****************
 ** linux/irq.h **
 *****************/

#include <linux/irqhandler.h>

struct irq_chip { int DUMMY; };
void irqd_set_trigger_type(struct irq_data *, u32);
void irq_set_chip_and_handler(unsigned int, struct irq_chip *,
                              irq_flow_handler_t);
void handle_simple_irq(struct irq_desc *);
extern struct irq_chip dummy_irq_chip;

/************************
 ** linux/capability.h **
 ************************/

#define CAP_SYS_ADMIN 21
#define CAP_SYS_NICE  23

bool capable(int);


/*************************
 ** linux/agp_backend.h **
 *************************/

#include <linux/agp_backend.h>


/********************
 ** linux/vgaarb.h **
 ********************/

/*
 * needed for compiling i915_dma.c
 */

enum {
	VGA_RSRC_LEGACY_IO  = 0x01,
	VGA_RSRC_LEGACY_MEM = 0x02,
	VGA_RSRC_NORMAL_IO  = 0x04,
	VGA_RSRC_NORMAL_MEM = 0x08,
};

int vga_client_register(struct pci_dev *pdev, void *cookie,
		void (*irq_set_state)(void *cookie, bool state),
		unsigned int (*set_vga_decode)(void *cookie, bool state));

int vga_get_uninterruptible(struct pci_dev *pdev, unsigned int rsrc);

void vga_put(struct pci_dev *pdev, unsigned int rsrc);


/**********************
 ** linux/notifier.h **
 **********************/

/* needed by intel_lvds.c */

struct notifier_block;

typedef int (*notifier_fn_t)(struct notifier_block *nb, unsigned long action, void *data);

struct notifier_block { notifier_fn_t notifier_call; };

enum {
	NOTIFY_DONE      = 0x0000,
	NOTIFY_OK        = 0x0001,
	NOTIFY_STOP_MASK = 0x8000,
	NOTIFY_BAD       = (NOTIFY_STOP_MASK|0x0002),
};

struct atomic_notifier_head { unsigned dummy; };

extern int atomic_notifier_chain_unregister(struct atomic_notifier_head *nh, struct notifier_block *nb);
extern int atomic_notifier_chain_register(struct atomic_notifier_head *nh, struct notifier_block *nb);

#define ATOMIC_INIT_NOTIFIER_HEAD(name) do { } while (0)

int atomic_notifier_call_chain(struct atomic_notifier_head *nh,
                               unsigned long val, void *v);

/*******************
 ** acpi/button.h **
 *******************/

int acpi_lid_open(void);
int acpi_lid_notifier_register(struct notifier_block *nb);
int acpi_lid_notifier_unregister(struct notifier_block *nb);


/*********************
 ** linux/console.h **
 *********************/

static inline bool vgacon_text_force(void) { return false; }


/******************
 ** acpi/video.h **
 ******************/

#define ACPI_VIDEO_CLASS "video"

int acpi_video_register(void);
void acpi_video_unregister(void);

enum acpi_backlight_type {
	acpi_backlight_native = 3,
};
enum acpi_backlight_type acpi_video_get_backlight_type(void);


/******************
 ** acpi/video.h **
 ******************/

int register_acpi_notifier(struct notifier_block *);
int unregister_acpi_notifier(struct notifier_block *);


/**********************
 ** linux/memremap.h **
 **********************/

void *memremap(resource_size_t offset, size_t size, unsigned long flags);
void memunmap(void *addr);


/*****************
 ** asm/ioctl.h **
 *****************/

#include <asm-generic/ioctl.h>


/****************
 ** linux/fs.h **
 ****************/

struct inode {
	const struct inode_operations *i_op;
	struct address_space *i_mapping;
};

struct file
{
	atomic_long_t         f_count;
	struct inode         *f_inode;
	struct address_space *f_mapping;
	void                 *private_data;
};

struct poll_table_struct;
typedef struct poll_table_struct poll_table;

struct inode;
struct inode_operations { void (*truncate) (struct inode *); };

/* i915_drv.c */
struct file_operations {
	struct module *owner;
	loff_t (*llseek) (struct file *, loff_t, int);
	ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
	unsigned int (*poll) (struct file *, struct poll_table_struct *);
	long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
	int (*mmap) (struct file *, struct vm_area_struct *);
	long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
	int (*open) (struct inode *, struct file *);
	int (*release) (struct inode *, struct file *);
};

enum { PROT_READ  = 0x1, PROT_WRITE = 0x2 };

enum { MAP_SHARED = 0x1 };

loff_t noop_llseek(struct file *file, loff_t offset, int whence);

struct inode *file_inode(struct file *f);

unsigned long invalidate_mapping_pages(struct address_space *mapping,
		pgoff_t start, pgoff_t end);

int pagecache_write_begin(struct file *, struct address_space *, loff_t,
                          unsigned, unsigned, struct page **, void **);
int pagecache_write_end(struct file *, struct address_space *, loff_t,
                        unsigned, unsigned, struct page *, void *);


/******************************
 ** include/asm/set_memory.h **
 ******************************/

int set_pages_array_wc(struct page **, int);
int set_pages_array_wb(struct page **, int);


/**************************
 ** linux/stop_machine.h **
 **************************/
struct cpumask;

typedef int (*cpu_stop_fn_t)(void *arg);

int stop_machine(cpu_stop_fn_t, void *, const struct cpumask *);


/*****
 *
 */
struct rcu_head { int dummy; };

void clflush(volatile void *);
void clflushopt(volatile void *);


/*********************
 ** linux/vmalloc.h **
 *********************/

void vunmap(const void *);
void *vmap(struct page **, unsigned int, unsigned long, pgprot_t);


/*********************
 ** linux/seqlock.h **
 *********************/

typedef unsigned seqlock_t;

typedef struct seqcount {
	unsigned DUMMY;
} seqcount_t;

void seqlock_init (seqlock_t *);
unsigned __read_seqcount_begin(const seqcount_t *);
int __read_seqcount_retry(const seqcount_t *, unsigned);
unsigned raw_read_seqcount(const seqcount_t *);
int read_seqcount_retry(const seqcount_t *, unsigned);
void write_seqlock(seqlock_t *);
void write_sequnlock(seqlock_t *);
unsigned read_seqbegin(const seqlock_t *);
unsigned read_seqretry(const seqlock_t *, unsigned);

/*************************
 ** linux/reservation.h **
 *************************/

struct reservation_object_list {
	u32 shared_count;
	struct dma_fence *shared[];
};

struct reservation_object {
	seqcount_t seq;
	struct dma_fence *fence_excl;
	struct reservation_object_list *fence;
};
struct ww_acquire_ctx;
int reservation_object_lock(struct reservation_object *, struct ww_acquire_ctx *);
void reservation_object_unlock(struct reservation_object *);
struct dma_fence * reservation_object_get_excl_rcu(struct reservation_object *);
int reservation_object_get_fences_rcu(struct reservation_object *,
                                      struct dma_fence **, unsigned *,
                                      struct dma_fence ***);
bool reservation_object_trylock(struct reservation_object *);
void reservation_object_add_excl_fence(struct reservation_object *, struct dma_fence *);
void reservation_object_init(struct reservation_object *);
void reservation_object_fini(struct reservation_object *);
bool reservation_object_test_signaled_rcu(struct reservation_object *, bool);


/*******************
 * linux/swiotlb.h *
 *******************/

unsigned int swiotlb_max_segment(void);


/****************
 * linux/uuid.h *
 ****************/

#define	UUID_STRING_LEN 36


/**********************
 ** linux/shmem_fs.h **
 **********************/

extern void shmem_truncate_range(struct inode *inode, loff_t start, loff_t end);

extern struct page *shmem_read_mapping_page_gfp(struct address_space *mapping,
		pgoff_t index, gfp_t gfp_mask);
extern struct page *shmem_read_mapping_page( struct address_space *mapping, pgoff_t index);
struct file *shmem_file_setup(const char *, loff_t, unsigned long);
struct vfsmount;
struct file *shmem_file_setup_with_mnt(struct vfsmount *, const char *, loff_t, unsigned long);

/*****************************
 ** linux/mod_devicetable.h **
 *****************************/

enum dmi_field {
	DMI_SYS_VENDOR,
	DMI_PRODUCT_NAME,
	DMI_PRODUCT_VERSION,
	DMI_BOARD_VENDOR,
	DMI_BOARD_NAME,
};

struct dmi_strmatch {
	unsigned char slot:7;
	unsigned char exact_match:1;
	char substr[79];
};

struct dmi_system_id {
	int (*callback)(const struct dmi_system_id *);
	const char *ident;
	struct dmi_strmatch matches[4];
	void *driver_data;
};

extern int dmi_check_system(const struct dmi_system_id *list);

#define DMI_MATCH(a, b)       { .slot = a, .substr = b }
#define DMI_EXACT_MATCH(a, b) { .slot = a, .substr = b, .exact_match = 1 }

#define I2C_MODULE_PREFIX "i2c:"
#define I2C_NAME_SIZE 20

struct i2c_device_id {
	char name[I2C_NAME_SIZE];
	kernel_ulong_t driver_data;	/* Data private to the driver */
};

/*********************
 ** asm/processor.h **
 *********************/

struct boot_cpu_data {
	unsigned x86_clflush_size;
};

extern struct boot_cpu_data boot_cpu_data;


/***********************
 ** linux/backlight.h **
 ***********************/

enum backlight_type {
	BACKLIGHT_RAW = 1,
	BACKLIGHT_PLATFORM,
	BACKLIGHT_FIRMWARE,
	BACKLIGHT_TYPE_MAX,
};

struct backlight_properties {
	int brightness;
	int max_brightness;
	int power;
	enum backlight_type type;
};

struct backlight_device {
	struct backlight_properties props;
	const struct backlight_ops * ops;
	struct intel_connector *connector;
};

static inline struct intel_connector* bl_get_data(struct backlight_device *bl_dev)
{
	if (bl_dev)
		return bl_dev->connector;
	return NULL;
}

struct fb_info;
struct backlight_ops {
	unsigned int options;
	int (*update_status)(struct backlight_device *);
	int (*get_brightness)(struct backlight_device *);
	int (*check_fb)(struct backlight_device *, struct fb_info *);
};

extern struct backlight_device *backlight_device_register(const char *name,
		struct device *dev, void *devdata, const struct backlight_ops *ops,
		const struct backlight_properties *props);
extern void backlight_device_unregister(struct backlight_device *bd);

/*****************
 ** linux/i2c.h **
 *****************/

struct i2c_adapter;
struct i2c_msg;

enum i2c_slave_event { DUMMY };


/***********************
 ** linux/i2c-smbus.h **
 ***********************/

struct i2c_smbus_alert_setup;


/****************
 ** linux/of.h **
 ****************/

int of_alias_get_id(struct device_node *np, const char *stem);
void of_node_put(struct device_node *);
int of_property_match_string(const struct device_node *, const char *,
                             const char *);
int of_property_read_u32_index(const struct device_node *, const char *, u32,
                               u32 *);


/***********************
 ** linux/of_device.h **
 ***********************/

int of_driver_match_device(struct device *dev, const struct device_driver *drv);


/******************
 ** linux/acpi.h **
 ******************/

struct kobject_uevent_env;

bool acpi_driver_match_device(struct device *dev, const struct device_driver *drv);
int acpi_device_uevent_modalias(struct device *, struct kobj_uevent_env *);

int acpi_dev_pm_attach(struct device *dev, bool power_on);
void acpi_dev_pm_detach(struct device *dev, bool power_off);

int acpi_device_modalias(struct device *, char *, int);

#define ACPI_COMPANION(dev)		(NULL)
#define ACPI_COMPANION_SET(dev, adev)	do { } while (0)

const char *acpi_dev_name(struct acpi_device *adev);
int acpi_dev_gpio_irq_get(struct acpi_device *adev, int index);
void acpi_device_clear_enumerated(struct acpi_device *);
int acpi_reconfig_notifier_register(struct notifier_block *);
int acpi_reconfig_notifier_unregister(struct notifier_block *);

/******************
 ** linux/gpio.h **
 ******************/

/* make these flag values available regardless of GPIO kconfig options */
#define GPIOF_DIR_OUT	(0 << 0)
#define GPIOF_DIR_IN	(1 << 0)

#define GPIOF_INIT_LOW	(0 << 1)
#define GPIOF_INIT_HIGH	(1 << 1)

#define GPIOF_IN		(GPIOF_DIR_IN)
#define GPIOF_OUT_INIT_HIGH	(GPIOF_DIR_OUT | GPIOF_INIT_HIGH)

#define GPIOF_OPEN_DRAIN	(1 << 3)

/* needed by drivers/gpu/drm/drm_modes.c */
#include <linux/list_sort.h>

/*********************
 ** linux/cpufreq.h **
 *********************/

struct cpufreq_cpuinfo {
	unsigned int max_freq;
	unsigned int min_freq;
};

struct cpufreq_policy {
	struct cpufreq_cpuinfo cpuinfo;
};

struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu);
void cpufreq_cpu_put(struct cpufreq_policy *policy);


/********************************
 ** arch/x86/include/asm/tsc.h **
 ********************************/

extern unsigned int tsc_khz;


/**************************************
 ** drivers/platform/x86/intel_ips.h **
 **************************************/

void ips_link_to_i915_driver(void);


/**************************************
 ** drivers/gpu/drm/i915/intel_drv.h **
 **************************************/

struct drm_device;


/******************
 ** linux/kgdb.h **
 ******************/

#define in_dbg_master() (0)


/*************************
 ** asm-generic/div64.h **
 *************************/

#define do_div(n,base) ({ \
		unsigned long __base = (base); \
		unsigned long __rem; \
		__rem = ((uint64_t)(n)) % __base; \
		(n)   = ((uint64_t)(n)) / __base; \
		__rem; \
		})


/**************************************
 ** definitions needed by intel_pm.c **
 **************************************/

void trace_intel_gpu_freq_change(int);


/****************
 ** linux/fb.h **
 ****************/

#include <uapi/linux/fb.h>

enum {
	FBINFO_STATE_RUNNING = 0,
	FBINFO_STATE_SUSPENDED = 1,
	FBINFO_CAN_FORCE_OUTPUT = 0x200000,
	FBINFO_DEFAULT = 0,
};

extern int fb_get_options(const char *name, char **option);

struct aperture {
	resource_size_t base;
	resource_size_t size;
};

struct apertures_struct {
	unsigned int count;
	struct aperture ranges[0];
};

static inline struct apertures_struct *alloc_apertures(unsigned int max_num) {
	void * p = kzalloc(sizeof(struct apertures_struct) + max_num *
	                   sizeof(struct aperture), GFP_KERNEL);
	struct apertures_struct *a = (struct apertures_struct *)p;
	if (!a)
		return NULL;
	a->count = max_num;
	return a;
}

/*******************
 ** linux/sysrq.h **
 *******************/

struct sysrq_key_op { unsigned dummy; };

int register_sysrq_key(int key, struct sysrq_key_op *op);
int unregister_sysrq_key(int key, struct sysrq_key_op *op);


/*******************
 ** linux/sysrq.h **
 *******************/

struct fence;
void fence_put(struct fence *fence);
signed long fence_wait(struct fence *fence, bool intr);


/*******************
 ** drm/drm_pci.h **
 *******************/

struct drm_dma_handle *drm_pci_alloc(struct drm_device *, size_t, size_t);


/****************************
 ** drm/drm_modeset_lock.h **
 ****************************/

#include <video/videomode.h>

//extern struct ww_class crtc_ww_class;

void ww_mutex_init(struct ww_mutex *lock, struct ww_class *ww_class);
bool ww_mutex_is_locked(struct ww_mutex *lock);
int  ww_mutex_trylock(struct ww_mutex *lock);
void ww_acquire_fini(struct ww_acquire_ctx *ctx);
void ww_acquire_init(struct ww_acquire_ctx *ctx, struct ww_class *ww_class);
int  ww_mutex_lock_slow_interruptible(struct ww_mutex *lock, struct ww_acquire_ctx *ctx);
void ww_mutex_unlock(struct ww_mutex *lock);
int  ww_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ctx);
void ww_mutex_lock_slow(struct ww_mutex *lock, struct ww_acquire_ctx *ctx);
int  ww_mutex_lock_interruptible(struct ww_mutex *lock, struct ww_acquire_ctx *ctx);


struct drm_crtc;


/************************
 ** linux/jump_label.h **
 ************************/

struct static_key { int dummy; };

#define STATIC_KEY_INIT_TRUE { .dummy = 0 }
#define STATIC_KEY_INIT_FALSE { .dummy = 0 }

extern void static_key_slow_inc(struct static_key *key);
extern void static_key_slow_dec(struct static_key *key);
extern bool static_key_false(struct static_key *key);


/**********************
 ** linux/seq_file.h **
 **********************/

struct seq_file { unsigned dummy; };

void seq_printf(struct seq_file *m, const char *fmt, ...);
void seq_puts(struct seq_file *m, const char *s);


/**********************
 ** linux/hastable.h **
 **********************/

/* needed by intel_ringbuffer */
#define DECLARE_HASHTABLE(name, bits)


/**************************
 ** linux/clk/clk-conf.h **
 **************************/

static inline int of_clk_set_defaults(struct device_node *node, bool clk_supplier) {
	return 0; }


/****************
 ** linux/of.h **
 ****************/

enum {
	OF_DYNAMIC       = 1,
	OF_DETACHED      = 2,
	OF_POPULATED     = 3,
	OF_POPULATED_BUS = 4,
};

void of_node_clear_flag(struct device_node *n, unsigned long flag);
extern int of_alias_get_highest_id(const char *stem);
static inline int of_reconfig_notifier_register(struct notifier_block *nb) {
	return -EINVAL; }
static inline int of_reconfig_notifier_unregister(struct notifier_block *nb) {
	return -EINVAL; }


/**********************
 ** linux/refcount.h **
 **********************/

bool refcount_dec_and_test(atomic_t *);


/*********************
 ** drm/drm_lease.h **
 *********************/

struct drm_file;
bool drm_lease_held(struct drm_file *, int);
bool _drm_lease_held(struct drm_file *, int);
uint32_t drm_lease_filter_crtcs(struct drm_file *, uint32_t);


/********************
 ** linux/time64.h **
 ********************/

typedef __s64 time64_t;
struct timespec64 {
	time64_t tv_sec;  /* seconds */
	long     tv_nsec; /* nanoseconds */
};


/********************
 ** linux/rwlock.h **
 ********************/

typedef unsigned long rwlock_t;

void rwlock_init(rwlock_t *);
void read_lock(rwlock_t *);
void read_unlock(rwlock_t *);
void write_lock(rwlock_t *);
void write_unlock(rwlock_t *);


/************************
 ** linux/tracepoint.h **
 ************************/

#define EXPORT_TRACEPOINT_SYMBOL(name)

void tracepoint_synchronize_unregister(void);


/*******************
 ** linux/async.h **
 *******************/

typedef u64 async_cookie_t;
typedef void (*async_func_t) (void *data, async_cookie_t cookie);

extern async_cookie_t async_schedule(async_func_t func, void *data);
extern void async_synchronize_full(void);

/*******************
 ** linux/ktime.h **
 *******************/

#define ktime_to_ns(kt) kt

ktime_t ktime_get_raw(void);
u64 ktime_get_raw_ns(void);
extern struct timespec64 ns_to_timespec64(const s64 nsec);
#define ktime_to_timespec64(kt)		ns_to_timespec64((kt))
#define ktime_sub_ns(kt, nsval)		((kt) - (nsval))

#define ktime_sub(lhs, rhs) (lhs - rhs)

static inline s64 ktime_to_us(const ktime_t kt) {
	return kt / NSEC_PER_USEC; }

static inline s64 ktime_to_ms(const ktime_t kt) {
	return kt / NSEC_PER_MSEC; }

/*****************
 ** linux/pid.h **
 *****************/

enum pid_type { PIDTYPE_PID };

struct pid { atomic_t count; };

static inline struct pid *get_pid(struct pid *pid)
{
	if (pid)
		atomic_inc(&pid->count);
	return pid;
}
extern void put_pid(struct pid *pid);
struct pid *get_task_pid(struct task_struct *, enum pid_type);

typedef int pid_t;
pid_t pid_nr(struct pid *);


/***********************
 ** include/lockdep.h **
 ***********************/

#define MAX_LOCKDEP_SUBCLASSES 8UL
#define SINGLE_DEPTH_NESTING 1

#define lockdep_assert_held(l) do { (void)(l); } while (0)
#define lockdep_set_class_and_name(lock, key, name) \
	do { (void)(key); (void)(name); } while (0)


/**************************************
 ** arch/x86/include/asm/cpufeature* **
 **************************************/

#define cpu_has_pat 1
bool static_cpu_has(long);
bool boot_cpu_has(long);
#define X86_FEATURE_PAT			( 0*32+16) /* Page Attribute Table */
#define X86_FEATURE_CLFLUSH		( 0*32+19) /* CLFLUSH instruction */


/********************
 ** linux/bitmap.h **
 ********************/

extern void bitmap_set(unsigned long *map, unsigned int start, int len);
extern void bitmap_zero(unsigned long *dst, unsigned int nbits);
extern void bitmap_or(unsigned long *dst, const unsigned long *src1,
		const unsigned long *src2, unsigned int nbits);
void bitmap_clear(unsigned long *, unsigned int, unsigned int);

#define BITMAP_LAST_WORD_MASK(nbits) (~0UL >> (-(nbits) & (BITS_PER_LONG - 1)))

#define small_const_nbits(nbits) \
	(__builtin_constant_p(nbits) && (nbits) <= BITS_PER_LONG)

static inline int bitmap_empty(const unsigned long *src, unsigned nbits)
{
	if (small_const_nbits(nbits))
		return ! (*src & BITMAP_LAST_WORD_MASK(nbits));

	return find_first_bit(src, nbits) == nbits;
}

static inline int bitmap_full(const unsigned long *src, unsigned int nbits)
{
	if (small_const_nbits(nbits))
		return ! (~(*src) & BITMAP_LAST_WORD_MASK(nbits));

	return find_first_zero_bit(src, nbits) == nbits;
}

static inline void bitmap_fill(unsigned long *dst, unsigned int nbits)
{
	unsigned int nlongs = BITS_TO_LONGS(nbits);
	if (!small_const_nbits(nbits)) {
		unsigned int len = (nlongs - 1) * sizeof(unsigned long);
		memset(dst, 0xff,  len);
	}
	dst[nlongs - 1] = BITMAP_LAST_WORD_MASK(nbits);
}


/************************************
 ** include/asm-generic/int-ll64.h **
 ************************************/

#define U64_C(x) x ## ULL


/********************
 ** linux/reboot.h **
 ********************/

#define SYS_RESTART 0x0001

extern int register_reboot_notifier(struct notifier_block *);
extern int unregister_reboot_notifier(struct notifier_block *);


/*****************
 ** linux/err.h **
 *****************/

int PTR_ERR_OR_ZERO(__force const void *ptr);


/*********************
 ** linux/preempt.h **
 *********************/

#define in_interrupt() 1
bool preemptible();


/***********************
 ** linux/interrupt.h **
 ***********************/

enum {
	TASKLET_STATE_SCHED,
};

#define IRQF_SHARED 0x00000080

int request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags, const char *name, void *dev);
void free_irq(unsigned int, void *);


/*****************
 ** linux/pwm.h **
 *****************/

struct pwm_device { int dummy; };
unsigned int pwm_get_duty_cycle(const struct pwm_device *pwm);
int pwm_config(struct pwm_device *pwm, int duty_ns, int period_ns);
int pwm_enable(struct pwm_device *pwm);
void pwm_disable(struct pwm_device *pwm);
struct pwm_device *pwm_get(struct device *dev, const char *con_id);
void pwm_put(struct pwm_device *);
void pwm_apply_args(struct pwm_device *);


/********************
 * linux/property.h *
 ********************/

struct property_entry;
struct property_entry * property_entries_dup(const struct property_entry *);
int device_add_properties(struct device *, const struct property_entry *);
void device_remove_properties(struct device *);
int device_property_read_u32_array(struct device *, const char *, u32 *,
                                   size_t);
int device_property_read_u32(struct device *, const char *, u32 *);


/**********************
 ** linux/rcupdate.h **
 **********************/

#define kfree_rcu(ptr, offset) kfree(ptr)

#define rcu_access_pointer(p) p
#define rcu_assign_pointer(p, v) p = v
#define rcu_dereference(p) p
#define rcu_dereference_protected(p, c) p
#define rcu_dereference_raw(p) p
#define rcu_pointer_handoff(p) (p)

void rcu_read_lock(void);
void rcu_read_unlock(void);

void rcu_barrier(void);
void synchronize_rcu(void);
void call_rcu(struct rcu_head *, void (*)(struct rcu_head *));

#define RCU_INIT_POINTER(p, v) do { p = (typeof(*v) *)v; } while (0)

/************************
 ** drm/drm_os_linux.h **
 ************************/

#define DRM_WAIT_ON( ret, queue, timeout, condition )       \
	do {                                                    \
		DECLARE_WAITQUEUE(entry, current);                  \
		unsigned long end = jiffies + (timeout);            \
		add_wait_queue(&(queue), &entry);                   \
		                                                    \
		for (;;) {                                          \
			__set_current_state(TASK_INTERRUPTIBLE);        \
			if (condition)                                  \
			break;                                          \
			if (time_after_eq(jiffies, end)) {              \
				ret = -EBUSY;                               \
				break;                                      \
			}                                               \
			schedule_timeout((HZ/100 > 1) ? HZ/100 : 1);    \
			if (signal_pending(current)) {                  \
				ret = -EINTR;                               \
				break;                                      \
			}                                               \
		}                                                   \
		__set_current_state(TASK_RUNNING);                  \
		remove_wait_queue(&(queue), &entry);                \
	} while (0)


/************************
 ** linux/perf_event.h **
 ************************/

struct pmu { unsigned dummy; };

/*************************
 ** drm/drm_fb_helper.h **
 *************************/

struct drm_connector;
struct drm_fb_helper { unsigned dummy; };

int drm_fb_helper_remove_conflicting_framebuffers(struct apertures_struct *,
                                                  const char *, bool);
int drm_fb_helper_add_one_connector(struct drm_fb_helper *fb_helper,
                                    struct drm_connector *connector);
int drm_fb_helper_remove_one_connector(struct drm_fb_helper *fb_helper,
                                       struct drm_connector *connector);
void drm_fb_helper_set_suspend_unlocked(struct drm_fb_helper *fb_helper,
                                        bool suspend);

/********************
 ** drm/drm_file.h **
 ********************/

struct drm_file;


/**********************
 ** drm/drm_atomic.h **
 **********************/

struct drm_atomic_state;


/*********************
 ** drm/drm_sysfs.h **
 *********************/
void drm_sysfs_hotplug_event(struct drm_device *);


/*******************
 ** drm/drm_drv.h **
 *******************/

void drm_printk(const char *, unsigned int, const char *, ...);

/* XXX */
void put_unused_fd(unsigned int);
void fd_install(unsigned int, struct file *);
void fput(struct file *);
enum { O_CLOEXEC = 0xbadaffe };
int get_unused_fd_flags(unsigned);


/***********************
 ** linux/irqdomain.h **
 ***********************/

typedef unsigned long irq_hw_number_t;

struct irq_domain;
struct irq_domain_ops {
	int (*map)(struct irq_domain *, unsigned int, irq_hw_number_t);
};

unsigned int irq_find_mapping(struct irq_domain *, irq_hw_number_t);
unsigned int irq_create_mapping(struct irq_domain *, irq_hw_number_t);
void irq_dispose_mapping(unsigned int);
void irq_domain_remove(struct irq_domain *);

struct irq_domain *irq_domain_create_linear(struct fwnode_handle *,
                                            unsigned int,
                                            const struct irq_domain_ops *,
                                            void *);


/*********************
 ** linux/irqdesc.h **
 *********************/

int generic_handle_irq(unsigned int);


/*******************
 ** Configuration **
 *******************/

#define CONFIG_AGP                             1
#define CONFIG_AGP_INTEL                       1
#define CONFIG_BACKLIGHT_CLASS_DEVICE          1
#define CONFIG_DRM_I915                        1
#define CONFIG_DRM_I915_DEBUG                  0
#define CONFIG_DRM_I915_DEBUG_GEM              0
#define CONFIG_DRM_I915_PRELIMINARY_HW_SUPPORT 1
#define CONFIG_EXTRA_FIRMWARE                 ""
#define CONFIG_I2C                             1
#define CONFIG_I2C_BOARDINFO                   1
#define CONFIG_OF_DYNAMIC                      0
#define CONFIG_PCI                             1
#define CONFIG_BASE_SMALL                      0
#define CONFIG_DRM_LOAD_EDID_FIRMWARE          0
#define CONFIG_ARCH_HAS_SG_CHAIN               1
#define CONFIG_X86                             1


/**************************
 ** Dummy trace funtions **
 **************************/

/* normally provided by i915_trace.h */

#define trace_drm_vblank_event_delivered(...)
#define trace_drm_vblank_event_queued(...)
#define trace_drm_vblank_event(...)

#define trace_i915_context_free(...)
#define trace_i915_context_create(...)
#define trace_i915_gem_object_pread(...)
#define trace_i915_gem_object_pwrite(...)
#define trace_i915_gem_request_wait_begin(...)
#define trace_i915_gem_request_wait_end(...)
#define trace_i915_gem_object_fault(...)
#define trace_i915_gem_request_add(...)
#define trace_i915_gem_request_retire(...)
#define trace_i915_gem_ring_sync_to(...)
#define trace_i915_gem_object_change_domain(...)
#define trace_i915_vma_unbind(...)
#define trace_i915_vma_bind(...)
#define trace_i915_gem_object_clflush(...)
#define trace_i915_gem_object_create(...)
#define trace_i915_gem_object_destroy(...)
#define trace_i915_flip_complete(...)
#define trace_i915_flip_request(...)
#define trace_i915_reg_rw(...)
#define trace_i915_gem_request_complete(...)
#define trace_i915_gem_ring_flush(...)
#define trace_i915_page_table_entry_alloc(...)
#define trace_i915_page_directory_entry_alloc(...)
#define trace_i915_page_directory_pointer_entry_alloc(...)
#define trace_i915_page_table_entry_map(...)
#define trace_i915_pipe_update_end(...)
#define trace_i915_pipe_update_start(...)
#define trace_i915_pipe_update_vblank_evaded(...)
#define trace_i915_ppgtt_create(...)
#define trace_i915_ppgtt_release(...)
#define trace_i915_va_alloc(...)
#define trace_i915_gem_request_notify(...)

#define trace_i2c_read(...)
#define trace_i2c_write(...)
#define trace_i2c_reply(...)
#define trace_i2c_result(...)

#define trace_smbus_read(...)
#define trace_smbus_write(...)
#define trace_smbus_reply(...)
#define trace_smbus_result(...)

#define trace_switch_mm(...)

#define trace_intel_disable_plane(...)     while (0) { }
#define trace_intel_engine_notify(...)     while (0) { }
#define trace_intel_update_plane(...)      while (0) { }
#define trace_intel_cpu_fifo_underrun(...) while (0) { }
#define trace_intel_pch_fifo_underrun(...) while (0) { }

#define trace_intel_memory_cxsr(...)       while (0) { }
#define trace_vlv_wm(...)                  while (0) { }
#define trace_g4x_wm(...)                  while (0) { }
#define trace_vlv_fifo_size(...)           while (0) { }
#define trace_i915_gem_request_in(...)     while (0) { }
#define trace_i915_gem_request_out(...)    while (0) { }
#define trace_dma_fence_enable_signal(...) while (0) { }
#define trace_i915_gem_request_execute(...) while (0) { }
#define trace_i915_gem_request_submit(...)  while (0) { }

#define trace_dma_fence_init(...)           while (0) { }
#define trace_dma_fence_signaled(...)       while (0) { }
#define trace_dma_fence_destroy(...)        while (0) { }
#define trace_dma_fence_wait_start(...)     while (0) { }
#define trace_dma_fence_wait_end(...)       while (0) { }


/*********************
 ** linux/stringify **
 *********************/

#define __stringify(x...) #x


/******************
 ** linux/wait.h **
 ******************/

void __add_wait_queue_entry_tail(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry);
void __init_waitqueue_head(struct wait_queue_head *wq_head, const char *name, struct lock_class_key *);


/*******************
 ** linux/cache.h **
 *******************/
unsigned cache_line_size();


/***********************
 ** linux/interrupt.h **
 ***********************/

struct tasklet_struct
{
	unsigned long state;
	void (*func)(unsigned long);
	unsigned long data;
};

void tasklet_schedule(struct tasklet_struct *);
void tasklet_hi_schedule(struct tasklet_struct *);
void tasklet_kill(struct tasklet_struct *);
void tasklet_init(struct tasklet_struct *, void (*)(unsigned long), unsigned long);
void tasklet_enable(struct tasklet_struct *);
void tasklet_disable(struct tasklet_struct *);

void enable_irq(unsigned int);
void disable_irq(unsigned int);

#include <linux/math64.h>

#include <lx_emul/extern_c_end.h>

#endif /* _LX_EMUL_H_ */
