URL https://opencores.org/ocsvn/or1k_soc_on_altera_embedded_dev_kit/or1k_soc_on_altera_embedded_dev_kit/trunk

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [trunk/] [linux-2.6/] [linux-2.6.24/] [include/] [asm-or32/] [atomic.h] - Blame information for rev 9

Details | Compare with Previous | View Log


#ifndef __ASM_OR32_ATOMIC__
#define __ASM_OR32_ATOMIC__
 
#include <asm/system.h>
#include <linux/linkage.h>
#include <linux/compiler.h>
 
/*
 * Atomic operations that C can't guarantee us.  Useful for
 * resource counting etc..
 */
 
/*
 * Make sure gcc doesn't try to be clever and move things around
 * on us. We need to use _exactly_ the address the user gave us,
 * not some alias that contains the same information.
 */
 
#define __atomic_fool_gcc(x) (*(struct { int a[100]; } *)x)
 
typedef struct { int counter; } atomic_t;
 
#define ATOMIC_INIT(i)  { (i) }
 
#define atomic_read(v) ((v)->counter)
#define atomic_set(v,i) (((v)->counter) = (i))
 
/* These should be written in asm but we do it in C for now. */
 
extern __inline__ void atomic_add(int i, volatile atomic_t *v)
{
        unsigned long flags;
        local_save_flags(flags);
        local_irq_disable();
        v->counter += i;
        local_irq_restore(flags);
}
 
extern __inline__ void atomic_sub(int i, volatile atomic_t *v)
{
        unsigned long flags;
        local_save_flags(flags);
        local_irq_disable();
        v->counter -= i;
        local_irq_restore(flags);
}
 
extern __inline__ int atomic_add_return(int i, volatile atomic_t *v)
{
        unsigned long flags;
        int retval;
        local_save_flags(flags);
        local_irq_disable();
        retval = (v->counter += i);
        local_irq_restore(flags);
        return retval;
}
 
#define atomic_add_negative(a, v)       (atomic_add_return((a), (v)) < 0)
 
extern __inline__ int atomic_sub_return(int i, volatile atomic_t *v)
{
        unsigned long flags;
        int retval;
        local_save_flags(flags);
        local_irq_disable();
        retval = (v->counter -= i);
        local_irq_restore(flags);
        return retval;
}
 
extern __inline__ int atomic_sub_and_test(int i, volatile atomic_t *v)
{
        int retval;
        unsigned long flags;
        local_save_flags(flags);
        local_irq_disable();
        retval = (v->counter -= i) == 0;
        local_irq_restore(flags);
        return retval;
}
 
extern __inline__ void atomic_inc(volatile atomic_t *v)
{
        unsigned long flags;
        local_save_flags(flags);
        local_irq_disable();
        (v->counter)++;
        local_irq_restore(flags);
}
 
extern __inline__ void atomic_dec(volatile atomic_t *v)
{
        unsigned long flags;
        local_save_flags(flags);
        local_irq_disable();
        (v->counter)--;
        local_irq_restore(flags);
}
 
extern __inline__ int atomic_inc_return(volatile atomic_t *v)
{
        unsigned long flags;
        int retval;
        local_save_flags(flags);
        local_irq_disable();
        retval = (v->counter)++;
        local_irq_restore(flags);
        return retval;
}
 
extern __inline__ int atomic_dec_return(volatile atomic_t *v)
{
        unsigned long flags;
        int retval;
        local_save_flags(flags);
        local_irq_disable();
        retval = (v->counter)--;
        local_irq_restore(flags);
        return retval;
}
extern __inline__ int atomic_dec_and_test(volatile atomic_t *v)
{
        int retval;
        unsigned long flags;
        local_save_flags(flags);
        local_irq_disable();
        retval = --(v->counter) == 0;
        local_irq_restore(flags);
        return retval;
}
 
extern __inline__ int atomic_inc_and_test(volatile atomic_t *v)
{
        int retval;
        unsigned long flags;
        local_save_flags(flags);
        local_irq_disable();
        retval = ++(v->counter) == 0;
        local_irq_restore(flags);
        return retval;
}
/*RGD*/
static inline int atomic_cmpxchg(atomic_t *v, int old, int new)
{
        int ret;
        unsigned long flags;
 
        local_irq_save(flags);
        ret = v->counter;
        if (likely(ret == old))
                v->counter = new;
        local_irq_restore(flags);
 
        return ret;
}
 
/* Atomic operations are already serializing */
#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()
#define atomic_xchg(v, new) (xchg(&((v)->counter), new)) /*RGD*/
 
/*RGD*/
static inline int atomic_add_unless(atomic_t *v, int a, int u)
{
        int ret;
        unsigned long flags;
 
        local_save_flags(flags);
        local_irq_disable();
        ret = v->counter;
        if (ret != u)
                v->counter += a;
        local_irq_restore(flags);
        return ret != u;
}
#define atomic_inc_not_zero(v) atomic_add_unless((v), 1, 0)
/*RGD*/
/*RGD*/
#include <asm/errno.h>
#include <asm/uaccess.h>
static inline int
futex_atomic_cmpxchg_inatomic(int __user *uaddr, int oldval, int newval)
{
        return -ENOSYS;
}
/*RGD*/
 
#include <asm-generic/atomic.h> /*RGD*/
#endif /* __ASM_OR32_ATOMIC__ */

Line No.	Rev	Author	Line
1	7	xianfeng	`#ifndef __ASM_OR32_ATOMIC__`
2			`#define __ASM_OR32_ATOMIC__`
3
4			`#include <asm/system.h>`
5			`#include <linux/linkage.h>`
6			`#include <linux/compiler.h>`
7	9	xianfeng
8	7	xianfeng	`/*`
9			`* Atomic operations that C can't guarantee us. Useful for`
10			`* resource counting etc..`
11			`*/`
12
13			`/*`
14			`* Make sure gcc doesn't try to be clever and move things around`
15			`* on us. We need to use _exactly_ the address the user gave us,`
16			`* not some alias that contains the same information.`
17			`*/`
18
19			`#define __atomic_fool_gcc(x) ((struct { int a[100]; } )x)`
20
21			`typedef struct { int counter; } atomic_t;`
22
23			`#define ATOMIC_INIT(i) { (i) }`
24
25			`#define atomic_read(v) ((v)->counter)`
26			`#define atomic_set(v,i) (((v)->counter) = (i))`
27
28			`/* These should be written in asm but we do it in C for now. */`
29
30			`extern __inline__ void atomic_add(int i, volatile atomic_t *v)`
31			`{`
32			`unsigned long flags;`
33			`local_save_flags(flags);`
34			`local_irq_disable();`
35			`v->counter += i;`
36			`local_irq_restore(flags);`
37			`}`
38
39			`extern __inline__ void atomic_sub(int i, volatile atomic_t *v)`
40			`{`
41			`unsigned long flags;`
42			`local_save_flags(flags);`
43			`local_irq_disable();`
44			`v->counter -= i;`
45			`local_irq_restore(flags);`
46			`}`
47
48			`extern __inline__ int atomic_add_return(int i, volatile atomic_t *v)`
49			`{`
50			`unsigned long flags;`
51			`int retval;`
52			`local_save_flags(flags);`
53			`local_irq_disable();`
54			`retval = (v->counter += i);`
55			`local_irq_restore(flags);`
56			`return retval;`
57			`}`
58
59			`#define atomic_add_negative(a, v) (atomic_add_return((a), (v)) < 0)`
60
61			`extern __inline__ int atomic_sub_return(int i, volatile atomic_t *v)`
62			`{`
63			`unsigned long flags;`
64			`int retval;`
65			`local_save_flags(flags);`
66			`local_irq_disable();`
67			`retval = (v->counter -= i);`
68			`local_irq_restore(flags);`
69			`return retval;`
70			`}`
71
72			`extern __inline__ int atomic_sub_and_test(int i, volatile atomic_t *v)`
73			`{`
74			`int retval;`
75			`unsigned long flags;`
76			`local_save_flags(flags);`
77			`local_irq_disable();`
78			`retval = (v->counter -= i) == 0;`
79			`local_irq_restore(flags);`
80			`return retval;`
81			`}`
82
83			`extern __inline__ void atomic_inc(volatile atomic_t *v)`
84			`{`
85			`unsigned long flags;`
86			`local_save_flags(flags);`
87			`local_irq_disable();`
88			`(v->counter)++;`
89			`local_irq_restore(flags);`
90			`}`
91
92			`extern __inline__ void atomic_dec(volatile atomic_t *v)`
93			`{`
94			`unsigned long flags;`
95			`local_save_flags(flags);`
96			`local_irq_disable();`
97			`(v->counter)--;`
98			`local_irq_restore(flags);`
99			`}`
100
101			`extern __inline__ int atomic_inc_return(volatile atomic_t *v)`
102			`{`
103			`unsigned long flags;`
104			`int retval;`
105			`local_save_flags(flags);`
106			`local_irq_disable();`
107			`retval = (v->counter)++;`
108			`local_irq_restore(flags);`
109			`return retval;`
110			`}`
111
112			`extern __inline__ int atomic_dec_return(volatile atomic_t *v)`
113			`{`
114			`unsigned long flags;`
115			`int retval;`
116			`local_save_flags(flags);`
117			`local_irq_disable();`
118			`retval = (v->counter)--;`
119			`local_irq_restore(flags);`
120			`return retval;`
121			`}`
122			`extern __inline__ int atomic_dec_and_test(volatile atomic_t *v)`
123			`{`
124			`int retval;`
125			`unsigned long flags;`
126			`local_save_flags(flags);`
127			`local_irq_disable();`
128			`retval = --(v->counter) == 0;`
129			`local_irq_restore(flags);`
130			`return retval;`
131			`}`
132
133			`extern __inline__ int atomic_inc_and_test(volatile atomic_t *v)`
134			`{`
135			`int retval;`
136			`unsigned long flags;`
137			`local_save_flags(flags);`
138			`local_irq_disable();`
139			`retval = ++(v->counter) == 0;`
140			`local_irq_restore(flags);`
141			`return retval;`
142			`}`
143			`/RGD/`
144			`static inline int atomic_cmpxchg(atomic_t *v, int old, int new)`
145			`{`
146			`int ret;`
147			`unsigned long flags;`
148
149			`local_irq_save(flags);`
150			`ret = v->counter;`
151			`if (likely(ret == old))`
152			`v->counter = new;`
153			`local_irq_restore(flags);`
154
155			`return ret;`
156			`}`
157
158			`/* Atomic operations are already serializing */`
159			`#define smp_mb__before_atomic_dec() barrier()`
160			`#define smp_mb__after_atomic_dec() barrier()`
161			`#define smp_mb__before_atomic_inc() barrier()`
162			`#define smp_mb__after_atomic_inc() barrier()`
163			`#define atomic_xchg(v, new) (xchg(&((v)->counter), new)) /RGD/`
164
165			`/RGD/`
166			`static inline int atomic_add_unless(atomic_t *v, int a, int u)`
167			`{`
168			`int ret;`
169			`unsigned long flags;`
170
171			`local_save_flags(flags);`
172			`local_irq_disable();`
173			`ret = v->counter;`
174			`if (ret != u)`
175			`v->counter += a;`
176			`local_irq_restore(flags);`
177			`return ret != u;`
178			`}`
179			`#define atomic_inc_not_zero(v) atomic_add_unless((v), 1, 0)`
180			`/RGD/`
181			`/RGD/`
182			`#include <asm/errno.h>`
183			`#include <asm/uaccess.h>`
184			`static inline int`
185			`futex_atomic_cmpxchg_inatomic(int __user *uaddr, int oldval, int newval)`
186			`{`
187			`return -ENOSYS;`
188			`}`
189			`/RGD/`
190
191			`#include <asm-generic/atomic.h> /RGD/`
192			`#endif /* __ASM_OR32_ATOMIC__ */`

Browse

Tools

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [trunk/] [linux-2.6/] [linux-2.6.24/] [include/] [asm-or32/] [atomic.h] - Blame information for rev 9