1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36#ifndef _ASM_POWERPC_BITOPS_H
37#define _ASM_POWERPC_BITOPS_H
38
39#ifdef __KERNEL__
40
41#ifndef _LINUX_BITOPS_H
42#error only <linux/bitops.h> can be included directly
43#endif
44
45#include <linux/compiler.h>
46#include <asm/asm-compat.h>
47#include <asm/synch.h>
48#include <asm/asm-405.h>
49
50
51#define PPC_BITLSHIFT(be) (BITS_PER_LONG - 1 - (be))
52#define PPC_BIT(bit) (1UL << PPC_BITLSHIFT(bit))
53#define PPC_BITMASK(bs, be) ((PPC_BIT(bs) - PPC_BIT(be)) | PPC_BIT(bs))
54
55
56#define PPC_BITEXTRACT(bits, ppc_bit, dst_bit) \
57 ((((bits) >> PPC_BITLSHIFT(ppc_bit)) & 1) << (dst_bit))
58
59#define PPC_BITLSHIFT32(be) (32 - 1 - (be))
60#define PPC_BIT32(bit) (1UL << PPC_BITLSHIFT32(bit))
61#define PPC_BITMASK32(bs, be) ((PPC_BIT32(bs) - PPC_BIT32(be))|PPC_BIT32(bs))
62
63#define PPC_BITLSHIFT8(be) (8 - 1 - (be))
64#define PPC_BIT8(bit) (1UL << PPC_BITLSHIFT8(bit))
65#define PPC_BITMASK8(bs, be) ((PPC_BIT8(bs) - PPC_BIT8(be))|PPC_BIT8(bs))
66
67#include <asm/barrier.h>
68
69
70#define DEFINE_BITOP(fn, op, prefix) \
71static __inline__ void fn(unsigned long mask, \
72 volatile unsigned long *_p) \
73{ \
74 unsigned long old; \
75 unsigned long *p = (unsigned long *)_p; \
76 __asm__ __volatile__ ( \
77 prefix \
78"1:" PPC_LLARX(%0,0,%3,0) "\n" \
79 stringify_in_c(op) "%0,%0,%2\n" \
80 PPC405_ERR77(0,%3) \
81 PPC_STLCX "%0,0,%3\n" \
82 "bne- 1b\n" \
83 : "=&r" (old), "+m" (*p) \
84 : "r" (mask), "r" (p) \
85 : "cc", "memory"); \
86}
87
88DEFINE_BITOP(set_bits, or, "")
89DEFINE_BITOP(clear_bits, andc, "")
90DEFINE_BITOP(clear_bits_unlock, andc, PPC_RELEASE_BARRIER)
91DEFINE_BITOP(change_bits, xor, "")
92
93static __inline__ void set_bit(int nr, volatile unsigned long *addr)
94{
95 set_bits(BIT_MASK(nr), addr + BIT_WORD(nr));
96}
97
98static __inline__ void clear_bit(int nr, volatile unsigned long *addr)
99{
100 clear_bits(BIT_MASK(nr), addr + BIT_WORD(nr));
101}
102
103static __inline__ void clear_bit_unlock(int nr, volatile unsigned long *addr)
104{
105 clear_bits_unlock(BIT_MASK(nr), addr + BIT_WORD(nr));
106}
107
108static __inline__ void change_bit(int nr, volatile unsigned long *addr)
109{
110 change_bits(BIT_MASK(nr), addr + BIT_WORD(nr));
111}
112
113
114
115#define DEFINE_TESTOP(fn, op, prefix, postfix, eh) \
116static __inline__ unsigned long fn( \
117 unsigned long mask, \
118 volatile unsigned long *_p) \
119{ \
120 unsigned long old, t; \
121 unsigned long *p = (unsigned long *)_p; \
122 __asm__ __volatile__ ( \
123 prefix \
124"1:" PPC_LLARX(%0,0,%3,eh) "\n" \
125 stringify_in_c(op) "%1,%0,%2\n" \
126 PPC405_ERR77(0,%3) \
127 PPC_STLCX "%1,0,%3\n" \
128 "bne- 1b\n" \
129 postfix \
130 : "=&r" (old), "=&r" (t) \
131 : "r" (mask), "r" (p) \
132 : "cc", "memory"); \
133 return (old & mask); \
134}
135
136DEFINE_TESTOP(test_and_set_bits, or, PPC_ATOMIC_ENTRY_BARRIER,
137 PPC_ATOMIC_EXIT_BARRIER, 0)
138DEFINE_TESTOP(test_and_set_bits_lock, or, "",
139 PPC_ACQUIRE_BARRIER, 1)
140DEFINE_TESTOP(test_and_clear_bits, andc, PPC_ATOMIC_ENTRY_BARRIER,
141 PPC_ATOMIC_EXIT_BARRIER, 0)
142DEFINE_TESTOP(test_and_change_bits, xor, PPC_ATOMIC_ENTRY_BARRIER,
143 PPC_ATOMIC_EXIT_BARRIER, 0)
144
145static __inline__ int test_and_set_bit(unsigned long nr,
146 volatile unsigned long *addr)
147{
148 return test_and_set_bits(BIT_MASK(nr), addr + BIT_WORD(nr)) != 0;
149}
150
151static __inline__ int test_and_set_bit_lock(unsigned long nr,
152 volatile unsigned long *addr)
153{
154 return test_and_set_bits_lock(BIT_MASK(nr),
155 addr + BIT_WORD(nr)) != 0;
156}
157
158static __inline__ int test_and_clear_bit(unsigned long nr,
159 volatile unsigned long *addr)
160{
161 return test_and_clear_bits(BIT_MASK(nr), addr + BIT_WORD(nr)) != 0;
162}
163
164static __inline__ int test_and_change_bit(unsigned long nr,
165 volatile unsigned long *addr)
166{
167 return test_and_change_bits(BIT_MASK(nr), addr + BIT_WORD(nr)) != 0;
168}
169
170#ifdef CONFIG_PPC64
171static __inline__ unsigned long clear_bit_unlock_return_word(int nr,
172 volatile unsigned long *addr)
173{
174 unsigned long old, t;
175 unsigned long *p = (unsigned long *)addr + BIT_WORD(nr);
176 unsigned long mask = BIT_MASK(nr);
177
178 __asm__ __volatile__ (
179 PPC_RELEASE_BARRIER
180"1:" PPC_LLARX(%0,0,%3,0) "\n"
181 "andc %1,%0,%2\n"
182 PPC405_ERR77(0,%3)
183 PPC_STLCX "%1,0,%3\n"
184 "bne- 1b\n"
185 : "=&r" (old), "=&r" (t)
186 : "r" (mask), "r" (p)
187 : "cc", "memory");
188
189 return old;
190}
191
192
193#define clear_bit_unlock_is_negative_byte(nr, addr) \
194 (clear_bit_unlock_return_word(nr, addr) & BIT_MASK(PG_waiters))
195
196#endif
197
198#include <asm-generic/bitops/non-atomic.h>
199
200static __inline__ void __clear_bit_unlock(int nr, volatile unsigned long *addr)
201{
202 __asm__ __volatile__(PPC_RELEASE_BARRIER "" ::: "memory");
203 __clear_bit(nr, addr);
204}
205
206
207
208
209
210#define __ilog2(x) ilog2(x)
211
212#include <asm-generic/bitops/ffz.h>
213
214#include <asm-generic/bitops/builtin-__ffs.h>
215
216#include <asm-generic/bitops/builtin-ffs.h>
217
218
219
220
221
222static __inline__ int fls(unsigned int x)
223{
224 return 32 - __builtin_clz(x);
225}
226
227#include <asm-generic/bitops/builtin-__fls.h>
228
229static __inline__ int fls64(__u64 x)
230{
231 return 64 - __builtin_clzll(x);
232}
233
234#ifdef CONFIG_PPC64
235unsigned int __arch_hweight8(unsigned int w);
236unsigned int __arch_hweight16(unsigned int w);
237unsigned int __arch_hweight32(unsigned int w);
238unsigned long __arch_hweight64(__u64 w);
239#include <asm-generic/bitops/const_hweight.h>
240#else
241#include <asm-generic/bitops/hweight.h>
242#endif
243
244#include <asm-generic/bitops/find.h>
245
246
247#include <asm-generic/bitops/le.h>
248
249
250
251#include <asm-generic/bitops/ext2-atomic-setbit.h>
252
253#include <asm-generic/bitops/sched.h>
254
255#endif
256
257#endif
258