Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
awilliam
GitHub Repository: awilliam/linux-vfio
 Path: blob/master/arch/cris/include/asm/atomic.h
15126 views
1
/* $Id: atomic.h,v 1.3 2001/07/25 16:15:19 bjornw Exp $ */

2


3
#ifndef __ASM_CRIS_ATOMIC__

4
#define __ASM_CRIS_ATOMIC__

5


6
#include <linux/compiler.h>

7
#include <linux/types.h>

8
#include <asm/system.h>

9
#include <arch/atomic.h>

10


11
/*

12
 * Atomic operations that C can't guarantee us.  Useful for

13
 * resource counting etc..

14
 */

15


16
#define ATOMIC_INIT(i)  { (i) }

17


18
#define atomic_read(v) (*(volatile int *)&(v)->counter)

19
#define atomic_set(v,i) (((v)->counter) = (i))

20


21
/* These should be written in asm but we do it in C for now. */

22


23
static inline void atomic_add(int i, volatile atomic_t *v)

24
{

25
	unsigned long flags;

26
	cris_atomic_save(v, flags);

27
	v->counter += i;

28
	cris_atomic_restore(v, flags);

29
}

30


31
static inline void atomic_sub(int i, volatile atomic_t *v)

32
{

33
	unsigned long flags;

34
	cris_atomic_save(v, flags);

35
	v->counter -= i;

36
	cris_atomic_restore(v, flags);

37
}

38


39
static inline int atomic_add_return(int i, volatile atomic_t *v)

40
{

41
	unsigned long flags;

42
	int retval;

43
	cris_atomic_save(v, flags);

44
	retval = (v->counter += i);

45
	cris_atomic_restore(v, flags);

46
	return retval;

47
}

48


49
#define atomic_add_negative(a, v)	(atomic_add_return((a), (v)) < 0)

50


51
static inline int atomic_sub_return(int i, volatile atomic_t *v)

52
{

53
	unsigned long flags;

54
	int retval;

55
	cris_atomic_save(v, flags);

56
	retval = (v->counter -= i);

57
	cris_atomic_restore(v, flags);

58
	return retval;

59
}

60


61
static inline int atomic_sub_and_test(int i, volatile atomic_t *v)

62
{

63
	int retval;

64
	unsigned long flags;

65
	cris_atomic_save(v, flags);

66
	retval = (v->counter -= i) == 0;

67
	cris_atomic_restore(v, flags);

68
	return retval;

69
}

70


71
static inline void atomic_inc(volatile atomic_t *v)

72
{

73
	unsigned long flags;

74
	cris_atomic_save(v, flags);

75
	(v->counter)++;

76
	cris_atomic_restore(v, flags);

77
}

78


79
static inline void atomic_dec(volatile atomic_t *v)

80
{

81
	unsigned long flags;

82
	cris_atomic_save(v, flags);

83
	(v->counter)--;

84
	cris_atomic_restore(v, flags);

85
}

86


87
static inline int atomic_inc_return(volatile atomic_t *v)

88
{

89
	unsigned long flags;

90
	int retval;

91
	cris_atomic_save(v, flags);

92
	retval = ++(v->counter);

93
	cris_atomic_restore(v, flags);

94
	return retval;

95
}

96


97
static inline int atomic_dec_return(volatile atomic_t *v)

98
{

99
	unsigned long flags;

100
	int retval;

101
	cris_atomic_save(v, flags);

102
	retval = --(v->counter);

103
	cris_atomic_restore(v, flags);

104
	return retval;

105
}

106
static inline int atomic_dec_and_test(volatile atomic_t *v)

107
{

108
	int retval;

109
	unsigned long flags;

110
	cris_atomic_save(v, flags);

111
	retval = --(v->counter) == 0;

112
	cris_atomic_restore(v, flags);

113
	return retval;

114
}

115


116
static inline int atomic_inc_and_test(volatile atomic_t *v)

117
{

118
	int retval;

119
	unsigned long flags;

120
	cris_atomic_save(v, flags);

121
	retval = ++(v->counter) == 0;

122
	cris_atomic_restore(v, flags);

123
	return retval;

124
}

125


126
static inline int atomic_cmpxchg(atomic_t *v, int old, int new)

127
{

128
	int ret;

129
	unsigned long flags;

130


131
	cris_atomic_save(v, flags);

132
	ret = v->counter;

133
	if (likely(ret == old))

134
		v->counter = new;

135
	cris_atomic_restore(v, flags);

136
	return ret;

137
}

138


139
#define atomic_xchg(v, new) (xchg(&((v)->counter), new))

140


141
static inline int atomic_add_unless(atomic_t *v, int a, int u)

142
{

143
	int ret;

144
	unsigned long flags;

145


146
	cris_atomic_save(v, flags);

147
	ret = v->counter;

148
	if (ret != u)

149
		v->counter += a;

150
	cris_atomic_restore(v, flags);

151
	return ret != u;

152
}

153
#define atomic_inc_not_zero(v) atomic_add_unless((v), 1, 0)

154


155
/* Atomic operations are already serializing */

156
#define smp_mb__before_atomic_dec()    barrier()

157
#define smp_mb__after_atomic_dec()     barrier()

158
#define smp_mb__before_atomic_inc()    barrier()

159
#define smp_mb__after_atomic_inc()     barrier()

160


161
#include <asm-generic/atomic-long.h>

162
#endif

163


164