/drivers/include/linux/asm/atomic.h |
---|
1,318 → 1,5 |
#ifndef _ASM_X86_ATOMIC_H |
#define _ASM_X86_ATOMIC_H |
#include <linux/compiler.h> |
#include <linux/types.h> |
//#include <asm/processor.h> |
//#include <asm/alternative.h> |
#include <asm/cmpxchg.h> |
/* |
* Atomic operations that C can't guarantee us. Useful for |
* resource counting etc.. |
*/ |
#define ATOMIC_INIT(i) { (i) } |
/** |
* atomic_read - read atomic variable |
* @v: pointer of type atomic_t |
* |
* Atomically reads the value of @v. |
*/ |
static inline int atomic_read(const atomic_t *v) |
{ |
return (*(volatile int *)&(v)->counter); |
} |
/** |
* atomic_set - set atomic variable |
* @v: pointer of type atomic_t |
* @i: required value |
* |
* Atomically sets the value of @v to @i. |
*/ |
static inline void atomic_set(atomic_t *v, int i) |
{ |
v->counter = i; |
} |
/** |
* atomic_add - add integer to atomic variable |
* @i: integer value to add |
* @v: pointer of type atomic_t |
* |
* Atomically adds @i to @v. |
*/ |
static inline void atomic_add(int i, atomic_t *v) |
{ |
asm volatile(LOCK_PREFIX "addl %1,%0" |
: "+m" (v->counter) |
: "ir" (i)); |
} |
/** |
* atomic_sub - subtract integer from atomic variable |
* @i: integer value to subtract |
* @v: pointer of type atomic_t |
* |
* Atomically subtracts @i from @v. |
*/ |
static inline void atomic_sub(int i, atomic_t *v) |
{ |
asm volatile(LOCK_PREFIX "subl %1,%0" |
: "+m" (v->counter) |
: "ir" (i)); |
} |
/** |
* atomic_sub_and_test - subtract value from variable and test result |
* @i: integer value to subtract |
* @v: pointer of type atomic_t |
* |
* Atomically subtracts @i from @v and returns |
* true if the result is zero, or false for all |
* other cases. |
*/ |
static inline int atomic_sub_and_test(int i, atomic_t *v) |
{ |
unsigned char c; |
asm volatile(LOCK_PREFIX "subl %2,%0; sete %1" |
: "+m" (v->counter), "=qm" (c) |
: "ir" (i) : "memory"); |
return c; |
} |
/** |
* atomic_inc - increment atomic variable |
* @v: pointer of type atomic_t |
* |
* Atomically increments @v by 1. |
*/ |
static inline void atomic_inc(atomic_t *v) |
{ |
asm volatile(LOCK_PREFIX "incl %0" |
: "+m" (v->counter)); |
} |
/** |
* atomic_dec - decrement atomic variable |
* @v: pointer of type atomic_t |
* |
* Atomically decrements @v by 1. |
*/ |
static inline void atomic_dec(atomic_t *v) |
{ |
asm volatile(LOCK_PREFIX "decl %0" |
: "+m" (v->counter)); |
} |
/** |
* atomic_dec_and_test - decrement and test |
* @v: pointer of type atomic_t |
* |
* Atomically decrements @v by 1 and |
* returns true if the result is 0, or false for all other |
* cases. |
*/ |
static inline int atomic_dec_and_test(atomic_t *v) |
{ |
unsigned char c; |
asm volatile(LOCK_PREFIX "decl %0; sete %1" |
: "+m" (v->counter), "=qm" (c) |
: : "memory"); |
return c != 0; |
} |
/** |
* atomic_inc_and_test - increment and test |
* @v: pointer of type atomic_t |
* |
* Atomically increments @v by 1 |
* and returns true if the result is zero, or false for all |
* other cases. |
*/ |
static inline int atomic_inc_and_test(atomic_t *v) |
{ |
unsigned char c; |
asm volatile(LOCK_PREFIX "incl %0; sete %1" |
: "+m" (v->counter), "=qm" (c) |
: : "memory"); |
return c != 0; |
} |
/** |
* atomic_add_negative - add and test if negative |
* @i: integer value to add |
* @v: pointer of type atomic_t |
* |
* Atomically adds @i to @v and returns true |
* if the result is negative, or false when |
* result is greater than or equal to zero. |
*/ |
static inline int atomic_add_negative(int i, atomic_t *v) |
{ |
unsigned char c; |
asm volatile(LOCK_PREFIX "addl %2,%0; sets %1" |
: "+m" (v->counter), "=qm" (c) |
: "ir" (i) : "memory"); |
return c; |
} |
/** |
* atomic_add_return - add integer and return |
* @i: integer value to add |
* @v: pointer of type atomic_t |
* |
* Atomically adds @i to @v and returns @i + @v |
*/ |
static inline int atomic_add_return(int i, atomic_t *v) |
{ |
int __i; |
#ifdef CONFIG_M386 |
unsigned long flags; |
if (unlikely(boot_cpu_data.x86 <= 3)) |
goto no_xadd; |
#ifdef CONFIG_X86_32 |
# include "atomic_32.h" |
#else |
# include "atomic_64.h" |
#endif |
/* Modern 486+ processor */ |
__i = i; |
asm volatile(LOCK_PREFIX "xaddl %0, %1" |
: "+r" (i), "+m" (v->counter) |
: : "memory"); |
return i + __i; |
#ifdef CONFIG_M386 |
no_xadd: /* Legacy 386 processor */ |
raw_local_irq_save(flags); |
__i = atomic_read(v); |
atomic_set(v, i + __i); |
raw_local_irq_restore(flags); |
return i + __i; |
#endif |
} |
/** |
* atomic_sub_return - subtract integer and return |
* @v: pointer of type atomic_t |
* @i: integer value to subtract |
* |
* Atomically subtracts @i from @v and returns @v - @i |
*/ |
static inline int atomic_sub_return(int i, atomic_t *v) |
{ |
return atomic_add_return(-i, v); |
} |
#define atomic_inc_return(v) (atomic_add_return(1, v)) |
#define atomic_dec_return(v) (atomic_sub_return(1, v)) |
static inline int atomic_cmpxchg(atomic_t *v, int old, int new) |
{ |
return cmpxchg(&v->counter, old, new); |
} |
static inline int atomic_xchg(atomic_t *v, int new) |
{ |
return xchg(&v->counter, new); |
} |
/** |
* atomic_add_unless - add unless the number is already a given value |
* @v: pointer of type atomic_t |
* @a: the amount to add to v... |
* @u: ...unless v is equal to u. |
* |
* Atomically adds @a to @v, so long as @v was not already @u. |
* Returns non-zero if @v was not @u, and zero otherwise. |
*/ |
static inline int atomic_add_unless(atomic_t *v, int a, int u) |
{ |
int c, old; |
c = atomic_read(v); |
for (;;) { |
if (unlikely(c == (u))) |
break; |
old = atomic_cmpxchg((v), c, c + (a)); |
if (likely(old == c)) |
break; |
c = old; |
} |
return c != (u); |
} |
#define atomic_inc_not_zero(v) atomic_add_unless((v), 1, 0) |
/* |
* atomic_dec_if_positive - decrement by 1 if old value positive |
* @v: pointer of type atomic_t |
* |
* The function returns the old value of *v minus 1, even if |
* the atomic variable, v, was not decremented. |
*/ |
static inline int atomic_dec_if_positive(atomic_t *v) |
{ |
int c, old, dec; |
c = atomic_read(v); |
for (;;) { |
dec = c - 1; |
if (unlikely(dec < 0)) |
break; |
old = atomic_cmpxchg((v), c, dec); |
if (likely(old == c)) |
break; |
c = old; |
} |
return dec; |
} |
/** |
* atomic_inc_short - increment of a short integer |
* @v: pointer to type int |
* |
* Atomically adds 1 to @v |
* Returns the new value of @u |
*/ |
static inline short int atomic_inc_short(short int *v) |
{ |
asm(LOCK_PREFIX "addw $1, %0" : "+m" (*v)); |
return *v; |
} |
#ifdef CONFIG_X86_64 |
/** |
* atomic_or_long - OR of two long integers |
* @v1: pointer to type unsigned long |
* @v2: pointer to type unsigned long |
* |
* Atomically ORs @v1 and @v2 |
* Returns the result of the OR |
*/ |
static inline void atomic_or_long(unsigned long *v1, unsigned long v2) |
{ |
asm(LOCK_PREFIX "orq %1, %0" : "+m" (*v1) : "r" (v2)); |
} |
#endif |
/* These are x86-specific, used by some header files */ |
#define atomic_clear_mask(mask, addr) \ |
asm volatile(LOCK_PREFIX "andl %0,%1" \ |
: : "r" (~(mask)), "m" (*(addr)) : "memory") |
#define atomic_set_mask(mask, addr) \ |
asm volatile(LOCK_PREFIX "orl %0,%1" \ |
: : "r" ((unsigned)(mask)), "m" (*(addr)) \ |
: "memory") |
/* Atomic operations are already serializing on x86 */ |
#define smp_mb__before_atomic_dec() barrier() |
#define smp_mb__after_atomic_dec() barrier() |
#define smp_mb__before_atomic_inc() barrier() |
#define smp_mb__after_atomic_inc() barrier() |
//#include <asm-generic/atomic-long.h> |
#endif /* _ASM_X86_ATOMIC_H */ |
/drivers/include/linux/asm/atomic_32.h |
---|
0,0 → 1,415 |
#ifndef _ASM_X86_ATOMIC_32_H |
#define _ASM_X86_ATOMIC_32_H |
#include <linux/compiler.h> |
#include <linux/types.h> |
//#include <asm/processor.h> |
#include <asm/cmpxchg.h> |
/* |
* Atomic operations that C can't guarantee us. Useful for |
* resource counting etc.. |
*/ |
#define ATOMIC_INIT(i) { (i) } |
/** |
* atomic_read - read atomic variable |
* @v: pointer of type atomic_t |
* |
* Atomically reads the value of @v. |
*/ |
static inline int atomic_read(const atomic_t *v) |
{ |
return v->counter; |
} |
/** |
* atomic_set - set atomic variable |
* @v: pointer of type atomic_t |
* @i: required value |
* |
* Atomically sets the value of @v to @i. |
*/ |
static inline void atomic_set(atomic_t *v, int i) |
{ |
v->counter = i; |
} |
/** |
* atomic_add - add integer to atomic variable |
* @i: integer value to add |
* @v: pointer of type atomic_t |
* |
* Atomically adds @i to @v. |
*/ |
static inline void atomic_add(int i, atomic_t *v) |
{ |
asm volatile(LOCK_PREFIX "addl %1,%0" |
: "+m" (v->counter) |
: "ir" (i)); |
} |
/** |
* atomic_sub - subtract integer from atomic variable |
* @i: integer value to subtract |
* @v: pointer of type atomic_t |
* |
* Atomically subtracts @i from @v. |
*/ |
static inline void atomic_sub(int i, atomic_t *v) |
{ |
asm volatile(LOCK_PREFIX "subl %1,%0" |
: "+m" (v->counter) |
: "ir" (i)); |
} |
/** |
* atomic_sub_and_test - subtract value from variable and test result |
* @i: integer value to subtract |
* @v: pointer of type atomic_t |
* |
* Atomically subtracts @i from @v and returns |
* true if the result is zero, or false for all |
* other cases. |
*/ |
static inline int atomic_sub_and_test(int i, atomic_t *v) |
{ |
unsigned char c; |
asm volatile(LOCK_PREFIX "subl %2,%0; sete %1" |
: "+m" (v->counter), "=qm" (c) |
: "ir" (i) : "memory"); |
return c; |
} |
/** |
* atomic_inc - increment atomic variable |
* @v: pointer of type atomic_t |
* |
* Atomically increments @v by 1. |
*/ |
static inline void atomic_inc(atomic_t *v) |
{ |
asm volatile(LOCK_PREFIX "incl %0" |
: "+m" (v->counter)); |
} |
/** |
* atomic_dec - decrement atomic variable |
* @v: pointer of type atomic_t |
* |
* Atomically decrements @v by 1. |
*/ |
static inline void atomic_dec(atomic_t *v) |
{ |
asm volatile(LOCK_PREFIX "decl %0" |
: "+m" (v->counter)); |
} |
/** |
* atomic_dec_and_test - decrement and test |
* @v: pointer of type atomic_t |
* |
* Atomically decrements @v by 1 and |
* returns true if the result is 0, or false for all other |
* cases. |
*/ |
static inline int atomic_dec_and_test(atomic_t *v) |
{ |
unsigned char c; |
asm volatile(LOCK_PREFIX "decl %0; sete %1" |
: "+m" (v->counter), "=qm" (c) |
: : "memory"); |
return c != 0; |
} |
/** |
* atomic_inc_and_test - increment and test |
* @v: pointer of type atomic_t |
* |
* Atomically increments @v by 1 |
* and returns true if the result is zero, or false for all |
* other cases. |
*/ |
static inline int atomic_inc_and_test(atomic_t *v) |
{ |
unsigned char c; |
asm volatile(LOCK_PREFIX "incl %0; sete %1" |
: "+m" (v->counter), "=qm" (c) |
: : "memory"); |
return c != 0; |
} |
/** |
* atomic_add_negative - add and test if negative |
* @v: pointer of type atomic_t |
* @i: integer value to add |
* |
* Atomically adds @i to @v and returns true |
* if the result is negative, or false when |
* result is greater than or equal to zero. |
*/ |
static inline int atomic_add_negative(int i, atomic_t *v) |
{ |
unsigned char c; |
asm volatile(LOCK_PREFIX "addl %2,%0; sets %1" |
: "+m" (v->counter), "=qm" (c) |
: "ir" (i) : "memory"); |
return c; |
} |
/** |
* atomic_add_return - add integer and return |
* @v: pointer of type atomic_t |
* @i: integer value to add |
* |
* Atomically adds @i to @v and returns @i + @v |
*/ |
static inline int atomic_add_return(int i, atomic_t *v) |
{ |
int __i; |
#ifdef CONFIG_M386 |
unsigned long flags; |
if (unlikely(boot_cpu_data.x86 <= 3)) |
goto no_xadd; |
#endif |
/* Modern 486+ processor */ |
__i = i; |
asm volatile(LOCK_PREFIX "xaddl %0, %1" |
: "+r" (i), "+m" (v->counter) |
: : "memory"); |
return i + __i; |
#ifdef CONFIG_M386 |
no_xadd: /* Legacy 386 processor */ |
local_irq_save(flags); |
__i = atomic_read(v); |
atomic_set(v, i + __i); |
local_irq_restore(flags); |
return i + __i; |
#endif |
} |
/** |
* atomic_sub_return - subtract integer and return |
* @v: pointer of type atomic_t |
* @i: integer value to subtract |
* |
* Atomically subtracts @i from @v and returns @v - @i |
*/ |
static inline int atomic_sub_return(int i, atomic_t *v) |
{ |
return atomic_add_return(-i, v); |
} |
static inline int atomic_cmpxchg(atomic_t *v, int old, int new) |
{ |
return cmpxchg(&v->counter, old, new); |
} |
static inline int atomic_xchg(atomic_t *v, int new) |
{ |
return xchg(&v->counter, new); |
} |
/** |
* atomic_add_unless - add unless the number is already a given value |
* @v: pointer of type atomic_t |
* @a: the amount to add to v... |
* @u: ...unless v is equal to u. |
* |
* Atomically adds @a to @v, so long as @v was not already @u. |
* Returns non-zero if @v was not @u, and zero otherwise. |
*/ |
static inline int atomic_add_unless(atomic_t *v, int a, int u) |
{ |
int c, old; |
c = atomic_read(v); |
for (;;) { |
if (unlikely(c == (u))) |
break; |
old = atomic_cmpxchg((v), c, c + (a)); |
if (likely(old == c)) |
break; |
c = old; |
} |
return c != (u); |
} |
#define atomic_inc_not_zero(v) atomic_add_unless((v), 1, 0) |
#define atomic_inc_return(v) (atomic_add_return(1, v)) |
#define atomic_dec_return(v) (atomic_sub_return(1, v)) |
/* These are x86-specific, used by some header files */ |
#define atomic_clear_mask(mask, addr) \ |
asm volatile(LOCK_PREFIX "andl %0,%1" \ |
: : "r" (~(mask)), "m" (*(addr)) : "memory") |
#define atomic_set_mask(mask, addr) \ |
asm volatile(LOCK_PREFIX "orl %0,%1" \ |
: : "r" (mask), "m" (*(addr)) : "memory") |
/* Atomic operations are already serializing on x86 */ |
#define smp_mb__before_atomic_dec() barrier() |
#define smp_mb__after_atomic_dec() barrier() |
#define smp_mb__before_atomic_inc() barrier() |
#define smp_mb__after_atomic_inc() barrier() |
/* An 64bit atomic type */ |
typedef struct { |
u64 __aligned(8) counter; |
} atomic64_t; |
#define ATOMIC64_INIT(val) { (val) } |
extern u64 atomic64_cmpxchg(atomic64_t *ptr, u64 old_val, u64 new_val); |
/** |
* atomic64_xchg - xchg atomic64 variable |
* @ptr: pointer to type atomic64_t |
* @new_val: value to assign |
* |
* Atomically xchgs the value of @ptr to @new_val and returns |
* the old value. |
*/ |
extern u64 atomic64_xchg(atomic64_t *ptr, u64 new_val); |
/** |
* atomic64_set - set atomic64 variable |
* @ptr: pointer to type atomic64_t |
* @new_val: value to assign |
* |
* Atomically sets the value of @ptr to @new_val. |
*/ |
extern void atomic64_set(atomic64_t *ptr, u64 new_val); |
/** |
* atomic64_read - read atomic64 variable |
* @ptr: pointer to type atomic64_t |
* |
* Atomically reads the value of @ptr and returns it. |
*/ |
static inline u64 atomic64_read(atomic64_t *ptr) |
{ |
u64 res; |
/* |
* Note, we inline this atomic64_t primitive because |
* it only clobbers EAX/EDX and leaves the others |
* untouched. We also (somewhat subtly) rely on the |
* fact that cmpxchg8b returns the current 64-bit value |
* of the memory location we are touching: |
*/ |
asm volatile( |
"mov %%ebx, %%eax\n\t" |
"mov %%ecx, %%edx\n\t" |
LOCK_PREFIX "cmpxchg8b %1\n" |
: "=&A" (res) |
: "m" (*ptr) |
); |
return res; |
} |
extern u64 atomic64_read(atomic64_t *ptr); |
/** |
* atomic64_add_return - add and return |
* @delta: integer value to add |
* @ptr: pointer to type atomic64_t |
* |
* Atomically adds @delta to @ptr and returns @delta + *@ptr |
*/ |
extern u64 atomic64_add_return(u64 delta, atomic64_t *ptr); |
/* |
* Other variants with different arithmetic operators: |
*/ |
extern u64 atomic64_sub_return(u64 delta, atomic64_t *ptr); |
extern u64 atomic64_inc_return(atomic64_t *ptr); |
extern u64 atomic64_dec_return(atomic64_t *ptr); |
/** |
* atomic64_add - add integer to atomic64 variable |
* @delta: integer value to add |
* @ptr: pointer to type atomic64_t |
* |
* Atomically adds @delta to @ptr. |
*/ |
extern void atomic64_add(u64 delta, atomic64_t *ptr); |
/** |
* atomic64_sub - subtract the atomic64 variable |
* @delta: integer value to subtract |
* @ptr: pointer to type atomic64_t |
* |
* Atomically subtracts @delta from @ptr. |
*/ |
extern void atomic64_sub(u64 delta, atomic64_t *ptr); |
/** |
* atomic64_sub_and_test - subtract value from variable and test result |
* @delta: integer value to subtract |
* @ptr: pointer to type atomic64_t |
* |
* Atomically subtracts @delta from @ptr and returns |
* true if the result is zero, or false for all |
* other cases. |
*/ |
extern int atomic64_sub_and_test(u64 delta, atomic64_t *ptr); |
/** |
* atomic64_inc - increment atomic64 variable |
* @ptr: pointer to type atomic64_t |
* |
* Atomically increments @ptr by 1. |
*/ |
extern void atomic64_inc(atomic64_t *ptr); |
/** |
* atomic64_dec - decrement atomic64 variable |
* @ptr: pointer to type atomic64_t |
* |
* Atomically decrements @ptr by 1. |
*/ |
extern void atomic64_dec(atomic64_t *ptr); |
/** |
* atomic64_dec_and_test - decrement and test |
* @ptr: pointer to type atomic64_t |
* |
* Atomically decrements @ptr by 1 and |
* returns true if the result is 0, or false for all other |
* cases. |
*/ |
extern int atomic64_dec_and_test(atomic64_t *ptr); |
/** |
* atomic64_inc_and_test - increment and test |
* @ptr: pointer to type atomic64_t |
* |
* Atomically increments @ptr by 1 |
* and returns true if the result is zero, or false for all |
* other cases. |
*/ |
extern int atomic64_inc_and_test(atomic64_t *ptr); |
/** |
* atomic64_add_negative - add and test if negative |
* @delta: integer value to add |
* @ptr: pointer to type atomic64_t |
* |
* Atomically adds @delta to @ptr and returns true |
* if the result is negative, or false when |
* result is greater than or equal to zero. |
*/ |
extern int atomic64_add_negative(u64 delta, atomic64_t *ptr); |
#include <asm-generic/atomic-long.h> |
#endif /* _ASM_X86_ATOMIC_32_H */ |
/drivers/include/linux/bitmap.h |
---|
42,6 → 42,9 |
* bitmap_empty(src, nbits) Are all bits zero in *src? |
* bitmap_full(src, nbits) Are all bits set in *src? |
* bitmap_weight(src, nbits) Hamming Weight: number set bits |
* bitmap_set(dst, pos, nbits) Set specified bit area |
* bitmap_clear(dst, pos, nbits) Clear specified bit area |
* bitmap_find_next_zero_area(buf, len, pos, n, mask) Find bit free area |
* bitmap_shift_right(dst, src, n, nbits) *dst = *src >> n |
* bitmap_shift_left(dst, src, n, nbits) *dst = *src << n |
* bitmap_remap(dst, src, old, new, nbits) *dst = map(old, new)(src) |
108,6 → 111,14 |
const unsigned long *bitmap2, int bits); |
extern int __bitmap_weight(const unsigned long *bitmap, int bits); |
extern void bitmap_set(unsigned long *map, int i, int len); |
extern void bitmap_clear(unsigned long *map, int start, int nr); |
extern unsigned long bitmap_find_next_zero_area(unsigned long *map, |
unsigned long size, |
unsigned long start, |
unsigned int nr, |
unsigned long align_mask); |
extern int bitmap_scnprintf(char *buf, unsigned int len, |
const unsigned long *src, int nbits); |
extern int __bitmap_parse(const char *buf, unsigned int buflen, int is_user, |
/drivers/include/linux/bitops.h |
---|
1,12 → 1,20 |
#ifndef _LINUX_BITOPS_H |
#define _LINUX_BITOPS_H |
#include <asm/types.h> |
#ifdef __KERNEL__ |
#define BIT(nr) (1UL << (nr)) |
#define BIT_MASK(nr) (1UL << ((nr) % BITS_PER_LONG)) |
#define BIT_WORD(nr) ((nr) / BITS_PER_LONG) |
#define BITS_PER_BYTE 8 |
#define BITS_TO_LONGS(nr) DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long)) |
#endif |
extern unsigned int __sw_hweight8(unsigned int w); |
extern unsigned int __sw_hweight16(unsigned int w); |
extern unsigned int __sw_hweight32(unsigned int w); |
extern unsigned long __sw_hweight64(__u64 w); |
/* |
* Include this here because some architectures need generic_ffs/fls in |
* scope |
13,12 → 21,11 |
*/ |
#include <asm/bitops.h> |
#define for_each_bit(bit, addr, size) \ |
#define for_each_set_bit(bit, addr, size) \ |
for ((bit) = find_first_bit((addr), (size)); \ |
(bit) < (size); \ |
(bit) = find_next_bit((addr), (size), (bit) + 1)) |
static __inline__ int get_bitmask_order(unsigned int count) |
{ |
int order; |
129,29 → 136,7 |
} |
#ifdef __KERNEL__ |
#ifdef CONFIG_GENERIC_FIND_FIRST_BIT |
/** |
* find_first_bit - find the first set bit in a memory region |
* @addr: The address to start the search at |
* @size: The maximum size to search |
* |
* Returns the bit number of the first set bit. |
*/ |
extern unsigned long find_first_bit(const unsigned long *addr, |
unsigned long size); |
/** |
* find_first_zero_bit - find the first cleared bit in a memory region |
* @addr: The address to start the search at |
* @size: The maximum size to search |
* |
* Returns the bit number of the first cleared bit. |
*/ |
extern unsigned long find_first_zero_bit(const unsigned long *addr, |
unsigned long size); |
#endif /* CONFIG_GENERIC_FIND_FIRST_BIT */ |
#ifdef CONFIG_GENERIC_FIND_LAST_BIT |
/** |
* find_last_bit - find the last set bit in a memory region |
164,28 → 149,5 |
unsigned long size); |
#endif /* CONFIG_GENERIC_FIND_LAST_BIT */ |
#ifdef CONFIG_GENERIC_FIND_NEXT_BIT |
/** |
* find_next_bit - find the next set bit in a memory region |
* @addr: The address to base the search on |
* @offset: The bitnumber to start searching at |
* @size: The bitmap size in bits |
*/ |
extern unsigned long find_next_bit(const unsigned long *addr, |
unsigned long size, unsigned long offset); |
/** |
* find_next_zero_bit - find the next cleared bit in a memory region |
* @addr: The address to base the search on |
* @offset: The bitnumber to start searching at |
* @size: The bitmap size in bits |
*/ |
extern unsigned long find_next_zero_bit(const unsigned long *addr, |
unsigned long size, |
unsigned long offset); |
#endif /* CONFIG_GENERIC_FIND_NEXT_BIT */ |
#endif /* __KERNEL__ */ |
#endif |
/drivers/include/linux/compiler-gcc.h |
---|
35,8 → 35,7 |
(typeof(ptr)) (__ptr + (off)); }) |
/* &a[0] degrades to a pointer: a different type from an array */ |
#define __must_be_array(a) \ |
BUILD_BUG_ON_ZERO(__builtin_types_compatible_p(typeof(a), typeof(&a[0]))) |
#define __must_be_array(a) BUILD_BUG_ON_ZERO(__same_type((a), &(a)[0])) |
/* |
* Force always-inline if the user requests it so via the .config, |
58,8 → 57,12 |
* naked functions because then mcount is called without stack and frame pointer |
* being set up and there is no chance to restore the lr register to the value |
* before mcount was called. |
* |
* The asm() bodies of naked functions often depend on standard calling conventions, |
* therefore they must be noinline and noclone. GCC 4.[56] currently fail to enforce |
* this, so we must do so ourselves. See GCC PR44290. |
*/ |
#define __naked __attribute__((naked)) notrace |
#define __naked __attribute__((naked)) noinline __noclone notrace |
#define __noreturn __attribute__((noreturn)) |
85,3 → 88,7 |
#define _gcc_header(x) __gcc_header(linux/compiler-gcc##x.h) |
#define gcc_header(x) _gcc_header(x) |
#include gcc_header(__GNUC__) |
#if !defined(__noclone) |
#define __noclone /* not needed */ |
#endif |
/drivers/include/linux/compiler-gcc4.h |
---|
48,6 → 48,10 |
* unreleased. Really, we need to have autoconf for the kernel. |
*/ |
#define unreachable() __builtin_unreachable() |
/* Mark a function definition as prohibited from being cloned. */ |
#define __noclone __attribute__((__noclone__)) |
#endif |
#endif |
/drivers/include/linux/compiler.h |
---|
5,7 → 5,7 |
#ifdef __CHECKER__ |
# define __user __attribute__((noderef, address_space(1))) |
# define __kernel /* default address space */ |
# define __kernel __attribute__((address_space(0))) |
# define __safe __attribute__((safe)) |
# define __force __attribute__((force)) |
# define __nocast __attribute__((nocast)) |
15,6 → 15,12 |
# define __acquire(x) __context__(x,1) |
# define __release(x) __context__(x,-1) |
# define __cond_lock(x,c) ((c) ? ({ __acquire(x); 1; }) : 0) |
# define __percpu __attribute__((noderef, address_space(3))) |
#ifdef CONFIG_SPARSE_RCU_POINTER |
# define __rcu __attribute__((noderef, address_space(4))) |
#else |
# define __rcu |
#endif |
extern void __chk_user_ptr(const volatile void __user *); |
extern void __chk_io_ptr(const volatile void __iomem *); |
#else |
32,6 → 38,8 |
# define __acquire(x) (void)0 |
# define __release(x) (void)0 |
# define __cond_lock(x,c) (c) |
# define __percpu |
# define __rcu |
#endif |
#ifdef __KERNEL__ |
/drivers/include/linux/fb.h |
---|
2,7 → 2,6 |
#define _LINUX_FB_H |
#include <linux/types.h> |
#include <list.h> |
#include <linux/i2c.h> |
struct dentry; |
11,6 → 10,34 |
#define FB_MAX 32 /* sufficient for now */ |
/* ioctls |
0x46 is 'F' */ |
#define FBIOGET_VSCREENINFO 0x4600 |
#define FBIOPUT_VSCREENINFO 0x4601 |
#define FBIOGET_FSCREENINFO 0x4602 |
#define FBIOGETCMAP 0x4604 |
#define FBIOPUTCMAP 0x4605 |
#define FBIOPAN_DISPLAY 0x4606 |
#ifdef __KERNEL__ |
#define FBIO_CURSOR _IOWR('F', 0x08, struct fb_cursor_user) |
#else |
#define FBIO_CURSOR _IOWR('F', 0x08, struct fb_cursor) |
#endif |
/* 0x4607-0x460B are defined below */ |
/* #define FBIOGET_MONITORSPEC 0x460C */ |
/* #define FBIOPUT_MONITORSPEC 0x460D */ |
/* #define FBIOSWITCH_MONIBIT 0x460E */ |
#define FBIOGET_CON2FBMAP 0x460F |
#define FBIOPUT_CON2FBMAP 0x4610 |
#define FBIOBLANK 0x4611 /* arg: 0 or vesa level + 1 */ |
#define FBIOGET_VBLANK _IOR('F', 0x12, struct fb_vblank) |
#define FBIO_ALLOC 0x4613 |
#define FBIO_FREE 0x4614 |
#define FBIOGET_GLYPH 0x4615 |
#define FBIOGET_HWCINFO 0x4616 |
#define FBIOPUT_MODEINFO 0x4617 |
#define FBIOGET_DISPINFO 0x4618 |
#define FBIO_WAITFORVSYNC _IOW('F', 0x20, __u32) |
#define FB_TYPE_PACKED_PIXELS 0 /* Packed Pixels */ |
#define FB_TYPE_PLANES 1 /* Non interleaved planes */ |
375,13 → 402,14 |
//#include <linux/workqueue.h> |
//#include <linux/notifier.h> |
#include <linux/list.h> |
#include <linux/mutex.h> |
//#include <linux/backlight.h> |
//#include <asm/io.h> |
//struct vm_area_struct; |
//struct fb_info; |
//struct device; |
//struct file; |
struct vm_area_struct; |
struct fb_info; |
struct device; |
struct file; |
/* Definitions below are used in the parsed monitor specs */ |
#define FB_DPMS_ACTIVE_OFF 1 |
408,7 → 436,6 |
#define FB_MISC_PRIM_COLOR 1 |
#define FB_MISC_1ST_DETAIL 2 /* First Detailed Timing is preferred */ |
struct fb_chroma { |
__u32 redx; /* in fraction of 1024 */ |
__u32 greenx; |
517,6 → 544,8 |
#define FB_EVENT_GET_REQ 0x0D |
/* Unbind from the console if possible */ |
#define FB_EVENT_FB_UNBIND 0x0E |
/* CONSOLE-SPECIFIC: remap all consoles to new fb - for vga switcheroo */ |
#define FB_EVENT_REMAP_ALL_CONSOLE 0x0F |
struct fb_event { |
struct fb_info *info; |
577,6 → 606,12 |
* LOCKING NOTE: those functions must _ALL_ be called with the console |
* semaphore held, this is the only suitable locking mechanism we have |
* in 2.6. Some may be called at interrupt time at this point though. |
* |
* The exception to this is the debug related hooks. Putting the fb |
* into a debug state (e.g. flipping to the kernel console) and restoring |
* it must be done in a lock-free manner, so low level drivers should |
* keep track of the initial console (if applicable) and may need to |
* perform direct, unlocked hardware writes in these hooks. |
*/ |
struct fb_ops { |
734,6 → 769,7 |
* takes over; acceleration engine should be in a quiescent state */ |
/* hints */ |
#define FBINFO_VIRTFB 0x0004 /* FB is System RAM, not device. */ |
#define FBINFO_PARTIAL_PAN_OK 0x0040 /* otw use pan only for double-buffering */ |
#define FBINFO_READS_FAST 0x0080 /* soft-copy faster than rendering */ |
755,8 → 791,6 |
#define FBINFO_MISC_USEREVENT 0x10000 /* event request |
from userspace */ |
#define FBINFO_MISC_TILEBLITTING 0x20000 /* use tile blitting */ |
#define FBINFO_MISC_FIRMWARE 0x40000 /* a replaceable firmware |
inited framebuffer */ |
/* A driver may set this flag to indicate that it does want a set_par to be |
* called every time when fbcon_switch is executed. The advantage is that with |
770,6 → 804,8 |
*/ |
#define FBINFO_MISC_ALWAYS_SETPAR 0x40000 |
/* where the fb is a firmware driver, and can be replaced with a proper one */ |
#define FBINFO_MISC_FIRMWARE 0x80000 |
/* |
* Host and GPU endianness differ. |
*/ |
781,11 → 817,15 |
*/ |
#define FBINFO_BE_MATH 0x100000 |
/* report to the VT layer that this fb driver can accept forced console |
output like oopses */ |
#define FBINFO_CAN_FORCE_OUTPUT 0x200000 |
struct fb_info { |
int node; |
int flags; |
// struct mutex lock; /* Lock for open/release/ioctl funcs */ |
// struct mutex mm_lock; /* Lock for fb_mmap and smem_* fields */ |
struct mutex lock; /* Lock for open/release/ioctl funcs */ |
struct mutex mm_lock; /* Lock for fb_mmap and smem_* fields */ |
struct fb_var_screeninfo var; /* Current var */ |
struct fb_fix_screeninfo fix; /* Current fix */ |
struct fb_monspecs monspecs; /* Current Monitor specs */ |
812,8 → 852,8 |
#endif |
struct fb_ops *fbops; |
// struct device *device; /* This is the parent */ |
// struct device *dev; /* This is this fb device */ |
struct device *device; /* This is the parent */ |
struct device *dev; /* This is this fb device */ |
int class_flag; /* private sysfs flags */ |
#ifdef CONFIG_FB_TILEBLITTING |
struct fb_tile_ops *tileops; /* Tile Blitting */ |
830,10 → 870,24 |
/* we need the PCI or similiar aperture base/size not |
smem_start/size as smem_start may just be an object |
allocated inside the aperture so may not actually overlap */ |
resource_size_t aperture_base; |
resource_size_t aperture_size; |
struct apertures_struct { |
unsigned int count; |
struct aperture { |
resource_size_t base; |
resource_size_t size; |
} ranges[0]; |
} *apertures; |
}; |
static inline struct apertures_struct *alloc_apertures(unsigned int max_num) { |
struct apertures_struct *a = kzalloc(sizeof(struct apertures_struct) |
+ max_num * sizeof(struct aperture), GFP_KERNEL); |
if (!a) |
return NULL; |
a->count = max_num; |
return a; |
} |
#ifdef MODULE |
#define FBINFO_DEFAULT FBINFO_MODULE |
#else |
852,6 → 906,42 |
*/ |
#define STUPID_ACCELF_TEXT_SHIT |
// This will go away |
#if defined(__sparc__) |
/* We map all of our framebuffers such that big-endian accesses |
* are what we want, so the following is sufficient. |
*/ |
// This will go away |
#define fb_readb sbus_readb |
#define fb_readw sbus_readw |
#define fb_readl sbus_readl |
#define fb_readq sbus_readq |
#define fb_writeb sbus_writeb |
#define fb_writew sbus_writew |
#define fb_writel sbus_writel |
#define fb_writeq sbus_writeq |
#define fb_memset sbus_memset_io |
#define fb_memcpy_fromfb sbus_memcpy_fromio |
#define fb_memcpy_tofb sbus_memcpy_toio |
#elif defined(__i386__) || defined(__alpha__) || defined(__x86_64__) || defined(__hppa__) || defined(__sh__) || defined(__powerpc__) || defined(__avr32__) || defined(__bfin__) |
#define fb_readb __raw_readb |
#define fb_readw __raw_readw |
#define fb_readl __raw_readl |
#define fb_readq __raw_readq |
#define fb_writeb __raw_writeb |
#define fb_writew __raw_writew |
#define fb_writel __raw_writel |
#define fb_writeq __raw_writeq |
#define fb_memset memset_io |
#define fb_memcpy_fromfb memcpy_fromio |
#define fb_memcpy_tofb memcpy_toio |
#else |
#define fb_readb(addr) (*(volatile u8 *) (addr)) |
#define fb_readw(addr) (*(volatile u16 *) (addr)) |
#define fb_readl(addr) (*(volatile u32 *) (addr)) |
861,7 → 951,11 |
#define fb_writel(b,addr) (*(volatile u32 *) (addr) = (b)) |
#define fb_writeq(b,addr) (*(volatile u64 *) (addr) = (b)) |
#define fb_memset memset |
#define fb_memcpy_fromfb memcpy |
#define fb_memcpy_tofb memcpy |
#endif |
#define FB_LEFT_POS(p, bpp) (fb_be_math(p) ? (32 - (bpp)) : 0) |
#define FB_SHIFT_HIGH(p, val, bits) (fb_be_math(p) ? (val) >> (bits) : \ |
(val) << (bits)) |
892,6 → 986,8 |
/* drivers/video/fbmem.c */ |
extern int register_framebuffer(struct fb_info *fb_info); |
extern int unregister_framebuffer(struct fb_info *fb_info); |
extern void remove_conflicting_framebuffers(struct apertures_struct *a, |
const char *name, bool primary); |
extern int fb_prepare_logo(struct fb_info *fb_info, int rotate); |
extern int fb_show_logo(struct fb_info *fb_info, int rotate); |
extern char* fb_get_buffer_offset(struct fb_info *info, struct fb_pixmap *buf, u32 size); |
912,7 → 1008,7 |
static inline void unlock_fb_info(struct fb_info *info) |
{ |
// mutex_unlock(&info->lock); |
mutex_unlock(&info->lock); |
} |
static inline void __fb_pad_aligned_buffer(u8 *dst, u32 d_pitch, |
/drivers/include/linux/i2c-algo-bit.h |
---|
36,6 → 36,8 |
void (*setscl) (void *data, int state); |
int (*getsda) (void *data); |
int (*getscl) (void *data); |
int (*pre_xfer) (struct i2c_adapter *); |
void (*post_xfer) (struct i2c_adapter *); |
/* local settings */ |
int udelay; /* half clock cycle time in us, |
/drivers/include/linux/i2c.h |
---|
26,27 → 26,22 |
#ifndef _LINUX_I2C_H |
#define _LINUX_I2C_H |
#include <types.h> |
#include <list.h> |
#include <linux/types.h> |
#ifdef __KERNEL__ |
#include <linux/module.h> |
#include <linux/i2c-id.h> |
#include <linux/mod_devicetable.h> |
#define I2C_NAME_SIZE 20 |
#define I2C_MODULE_PREFIX "i2c:" |
/* --- General options ------------------------------------------------ */ |
struct i2c_device_id { |
char name[I2C_NAME_SIZE]; |
u32 driver_data /* Data private to the driver */ |
__attribute__((aligned(sizeof(u32)))); |
}; |
struct i2c_msg; |
struct i2c_algorithm; |
struct i2c_adapter; |
struct i2c_client; |
struct i2c_driver; |
union i2c_smbus_data; |
struct i2c_board_info; |
/* Transfer num messages. |
64,6 → 59,7 |
* @shutdown: Callback for device shutdown |
* @suspend: Callback for device suspend |
* @resume: Callback for device resume |
* @alert: Alert callback, for example for the SMBus alert protocol |
* @command: Callback for bus-wide signaling (optional) |
* @driver: Device driver model driver |
* @id_table: List of I2C devices supported by this driver |
95,8 → 91,8 |
unsigned int class; |
/* Notifies the driver that a new bus has appeared or is about to be |
* removed. You should avoid using this if you can, it will probably |
* be removed in a near future. |
* removed. You should avoid using this, it will be removed in a |
* near future. |
*/ |
int (*attach_adapter)(struct i2c_adapter *); |
int (*detach_adapter)(struct i2c_adapter *); |
158,8 → 154,8 |
char name[I2C_NAME_SIZE]; |
struct i2c_adapter *adapter; /* the adapter we sit on */ |
struct i2c_driver *driver; /* and our access routines */ |
// struct device dev; /* the device structure */ |
int irq; /* irq issued by device (or -1) */ |
struct device dev; /* the device structure */ |
int irq; /* irq issued by device */ |
struct list_head detected; |
}; |
#define to_i2c_client(d) container_of(d, struct i2c_client, dev) |
166,6 → 162,51 |
extern struct i2c_client *i2c_verify_client(struct device *dev); |
/** |
* struct i2c_board_info - template for device creation |
* @type: chip type, to initialize i2c_client.name |
* @flags: to initialize i2c_client.flags |
* @addr: stored in i2c_client.addr |
* @platform_data: stored in i2c_client.dev.platform_data |
* @archdata: copied into i2c_client.dev.archdata |
* @of_node: pointer to OpenFirmware device node |
* @irq: stored in i2c_client.irq |
* |
* I2C doesn't actually support hardware probing, although controllers and |
* devices may be able to use I2C_SMBUS_QUICK to tell whether or not there's |
* a device at a given address. Drivers commonly need more information than |
* that, such as chip type, configuration, associated IRQ, and so on. |
* |
* i2c_board_info is used to build tables of information listing I2C devices |
* that are present. This information is used to grow the driver model tree. |
* For mainboards this is done statically using i2c_register_board_info(); |
* bus numbers identify adapters that aren't yet available. For add-on boards, |
* i2c_new_device() does this dynamically with the adapter already known. |
*/ |
struct i2c_board_info { |
char type[I2C_NAME_SIZE]; |
unsigned short flags; |
unsigned short addr; |
void *platform_data; |
struct dev_archdata *archdata; |
#ifdef CONFIG_OF |
struct device_node *of_node; |
#endif |
int irq; |
}; |
/** |
* I2C_BOARD_INFO - macro used to list an i2c device and its address |
* @dev_type: identifies the device type |
* @dev_addr: the device's address on the bus. |
* |
* This macro initializes essential fields of a struct i2c_board_info, |
* declaring what has been provided on a particular board. Optional |
* fields (such as associated irq, or device-specific platform_data) |
* are provided using conventional syntax. |
*/ |
#define I2C_BOARD_INFO(dev_type, dev_addr) \ |
.type = dev_type, .addr = (dev_addr) |
/* |
* The following structs are for those who like to implement new bus drivers: |
* i2c_algorithm is the interface to a class of hardware solutions which can |
194,7 → 235,7 |
* with the access algorithms necessary to access it. |
*/ |
struct i2c_adapter { |
unsigned int id; |
struct module *owner; |
unsigned int class; /* classes to allow probing for */ |
const struct i2c_algorithm *algo; /* the algorithm to access the bus */ |
void *algo_data; |
211,7 → 252,7 |
}; |
#define to_i2c_adapter(d) container_of(d, struct i2c_adapter, dev) |
static inline void *i2c_get_adapdata(struct i2c_adapter *dev) |
static inline void *i2c_get_adapdata(const struct i2c_adapter *dev) |
{ |
return dev_get_drvdata(&dev->dev); |
} |
221,6 → 262,10 |
dev_set_drvdata(&dev->dev, data); |
} |
/* Adapter locking functions, exported for shared pin cases */ |
void i2c_lock_adapter(struct i2c_adapter *); |
void i2c_unlock_adapter(struct i2c_adapter *); |
/*flags for the client struct: */ |
#define I2C_CLIENT_PEC 0x04 /* Use Packet Error Checking */ |
#define I2C_CLIENT_TEN 0x10 /* we have a ten bit chip address */ |
229,10 → 274,8 |
/* i2c adapter classes (bitmask) */ |
#define I2C_CLASS_HWMON (1<<0) /* lm_sensors, ... */ |
#define I2C_CLASS_TV_ANALOG (1<<1) /* bttv + friends */ |
#define I2C_CLASS_TV_DIGITAL (1<<2) /* dvb cards */ |
#define I2C_CLASS_DDC (1<<3) /* DDC bus on graphics adapters */ |
#define I2C_CLASS_SPD (1<<7) /* SPD EEPROMs and similar */ |
#define I2C_CLASS_SPD (1<<7) /* Memory modules */ |
/* Internal numbers to terminate lists */ |
#define I2C_CLIENT_END 0xfffeU |
245,6 → 288,7 |
((const unsigned short []){ addr, ## addrs, I2C_CLIENT_END }) |
#endif /* __KERNEL__ */ |
/** |
* struct i2c_msg - an I2C transaction segment beginning with START |
* @addr: Slave address, either seven or ten bits. When this is a ten |
282,8 → 326,8 |
* need (one or more of IGNORE_NAK, NO_RD_ACK, NOSTART, and REV_DIR_ADDR). |
*/ |
struct i2c_msg { |
u16 addr; /* slave address */ |
u16 flags; |
__u16 addr; /* slave address */ |
__u16 flags; |
#define I2C_M_TEN 0x0010 /* this is a ten bit chip address */ |
#define I2C_M_RD 0x0001 /* read data, from slave to master */ |
#define I2C_M_NOSTART 0x4000 /* if I2C_FUNC_PROTOCOL_MANGLING */ |
291,8 → 335,8 |
#define I2C_M_IGNORE_NAK 0x1000 /* if I2C_FUNC_PROTOCOL_MANGLING */ |
#define I2C_M_NO_RD_ACK 0x0800 /* if I2C_FUNC_PROTOCOL_MANGLING */ |
#define I2C_M_RECV_LEN 0x0400 /* length will be first received byte */ |
u16 len; /* msg length */ |
u8 *buf; /* pointer to msg data */ |
__u16 len; /* msg length */ |
__u8 *buf; /* pointer to msg data */ |
}; |
/* To determine what functionality is present */ |
/drivers/include/linux/idr.h |
---|
12,10 → 12,8 |
#ifndef __IDR_H__ |
#define __IDR_H__ |
#include <types.h> |
#include <errno-base.h> |
//#include <linux/bitops.h> |
#include <linux/types.h> |
#include <linux/bitops.h> |
//#include <linux/init.h> |
//#include <linux/rcupdate.h> |
25,6 → 23,7 |
}; |
#if BITS_PER_LONG == 32 |
# define IDR_BITS 5 |
# define IDR_FULL 0xfffffffful |
/* We can only use two of the bits in the top level because there is |
31,6 → 30,16 |
only one possible bit in the top level (5 bits * 7 levels = 35 |
bits, but you only use 31 bits in the id). */ |
# define TOP_LEVEL_FULL (IDR_FULL >> 30) |
#elif BITS_PER_LONG == 64 |
# define IDR_BITS 6 |
# define IDR_FULL 0xfffffffffffffffful |
/* We can only use two of the bits in the top level because there is |
only one possible bit in the top level (6 bits * 6 levels = 36 |
bits, but you only use 31 bits in the id). */ |
# define TOP_LEVEL_FULL (IDR_FULL >> 62) |
#else |
# error "BITS_PER_LONG is not 32 or 64" |
#endif |
#define IDR_SIZE (1 << IDR_BITS) |
#define IDR_MASK ((1 << IDR_BITS)-1) |
47,7 → 56,7 |
struct idr_layer { |
unsigned long bitmap; /* A zero bit means "space here" */ |
struct idr_layer *ary[1<<IDR_BITS]; |
struct idr_layer __rcu *ary[1<<IDR_BITS]; |
int count; /* When zero, we can release it */ |
int layer; /* distance from leaf */ |
struct rcu_head rcu_head; |
54,7 → 63,7 |
}; |
struct idr { |
struct idr_layer *top; |
struct idr_layer __rcu *top; |
struct idr_layer *id_free; |
int layers; /* only valid without concurrent changes */ |
int id_free_cnt; |
78,6 → 87,7 |
#define _idr_rc_to_errno(rc) ((rc) == -1 ? -EAGAIN : -ENOSPC) |
/** |
* DOC: idr sync |
* idr synchronization (stolen from radix-tree.h) |
* |
* idr_find() is able to be called locklessly, using RCU. The caller must |
98,7 → 108,7 |
*/ |
void *idr_find(struct idr *idp, int id); |
int idr_pre_get(struct idr *idp, u32_t gfp_mask); |
int idr_pre_get(struct idr *idp, gfp_t gfp_mask); |
int idr_get_new(struct idr *idp, void *ptr, int *id); |
int idr_get_new_above(struct idr *idp, void *ptr, int starting_id, int *id); |
int idr_for_each(struct idr *idp, |
114,9 → 124,12 |
/* |
* IDA - IDR based id allocator, use when translation from id to |
* pointer isn't necessary. |
* |
* IDA_BITMAP_LONGS is calculated to be one less to accommodate |
* ida_bitmap->nr_busy so that the whole struct fits in 128 bytes. |
*/ |
#define IDA_CHUNK_SIZE 128 /* 128 bytes per chunk */ |
#define IDA_BITMAP_LONGS (128 / sizeof(long) - 1) |
#define IDA_BITMAP_LONGS (IDA_CHUNK_SIZE / sizeof(long) - 1) |
#define IDA_BITMAP_BITS (IDA_BITMAP_LONGS * sizeof(long) * 8) |
struct ida_bitmap { |
132,7 → 145,7 |
#define IDA_INIT(name) { .idr = IDR_INIT(name), .free_bitmap = NULL, } |
#define DEFINE_IDA(name) struct ida name = IDA_INIT(name) |
int ida_pre_get(struct ida *ida, u32_t gfp_mask); |
int ida_pre_get(struct ida *ida, gfp_t gfp_mask); |
int ida_get_new_above(struct ida *ida, int starting_id, int *p_id); |
int ida_get_new(struct ida *ida, int *p_id); |
void ida_remove(struct ida *ida, int id); |
/drivers/include/linux/kernel.h |
---|
12,9 → 12,9 |
#include <linux/types.h> |
#include <linux/compiler.h> |
#define USHORT_MAX ((u16)(~0U)) |
#define SHORT_MAX ((s16)(USHORT_MAX>>1)) |
#define SHORT_MIN (-SHORT_MAX - 1) |
#define USHRT_MAX ((u16)(~0U)) |
#define SHRT_MAX ((s16)(USHRT_MAX>>1)) |
#define SHRT_MIN ((s16)(-SHRT_MAX - 1)) |
#define INT_MAX ((int)(~0U>>1)) |
#define INT_MIN (-INT_MAX - 1) |
#define UINT_MAX (~0U) |
46,7 → 46,6 |
*/ |
#define lower_32_bits(n) ((u32)(n)) |
#define KERN_EMERG "<0>" /* system is unusable */ |
#define KERN_ALERT "<1>" /* action must be taken immediately */ |
#define KERN_CRIT "<2>" /* critical conditions */ |
113,18 → 112,6 |
return kzalloc(n * size, 0); |
} |
extern const char hex_asc[]; |
#define hex_asc_lo(x) hex_asc[((x) & 0x0f)] |
#define hex_asc_hi(x) hex_asc[((x) & 0xf0) >> 4] |
static inline char *pack_hex_byte(char *buf, u8 byte) |
{ |
*buf++ = hex_asc_hi(byte); |
*buf++ = hex_asc_lo(byte); |
return buf; |
} |
void free (void *ptr); |
#endif /* __KERNEL__ */ |
162,6 → 149,7 |
#define preempt_enable_no_resched_notrace() do { } while (0) |
#define preempt_enable_notrace() do { } while (0) |
#define in_dbg_master() (0) |
#endif |
/drivers/include/linux/kref.h |
---|
1,5 → 1,5 |
/* |
* kref.c - library routines for handling generic reference counted objects |
* kref.h - library routines for handling generic reference counted objects |
* |
* Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com> |
* Copyright (C) 2004 IBM Corp. |
21,7 → 21,6 |
atomic_t refcount; |
}; |
void kref_set(struct kref *kref, int num); |
void kref_init(struct kref *kref); |
void kref_get(struct kref *kref); |
int kref_put(struct kref *kref, void (*release) (struct kref *kref)); |
/drivers/include/linux/list.h |
---|
1,11 → 1,12 |
#ifndef _LINUX_LIST_H |
#define _LINUX_LIST_H |
#include <linux/types.h> |
#include <linux/stddef.h> |
//#include <linux/poison.h> |
//#include <linux/prefetch.h> |
//#include <asm/system.h> |
#include <linux/poison.h> |
#define prefetch(x) __builtin_prefetch(x) |
/* |
* Simple doubly linked list implementation. |
* |
16,15 → 17,6 |
* using the generic single-entry routines. |
*/ |
#define LIST_POISON1 ((struct list_head*)0xFFFF0100) |
#define LIST_POISON2 ((struct list_head*)0xFFFF0200) |
#define prefetch(x) __builtin_prefetch(x) |
struct list_head { |
struct list_head *next, *prev; |
}; |
#define LIST_HEAD_INIT(name) { &(name), &(name) } |
#define LIST_HEAD(name) \ |
211,6 → 203,20 |
} |
/** |
* list_rotate_left - rotate the list to the left |
* @head: the head of the list |
*/ |
static inline void list_rotate_left(struct list_head *head) |
{ |
struct list_head *first; |
if (!list_empty(head)) { |
first = head->next; |
list_move_tail(first, head); |
} |
} |
/** |
* list_is_singular - tests whether a list has just one entry. |
* @head: the list to test. |
*/ |
489,7 → 495,7 |
pos = n, n = list_entry(n->member.next, typeof(*n), member)) |
/** |
* list_for_each_entry_safe_continue |
* list_for_each_entry_safe_continue - continue list iteration safe against removal |
* @pos: the type * to use as a loop cursor. |
* @n: another type * to use as temporary storage |
* @head: the head for your list. |
505,7 → 511,7 |
pos = n, n = list_entry(n->member.next, typeof(*n), member)) |
/** |
* list_for_each_entry_safe_from |
* list_for_each_entry_safe_from - iterate over list from current point safe against removal |
* @pos: the type * to use as a loop cursor. |
* @n: another type * to use as temporary storage |
* @head: the head for your list. |
520,7 → 526,7 |
pos = n, n = list_entry(n->member.next, typeof(*n), member)) |
/** |
* list_for_each_entry_safe_reverse |
* list_for_each_entry_safe_reverse - iterate backwards over list safe against removal |
* @pos: the type * to use as a loop cursor. |
* @n: another type * to use as temporary storage |
* @head: the head for your list. |
535,6 → 541,21 |
&pos->member != (head); \ |
pos = n, n = list_entry(n->member.prev, typeof(*n), member)) |
/** |
* list_safe_reset_next - reset a stale list_for_each_entry_safe loop |
* @pos: the loop cursor used in the list_for_each_entry_safe loop |
* @n: temporary storage used in list_for_each_entry_safe |
* @member: the name of the list_struct within the struct. |
* |
* list_safe_reset_next is not safe to use in general if the list may be |
* modified concurrently (eg. the lock is dropped in the loop body). An |
* exception to this is if the cursor element (pos) is pinned in the list, |
* and list_safe_reset_next is called after re-taking the lock and before |
* completing the current iteration of the loop body. |
*/ |
#define list_safe_reset_next(pos, n, member) \ |
n = list_entry(pos->member.next, typeof(*pos), member) |
/* |
* Double linked lists with a single pointer list head. |
* Mostly useful for hash tables where the two pointer list head is |
542,14 → 563,6 |
* You lose the ability to access the tail in O(1). |
*/ |
struct hlist_head { |
struct hlist_node *first; |
}; |
struct hlist_node { |
struct hlist_node *next, **pprev; |
}; |
#define HLIST_HEAD_INIT { .first = NULL } |
#define HLIST_HEAD(name) struct hlist_head name = { .first = NULL } |
#define INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL) |
581,8 → 594,8 |
static inline void hlist_del(struct hlist_node *n) |
{ |
__hlist_del(n); |
n->next = (struct hlist_node*)LIST_POISON1; |
n->pprev = (struct hlist_node**)LIST_POISON2; |
n->next = LIST_POISON1; |
n->pprev = LIST_POISON2; |
} |
static inline void hlist_del_init(struct hlist_node *n) |
624,6 → 637,12 |
next->next->pprev = &next->next; |
} |
/* after that we'll appear to be on some hlist and hlist_del will work */ |
static inline void hlist_add_fake(struct hlist_node *n) |
{ |
n->pprev = &n->next; |
} |
/* |
* Move a list from one list head to another. Fixup the pprev |
* reference of the first entry if it exists. |
/drivers/include/linux/lockdep.h |
---|
28,6 → 28,17 |
#define MAX_LOCKDEP_SUBCLASSES 8UL |
/* |
* NR_LOCKDEP_CACHING_CLASSES ... Number of classes |
* cached in the instance of lockdep_map |
* |
* Currently main class (subclass == 0) and signle depth subclass |
* are cached in lockdep_map. This optimization is mainly targeting |
* on rq->lock. double_rq_lock() acquires this highly competitive with |
* single depth. |
*/ |
#define NR_LOCKDEP_CACHING_CLASSES 2 |
/* |
* Lock-classes are keyed via unique addresses, by embedding the |
* lockclass-key into the kernel (or module) .data section. (For |
* static locks we use the lock address itself as the key.) |
132,7 → 143,7 |
*/ |
struct lockdep_map { |
struct lock_class_key *key; |
struct lock_class *class_cache; |
struct lock_class *class_cache[NR_LOCKDEP_CACHING_CLASSES]; |
const char *name; |
#ifdef CONFIG_LOCK_STAT |
int cpu; |
266,6 → 277,9 |
#define lockdep_set_subclass(lock, sub) \ |
lockdep_init_map(&(lock)->dep_map, #lock, \ |
(lock)->dep_map.key, sub) |
#define lockdep_set_novalidate_class(lock) \ |
lockdep_set_class(lock, &__lockdep_no_validate__) |
/* |
* Compare locking classes |
*/ |
350,6 → 364,9 |
#define lockdep_set_class_and_subclass(lock, key, sub) \ |
do { (void)(key); } while (0) |
#define lockdep_set_subclass(lock, sub) do { } while (0) |
#define lockdep_set_novalidate_class(lock) do { } while (0) |
/* |
* We don't define lockdep_match_class() and lockdep_match_key() for !LOCKDEP |
* case since the result is not well defined and the caller should rather |
412,14 → 429,6 |
#endif /* CONFIG_LOCKDEP */ |
#ifdef CONFIG_GENERIC_HARDIRQS |
extern void early_init_irq_lock_class(void); |
#else |
static inline void early_init_irq_lock_class(void) |
{ |
} |
#endif |
#ifdef CONFIG_TRACE_IRQFLAGS |
extern void early_boot_irqs_off(void); |
extern void early_boot_irqs_on(void); |
534,4 → 543,8 |
# define might_lock_read(lock) do { } while (0) |
#endif |
#ifdef CONFIG_PROVE_RCU |
extern void lockdep_rcu_dereference(const char *file, const int line); |
#endif |
#endif /* __LINUX_LOCKDEP_H */ |
/drivers/include/linux/mod_devicetable.h |
---|
0,0 → 1,519 |
/* |
* Device tables which are exported to userspace via |
* scripts/mod/file2alias.c. You must keep that file in sync with this |
* header. |
*/ |
#ifndef LINUX_MOD_DEVICETABLE_H |
#define LINUX_MOD_DEVICETABLE_H |
#ifdef __KERNEL__ |
#include <linux/types.h> |
typedef unsigned long kernel_ulong_t; |
#endif |
#define PCI_ANY_ID (~0) |
struct pci_device_id { |
__u32 vendor, device; /* Vendor and device ID or PCI_ANY_ID*/ |
__u32 subvendor, subdevice; /* Subsystem ID's or PCI_ANY_ID */ |
__u32 class, class_mask; /* (class,subclass,prog-if) triplet */ |
kernel_ulong_t driver_data; /* Data private to the driver */ |
}; |
#define IEEE1394_MATCH_VENDOR_ID 0x0001 |
#define IEEE1394_MATCH_MODEL_ID 0x0002 |
#define IEEE1394_MATCH_SPECIFIER_ID 0x0004 |
#define IEEE1394_MATCH_VERSION 0x0008 |
struct ieee1394_device_id { |
__u32 match_flags; |
__u32 vendor_id; |
__u32 model_id; |
__u32 specifier_id; |
__u32 version; |
kernel_ulong_t driver_data |
__attribute__((aligned(sizeof(kernel_ulong_t)))); |
}; |
/* |
* Device table entry for "new style" table-driven USB drivers. |
* User mode code can read these tables to choose which modules to load. |
* Declare the table as a MODULE_DEVICE_TABLE. |
* |
* A probe() parameter will point to a matching entry from this table. |
* Use the driver_info field for each match to hold information tied |
* to that match: device quirks, etc. |
* |
* Terminate the driver's table with an all-zeroes entry. |
* Use the flag values to control which fields are compared. |
*/ |
/** |
* struct usb_device_id - identifies USB devices for probing and hotplugging |
* @match_flags: Bit mask controlling of the other fields are used to match |
* against new devices. Any field except for driver_info may be used, |
* although some only make sense in conjunction with other fields. |
* This is usually set by a USB_DEVICE_*() macro, which sets all |
* other fields in this structure except for driver_info. |
* @idVendor: USB vendor ID for a device; numbers are assigned |
* by the USB forum to its members. |
* @idProduct: Vendor-assigned product ID. |
* @bcdDevice_lo: Low end of range of vendor-assigned product version numbers. |
* This is also used to identify individual product versions, for |
* a range consisting of a single device. |
* @bcdDevice_hi: High end of version number range. The range of product |
* versions is inclusive. |
* @bDeviceClass: Class of device; numbers are assigned |
* by the USB forum. Products may choose to implement classes, |
* or be vendor-specific. Device classes specify behavior of all |
* the interfaces on a devices. |
* @bDeviceSubClass: Subclass of device; associated with bDeviceClass. |
* @bDeviceProtocol: Protocol of device; associated with bDeviceClass. |
* @bInterfaceClass: Class of interface; numbers are assigned |
* by the USB forum. Products may choose to implement classes, |
* or be vendor-specific. Interface classes specify behavior only |
* of a given interface; other interfaces may support other classes. |
* @bInterfaceSubClass: Subclass of interface; associated with bInterfaceClass. |
* @bInterfaceProtocol: Protocol of interface; associated with bInterfaceClass. |
* @driver_info: Holds information used by the driver. Usually it holds |
* a pointer to a descriptor understood by the driver, or perhaps |
* device flags. |
* |
* In most cases, drivers will create a table of device IDs by using |
* USB_DEVICE(), or similar macros designed for that purpose. |
* They will then export it to userspace using MODULE_DEVICE_TABLE(), |
* and provide it to the USB core through their usb_driver structure. |
* |
* See the usb_match_id() function for information about how matches are |
* performed. Briefly, you will normally use one of several macros to help |
* construct these entries. Each entry you provide will either identify |
* one or more specific products, or will identify a class of products |
* which have agreed to behave the same. You should put the more specific |
* matches towards the beginning of your table, so that driver_info can |
* record quirks of specific products. |
*/ |
struct usb_device_id { |
/* which fields to match against? */ |
__u16 match_flags; |
/* Used for product specific matches; range is inclusive */ |
__u16 idVendor; |
__u16 idProduct; |
__u16 bcdDevice_lo; |
__u16 bcdDevice_hi; |
/* Used for device class matches */ |
__u8 bDeviceClass; |
__u8 bDeviceSubClass; |
__u8 bDeviceProtocol; |
/* Used for interface class matches */ |
__u8 bInterfaceClass; |
__u8 bInterfaceSubClass; |
__u8 bInterfaceProtocol; |
/* not matched against */ |
kernel_ulong_t driver_info; |
}; |
/* Some useful macros to use to create struct usb_device_id */ |
#define USB_DEVICE_ID_MATCH_VENDOR 0x0001 |
#define USB_DEVICE_ID_MATCH_PRODUCT 0x0002 |
#define USB_DEVICE_ID_MATCH_DEV_LO 0x0004 |
#define USB_DEVICE_ID_MATCH_DEV_HI 0x0008 |
#define USB_DEVICE_ID_MATCH_DEV_CLASS 0x0010 |
#define USB_DEVICE_ID_MATCH_DEV_SUBCLASS 0x0020 |
#define USB_DEVICE_ID_MATCH_DEV_PROTOCOL 0x0040 |
#define USB_DEVICE_ID_MATCH_INT_CLASS 0x0080 |
#define USB_DEVICE_ID_MATCH_INT_SUBCLASS 0x0100 |
#define USB_DEVICE_ID_MATCH_INT_PROTOCOL 0x0200 |
#define HID_ANY_ID (~0) |
struct hid_device_id { |
__u16 bus; |
__u16 pad1; |
__u32 vendor; |
__u32 product; |
kernel_ulong_t driver_data |
__attribute__((aligned(sizeof(kernel_ulong_t)))); |
}; |
/* s390 CCW devices */ |
struct ccw_device_id { |
__u16 match_flags; /* which fields to match against */ |
__u16 cu_type; /* control unit type */ |
__u16 dev_type; /* device type */ |
__u8 cu_model; /* control unit model */ |
__u8 dev_model; /* device model */ |
kernel_ulong_t driver_info; |
}; |
#define CCW_DEVICE_ID_MATCH_CU_TYPE 0x01 |
#define CCW_DEVICE_ID_MATCH_CU_MODEL 0x02 |
#define CCW_DEVICE_ID_MATCH_DEVICE_TYPE 0x04 |
#define CCW_DEVICE_ID_MATCH_DEVICE_MODEL 0x08 |
/* s390 AP bus devices */ |
struct ap_device_id { |
__u16 match_flags; /* which fields to match against */ |
__u8 dev_type; /* device type */ |
__u8 pad1; |
__u32 pad2; |
kernel_ulong_t driver_info; |
}; |
#define AP_DEVICE_ID_MATCH_DEVICE_TYPE 0x01 |
/* s390 css bus devices (subchannels) */ |
struct css_device_id { |
__u8 match_flags; |
__u8 type; /* subchannel type */ |
__u16 pad2; |
__u32 pad3; |
kernel_ulong_t driver_data; |
}; |
#define ACPI_ID_LEN 16 /* only 9 bytes needed here, 16 bytes are used */ |
/* to workaround crosscompile issues */ |
struct acpi_device_id { |
__u8 id[ACPI_ID_LEN]; |
kernel_ulong_t driver_data; |
}; |
#define PNP_ID_LEN 8 |
#define PNP_MAX_DEVICES 8 |
struct pnp_device_id { |
__u8 id[PNP_ID_LEN]; |
kernel_ulong_t driver_data; |
}; |
struct pnp_card_device_id { |
__u8 id[PNP_ID_LEN]; |
kernel_ulong_t driver_data; |
struct { |
__u8 id[PNP_ID_LEN]; |
} devs[PNP_MAX_DEVICES]; |
}; |
#define SERIO_ANY 0xff |
struct serio_device_id { |
__u8 type; |
__u8 extra; |
__u8 id; |
__u8 proto; |
}; |
/* |
* Struct used for matching a device |
*/ |
struct of_device_id |
{ |
char name[32]; |
char type[32]; |
char compatible[128]; |
#ifdef __KERNEL__ |
void *data; |
#else |
kernel_ulong_t data; |
#endif |
}; |
/* VIO */ |
struct vio_device_id { |
char type[32]; |
char compat[32]; |
}; |
/* PCMCIA */ |
struct pcmcia_device_id { |
__u16 match_flags; |
__u16 manf_id; |
__u16 card_id; |
__u8 func_id; |
/* for real multi-function devices */ |
__u8 function; |
/* for pseudo multi-function devices */ |
__u8 device_no; |
__u32 prod_id_hash[4] |
__attribute__((aligned(sizeof(__u32)))); |
/* not matched against in kernelspace*/ |
#ifdef __KERNEL__ |
const char * prod_id[4]; |
#else |
kernel_ulong_t prod_id[4] |
__attribute__((aligned(sizeof(kernel_ulong_t)))); |
#endif |
/* not matched against */ |
kernel_ulong_t driver_info; |
#ifdef __KERNEL__ |
char * cisfile; |
#else |
kernel_ulong_t cisfile; |
#endif |
}; |
#define PCMCIA_DEV_ID_MATCH_MANF_ID 0x0001 |
#define PCMCIA_DEV_ID_MATCH_CARD_ID 0x0002 |
#define PCMCIA_DEV_ID_MATCH_FUNC_ID 0x0004 |
#define PCMCIA_DEV_ID_MATCH_FUNCTION 0x0008 |
#define PCMCIA_DEV_ID_MATCH_PROD_ID1 0x0010 |
#define PCMCIA_DEV_ID_MATCH_PROD_ID2 0x0020 |
#define PCMCIA_DEV_ID_MATCH_PROD_ID3 0x0040 |
#define PCMCIA_DEV_ID_MATCH_PROD_ID4 0x0080 |
#define PCMCIA_DEV_ID_MATCH_DEVICE_NO 0x0100 |
#define PCMCIA_DEV_ID_MATCH_FAKE_CIS 0x0200 |
#define PCMCIA_DEV_ID_MATCH_ANONYMOUS 0x0400 |
/* Input */ |
#define INPUT_DEVICE_ID_EV_MAX 0x1f |
#define INPUT_DEVICE_ID_KEY_MIN_INTERESTING 0x71 |
#define INPUT_DEVICE_ID_KEY_MAX 0x2ff |
#define INPUT_DEVICE_ID_REL_MAX 0x0f |
#define INPUT_DEVICE_ID_ABS_MAX 0x3f |
#define INPUT_DEVICE_ID_MSC_MAX 0x07 |
#define INPUT_DEVICE_ID_LED_MAX 0x0f |
#define INPUT_DEVICE_ID_SND_MAX 0x07 |
#define INPUT_DEVICE_ID_FF_MAX 0x7f |
#define INPUT_DEVICE_ID_SW_MAX 0x0f |
#define INPUT_DEVICE_ID_MATCH_BUS 1 |
#define INPUT_DEVICE_ID_MATCH_VENDOR 2 |
#define INPUT_DEVICE_ID_MATCH_PRODUCT 4 |
#define INPUT_DEVICE_ID_MATCH_VERSION 8 |
#define INPUT_DEVICE_ID_MATCH_EVBIT 0x0010 |
#define INPUT_DEVICE_ID_MATCH_KEYBIT 0x0020 |
#define INPUT_DEVICE_ID_MATCH_RELBIT 0x0040 |
#define INPUT_DEVICE_ID_MATCH_ABSBIT 0x0080 |
#define INPUT_DEVICE_ID_MATCH_MSCIT 0x0100 |
#define INPUT_DEVICE_ID_MATCH_LEDBIT 0x0200 |
#define INPUT_DEVICE_ID_MATCH_SNDBIT 0x0400 |
#define INPUT_DEVICE_ID_MATCH_FFBIT 0x0800 |
#define INPUT_DEVICE_ID_MATCH_SWBIT 0x1000 |
struct input_device_id { |
kernel_ulong_t flags; |
__u16 bustype; |
__u16 vendor; |
__u16 product; |
__u16 version; |
kernel_ulong_t evbit[INPUT_DEVICE_ID_EV_MAX / BITS_PER_LONG + 1]; |
kernel_ulong_t keybit[INPUT_DEVICE_ID_KEY_MAX / BITS_PER_LONG + 1]; |
kernel_ulong_t relbit[INPUT_DEVICE_ID_REL_MAX / BITS_PER_LONG + 1]; |
kernel_ulong_t absbit[INPUT_DEVICE_ID_ABS_MAX / BITS_PER_LONG + 1]; |
kernel_ulong_t mscbit[INPUT_DEVICE_ID_MSC_MAX / BITS_PER_LONG + 1]; |
kernel_ulong_t ledbit[INPUT_DEVICE_ID_LED_MAX / BITS_PER_LONG + 1]; |
kernel_ulong_t sndbit[INPUT_DEVICE_ID_SND_MAX / BITS_PER_LONG + 1]; |
kernel_ulong_t ffbit[INPUT_DEVICE_ID_FF_MAX / BITS_PER_LONG + 1]; |
kernel_ulong_t swbit[INPUT_DEVICE_ID_SW_MAX / BITS_PER_LONG + 1]; |
kernel_ulong_t driver_info; |
}; |
/* EISA */ |
#define EISA_SIG_LEN 8 |
/* The EISA signature, in ASCII form, null terminated */ |
struct eisa_device_id { |
char sig[EISA_SIG_LEN]; |
kernel_ulong_t driver_data; |
}; |
#define EISA_DEVICE_MODALIAS_FMT "eisa:s%s" |
struct parisc_device_id { |
__u8 hw_type; /* 5 bits used */ |
__u8 hversion_rev; /* 4 bits */ |
__u16 hversion; /* 12 bits */ |
__u32 sversion; /* 20 bits */ |
}; |
#define PA_HWTYPE_ANY_ID 0xff |
#define PA_HVERSION_REV_ANY_ID 0xff |
#define PA_HVERSION_ANY_ID 0xffff |
#define PA_SVERSION_ANY_ID 0xffffffff |
/* SDIO */ |
#define SDIO_ANY_ID (~0) |
struct sdio_device_id { |
__u8 class; /* Standard interface or SDIO_ANY_ID */ |
__u16 vendor; /* Vendor or SDIO_ANY_ID */ |
__u16 device; /* Device ID or SDIO_ANY_ID */ |
kernel_ulong_t driver_data /* Data private to the driver */ |
__attribute__((aligned(sizeof(kernel_ulong_t)))); |
}; |
/* SSB core, see drivers/ssb/ */ |
struct ssb_device_id { |
__u16 vendor; |
__u16 coreid; |
__u8 revision; |
}; |
#define SSB_DEVICE(_vendor, _coreid, _revision) \ |
{ .vendor = _vendor, .coreid = _coreid, .revision = _revision, } |
#define SSB_DEVTABLE_END \ |
{ 0, }, |
#define SSB_ANY_VENDOR 0xFFFF |
#define SSB_ANY_ID 0xFFFF |
#define SSB_ANY_REV 0xFF |
struct virtio_device_id { |
__u32 device; |
__u32 vendor; |
}; |
#define VIRTIO_DEV_ANY_ID 0xffffffff |
/* i2c */ |
#define I2C_NAME_SIZE 20 |
#define I2C_MODULE_PREFIX "i2c:" |
struct i2c_device_id { |
char name[I2C_NAME_SIZE]; |
kernel_ulong_t driver_data /* Data private to the driver */ |
__attribute__((aligned(sizeof(kernel_ulong_t)))); |
}; |
/* spi */ |
#define SPI_NAME_SIZE 32 |
#define SPI_MODULE_PREFIX "spi:" |
struct spi_device_id { |
char name[SPI_NAME_SIZE]; |
kernel_ulong_t driver_data /* Data private to the driver */ |
__attribute__((aligned(sizeof(kernel_ulong_t)))); |
}; |
/* dmi */ |
enum dmi_field { |
DMI_NONE, |
DMI_BIOS_VENDOR, |
DMI_BIOS_VERSION, |
DMI_BIOS_DATE, |
DMI_SYS_VENDOR, |
DMI_PRODUCT_NAME, |
DMI_PRODUCT_VERSION, |
DMI_PRODUCT_SERIAL, |
DMI_PRODUCT_UUID, |
DMI_BOARD_VENDOR, |
DMI_BOARD_NAME, |
DMI_BOARD_VERSION, |
DMI_BOARD_SERIAL, |
DMI_BOARD_ASSET_TAG, |
DMI_CHASSIS_VENDOR, |
DMI_CHASSIS_TYPE, |
DMI_CHASSIS_VERSION, |
DMI_CHASSIS_SERIAL, |
DMI_CHASSIS_ASSET_TAG, |
DMI_STRING_MAX, |
}; |
struct dmi_strmatch { |
unsigned char slot; |
char substr[79]; |
}; |
#ifndef __KERNEL__ |
struct dmi_system_id { |
kernel_ulong_t callback; |
kernel_ulong_t ident; |
struct dmi_strmatch matches[4]; |
kernel_ulong_t driver_data |
__attribute__((aligned(sizeof(kernel_ulong_t)))); |
}; |
#else |
struct dmi_system_id { |
int (*callback)(const struct dmi_system_id *); |
const char *ident; |
struct dmi_strmatch matches[4]; |
void *driver_data; |
}; |
/* |
* struct dmi_device_id appears during expansion of |
* "MODULE_DEVICE_TABLE(dmi, x)". Compiler doesn't look inside it |
* but this is enough for gcc 3.4.6 to error out: |
* error: storage size of '__mod_dmi_device_table' isn't known |
*/ |
#define dmi_device_id dmi_system_id |
#endif |
#define DMI_MATCH(a, b) { a, b } |
#define PLATFORM_NAME_SIZE 20 |
#define PLATFORM_MODULE_PREFIX "platform:" |
struct platform_device_id { |
char name[PLATFORM_NAME_SIZE]; |
kernel_ulong_t driver_data |
__attribute__((aligned(sizeof(kernel_ulong_t)))); |
}; |
#define MDIO_MODULE_PREFIX "mdio:" |
#define MDIO_ID_FMT "%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d" |
#define MDIO_ID_ARGS(_id) \ |
(_id)>>31, ((_id)>>30) & 1, ((_id)>>29) & 1, ((_id)>>28) & 1, \ |
((_id)>>27) & 1, ((_id)>>26) & 1, ((_id)>>25) & 1, ((_id)>>24) & 1, \ |
((_id)>>23) & 1, ((_id)>>22) & 1, ((_id)>>21) & 1, ((_id)>>20) & 1, \ |
((_id)>>19) & 1, ((_id)>>18) & 1, ((_id)>>17) & 1, ((_id)>>16) & 1, \ |
((_id)>>15) & 1, ((_id)>>14) & 1, ((_id)>>13) & 1, ((_id)>>12) & 1, \ |
((_id)>>11) & 1, ((_id)>>10) & 1, ((_id)>>9) & 1, ((_id)>>8) & 1, \ |
((_id)>>7) & 1, ((_id)>>6) & 1, ((_id)>>5) & 1, ((_id)>>4) & 1, \ |
((_id)>>3) & 1, ((_id)>>2) & 1, ((_id)>>1) & 1, (_id) & 1 |
/** |
* struct mdio_device_id - identifies PHY devices on an MDIO/MII bus |
* @phy_id: The result of |
* (mdio_read(&MII_PHYSID1) << 16 | mdio_read(&PHYSID2)) & @phy_id_mask |
* for this PHY type |
* @phy_id_mask: Defines the significant bits of @phy_id. A value of 0 |
* is used to terminate an array of struct mdio_device_id. |
*/ |
struct mdio_device_id { |
__u32 phy_id; |
__u32 phy_id_mask; |
}; |
struct zorro_device_id { |
__u32 id; /* Device ID or ZORRO_WILDCARD */ |
kernel_ulong_t driver_data; /* Data private to the driver */ |
}; |
#define ZORRO_WILDCARD (0xffffffff) /* not official */ |
#define ZORRO_DEVICE_MODALIAS_FMT "zorro:i%08X" |
#define ISAPNP_ANY_ID 0xffff |
struct isapnp_device_id { |
unsigned short card_vendor, card_device; |
unsigned short vendor, function; |
kernel_ulong_t driver_data; /* data private to the driver */ |
}; |
#endif /* LINUX_MOD_DEVICETABLE_H */ |
/drivers/include/linux/mutex.h |
---|
10,7 → 10,6 |
#ifndef __LINUX_MUTEX_H |
#define __LINUX_MUTEX_H |
#include <kernel.h> |
#include <linux/list.h> |
#include <asm/atomic.h> |
57,14 → 56,6 |
int *task; |
}; |
#define __MUTEX_INITIALIZER(lockname) \ |
{ .count = ATOMIC_INIT(1) \ |
, .wait_list = LIST_HEAD_INIT(lockname.wait_list) } |
#define DEFINE_MUTEX(mutexname) \ |
struct mutex mutexname = __MUTEX_INITIALIZER(mutexname) |
void __attribute__ ((fastcall)) __attribute__ ((dllimport)) |
mutex_init(struct mutex*)__asm__("MutexInit"); |
void __attribute__ ((fastcall)) __attribute__ ((dllimport)) |
/drivers/include/linux/pci.h |
---|
1,23 → 1,25 |
/* |
* pci.h |
* |
* PCI defines and function prototypes |
* Copyright 1994, Drew Eckhardt |
* Copyright 1997--1999 Martin Mares <mj@ucw.cz> |
* |
* For more information, please consult the following manuals (look at |
* http://www.pcisig.com/ for how to get them): |
* |
* PCI BIOS Specification |
* PCI Local Bus Specification |
* PCI to PCI Bridge Specification |
* PCI System Design Guide |
*/ |
#ifndef __PCI_H__ |
#define __PCI_H__ |
#include <types.h> |
#include <list.h> |
#include <ioport.h> |
#include <pci_regs.h> |
#include <linux/errno.h> |
/* pci_slot represents a physical slot */ |
struct pci_slot { |
struct pci_bus *bus; /* The bus this slot is on */ |
struct list_head list; /* node in list of slots on this bus */ |
// struct hotplug_slot *hotplug; /* Hotplug info (migrate over time) */ |
unsigned char number; /* PCI_SLOT(pci_dev->devfn) */ |
// struct kobject kobj; |
}; |
#ifndef __PCI_H__ |
#define __PCI_H__ |
#define PCI_ANY_ID (~0) |
147,7 → 149,145 |
#define PCI_CLASS_OTHERS 0xff |
/* |
* Under PCI, each device has 256 bytes of configuration address space, |
* of which the first 64 bytes are standardized as follows: |
*/ |
#define PCI_VENDOR_ID 0x000 /* 16 bits */ |
#define PCI_DEVICE_ID 0x002 /* 16 bits */ |
#define PCI_COMMAND 0x004 /* 16 bits */ |
#define PCI_COMMAND_IO 0x001 /* Enable response in I/O space */ |
#define PCI_COMMAND_MEMORY 0x002 /* Enable response in Memory space */ |
#define PCI_COMMAND_MASTER 0x004 /* Enable bus mastering */ |
#define PCI_COMMAND_SPECIAL 0x008 /* Enable response to special cycles */ |
#define PCI_COMMAND_INVALIDATE 0x010 /* Use memory write and invalidate */ |
#define PCI_COMMAND_VGA_PALETTE 0x020 /* Enable palette snooping */ |
#define PCI_COMMAND_PARITY 0x040 /* Enable parity checking */ |
#define PCI_COMMAND_WAIT 0x080 /* Enable address/data stepping */ |
#define PCI_COMMAND_SERR 0x100 /* Enable SERR */ |
#define PCI_COMMAND_FAST_BACK 0x200 /* Enable back-to-back writes */ |
#define PCI_COMMAND_INTX_DISABLE 0x400 /* INTx Emulation Disable */ |
#define PCI_STATUS 0x006 /* 16 bits */ |
#define PCI_STATUS_CAP_LIST 0x010 /* Support Capability List */ |
#define PCI_STATUS_66MHZ 0x020 /* Support 66 Mhz PCI 2.1 bus */ |
#define PCI_STATUS_UDF 0x040 /* Support User Definable Features [obsolete] */ |
#define PCI_STATUS_FAST_BACK 0x080 /* Accept fast-back to back */ |
#define PCI_STATUS_PARITY 0x100 /* Detected parity error */ |
#define PCI_STATUS_DEVSEL_MASK 0x600 /* DEVSEL timing */ |
#define PCI_STATUS_DEVSEL_FAST 0x000 |
#define PCI_STATUS_DEVSEL_MEDIUM 0x200 |
#define PCI_STATUS_DEVSEL_SLOW 0x400 |
#define PCI_STATUS_SIG_TARGET_ABORT 0x800 /* Set on target abort */ |
#define PCI_STATUS_REC_TARGET_ABORT 0x1000 /* Master ack of " */ |
#define PCI_STATUS_REC_MASTER_ABORT 0x2000 /* Set on master abort */ |
#define PCI_STATUS_SIG_SYSTEM_ERROR 0x4000 /* Set when we drive SERR */ |
#define PCI_STATUS_DETECTED_PARITY 0x8000 /* Set on parity error */ |
#define PCI_CLASS_REVISION 0x08 /* High 24 bits are class, low 8 revision */ |
#define PCI_REVISION_ID 0x08 /* Revision ID */ |
#define PCI_CLASS_PROG 0x09 /* Reg. Level Programming Interface */ |
#define PCI_CLASS_DEVICE 0x0a /* Device class */ |
#define PCI_CACHE_LINE_SIZE 0x0c /* 8 bits */ |
#define PCI_LATENCY_TIMER 0x0d /* 8 bits */ |
#define PCI_HEADER_TYPE 0x0e /* 8 bits */ |
#define PCI_HEADER_TYPE_NORMAL 0 |
#define PCI_HEADER_TYPE_BRIDGE 1 |
#define PCI_HEADER_TYPE_CARDBUS 2 |
#define PCI_BIST 0x0f /* 8 bits */ |
#define PCI_BIST_CODE_MASK 0x0f /* Return result */ |
#define PCI_BIST_START 0x40 /* 1 to start BIST, 2 secs or less */ |
#define PCI_BIST_CAPABLE 0x80 /* 1 if BIST capable */ |
/* |
* Base addresses specify locations in memory or I/O space. |
* Decoded size can be determined by writing a value of |
* 0xffffffff to the register, and reading it back. Only |
* 1 bits are decoded. |
*/ |
#define PCI_BASE_ADDRESS_0 0x10 /* 32 bits */ |
#define PCI_BASE_ADDRESS_1 0x14 /* 32 bits [htype 0,1 only] */ |
#define PCI_BASE_ADDRESS_2 0x18 /* 32 bits [htype 0 only] */ |
#define PCI_BASE_ADDRESS_3 0x1c /* 32 bits */ |
#define PCI_BASE_ADDRESS_4 0x20 /* 32 bits */ |
#define PCI_BASE_ADDRESS_5 0x24 /* 32 bits */ |
#define PCI_BASE_ADDRESS_SPACE 0x01 /* 0 = memory, 1 = I/O */ |
#define PCI_BASE_ADDRESS_SPACE_IO 0x01 |
#define PCI_BASE_ADDRESS_SPACE_MEMORY 0x00 |
#define PCI_BASE_ADDRESS_MEM_TYPE_MASK 0x06 |
#define PCI_BASE_ADDRESS_MEM_TYPE_32 0x00 /* 32 bit address */ |
#define PCI_BASE_ADDRESS_MEM_TYPE_1M 0x02 /* Below 1M [obsolete] */ |
#define PCI_BASE_ADDRESS_MEM_TYPE_64 0x04 /* 64 bit address */ |
#define PCI_BASE_ADDRESS_MEM_PREFETCH 0x08 /* prefetchable? */ |
#define PCI_BASE_ADDRESS_MEM_MASK (~0x0fUL) |
#define PCI_BASE_ADDRESS_IO_MASK (~0x03UL) |
/* bit 1 is reserved if address_space = 1 */ |
#define PCI_ROM_ADDRESS1 0x38 /* Same as PCI_ROM_ADDRESS, but for htype 1 */ |
/* Header type 0 (normal devices) */ |
#define PCI_CARDBUS_CIS 0x28 |
#define PCI_SUBSYSTEM_VENDOR_ID 0x2c |
#define PCI_SUBSYSTEM_ID 0x2e |
#define PCI_ROM_ADDRESS 0x30 /* Bits 31..11 are address, 10..1 reserved */ |
#define PCI_ROM_ADDRESS_ENABLE 0x01 |
#define PCI_ROM_ADDRESS_MASK (~0x7ffUL) |
#define PCI_INTERRUPT_LINE 0x3c /* 8 bits */ |
#define PCI_INTERRUPT_PIN 0x3d /* 8 bits */ |
#define PCI_CB_SUBSYSTEM_VENDOR_ID 0x40 |
#define PCI_CB_SUBSYSTEM_ID 0x42 |
#define PCI_CAPABILITY_LIST 0x34 /* Offset of first capability list entry */ |
#define PCI_CB_CAPABILITY_LIST 0x14 |
/* Capability lists */ |
#define PCI_CAP_LIST_ID 0 /* Capability ID */ |
#define PCI_CAP_ID_PM 0x01 /* Power Management */ |
#define PCI_CAP_ID_AGP 0x02 /* Accelerated Graphics Port */ |
#define PCI_CAP_ID_VPD 0x03 /* Vital Product Data */ |
#define PCI_CAP_ID_SLOTID 0x04 /* Slot Identification */ |
#define PCI_CAP_ID_MSI 0x05 /* Message Signalled Interrupts */ |
#define PCI_CAP_ID_CHSWP 0x06 /* CompactPCI HotSwap */ |
#define PCI_CAP_ID_PCIX 0x07 /* PCI-X */ |
#define PCI_CAP_ID_HT 0x08 /* HyperTransport */ |
#define PCI_CAP_ID_VNDR 0x09 /* Vendor specific capability */ |
#define PCI_CAP_ID_SHPC 0x0C /* PCI Standard Hot-Plug Controller */ |
#define PCI_CAP_ID_EXP 0x10 /* PCI Express */ |
#define PCI_CAP_ID_MSIX 0x11 /* MSI-X */ |
#define PCI_CAP_LIST_NEXT 1 /* Next capability in the list */ |
#define PCI_CAP_FLAGS 2 /* Capability defined flags (16 bits) */ |
#define PCI_CAP_SIZEOF 4 |
/* AGP registers */ |
#define PCI_AGP_VERSION 2 /* BCD version number */ |
#define PCI_AGP_RFU 3 /* Rest of capability flags */ |
#define PCI_AGP_STATUS 4 /* Status register */ |
#define PCI_AGP_STATUS_RQ_MASK 0xff000000 /* Maximum number of requests - 1 */ |
#define PCI_AGP_STATUS_SBA 0x0200 /* Sideband addressing supported */ |
#define PCI_AGP_STATUS_64BIT 0x0020 /* 64-bit addressing supported */ |
#define PCI_AGP_STATUS_FW 0x0010 /* FW transfers supported */ |
#define PCI_AGP_STATUS_RATE4 0x0004 /* 4x transfer rate supported */ |
#define PCI_AGP_STATUS_RATE2 0x0002 /* 2x transfer rate supported */ |
#define PCI_AGP_STATUS_RATE1 0x0001 /* 1x transfer rate supported */ |
#define PCI_AGP_COMMAND 8 /* Control register */ |
#define PCI_AGP_COMMAND_RQ_MASK 0xff000000 /* Master: Maximum number of requests */ |
#define PCI_AGP_COMMAND_SBA 0x0200 /* Sideband addressing enabled */ |
#define PCI_AGP_COMMAND_AGP 0x0100 /* Allow processing of AGP transactions */ |
#define PCI_AGP_COMMAND_64BIT 0x0020 /* Allow processing of 64-bit addresses */ |
#define PCI_AGP_COMMAND_FW 0x0010 /* Force FW transfers */ |
#define PCI_AGP_COMMAND_RATE4 0x0004 /* Use 4x rate */ |
#define PCI_AGP_COMMAND_RATE2 0x0002 /* Use 2x rate */ |
#define PCI_AGP_COMMAND_RATE1 0x0001 /* Use 1x rate */ |
#define PCI_AGP_SIZEOF 12 |
#define PCI_MAP_REG_START 0x10 |
#define PCI_MAP_REG_END 0x28 |
#define PCI_MAP_ROM_REG 0x30 |
209,28 → 349,8 |
#define PCI_SLOT(devfn) (((devfn) >> 3) & 0x1f) |
#define PCI_FUNC(devfn) ((devfn) & 0x07) |
/* Ioctls for /proc/bus/pci/X/Y nodes. */ |
#define PCIIOC_BASE ('P' << 24 | 'C' << 16 | 'I' << 8) |
#define PCIIOC_CONTROLLER (PCIIOC_BASE | 0x00) /* Get controller for PCI device. */ |
#define PCIIOC_MMAP_IS_IO (PCIIOC_BASE | 0x01) /* Set mmap state to I/O space. */ |
#define PCIIOC_MMAP_IS_MEM (PCIIOC_BASE | 0x02) /* Set mmap state to MEM space. */ |
#define PCIIOC_WRITE_COMBINE (PCIIOC_BASE | 0x03) /* Enable/disable write-combining. */ |
typedef unsigned int __bitwise pci_channel_state_t; |
enum pci_channel_state { |
/* I/O channel is in normal state */ |
pci_channel_io_normal = (__force pci_channel_state_t) 1, |
/* I/O to channel is blocked */ |
pci_channel_io_frozen = (__force pci_channel_state_t) 2, |
/* PCI card is dead */ |
pci_channel_io_perm_failure = (__force pci_channel_state_t) 3, |
}; |
typedef unsigned int PCITAG; |
extern inline PCITAG |
239,44 → 359,83 |
return(PCI_MAKE_TAG(busnum,devnum,funcnum)); |
} |
/* This defines the direction arg to the DMA mapping routines. */ |
#define PCI_DMA_BIDIRECTIONAL 0 |
#define PCI_DMA_TODEVICE 1 |
#define PCI_DMA_FROMDEVICE 2 |
#define PCI_DMA_NONE 3 |
struct resource |
{ |
resource_size_t start; |
resource_size_t end; |
// const char *name; |
unsigned long flags; |
// struct resource *parent, *sibling, *child; |
}; |
/* |
* For PCI devices, the region numbers are assigned this way: |
* IO resources have these defined flags. |
*/ |
enum { |
/* #0-5: standard PCI resources */ |
PCI_STD_RESOURCES, |
PCI_STD_RESOURCE_END = 5, |
#define IORESOURCE_BITS 0x000000ff /* Bus-specific bits */ |
/* #6: expansion ROM resource */ |
PCI_ROM_RESOURCE, |
#define IORESOURCE_IO 0x00000100 /* Resource type */ |
#define IORESOURCE_MEM 0x00000200 |
#define IORESOURCE_IRQ 0x00000400 |
#define IORESOURCE_DMA 0x00000800 |
/* device specific resources */ |
#ifdef CONFIG_PCI_IOV |
PCI_IOV_RESOURCES, |
PCI_IOV_RESOURCE_END = PCI_IOV_RESOURCES + PCI_SRIOV_NUM_BARS - 1, |
#endif |
#define IORESOURCE_PREFETCH 0x00001000 /* No side effects */ |
#define IORESOURCE_READONLY 0x00002000 |
#define IORESOURCE_CACHEABLE 0x00004000 |
#define IORESOURCE_RANGELENGTH 0x00008000 |
#define IORESOURCE_SHADOWABLE 0x00010000 |
#define IORESOURCE_BUS_HAS_VGA 0x00080000 |
/* resources assigned to buses behind the bridge */ |
#define PCI_BRIDGE_RESOURCE_NUM 4 |
#define IORESOURCE_DISABLED 0x10000000 |
#define IORESOURCE_UNSET 0x20000000 |
#define IORESOURCE_AUTO 0x40000000 |
#define IORESOURCE_BUSY 0x80000000 /* Driver has marked this resource busy */ |
PCI_BRIDGE_RESOURCES, |
PCI_BRIDGE_RESOURCE_END = PCI_BRIDGE_RESOURCES + |
PCI_BRIDGE_RESOURCE_NUM - 1, |
/* ISA PnP IRQ specific bits (IORESOURCE_BITS) */ |
#define IORESOURCE_IRQ_HIGHEDGE (1<<0) |
#define IORESOURCE_IRQ_LOWEDGE (1<<1) |
#define IORESOURCE_IRQ_HIGHLEVEL (1<<2) |
#define IORESOURCE_IRQ_LOWLEVEL (1<<3) |
#define IORESOURCE_IRQ_SHAREABLE (1<<4) |
/* total resources associated with a PCI device */ |
PCI_NUM_RESOURCES, |
/* ISA PnP DMA specific bits (IORESOURCE_BITS) */ |
#define IORESOURCE_DMA_TYPE_MASK (3<<0) |
#define IORESOURCE_DMA_8BIT (0<<0) |
#define IORESOURCE_DMA_8AND16BIT (1<<0) |
#define IORESOURCE_DMA_16BIT (2<<0) |
/* preserve this for compatibility */ |
DEVICE_COUNT_RESOURCE |
}; |
#define IORESOURCE_DMA_MASTER (1<<2) |
#define IORESOURCE_DMA_BYTE (1<<3) |
#define IORESOURCE_DMA_WORD (1<<4) |
#define IORESOURCE_DMA_SPEED_MASK (3<<6) |
#define IORESOURCE_DMA_COMPATIBLE (0<<6) |
#define IORESOURCE_DMA_TYPEA (1<<6) |
#define IORESOURCE_DMA_TYPEB (2<<6) |
#define IORESOURCE_DMA_TYPEF (3<<6) |
/* ISA PnP memory I/O specific bits (IORESOURCE_BITS) */ |
#define IORESOURCE_MEM_WRITEABLE (1<<0) /* dup: IORESOURCE_READONLY */ |
#define IORESOURCE_MEM_CACHEABLE (1<<1) /* dup: IORESOURCE_CACHEABLE */ |
#define IORESOURCE_MEM_RANGELENGTH (1<<2) /* dup: IORESOURCE_RANGELENGTH */ |
#define IORESOURCE_MEM_TYPE_MASK (3<<3) |
#define IORESOURCE_MEM_8BIT (0<<3) |
#define IORESOURCE_MEM_16BIT (1<<3) |
#define IORESOURCE_MEM_8AND16BIT (2<<3) |
#define IORESOURCE_MEM_32BIT (3<<3) |
#define IORESOURCE_MEM_SHADOWABLE (1<<5) /* dup: IORESOURCE_SHADOWABLE */ |
#define IORESOURCE_MEM_EXPANSIONROM (1<<6) |
/* PCI ROM control bits (IORESOURCE_BITS) */ |
#define IORESOURCE_ROM_ENABLE (1<<0) /* ROM is enabled, same as PCI_ROM_ADDRESS_ENABLE */ |
#define IORESOURCE_ROM_SHADOW (1<<1) /* ROM is copy at C000:0 */ |
#define IORESOURCE_ROM_COPY (1<<2) /* ROM is alloc'd copy, resource field overlaid */ |
#define IORESOURCE_ROM_BIOS_COPY (1<<3) /* ROM is BIOS copy, resource field overlaid */ |
/* PCI control bits. Shares IORESOURCE_BITS with above PCI ROM. */ |
#define IORESOURCE_PCI_FIXED (1<<4) /* Do not move resource */ |
/* |
* For PCI devices, the region numbers are assigned this way: |
* |
295,56 → 454,32 |
#define DEVICE_COUNT_RESOURCE 12 |
#define PCI_CFG_SPACE_SIZE 256 |
#define PCI_CFG_SPACE_EXP_SIZE 4096 |
typedef int __bitwise pci_power_t; |
#define PCI_D0 ((pci_power_t __force) 0) |
#define PCI_D1 ((pci_power_t __force) 1) |
#define PCI_D2 ((pci_power_t __force) 2) |
#define PCI_D3hot ((pci_power_t __force) 3) |
#define PCI_D3cold ((pci_power_t __force) 4) |
#define PCI_UNKNOWN ((pci_power_t __force) 5) |
#define PCI_POWER_ERROR ((pci_power_t __force) -1) |
enum pci_bar_type { |
pci_bar_unknown, /* Standard PCI BAR probe */ |
pci_bar_io, /* An io port BAR */ |
pci_bar_mem32, /* A 32-bit memory BAR */ |
pci_bar_mem64, /* A 64-bit memory BAR */ |
}; |
/* |
* The pci_dev structure is used to describe PCI devices. |
*/ |
struct pci_dev { |
struct list_head bus_list; /* node in per-bus list */ |
struct pci_bus *bus; /* bus this device is on */ |
struct pci_bus *subordinate; /* bus this device bridges to */ |
// struct list_head bus_list; /* node in per-bus list */ |
// struct pci_bus *bus; /* bus this device is on */ |
// struct pci_bus *subordinate; /* bus this device bridges to */ |
void *sysdata; /* hook for sys-specific extension */ |
// void *sysdata; /* hook for sys-specific extension */ |
// struct proc_dir_entry *procent; /* device entry in /proc/bus/pci */ |
struct pci_slot *slot; /* Physical slot this device is in */ |
u32_t busnr; |
unsigned int devfn; /* encoded device & function index */ |
unsigned short vendor; |
unsigned short device; |
unsigned short subsystem_vendor; |
unsigned short subsystem_device; |
unsigned int class; /* 3 bytes: (base,sub,prog-if) */ |
u8 revision; /* PCI revision, low byte of class word */ |
u8 hdr_type; /* PCI header type (`multi' flag masked out) */ |
u8 pcie_cap; /* PCI-E capability offset */ |
u8 pcie_type; /* PCI-E device/port type */ |
u8 rom_base_reg; /* which config register controls the ROM */ |
u8 pin; /* which interrupt pin this device uses */ |
// struct pci_slot *slot; /* Physical slot this device is in */ |
u32_t bus; |
u32_t devfn; /* encoded device & function index */ |
u16_t vendor; |
u16_t device; |
u16_t subsystem_vendor; |
u16_t subsystem_device; |
u32_t class; /* 3 bytes: (base,sub,prog-if) */ |
uint8_t revision; /* PCI revision, low byte of class word */ |
uint8_t hdr_type; /* PCI header type (`multi' flag masked out) */ |
uint8_t pcie_type; /* PCI-E device/port type */ |
uint8_t rom_base_reg; /* which config register controls the ROM */ |
uint8_t pin; /* which interrupt pin this device uses */ |
// struct pci_driver *driver; /* which driver has allocated this device */ |
u64 dma_mask; /* Mask of the bits of bus address this |
uint64_t dma_mask; /* Mask of the bits of bus address this |
device implements. Normally this is |
0xffffffff. You only need to change |
this if your device has broken DMA |
352,29 → 487,22 |
// struct device_dma_parameters dma_parms; |
pci_power_t current_state; /* Current operating state. In ACPI-speak, |
this is D0-D3, D0 being fully functional, |
and D3 being off. */ |
int pm_cap; /* PM capability offset in the |
configuration space */ |
// pci_power_t current_state; /* Current operating state. In ACPI-speak, |
// this is D0-D3, D0 being fully functional, |
// and D3 being off. */ |
// int pm_cap; /* PM capability offset in the |
// configuration space */ |
unsigned int pme_support:5; /* Bitmask of states from which PME# |
can be generated */ |
unsigned int pme_interrupt:1; |
unsigned int d1_support:1; /* Low power state D1 is supported */ |
unsigned int d2_support:1; /* Low power state D2 is supported */ |
unsigned int no_d1d2:1; /* Only allow D0 and D3 */ |
unsigned int mmio_always_on:1; /* disallow turning off io/mem |
decoding during bar sizing */ |
unsigned int wakeup_prepared:1; |
unsigned int d3_delay; /* D3->D0 transition time in ms */ |
pci_channel_state_t error_state; /* current connectivity state */ |
// pci_channel_state_t error_state; /* current connectivity state */ |
struct device dev; /* Generic device interface */ |
struct acpi_device *acpi_dev; |
// int cfg_size; /* Size of configuration space */ |
int cfg_size; /* Size of configuration space */ |
/* |
* Instead of touching interrupt line and base address registers |
* directly, use the values stored here. They might be different! |
396,22 → 524,17 |
unsigned int msix_enabled:1; |
unsigned int ari_enabled:1; /* ARI forwarding */ |
unsigned int is_managed:1; |
unsigned int is_pcie:1; /* Obsolete. Will be removed. |
Use pci_is_pcie() instead */ |
unsigned int needs_freset:1; /* Dev requires fundamental reset */ |
unsigned int is_pcie:1; |
unsigned int state_saved:1; |
unsigned int is_physfn:1; |
unsigned int is_virtfn:1; |
unsigned int reset_fn:1; |
unsigned int is_hotplug_bridge:1; |
unsigned int __aer_firmware_first_valid:1; |
unsigned int __aer_firmware_first:1; |
// pci_dev_flags_t dev_flags; |
// atomic_t enable_cnt; /* pci_enable_device has been called */ |
// u32 saved_config_space[16]; /* config space saved at suspend time */ |
// struct hlist_head saved_cap_space; |
// struct bin_attribute *rom_attr; /* attribute descriptor for sysfs ROM entry */ |
int rom_attr_enabled; /* has display of the rom attribute been enabled? */ |
// int rom_attr_enabled; /* has display of the rom attribute been enabled? */ |
// struct bin_attribute *res_attr[DEVICE_COUNT_RESOURCE]; /* sysfs file for resources */ |
// struct bin_attribute *res_attr_wc[DEVICE_COUNT_RESOURCE]; /* sysfs file for WC mapping of resources */ |
}; |
427,14 → 550,9 |
(pci_resource_end((dev), (bar)) - \ |
pci_resource_start((dev), (bar)) + 1)) |
struct pci_device_id |
{ |
u16_t vendor, device; /* Vendor and device ID or PCI_ANY_ID*/ |
u16_t subvendor, subdevice; /* Subsystem ID's or PCI_ANY_ID */ |
u32_t class, class_mask; /* (class,subclass,prog-if) triplet */ |
u32_t driver_data; /* Data private to the driver */ |
}; |
typedef struct |
{ |
struct list_head link; |
441,122 → 559,6 |
struct pci_dev pci_dev; |
}pci_dev_t; |
typedef unsigned short __bitwise pci_bus_flags_t; |
enum pci_bus_flags { |
PCI_BUS_FLAGS_NO_MSI = (__force pci_bus_flags_t) 1, |
PCI_BUS_FLAGS_NO_MMRBC = (__force pci_bus_flags_t) 2, |
}; |
struct pci_sysdata |
{ |
int domain; /* PCI domain */ |
int node; /* NUMA node */ |
#ifdef CONFIG_X86_64 |
void *iommu; /* IOMMU private data */ |
#endif |
}; |
struct pci_bus; |
struct pci_ops |
{ |
int (*read)(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 *val); |
int (*write)(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 val); |
}; |
/* |
* The first PCI_BRIDGE_RESOURCE_NUM PCI bus resources (those that correspond |
* to P2P or CardBus bridge windows) go in a table. Additional ones (for |
* buses below host bridges or subtractive decode bridges) go in the list. |
* Use pci_bus_for_each_resource() to iterate through all the resources. |
*/ |
/* |
* PCI_SUBTRACTIVE_DECODE means the bridge forwards the window implicitly |
* and there's no way to program the bridge with the details of the window. |
* This does not apply to ACPI _CRS windows, even with the _DEC subtractive- |
* decode bit set, because they are explicit and can be programmed with _SRS. |
*/ |
#define PCI_SUBTRACTIVE_DECODE 0x1 |
struct pci_bus_resource { |
struct list_head list; |
struct resource *res; |
unsigned int flags; |
}; |
#define PCI_REGION_FLAG_MASK 0x0fU /* These bits of resource flags tell us the PCI region flags */ |
struct pci_bus { |
struct list_head node; /* node in list of buses */ |
struct pci_bus *parent; /* parent bus this bridge is on */ |
struct list_head children; /* list of child buses */ |
struct list_head devices; /* list of devices on this bus */ |
struct pci_dev *self; /* bridge device as seen by parent */ |
struct list_head slots; /* list of slots on this bus */ |
struct resource *resource[PCI_BRIDGE_RESOURCE_NUM]; |
struct list_head resources; /* address space routed to this bus */ |
struct pci_ops *ops; /* configuration access functions */ |
void *sysdata; /* hook for sys-specific extension */ |
unsigned char number; /* bus number */ |
unsigned char primary; /* number of primary bridge */ |
unsigned char secondary; /* number of secondary bridge */ |
unsigned char subordinate; /* max number of subordinate buses */ |
char name[48]; |
unsigned short bridge_ctl; /* manage NO_ISA/FBB/et al behaviors */ |
pci_bus_flags_t bus_flags; /* Inherited by child busses */ |
// struct device *bridge; |
// struct device dev; |
// struct bin_attribute *legacy_io; /* legacy I/O for this bus */ |
// struct bin_attribute *legacy_mem; /* legacy mem */ |
unsigned int is_added:1; |
}; |
#define pci_bus_b(n) list_entry(n, struct pci_bus, node) |
#define to_pci_bus(n) container_of(n, struct pci_bus, dev) |
#define pci_dev_b(n) list_entry(n, struct pci_dev, bus_list) |
#define to_pci_dev(n) container_of(n, struct pci_dev, dev) |
#define for_each_pci_dev(d) while ((d = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, d)) != NULL) |
static inline int pci_domain_nr(struct pci_bus *bus) |
{ |
struct pci_sysdata *sd = bus->sysdata; |
return sd->domain; |
} |
static inline bool pci_dev_msi_enabled(struct pci_dev *pci_dev) { return false; } |
/* |
* Error values that may be returned by PCI functions. |
*/ |
#define PCIBIOS_SUCCESSFUL 0x00 |
#define PCIBIOS_FUNC_NOT_SUPPORTED 0x81 |
#define PCIBIOS_BAD_VENDOR_ID 0x83 |
#define PCIBIOS_DEVICE_NOT_FOUND 0x86 |
#define PCIBIOS_BAD_REGISTER_NUMBER 0x87 |
#define PCIBIOS_SET_FAILED 0x88 |
#define PCIBIOS_BUFFER_TOO_SMALL 0x89 |
/* Low-level architecture-dependent routines */ |
struct pci_bus_region { |
resource_size_t start; |
resource_size_t end; |
}; |
extern struct list_head pci_root_buses; /* list of all known PCI buses */ |
int enum_pci_devices(void); |
struct pci_device_id* |
566,100 → 568,9 |
int pci_set_dma_mask(struct pci_dev *dev, u64 mask); |
struct pci_bus * pci_create_bus(int bus, struct pci_ops *ops, void *sysdata); |
struct pci_bus * pci_find_bus(int domain, int busnr); |
int pci_find_capability(struct pci_dev *dev, int cap); |
int pci_find_next_capability(struct pci_dev *dev, u8 pos, int cap); |
int pci_find_ext_capability(struct pci_dev *dev, int cap); |
int pci_bus_find_ext_capability(struct pci_bus *bus, unsigned int devfn, |
int cap); |
int pci_find_next_ht_capability(struct pci_dev *dev, int pos, int ht_cap); |
struct pci_bus * pci_find_next_bus(const struct pci_bus *from); |
unsigned int pci_scan_child_bus(struct pci_bus *bus); |
void pcibios_fixup_bus(struct pci_bus *b); |
u8 pci_swizzle_interrupt_pin(struct pci_dev *dev, u8 pin); |
struct pci_dev * pci_get_slot(struct pci_bus *bus, unsigned int devfn); |
#define pci_name(x) "radeon" |
static inline bool pci_is_root_bus(struct pci_bus *pbus) |
{ |
return !(pbus->parent); |
} |
/** |
* pci_pcie_cap - get the saved PCIe capability offset |
* @dev: PCI device |
* |
* PCIe capability offset is calculated at PCI device initialization |
* time and saved in the data structure. This function returns saved |
* PCIe capability offset. Using this instead of pci_find_capability() |
* reduces unnecessary search in the PCI configuration space. If you |
* need to calculate PCIe capability offset from raw device for some |
* reasons, please use pci_find_capability() instead. |
*/ |
static inline int pci_pcie_cap(struct pci_dev *dev) |
{ |
return dev->pcie_cap; |
} |
/** |
* pci_is_pcie - check if the PCI device is PCI Express capable |
* @dev: PCI device |
* |
* Retrun true if the PCI device is PCI Express capable, false otherwise. |
*/ |
static inline bool pci_is_pcie(struct pci_dev *dev) |
{ |
return !!pci_pcie_cap(dev); |
} |
int pci_read_config_dyte(struct pci_dev *dev, int where, u16 *val); |
int pci_read_config_word(struct pci_dev *dev, int where, u16 *val); |
int pci_read_config_dword(struct pci_dev *dev, int where, u32 *val); |
static inline int pci_iov_init(struct pci_dev *dev) |
{ |
return -ENODEV; |
} |
static inline void pci_iov_release(struct pci_dev *dev) |
{ |
} |
static inline int pci_iov_resource_bar(struct pci_dev *dev, int resno, |
enum pci_bar_type *type) |
{ |
return 0; |
} |
static inline void pci_restore_iov_state(struct pci_dev *dev) |
{ |
} |
static inline int pci_iov_bus_range(struct pci_bus *bus) |
{ |
return 0; |
} |
static inline int pci_enable_ats(struct pci_dev *dev, int ps) |
{ |
return -ENODEV; |
} |
static inline void pci_disable_ats(struct pci_dev *dev) |
{ |
} |
static inline int pci_ats_queue_depth(struct pci_dev *dev) |
{ |
return -ENODEV; |
} |
static inline int pci_ats_enabled(struct pci_dev *dev) |
{ |
return 0; |
} |
int acpi_get_irq(struct pci_dev *dev); |
#define pci_name(x) "" |
#endif //__PCI__H__ |
/drivers/include/linux/poison.h |
---|
0,0 → 1,89 |
#ifndef _LINUX_POISON_H |
#define _LINUX_POISON_H |
/********** include/linux/list.h **********/ |
/* |
* Architectures might want to move the poison pointer offset |
* into some well-recognized area such as 0xdead000000000000, |
* that is also not mappable by user-space exploits: |
*/ |
#ifdef CONFIG_ILLEGAL_POINTER_VALUE |
# define POISON_POINTER_DELTA _AC(CONFIG_ILLEGAL_POINTER_VALUE, UL) |
#else |
# define POISON_POINTER_DELTA 0 |
#endif |
/* |
* These are non-NULL pointers that will result in page faults |
* under normal circumstances, used to verify that nobody uses |
* non-initialized list entries. |
*/ |
#define LIST_POISON1 ((void *) 0x00100100 + POISON_POINTER_DELTA) |
#define LIST_POISON2 ((void *) 0x00200200 + POISON_POINTER_DELTA) |
/********** include/linux/timer.h **********/ |
/* |
* Magic number "tsta" to indicate a static timer initializer |
* for the object debugging code. |
*/ |
#define TIMER_ENTRY_STATIC ((void *) 0x74737461) |
/********** mm/debug-pagealloc.c **********/ |
#define PAGE_POISON 0xaa |
/********** mm/slab.c **********/ |
/* |
* Magic nums for obj red zoning. |
* Placed in the first word before and the first word after an obj. |
*/ |
#define RED_INACTIVE 0x09F911029D74E35BULL /* when obj is inactive */ |
#define RED_ACTIVE 0xD84156C5635688C0ULL /* when obj is active */ |
#define SLUB_RED_INACTIVE 0xbb |
#define SLUB_RED_ACTIVE 0xcc |
/* ...and for poisoning */ |
#define POISON_INUSE 0x5a /* for use-uninitialised poisoning */ |
#define POISON_FREE 0x6b /* for use-after-free poisoning */ |
#define POISON_END 0xa5 /* end-byte of poisoning */ |
/********** arch/$ARCH/mm/init.c **********/ |
#define POISON_FREE_INITMEM 0xcc |
/********** arch/ia64/hp/common/sba_iommu.c **********/ |
/* |
* arch/ia64/hp/common/sba_iommu.c uses a 16-byte poison string with a |
* value of "SBAIOMMU POISON\0" for spill-over poisoning. |
*/ |
/********** fs/jbd/journal.c **********/ |
#define JBD_POISON_FREE 0x5b |
#define JBD2_POISON_FREE 0x5c |
/********** drivers/base/dmapool.c **********/ |
#define POOL_POISON_FREED 0xa7 /* !inuse */ |
#define POOL_POISON_ALLOCATED 0xa9 /* !initted */ |
/********** drivers/atm/ **********/ |
#define ATM_POISON_FREE 0x12 |
#define ATM_POISON 0xdeadbeef |
/********** net/ **********/ |
#define NEIGHBOR_DEAD 0xdeadbeef |
#define NETFILTER_LINK_POISON 0xdead57ac |
/********** kernel/mutexes **********/ |
#define MUTEX_DEBUG_INIT 0x11 |
#define MUTEX_DEBUG_FREE 0x22 |
/********** lib/flex_array.c **********/ |
#define FLEX_ARRAY_FREE 0x6c /* for use-after-free poisoning */ |
/********** security/ **********/ |
#define KEY_DESTROY 0xbd |
/********** sound/oss/ **********/ |
#define OSS_POISON_FREE 0xAB |
#endif |
/drivers/include/linux/sched.h |
---|
1,6 → 1,7 |
/* stub */ |
static inline void mdelay(unsigned long time) |
/* |
static inline void mdelay(u32_t time) |
{ |
time /= 10; |
if(!time) time = 1; |
13,7 → 14,7 |
}; |
static inline void udelay(unsigned long delay) |
static inline void udelay(u32_t delay) |
{ |
if(!delay) delay++; |
delay*= 500; |
26,4 → 27,4 |
:::"eax","ebx","ecx","edx" ); |
} |
} |
*/ |
/drivers/include/linux/slab.h |
---|
0,0 → 1,2 |
// stub |
/drivers/include/linux/spinlock_api_up.h |
---|
16,7 → 16,7 |
#define in_lock_functions(ADDR) 0 |
#define assert_spin_locked(lock) do { (void)(lock); } while (0) |
#define assert_raw_spin_locked(lock) do { (void)(lock); } while (0) |
/* |
* In the UP-nondebug case there's no real locking going on, so the |
40,7 → 40,8 |
do { preempt_enable(); __release(lock); (void)(lock); } while (0) |
#define __UNLOCK_BH(lock) \ |
do { preempt_enable_no_resched(); local_bh_enable(); __release(lock); (void)(lock); } while (0) |
do { preempt_enable_no_resched(); local_bh_enable(); \ |
__release(lock); (void)(lock); } while (0) |
#define __UNLOCK_IRQ(lock) \ |
do { local_irq_enable(); __UNLOCK(lock); } while (0) |
/drivers/include/linux/string.h |
---|
62,10 → 62,21 |
#ifndef __HAVE_ARCH_STRRCHR |
extern char * strrchr(const char *,int); |
#endif |
extern char * __must_check strstrip(char *); |
extern char * __must_check skip_spaces(const char *); |
extern char *strim(char *); |
static inline __must_check char *strstrip(char *str) |
{ |
return strim(str); |
} |
#ifndef __HAVE_ARCH_STRSTR |
extern char * strstr(const char *,const char *); |
#endif |
#ifndef __HAVE_ARCH_STRNSTR |
extern char * strnstr(const char *, const char *, size_t); |
#endif |
#ifndef __HAVE_ARCH_STRLEN |
extern __kernel_size_t strlen(const char *); |
#endif |
/drivers/include/linux/sysrq.h |
---|
0,0 → 1,2 |
// stub |
/drivers/include/linux/types.h |
---|
8,7 → 8,10 |
#define DECLARE_BITMAP(name,bits) \ |
unsigned long name[BITS_TO_LONGS(bits)] |
#else |
#ifndef __EXPORTED_HEADERS__ |
#warning "Attempt to use kernel headers from user space, see http://kernelnewbies.org/KernelHeaders" |
#endif /* __EXPORTED_HEADERS__ */ |
#endif |
#include <linux/posix_types.h> |
175,6 → 178,19 |
typedef __u16 __bitwise __sum16; |
typedef __u32 __bitwise __wsum; |
/* |
* aligned_u64 should be used in defining kernel<->userspace ABIs to avoid |
* common 32/64-bit compat problems. |
* 64-bit values align to 4-byte boundaries on x86_32 (and possibly other |
* architectures) and to 8-byte boundaries on 64-bit architetures. The new |
* aligned_64 type enforces 8-byte alignment so that structs containing |
* aligned_64 values have the same alignment on 32-bit and 64-bit architectures. |
* No conversions are necessary between 32-bit user-space and a 64-bit kernel. |
*/ |
#define __aligned_u64 __u64 __attribute__((aligned(8))) |
#define __aligned_be64 __be64 __attribute__((aligned(8))) |
#define __aligned_le64 __le64 __attribute__((aligned(8))) |
#ifdef __KERNEL__ |
typedef unsigned __bitwise__ gfp_t; |
typedef unsigned __bitwise__ fmode_t; |
188,15 → 204,27 |
typedef phys_addr_t resource_size_t; |
typedef struct { |
volatile int counter; |
int counter; |
} atomic_t; |
#ifdef CONFIG_64BIT |
typedef struct { |
volatile long counter; |
long counter; |
} atomic64_t; |
#endif |
struct list_head { |
struct list_head *next, *prev; |
}; |
struct hlist_head { |
struct hlist_node *first; |
}; |
struct hlist_node { |
struct hlist_node *next, **pprev; |
}; |
struct ustat { |
__kernel_daddr_t f_tfree; |
__kernel_ino_t f_tinode; |
243,8 → 271,6 |
#define BUILD_BUG_ON_ZERO(e) (sizeof(char[1 - 2 * !!(e)]) - 1) |
#define __must_be_array(a) \ |
BUILD_BUG_ON_ZERO(__builtin_types_compatible_p(typeof(a), typeof(&a[0]))) |
#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]) + __must_be_array(arr)) |
274,6 → 300,7 |
int dbgprintf(const char* format, ...); |
#define GFP_KERNEL 0 |
#define GFP_ATOMIC 0 |
//#include <stdio.h> |
330,6 → 357,16 |
#define ENTER() dbgprintf("enter %s\n",__FUNCTION__) |
#define LEAVE() dbgprintf("leave %s\n",__FUNCTION__) |
struct timeval |
{ |
__kernel_time_t tv_sec; /* seconds */ |
__kernel_suseconds_t tv_usec; /* microseconds */ |
}; |
#define PCI_DEVICE_ID_ATI_RADEON_QY 0x5159 |
#endif /* _LINUX_TYPES_H */ |