Loading...
Note: File does not exist in v6.13.7.
1/* bitops.h: bit operations for the Fujitsu FR-V CPUs
2 *
3 * For an explanation of how atomic ops work in this arch, see:
4 * Documentation/frv/atomic-ops.txt
5 *
6 * Copyright (C) 2004 Red Hat, Inc. All Rights Reserved.
7 * Written by David Howells (dhowells@redhat.com)
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version
12 * 2 of the License, or (at your option) any later version.
13 */
14#ifndef _ASM_BITOPS_H
15#define _ASM_BITOPS_H
16
17#include <linux/compiler.h>
18#include <asm/byteorder.h>
19
20#ifdef __KERNEL__
21
22#ifndef _LINUX_BITOPS_H
23#error only <linux/bitops.h> can be included directly
24#endif
25
26#include <asm-generic/bitops/ffz.h>
27
28#include <asm/atomic.h>
29
30static inline int test_and_clear_bit(unsigned long nr, volatile void *addr)
31{
32 unsigned int *ptr = (void *)addr;
33 unsigned int mask = 1UL << (nr & 31);
34 ptr += nr >> 5;
35 return (__atomic32_fetch_and(~mask, ptr) & mask) != 0;
36}
37
38static inline int test_and_set_bit(unsigned long nr, volatile void *addr)
39{
40 unsigned int *ptr = (void *)addr;
41 unsigned int mask = 1UL << (nr & 31);
42 ptr += nr >> 5;
43 return (__atomic32_fetch_or(mask, ptr) & mask) != 0;
44}
45
46static inline int test_and_change_bit(unsigned long nr, volatile void *addr)
47{
48 unsigned int *ptr = (void *)addr;
49 unsigned int mask = 1UL << (nr & 31);
50 ptr += nr >> 5;
51 return (__atomic32_fetch_xor(mask, ptr) & mask) != 0;
52}
53
54static inline void clear_bit(unsigned long nr, volatile void *addr)
55{
56 test_and_clear_bit(nr, addr);
57}
58
59static inline void set_bit(unsigned long nr, volatile void *addr)
60{
61 test_and_set_bit(nr, addr);
62}
63
64static inline void change_bit(unsigned long nr, volatile void *addr)
65{
66 test_and_change_bit(nr, addr);
67}
68
69static inline void __clear_bit(unsigned long nr, volatile void *addr)
70{
71 volatile unsigned long *a = addr;
72 int mask;
73
74 a += nr >> 5;
75 mask = 1 << (nr & 31);
76 *a &= ~mask;
77}
78
79static inline void __set_bit(unsigned long nr, volatile void *addr)
80{
81 volatile unsigned long *a = addr;
82 int mask;
83
84 a += nr >> 5;
85 mask = 1 << (nr & 31);
86 *a |= mask;
87}
88
89static inline void __change_bit(unsigned long nr, volatile void *addr)
90{
91 volatile unsigned long *a = addr;
92 int mask;
93
94 a += nr >> 5;
95 mask = 1 << (nr & 31);
96 *a ^= mask;
97}
98
99static inline int __test_and_clear_bit(unsigned long nr, volatile void *addr)
100{
101 volatile unsigned long *a = addr;
102 int mask, retval;
103
104 a += nr >> 5;
105 mask = 1 << (nr & 31);
106 retval = (mask & *a) != 0;
107 *a &= ~mask;
108 return retval;
109}
110
111static inline int __test_and_set_bit(unsigned long nr, volatile void *addr)
112{
113 volatile unsigned long *a = addr;
114 int mask, retval;
115
116 a += nr >> 5;
117 mask = 1 << (nr & 31);
118 retval = (mask & *a) != 0;
119 *a |= mask;
120 return retval;
121}
122
123static inline int __test_and_change_bit(unsigned long nr, volatile void *addr)
124{
125 volatile unsigned long *a = addr;
126 int mask, retval;
127
128 a += nr >> 5;
129 mask = 1 << (nr & 31);
130 retval = (mask & *a) != 0;
131 *a ^= mask;
132 return retval;
133}
134
135/*
136 * This routine doesn't need to be atomic.
137 */
138static inline int
139__constant_test_bit(unsigned long nr, const volatile void *addr)
140{
141 return ((1UL << (nr & 31)) & (((const volatile unsigned int *) addr)[nr >> 5])) != 0;
142}
143
144static inline int __test_bit(unsigned long nr, const volatile void *addr)
145{
146 int * a = (int *) addr;
147 int mask;
148
149 a += nr >> 5;
150 mask = 1 << (nr & 0x1f);
151 return ((mask & *a) != 0);
152}
153
154#define test_bit(nr,addr) \
155(__builtin_constant_p(nr) ? \
156 __constant_test_bit((nr),(addr)) : \
157 __test_bit((nr),(addr)))
158
159#include <asm-generic/bitops/find.h>
160
161/**
162 * fls - find last bit set
163 * @x: the word to search
164 *
165 * This is defined the same way as ffs:
166 * - return 32..1 to indicate bit 31..0 most significant bit set
167 * - return 0 to indicate no bits set
168 */
169#define fls(x) \
170({ \
171 int bit; \
172 \
173 asm(" subcc %1,gr0,gr0,icc0 \n" \
174 " ckne icc0,cc4 \n" \
175 " cscan.p %1,gr0,%0 ,cc4,#1 \n" \
176 " csub %0,%0,%0 ,cc4,#0 \n" \
177 " csub %2,%0,%0 ,cc4,#1 \n" \
178 : "=&r"(bit) \
179 : "r"(x), "r"(32) \
180 : "icc0", "cc4" \
181 ); \
182 \
183 bit; \
184})
185
186/**
187 * fls64 - find last bit set in a 64-bit value
188 * @n: the value to search
189 *
190 * This is defined the same way as ffs:
191 * - return 64..1 to indicate bit 63..0 most significant bit set
192 * - return 0 to indicate no bits set
193 */
194static inline __attribute__((const))
195int fls64(u64 n)
196{
197 union {
198 u64 ll;
199 struct { u32 h, l; };
200 } _;
201 int bit, x, y;
202
203 _.ll = n;
204
205 asm(" subcc.p %3,gr0,gr0,icc0 \n"
206 " subcc %4,gr0,gr0,icc1 \n"
207 " ckne icc0,cc4 \n"
208 " ckne icc1,cc5 \n"
209 " norcr cc4,cc5,cc6 \n"
210 " csub.p %0,%0,%0 ,cc6,1 \n"
211 " orcr cc5,cc4,cc4 \n"
212 " andcr cc4,cc5,cc4 \n"
213 " cscan.p %3,gr0,%0 ,cc4,0 \n"
214 " setlos #64,%1 \n"
215 " cscan.p %4,gr0,%0 ,cc4,1 \n"
216 " setlos #32,%2 \n"
217 " csub.p %1,%0,%0 ,cc4,0 \n"
218 " csub %2,%0,%0 ,cc4,1 \n"
219 : "=&r"(bit), "=r"(x), "=r"(y)
220 : "0r"(_.h), "r"(_.l)
221 : "icc0", "icc1", "cc4", "cc5", "cc6"
222 );
223 return bit;
224
225}
226
227/**
228 * ffs - find first bit set
229 * @x: the word to search
230 *
231 * - return 32..1 to indicate bit 31..0 most least significant bit set
232 * - return 0 to indicate no bits set
233 */
234static inline __attribute__((const))
235int ffs(int x)
236{
237 /* Note: (x & -x) gives us a mask that is the least significant
238 * (rightmost) 1-bit of the value in x.
239 */
240 return fls(x & -x);
241}
242
243/**
244 * __ffs - find first bit set
245 * @x: the word to search
246 *
247 * - return 31..0 to indicate bit 31..0 most least significant bit set
248 * - if no bits are set in x, the result is undefined
249 */
250static inline __attribute__((const))
251int __ffs(unsigned long x)
252{
253 int bit;
254 asm("scan %1,gr0,%0" : "=r"(bit) : "r"(x & -x));
255 return 31 - bit;
256}
257
258/**
259 * __fls - find last (most-significant) set bit in a long word
260 * @word: the word to search
261 *
262 * Undefined if no set bit exists, so code should check against 0 first.
263 */
264static inline unsigned long __fls(unsigned long word)
265{
266 unsigned long bit;
267 asm("scan %1,gr0,%0" : "=r"(bit) : "r"(word));
268 return bit;
269}
270
271/*
272 * special slimline version of fls() for calculating ilog2_u32()
273 * - note: no protection against n == 0
274 */
275#define ARCH_HAS_ILOG2_U32
276static inline __attribute__((const))
277int __ilog2_u32(u32 n)
278{
279 int bit;
280 asm("scan %1,gr0,%0" : "=r"(bit) : "r"(n));
281 return 31 - bit;
282}
283
284/*
285 * special slimline version of fls64() for calculating ilog2_u64()
286 * - note: no protection against n == 0
287 */
288#define ARCH_HAS_ILOG2_U64
289static inline __attribute__((const))
290int __ilog2_u64(u64 n)
291{
292 union {
293 u64 ll;
294 struct { u32 h, l; };
295 } _;
296 int bit, x, y;
297
298 _.ll = n;
299
300 asm(" subcc %3,gr0,gr0,icc0 \n"
301 " ckeq icc0,cc4 \n"
302 " cscan.p %3,gr0,%0 ,cc4,0 \n"
303 " setlos #63,%1 \n"
304 " cscan.p %4,gr0,%0 ,cc4,1 \n"
305 " setlos #31,%2 \n"
306 " csub.p %1,%0,%0 ,cc4,0 \n"
307 " csub %2,%0,%0 ,cc4,1 \n"
308 : "=&r"(bit), "=r"(x), "=r"(y)
309 : "0r"(_.h), "r"(_.l)
310 : "icc0", "cc4"
311 );
312 return bit;
313}
314
315#include <asm-generic/bitops/sched.h>
316#include <asm-generic/bitops/hweight.h>
317#include <asm-generic/bitops/lock.h>
318
319#include <asm-generic/bitops/le.h>
320
321#include <asm-generic/bitops/ext2-atomic-setbit.h>
322
323#endif /* __KERNEL__ */
324
325#endif /* _ASM_BITOPS_H */