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 7

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