/* * \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 #include #include /***************** ** asm/param.h ** *****************/ enum { HZ = 100UL }; #define DEBUG_LINUX_PRINTK 0 #include #include #include #include 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 #include 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 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 #include /* needed by 'virt_to_phys', which is needed by agp/generic.c */ typedef unsigned long phys_addr_t; #include void *memchr_inv(const void *s, int c, size_t n); /********************** ** linux/compiler.h ** **********************/ #include #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 #include #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 #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 #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 #include #include 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 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 #define del_singleshot_timer_sync(t) del_timer_sync(t) void timer_setup(struct timer_list *, void (*func)(struct timer_list *), unsigned int); #include 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 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 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/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 /****************** ** 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 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 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 /******************** ** linux/random.h ** ********************/ unsigned int get_random_int(void); unsigned long get_random_long(void); /******************** ** linux/ioport.h ** ********************/ #include 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 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 /******************** ** 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 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/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 /**************** ** 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/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 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