]> git.sur5r.net Git - u-boot/blob - include/asm-microblaze/bitops.h
Make the serial driver framework work with CONFIG_SERIAL_MULTI enabled
[u-boot] / include / asm-microblaze / bitops.h
1 #ifndef _MICROBLAZE_BITOPS_H
2 #define _MICROBLAZE_BITOPS_H
3
4 /*
5  * Copyright 1992, Linus Torvalds.
6  */
7
8 #include <linux/config.h>
9 #include <asm/byteorder.h>      /* swab32 */
10 #include <asm/system.h>         /* save_flags */
11
12 #ifdef __KERNEL__
13 /*
14  * Function prototypes to keep gcc -Wall happy
15  */
16
17 /*
18  * The __ functions are not atomic
19  */
20
21 extern void set_bit(int nr, volatile void * addr);
22 extern void __set_bit(int nr, volatile void * addr);
23
24 extern void clear_bit(int nr, volatile void * addr);
25 #define __clear_bit(nr, addr) clear_bit(nr, addr)
26
27 extern void change_bit(int nr, volatile void * addr);
28 extern void __change_bit(int nr, volatile void * addr);
29 extern int test_and_set_bit(int nr, volatile void * addr);
30 extern int __test_and_set_bit(int nr, volatile void * addr);
31 extern int test_and_clear_bit(int nr, volatile void * addr);
32 extern int __test_and_clear_bit(int nr, volatile void * addr);
33 extern int test_and_change_bit(int nr, volatile void * addr);
34 extern int __test_and_change_bit(int nr, volatile void * addr);
35 extern int __constant_test_bit(int nr, const volatile void * addr);
36 extern int __test_bit(int nr, volatile void * addr);
37 extern int find_first_zero_bit(void * addr, unsigned size);
38 extern int find_next_zero_bit (void * addr, int size, int offset);
39
40 /*
41  * ffz = Find First Zero in word. Undefined if no zero exists,
42  * so code should check against ~0UL first..
43  */
44 extern __inline__ unsigned long ffz(unsigned long word)
45 {
46         unsigned long result = 0;
47
48         while(word & 1) {
49                 result++;
50                 word >>= 1;
51         }
52         return result;
53 }
54
55
56 extern __inline__ void set_bit(int nr, volatile void * addr)
57 {
58         int     * a = (int *) addr;
59         int     mask;
60         unsigned long flags;
61
62         a += nr >> 5;
63         mask = 1 << (nr & 0x1f);
64         save_flags_cli(flags);
65         *a |= mask;
66         restore_flags(flags);
67 }
68
69 extern __inline__ void __set_bit(int nr, volatile void * addr)
70 {
71         int     * a = (int *) addr;
72         int     mask;
73
74         a += nr >> 5;
75         mask = 1 << (nr & 0x1f);
76         *a |= mask;
77 }
78
79 /*
80  * clear_bit() doesn't provide any barrier for the compiler.
81  */
82 #define smp_mb__before_clear_bit()      barrier()
83 #define smp_mb__after_clear_bit()       barrier()
84
85 extern __inline__ void clear_bit(int nr, volatile void * addr)
86 {
87         int     * a = (int *) addr;
88         int     mask;
89         unsigned long flags;
90
91         a += nr >> 5;
92         mask = 1 << (nr & 0x1f);
93         save_flags_cli(flags);
94         *a &= ~mask;
95         restore_flags(flags);
96 }
97
98 extern __inline__ void change_bit(int nr, volatile void * addr)
99 {
100         int mask;
101         unsigned long flags;
102         unsigned long *ADDR = (unsigned long *) addr;
103
104         ADDR += nr >> 5;
105         mask = 1 << (nr & 31);
106         save_flags_cli(flags);
107         *ADDR ^= mask;
108         restore_flags(flags);
109 }
110
111 extern __inline__ void __change_bit(int nr, volatile void * addr)
112 {
113         int mask;
114         unsigned long *ADDR = (unsigned long *) addr;
115
116         ADDR += nr >> 5;
117         mask = 1 << (nr & 31);
118         *ADDR ^= mask;
119 }
120
121 extern __inline__ int test_and_set_bit(int nr, volatile void * addr)
122 {
123         int     mask, retval;
124         volatile unsigned int *a = (volatile unsigned int *) addr;
125         unsigned long flags;
126
127         a += nr >> 5;
128         mask = 1 << (nr & 0x1f);
129         save_flags_cli(flags);
130         retval = (mask & *a) != 0;
131         *a |= mask;
132         restore_flags(flags);
133
134         return retval;
135 }
136
137 extern __inline__ int __test_and_set_bit(int nr, volatile void * addr)
138 {
139         int     mask, retval;
140         volatile unsigned int *a = (volatile unsigned int *) addr;
141
142         a += nr >> 5;
143         mask = 1 << (nr & 0x1f);
144         retval = (mask & *a) != 0;
145         *a |= mask;
146         return retval;
147 }
148
149 extern __inline__ int test_and_clear_bit(int nr, volatile void * addr)
150 {
151         int     mask, retval;
152         volatile unsigned int *a = (volatile unsigned int *) addr;
153         unsigned long flags;
154
155         a += nr >> 5;
156         mask = 1 << (nr & 0x1f);
157         save_flags_cli(flags);
158         retval = (mask & *a) != 0;
159         *a &= ~mask;
160         restore_flags(flags);
161
162         return retval;
163 }
164
165 extern __inline__ int __test_and_clear_bit(int nr, volatile void * addr)
166 {
167         int     mask, retval;
168         volatile unsigned int *a = (volatile unsigned int *) addr;
169
170         a += nr >> 5;
171         mask = 1 << (nr & 0x1f);
172         retval = (mask & *a) != 0;
173         *a &= ~mask;
174         return retval;
175 }
176
177 extern __inline__ int test_and_change_bit(int nr, volatile void * addr)
178 {
179         int     mask, retval;
180         volatile unsigned int *a = (volatile unsigned int *) addr;
181         unsigned long flags;
182
183         a += nr >> 5;
184         mask = 1 << (nr & 0x1f);
185         save_flags_cli(flags);
186         retval = (mask & *a) != 0;
187         *a ^= mask;
188         restore_flags(flags);
189
190         return retval;
191 }
192
193 extern __inline__ int __test_and_change_bit(int nr, volatile void * addr)
194 {
195         int     mask, retval;
196         volatile unsigned int *a = (volatile unsigned int *) addr;
197
198         a += nr >> 5;
199         mask = 1 << (nr & 0x1f);
200         retval = (mask & *a) != 0;
201         *a ^= mask;
202         return retval;
203 }
204
205 /*
206  * This routine doesn't need to be atomic.
207  */
208 extern __inline__ int __constant_test_bit(int nr, const volatile void * addr)
209 {
210         return ((1UL << (nr & 31)) & (((const volatile unsigned int *) addr)[nr >> 5])) != 0;
211 }
212
213 extern __inline__ int __test_bit(int nr, volatile void * addr)
214 {
215         int     * a = (int *) addr;
216         int     mask;
217
218         a += nr >> 5;
219         mask = 1 << (nr & 0x1f);
220         return ((mask & *a) != 0);
221 }
222
223 #define test_bit(nr,addr) \
224 (__builtin_constant_p(nr) ? \
225  __constant_test_bit((nr),(addr)) : \
226  __test_bit((nr),(addr)))
227
228 #define find_first_zero_bit(addr, size) \
229         find_next_zero_bit((addr), (size), 0)
230
231 extern __inline__ int find_next_zero_bit (void * addr, int size, int offset)
232 {
233         unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
234         unsigned long result = offset & ~31UL;
235         unsigned long tmp;
236
237         if (offset >= size)
238                 return size;
239         size -= result;
240         offset &= 31UL;
241         if (offset) {
242                 tmp = *(p++);
243                 tmp |= ~0UL >> (32-offset);
244                 if (size < 32)
245                         goto found_first;
246                 if (~tmp)
247                         goto found_middle;
248                 size -= 32;
249                 result += 32;
250         }
251         while (size & ~31UL) {
252                 if (~(tmp = *(p++)))
253                         goto found_middle;
254                 result += 32;
255                 size -= 32;
256         }
257         if (!size)
258                 return result;
259         tmp = *p;
260
261 found_first:
262         tmp |= ~0UL >> size;
263 found_middle:
264         return result + ffz(tmp);
265 }
266
267 #define ffs(x) generic_ffs(x)
268
269 /*
270  * hweightN: returns the hamming weight (i.e. the number
271  * of bits set) of a N-bit word
272  */
273
274 #define hweight32(x) generic_hweight32(x)
275 #define hweight16(x) generic_hweight16(x)
276 #define hweight8(x) generic_hweight8(x)
277
278
279 extern __inline__ int ext2_set_bit(int nr, volatile void * addr)
280 {
281         int             mask, retval;
282         unsigned long   flags;
283         volatile unsigned char  *ADDR = (unsigned char *) addr;
284
285         ADDR += nr >> 3;
286         mask = 1 << (nr & 0x07);
287         save_flags_cli(flags);
288         retval = (mask & *ADDR) != 0;
289         *ADDR |= mask;
290         restore_flags(flags);
291         return retval;
292 }
293
294 extern __inline__ int ext2_clear_bit(int nr, volatile void * addr)
295 {
296         int             mask, retval;
297         unsigned long   flags;
298         volatile unsigned char  *ADDR = (unsigned char *) addr;
299
300         ADDR += nr >> 3;
301         mask = 1 << (nr & 0x07);
302         save_flags_cli(flags);
303         retval = (mask & *ADDR) != 0;
304         *ADDR &= ~mask;
305         restore_flags(flags);
306         return retval;
307 }
308
309 extern __inline__ int ext2_test_bit(int nr, const volatile void * addr)
310 {
311         int                     mask;
312         const volatile unsigned char    *ADDR = (const unsigned char *) addr;
313
314         ADDR += nr >> 3;
315         mask = 1 << (nr & 0x07);
316         return ((mask & *ADDR) != 0);
317 }
318
319 #define ext2_find_first_zero_bit(addr, size) \
320         ext2_find_next_zero_bit((addr), (size), 0)
321
322 extern __inline__ unsigned long ext2_find_next_zero_bit(void *addr, unsigned long size, unsigned long offset)
323 {
324         unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
325         unsigned long result = offset & ~31UL;
326         unsigned long tmp;
327
328         if (offset >= size)
329                 return size;
330         size -= result;
331         offset &= 31UL;
332         if(offset) {
333                 /* We hold the little endian value in tmp, but then the
334                  * shift is illegal. So we could keep a big endian value
335                  * in tmp, like this:
336                  *
337                  * tmp = __swab32(*(p++));
338                  * tmp |= ~0UL >> (32-offset);
339                  *
340                  * but this would decrease preformance, so we change the
341                  * shift:
342                  */
343                 tmp = *(p++);
344                 tmp |= __swab32(~0UL >> (32-offset));
345                 if(size < 32)
346                         goto found_first;
347                 if(~tmp)
348                         goto found_middle;
349                 size -= 32;
350                 result += 32;
351         }
352         while(size & ~31UL) {
353                 if(~(tmp = *(p++)))
354                         goto found_middle;
355                 result += 32;
356                 size -= 32;
357         }
358         if(!size)
359                 return result;
360         tmp = *p;
361
362 found_first:
363         /* tmp is little endian, so we would have to swab the shift,
364          * see above. But then we have to swab tmp below for ffz, so
365          * we might as well do this here.
366          */
367         return result + ffz(__swab32(tmp) | (~0UL << size));
368 found_middle:
369         return result + ffz(__swab32(tmp));
370 }
371
372 /* Bitmap functions for the minix filesystem.  */
373 #define minix_test_and_set_bit(nr,addr) test_and_set_bit(nr,addr)
374 #define minix_set_bit(nr,addr) set_bit(nr,addr)
375 #define minix_test_and_clear_bit(nr,addr) test_and_clear_bit(nr,addr)
376 #define minix_test_bit(nr,addr) test_bit(nr,addr)
377 #define minix_find_first_zero_bit(addr,size) find_first_zero_bit(addr,size)
378
379 /**
380  * hweightN - returns the hamming weight of a N-bit word
381  * @x: the word to weigh
382  *
383  * The Hamming Weight of a number is the total number of bits set in it.
384  */
385
386 #define hweight32(x) generic_hweight32(x)
387 #define hweight16(x) generic_hweight16(x)
388 #define hweight8(x) generic_hweight8(x)
389
390 #endif /* __KERNEL__ */
391
392 #endif /* _MICROBLAZE_BITOPS_H */