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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
|
/*
* Copyright 1995, Russell King.
* Various bits and pieces copyrights include:
* Linus Torvalds (test_bit).
* Big endian support: Copyright 2001, Nicolas Pitre
* reworked by rmk.
*/
#ifndef _ARM_BITOPS_H
#define _ARM_BITOPS_H
#include <asm/asm_defns.h>
/*
* Non-atomic bit manipulation.
*
* Implemented using atomics to be interrupt safe. Could alternatively
* implement with local interrupt masking.
*/
#define __set_bit(n,p) set_bit(n,p)
#define __clear_bit(n,p) clear_bit(n,p)
#define BITOP_BITS_PER_WORD 32
#define BITOP_MASK(nr) (1UL << ((nr) % BITOP_BITS_PER_WORD))
#define BITOP_WORD(nr) ((nr) / BITOP_BITS_PER_WORD)
#define BITS_PER_BYTE 8
#define ADDR (*(volatile int *) addr)
#define CONST_ADDR (*(const volatile int *) addr)
#if defined(CONFIG_ARM_32)
# include <asm/arm32/bitops.h>
#elif defined(CONFIG_ARM_64)
# include <asm/arm64/bitops.h>
#else
# error "unknown ARM variant"
#endif
/*
* Atomic bitops
*
* The helpers below *should* only be used on memory shared between
* trusted threads or we know the memory cannot be accessed by another
* thread.
*/
void set_bit(int nr, volatile void *p);
void clear_bit(int nr, volatile void *p);
void change_bit(int nr, volatile void *p);
int test_and_set_bit(int nr, volatile void *p);
int test_and_clear_bit(int nr, volatile void *p);
int test_and_change_bit(int nr, volatile void *p);
void clear_mask16(uint16_t mask, volatile void *p);
/*
* The helpers below may fail to update the memory if the action takes
* too long.
*
* @max_try: Maximum number of iterations
*
* The helpers will return true when the update has succeeded (i.e no
* timeout) and false if the update has failed.
*/
bool set_bit_timeout(int nr, volatile void *p, unsigned int max_try);
bool clear_bit_timeout(int nr, volatile void *p, unsigned int max_try);
bool change_bit_timeout(int nr, volatile void *p, unsigned int max_try);
bool test_and_set_bit_timeout(int nr, volatile void *p,
int *oldbit, unsigned int max_try);
bool test_and_clear_bit_timeout(int nr, volatile void *p,
int *oldbit, unsigned int max_try);
bool test_and_change_bit_timeout(int nr, volatile void *p,
int *oldbit, unsigned int max_try);
bool clear_mask16_timeout(uint16_t mask, volatile void *p,
unsigned int max_try);
/**
* __test_and_set_bit - Set a bit and return its old value
* @nr: Bit to set
* @addr: Address to count from
*
* This operation is non-atomic and can be reordered.
* If two examples of this operation race, one can appear to succeed
* but actually fail. You must protect multiple accesses with a lock.
*/
static inline int __test_and_set_bit(int nr, volatile void *addr)
{
unsigned int mask = BITOP_MASK(nr);
volatile unsigned int *p =
((volatile unsigned int *)addr) + BITOP_WORD(nr);
unsigned int old = *p;
*p = old | mask;
return (old & mask) != 0;
}
/**
* __test_and_clear_bit - Clear a bit and return its old value
* @nr: Bit to clear
* @addr: Address to count from
*
* This operation is non-atomic and can be reordered.
* If two examples of this operation race, one can appear to succeed
* but actually fail. You must protect multiple accesses with a lock.
*/
static inline int __test_and_clear_bit(int nr, volatile void *addr)
{
unsigned int mask = BITOP_MASK(nr);
volatile unsigned int *p =
((volatile unsigned int *)addr) + BITOP_WORD(nr);
unsigned int old = *p;
*p = old & ~mask;
return (old & mask) != 0;
}
/* WARNING: non atomic and it can be reordered! */
static inline int __test_and_change_bit(int nr,
volatile void *addr)
{
unsigned int mask = BITOP_MASK(nr);
volatile unsigned int *p =
((volatile unsigned int *)addr) + BITOP_WORD(nr);
unsigned int old = *p;
*p = old ^ mask;
return (old & mask) != 0;
}
/**
* test_bit - Determine whether a bit is set
* @nr: bit number to test
* @addr: Address to start counting from
*/
static inline int test_bit(int nr, const volatile void *addr)
{
const volatile unsigned int *p = (const volatile unsigned int *)addr;
return 1UL & (p[BITOP_WORD(nr)] >> (nr & (BITOP_BITS_PER_WORD-1)));
}
/*
* On ARMv5 and above those functions can be implemented around
* the clz instruction for much better code efficiency.
*/
static inline int fls(unsigned int x)
{
int ret;
if (__builtin_constant_p(x))
return generic_fls(x);
asm("clz\t%"__OP32"0, %"__OP32"1" : "=r" (ret) : "r" (x));
return 32 - ret;
}
#define ffs(x) ({ unsigned int __t = (x); fls(__t & -__t); })
#define ffsl(x) ({ unsigned long __t = (x); flsl(__t & -__t); })
/**
* find_first_set_bit - find the first set bit in @word
* @word: the word to search
*
* Returns the bit-number of the first set bit (first bit being 0).
* The input must *not* be zero.
*/
static inline unsigned int find_first_set_bit(unsigned long word)
{
return ffsl(word) - 1;
}
/**
* hweightN - returns the hamming weight of a N-bit word
* @x: the word to weigh
*
* The Hamming Weight of a number is the total number of bits set in it.
*/
#define hweight64(x) generic_hweight64(x)
#define hweight32(x) generic_hweight32(x)
#define hweight16(x) generic_hweight16(x)
#define hweight8(x) generic_hweight8(x)
#endif /* _ARM_BITOPS_H */
/*
* Local variables:
* mode: C
* c-file-style: "BSD"
* c-basic-offset: 4
* indent-tabs-mode: nil
* End:
*/
|
