[PATCH] bitops: use non atomic operations for minix_*_bit() and ext2_*_bit()
[linux-3.10.git] / include / asm-m32r / bitops.h
1 #ifndef _ASM_M32R_BITOPS_H
2 #define _ASM_M32R_BITOPS_H
3
4 /*
5  *  linux/include/asm-m32r/bitops.h
6  *
7  *  Copyright 1992, Linus Torvalds.
8  *
9  *  M32R version:
10  *    Copyright (C) 2001, 2002  Hitoshi Yamamoto
11  *    Copyright (C) 2004  Hirokazu Takata <takata at linux-m32r.org>
12  */
13
14 #include <linux/config.h>
15 #include <linux/compiler.h>
16 #include <asm/assembler.h>
17 #include <asm/system.h>
18 #include <asm/byteorder.h>
19 #include <asm/types.h>
20
21 /*
22  * These have to be done with inline assembly: that way the bit-setting
23  * is guaranteed to be atomic. All bit operations return 0 if the bit
24  * was cleared before the operation and != 0 if it was not.
25  *
26  * bit 0 is the LSB of addr; bit 32 is the LSB of (addr+1).
27  */
28
29 /**
30  * set_bit - Atomically set a bit in memory
31  * @nr: the bit to set
32  * @addr: the address to start counting from
33  *
34  * This function is atomic and may not be reordered.  See __set_bit()
35  * if you do not require the atomic guarantees.
36  * Note that @nr may be almost arbitrarily large; this function is not
37  * restricted to acting on a single-word quantity.
38  */
39 static __inline__ void set_bit(int nr, volatile void * addr)
40 {
41         __u32 mask;
42         volatile __u32 *a = addr;
43         unsigned long flags;
44         unsigned long tmp;
45
46         a += (nr >> 5);
47         mask = (1 << (nr & 0x1F));
48
49         local_irq_save(flags);
50         __asm__ __volatile__ (
51                 DCACHE_CLEAR("%0", "r6", "%1")
52                 M32R_LOCK" %0, @%1;             \n\t"
53                 "or     %0, %2;                 \n\t"
54                 M32R_UNLOCK" %0, @%1;           \n\t"
55                 : "=&r" (tmp)
56                 : "r" (a), "r" (mask)
57                 : "memory"
58 #ifdef CONFIG_CHIP_M32700_TS1
59                 , "r6"
60 #endif  /* CONFIG_CHIP_M32700_TS1 */
61         );
62         local_irq_restore(flags);
63 }
64
65 /**
66  * __set_bit - Set a bit in memory
67  * @nr: the bit to set
68  * @addr: the address to start counting from
69  *
70  * Unlike set_bit(), this function is non-atomic and may be reordered.
71  * If it's called on the same region of memory simultaneously, the effect
72  * may be that only one operation succeeds.
73  */
74 static __inline__ void __set_bit(int nr, volatile void * addr)
75 {
76         __u32 mask;
77         volatile __u32 *a = addr;
78
79         a += (nr >> 5);
80         mask = (1 << (nr & 0x1F));
81         *a |= mask;
82 }
83
84 /**
85  * clear_bit - Clears a bit in memory
86  * @nr: Bit to clear
87  * @addr: Address to start counting from
88  *
89  * clear_bit() is atomic and may not be reordered.  However, it does
90  * not contain a memory barrier, so if it is used for locking purposes,
91  * you should call smp_mb__before_clear_bit() and/or smp_mb__after_clear_bit()
92  * in order to ensure changes are visible on other processors.
93  */
94 static __inline__ void clear_bit(int nr, volatile void * addr)
95 {
96         __u32 mask;
97         volatile __u32 *a = addr;
98         unsigned long flags;
99         unsigned long tmp;
100
101         a += (nr >> 5);
102         mask = (1 << (nr & 0x1F));
103
104         local_irq_save(flags);
105
106         __asm__ __volatile__ (
107                 DCACHE_CLEAR("%0", "r6", "%1")
108                 M32R_LOCK" %0, @%1;             \n\t"
109                 "and    %0, %2;                 \n\t"
110                 M32R_UNLOCK" %0, @%1;           \n\t"
111                 : "=&r" (tmp)
112                 : "r" (a), "r" (~mask)
113                 : "memory"
114 #ifdef CONFIG_CHIP_M32700_TS1
115                 , "r6"
116 #endif  /* CONFIG_CHIP_M32700_TS1 */
117         );
118         local_irq_restore(flags);
119 }
120
121 static __inline__ void __clear_bit(int nr, volatile unsigned long * addr)
122 {
123         unsigned long mask;
124         volatile unsigned long *a = addr;
125
126         a += (nr >> 5);
127         mask = (1 << (nr & 0x1F));
128         *a &= ~mask;
129 }
130
131 #define smp_mb__before_clear_bit()      barrier()
132 #define smp_mb__after_clear_bit()       barrier()
133
134 /**
135  * __change_bit - Toggle a bit in memory
136  * @nr: the bit to set
137  * @addr: the address to start counting from
138  *
139  * Unlike change_bit(), this function is non-atomic and may be reordered.
140  * If it's called on the same region of memory simultaneously, the effect
141  * may be that only one operation succeeds.
142  */
143 static __inline__ void __change_bit(int nr, volatile void * addr)
144 {
145         __u32 mask;
146         volatile __u32 *a = addr;
147
148         a += (nr >> 5);
149         mask = (1 << (nr & 0x1F));
150         *a ^= mask;
151 }
152
153 /**
154  * change_bit - Toggle a bit in memory
155  * @nr: Bit to clear
156  * @addr: Address to start counting from
157  *
158  * change_bit() is atomic and may not be reordered.
159  * Note that @nr may be almost arbitrarily large; this function is not
160  * restricted to acting on a single-word quantity.
161  */
162 static __inline__ void change_bit(int nr, volatile void * addr)
163 {
164         __u32  mask;
165         volatile __u32  *a = addr;
166         unsigned long flags;
167         unsigned long tmp;
168
169         a += (nr >> 5);
170         mask = (1 << (nr & 0x1F));
171
172         local_irq_save(flags);
173         __asm__ __volatile__ (
174                 DCACHE_CLEAR("%0", "r6", "%1")
175                 M32R_LOCK" %0, @%1;             \n\t"
176                 "xor    %0, %2;                 \n\t"
177                 M32R_UNLOCK" %0, @%1;           \n\t"
178                 : "=&r" (tmp)
179                 : "r" (a), "r" (mask)
180                 : "memory"
181 #ifdef CONFIG_CHIP_M32700_TS1
182                 , "r6"
183 #endif  /* CONFIG_CHIP_M32700_TS1 */
184         );
185         local_irq_restore(flags);
186 }
187
188 /**
189  * test_and_set_bit - Set a bit and return its old value
190  * @nr: Bit to set
191  * @addr: Address to count from
192  *
193  * This operation is atomic and cannot be reordered.
194  * It also implies a memory barrier.
195  */
196 static __inline__ int test_and_set_bit(int nr, volatile void * addr)
197 {
198         __u32 mask, oldbit;
199         volatile __u32 *a = addr;
200         unsigned long flags;
201         unsigned long tmp;
202
203         a += (nr >> 5);
204         mask = (1 << (nr & 0x1F));
205
206         local_irq_save(flags);
207         __asm__ __volatile__ (
208                 DCACHE_CLEAR("%0", "%1", "%2")
209                 M32R_LOCK" %0, @%2;             \n\t"
210                 "mv     %1, %0;                 \n\t"
211                 "and    %0, %3;                 \n\t"
212                 "or     %1, %3;                 \n\t"
213                 M32R_UNLOCK" %1, @%2;           \n\t"
214                 : "=&r" (oldbit), "=&r" (tmp)
215                 : "r" (a), "r" (mask)
216                 : "memory"
217         );
218         local_irq_restore(flags);
219
220         return (oldbit != 0);
221 }
222
223 /**
224  * __test_and_set_bit - Set a bit and return its old value
225  * @nr: Bit to set
226  * @addr: Address to count from
227  *
228  * This operation is non-atomic and can be reordered.
229  * If two examples of this operation race, one can appear to succeed
230  * but actually fail.  You must protect multiple accesses with a lock.
231  */
232 static __inline__ int __test_and_set_bit(int nr, volatile void * addr)
233 {
234         __u32 mask, oldbit;
235         volatile __u32 *a = addr;
236
237         a += (nr >> 5);
238         mask = (1 << (nr & 0x1F));
239         oldbit = (*a & mask);
240         *a |= mask;
241
242         return (oldbit != 0);
243 }
244
245 /**
246  * test_and_clear_bit - Clear a bit and return its old value
247  * @nr: Bit to set
248  * @addr: Address to count from
249  *
250  * This operation is atomic and cannot be reordered.
251  * It also implies a memory barrier.
252  */
253 static __inline__ int test_and_clear_bit(int nr, volatile void * addr)
254 {
255         __u32 mask, oldbit;
256         volatile __u32 *a = addr;
257         unsigned long flags;
258         unsigned long tmp;
259
260         a += (nr >> 5);
261         mask = (1 << (nr & 0x1F));
262
263         local_irq_save(flags);
264
265         __asm__ __volatile__ (
266                 DCACHE_CLEAR("%0", "%1", "%3")
267                 M32R_LOCK" %0, @%3;             \n\t"
268                 "mv     %1, %0;                 \n\t"
269                 "and    %0, %2;                 \n\t"
270                 "not    %2, %2;                 \n\t"
271                 "and    %1, %2;                 \n\t"
272                 M32R_UNLOCK" %1, @%3;           \n\t"
273                 : "=&r" (oldbit), "=&r" (tmp), "+r" (mask)
274                 : "r" (a)
275                 : "memory"
276         );
277         local_irq_restore(flags);
278
279         return (oldbit != 0);
280 }
281
282 /**
283  * __test_and_clear_bit - Clear a bit and return its old value
284  * @nr: Bit to set
285  * @addr: Address to count from
286  *
287  * This operation is non-atomic and can be reordered.
288  * If two examples of this operation race, one can appear to succeed
289  * but actually fail.  You must protect multiple accesses with a lock.
290  */
291 static __inline__ int __test_and_clear_bit(int nr, volatile void * addr)
292 {
293         __u32 mask, oldbit;
294         volatile __u32 *a = addr;
295
296         a += (nr >> 5);
297         mask = (1 << (nr & 0x1F));
298         oldbit = (*a & mask);
299         *a &= ~mask;
300
301         return (oldbit != 0);
302 }
303
304 /* WARNING: non atomic and it can be reordered! */
305 static __inline__ int __test_and_change_bit(int nr, volatile void * addr)
306 {
307         __u32 mask, oldbit;
308         volatile __u32 *a = addr;
309
310         a += (nr >> 5);
311         mask = (1 << (nr & 0x1F));
312         oldbit = (*a & mask);
313         *a ^= mask;
314
315         return (oldbit != 0);
316 }
317
318 /**
319  * test_and_change_bit - Change a bit and return its old value
320  * @nr: Bit to set
321  * @addr: Address to count from
322  *
323  * This operation is atomic and cannot be reordered.
324  * It also implies a memory barrier.
325  */
326 static __inline__ int test_and_change_bit(int nr, volatile void * addr)
327 {
328         __u32 mask, oldbit;
329         volatile __u32 *a = addr;
330         unsigned long flags;
331         unsigned long tmp;
332
333         a += (nr >> 5);
334         mask = (1 << (nr & 0x1F));
335
336         local_irq_save(flags);
337         __asm__ __volatile__ (
338                 DCACHE_CLEAR("%0", "%1", "%2")
339                 M32R_LOCK" %0, @%2;             \n\t"
340                 "mv     %1, %0;                 \n\t"
341                 "and    %0, %3;                 \n\t"
342                 "xor    %1, %3;                 \n\t"
343                 M32R_UNLOCK" %1, @%2;           \n\t"
344                 : "=&r" (oldbit), "=&r" (tmp)
345                 : "r" (a), "r" (mask)
346                 : "memory"
347         );
348         local_irq_restore(flags);
349
350         return (oldbit != 0);
351 }
352
353 /**
354  * test_bit - Determine whether a bit is set
355  * @nr: bit number to test
356  * @addr: Address to start counting from
357  */
358 static __inline__ int test_bit(int nr, const volatile void * addr)
359 {
360         __u32 mask;
361         const volatile __u32 *a = addr;
362
363         a += (nr >> 5);
364         mask = (1 << (nr & 0x1F));
365
366         return ((*a & mask) != 0);
367 }
368
369 /**
370  * ffz - find first zero in word.
371  * @word: The word to search
372  *
373  * Undefined if no zero exists, so code should check against ~0UL first.
374  */
375 static __inline__ unsigned long ffz(unsigned long word)
376 {
377         int k;
378
379         word = ~word;
380         k = 0;
381         if (!(word & 0x0000ffff)) { k += 16; word >>= 16; }
382         if (!(word & 0x000000ff)) { k += 8; word >>= 8; }
383         if (!(word & 0x0000000f)) { k += 4; word >>= 4; }
384         if (!(word & 0x00000003)) { k += 2; word >>= 2; }
385         if (!(word & 0x00000001)) { k += 1; }
386
387         return k;
388 }
389
390 /**
391  * find_first_zero_bit - find the first zero bit in a memory region
392  * @addr: The address to start the search at
393  * @size: The maximum size to search
394  *
395  * Returns the bit-number of the first zero bit, not the number of the byte
396  * containing a bit.
397  */
398
399 #define find_first_zero_bit(addr, size) \
400         find_next_zero_bit((addr), (size), 0)
401
402 /**
403  * find_next_zero_bit - find the first zero bit in a memory region
404  * @addr: The address to base the search on
405  * @offset: The bitnumber to start searching at
406  * @size: The maximum size to search
407  */
408 static __inline__ int find_next_zero_bit(const unsigned long *addr,
409                                          int size, int offset)
410 {
411         const unsigned long *p = addr + (offset >> 5);
412         unsigned long result = offset & ~31UL;
413         unsigned long tmp;
414
415         if (offset >= size)
416                 return size;
417         size -= result;
418         offset &= 31UL;
419         if (offset) {
420                 tmp = *(p++);
421                 tmp |= ~0UL >> (32-offset);
422                 if (size < 32)
423                         goto found_first;
424                 if (~tmp)
425                         goto found_middle;
426                 size -= 32;
427                 result += 32;
428         }
429         while (size & ~31UL) {
430                 if (~(tmp = *(p++)))
431                         goto found_middle;
432                 result += 32;
433                 size -= 32;
434         }
435         if (!size)
436                 return result;
437         tmp = *p;
438
439 found_first:
440         tmp |= ~0UL << size;
441 found_middle:
442         return result + ffz(tmp);
443 }
444
445 /**
446  * __ffs - find first bit in word.
447  * @word: The word to search
448  *
449  * Undefined if no bit exists, so code should check against 0 first.
450  */
451 static __inline__ unsigned long __ffs(unsigned long word)
452 {
453         int k = 0;
454
455         if (!(word & 0x0000ffff)) { k += 16; word >>= 16; }
456         if (!(word & 0x000000ff)) { k += 8; word >>= 8; }
457         if (!(word & 0x0000000f)) { k += 4; word >>= 4; }
458         if (!(word & 0x00000003)) { k += 2; word >>= 2; }
459         if (!(word & 0x00000001)) { k += 1;}
460
461         return k;
462 }
463
464 /*
465  * fls: find last bit set.
466  */
467 #define fls(x) generic_fls(x)
468 #define fls64(x)   generic_fls64(x)
469
470 #ifdef __KERNEL__
471
472 /*
473  * Every architecture must define this function. It's the fastest
474  * way of searching a 140-bit bitmap where the first 100 bits are
475  * unlikely to be set. It's guaranteed that at least one of the 140
476  * bits is cleared.
477  */
478 static inline int sched_find_first_bit(unsigned long *b)
479 {
480         if (unlikely(b[0]))
481                 return __ffs(b[0]);
482         if (unlikely(b[1]))
483                 return __ffs(b[1]) + 32;
484         if (unlikely(b[2]))
485                 return __ffs(b[2]) + 64;
486         if (b[3])
487                 return __ffs(b[3]) + 96;
488         return __ffs(b[4]) + 128;
489 }
490
491 /**
492  * find_next_bit - find the first set bit in a memory region
493  * @addr: The address to base the search on
494  * @offset: The bitnumber to start searching at
495  * @size: The maximum size to search
496  */
497 static inline unsigned long find_next_bit(const unsigned long *addr,
498         unsigned long size, unsigned long offset)
499 {
500         unsigned int *p = ((unsigned int *) addr) + (offset >> 5);
501         unsigned int result = offset & ~31UL;
502         unsigned int tmp;
503
504         if (offset >= size)
505                 return size;
506         size -= result;
507         offset &= 31UL;
508         if (offset) {
509                 tmp = *p++;
510                 tmp &= ~0UL << offset;
511                 if (size < 32)
512                         goto found_first;
513                 if (tmp)
514                         goto found_middle;
515                 size -= 32;
516                 result += 32;
517         }
518         while (size >= 32) {
519                 if ((tmp = *p++) != 0)
520                         goto found_middle;
521                 result += 32;
522                 size -= 32;
523         }
524         if (!size)
525                 return result;
526         tmp = *p;
527
528 found_first:
529         tmp &= ~0UL >> (32 - size);
530         if (tmp == 0UL)        /* Are any bits set? */
531                 return result + size; /* Nope. */
532 found_middle:
533         return result + __ffs(tmp);
534 }
535
536 /**
537  * find_first_bit - find the first set bit in a memory region
538  * @addr: The address to start the search at
539  * @size: The maximum size to search
540  *
541  * Returns the bit-number of the first set bit, not the number of the byte
542  * containing a bit.
543  */
544 #define find_first_bit(addr, size) \
545         find_next_bit((addr), (size), 0)
546
547 /**
548  * ffs - find first bit set
549  * @x: the word to search
550  *
551  * This is defined the same way as
552  * the libc and compiler builtin ffs routines, therefore
553  * differs in spirit from the above ffz (man ffs).
554  */
555 #define ffs(x)  generic_ffs(x)
556
557 /**
558  * hweightN - returns the hamming weight of a N-bit word
559  * @x: the word to weigh
560  *
561  * The Hamming Weight of a number is the total number of bits set in it.
562  */
563
564 #define hweight32(x)    generic_hweight32(x)
565 #define hweight16(x)    generic_hweight16(x)
566 #define hweight8(x)     generic_hweight8(x)
567
568 #endif /* __KERNEL__ */
569
570 #ifdef __KERNEL__
571
572 /*
573  * ext2_XXXX function
574  * orig: include/asm-sh/bitops.h
575  */
576
577 #ifdef __LITTLE_ENDIAN__
578 #define ext2_set_bit                    __test_and_set_bit
579 #define ext2_clear_bit                  __test_and_clear_bit
580 #define ext2_test_bit                   test_bit
581 #define ext2_find_first_zero_bit        find_first_zero_bit
582 #define ext2_find_next_zero_bit         find_next_zero_bit
583 #else
584 static inline int ext2_set_bit(int nr, volatile void * addr)
585 {
586         __u8 mask, oldbit;
587         volatile __u8 *a = addr;
588
589         a += (nr >> 3);
590         mask = (1 << (nr & 0x07));
591         oldbit = (*a & mask);
592         *a |= mask;
593
594         return (oldbit != 0);
595 }
596
597 static inline int ext2_clear_bit(int nr, volatile void * addr)
598 {
599         __u8 mask, oldbit;
600         volatile __u8 *a = addr;
601
602         a += (nr >> 3);
603         mask = (1 << (nr & 0x07));
604         oldbit = (*a & mask);
605         *a &= ~mask;
606
607         return (oldbit != 0);
608 }
609
610 static inline int ext2_test_bit(int nr, const volatile void * addr)
611 {
612         __u32 mask;
613         const volatile __u8 *a = addr;
614
615         a += (nr >> 3);
616         mask = (1 << (nr & 0x07));
617
618         return ((mask & *a) != 0);
619 }
620
621 #define ext2_find_first_zero_bit(addr, size) \
622         ext2_find_next_zero_bit((addr), (size), 0)
623
624 static inline unsigned long ext2_find_next_zero_bit(void *addr,
625         unsigned long size, unsigned long offset)
626 {
627         unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
628         unsigned long result = offset & ~31UL;
629         unsigned long tmp;
630
631         if (offset >= size)
632                 return size;
633         size -= result;
634         offset &= 31UL;
635         if(offset) {
636                 /* We hold the little endian value in tmp, but then the
637                  * shift is illegal. So we could keep a big endian value
638                  * in tmp, like this:
639                  *
640                  * tmp = __swab32(*(p++));
641                  * tmp |= ~0UL >> (32-offset);
642                  *
643                  * but this would decrease preformance, so we change the
644                  * shift:
645                  */
646                 tmp = *(p++);
647                 tmp |= __swab32(~0UL >> (32-offset));
648                 if(size < 32)
649                         goto found_first;
650                 if(~tmp)
651                         goto found_middle;
652                 size -= 32;
653                 result += 32;
654         }
655         while(size & ~31UL) {
656                 if(~(tmp = *(p++)))
657                         goto found_middle;
658                 result += 32;
659                 size -= 32;
660         }
661         if(!size)
662                 return result;
663         tmp = *p;
664
665 found_first:
666         /* tmp is little endian, so we would have to swab the shift,
667          * see above. But then we have to swab tmp below for ffz, so
668          * we might as well do this here.
669          */
670         return result + ffz(__swab32(tmp) | (~0UL << size));
671 found_middle:
672         return result + ffz(__swab32(tmp));
673 }
674 #endif
675
676 #define ext2_set_bit_atomic(lock, nr, addr)             \
677         ({                                              \
678                 int ret;                                \
679                 spin_lock(lock);                        \
680                 ret = ext2_set_bit((nr), (addr));       \
681                 spin_unlock(lock);                      \
682                 ret;                                    \
683         })
684
685 #define ext2_clear_bit_atomic(lock, nr, addr)           \
686         ({                                              \
687                 int ret;                                \
688                 spin_lock(lock);                        \
689                 ret = ext2_clear_bit((nr), (addr));     \
690                 spin_unlock(lock);                      \
691                 ret;                                    \
692         })
693
694 /* Bitmap functions for the minix filesystem.  */
695 #define minix_test_and_set_bit(nr,addr)         __test_and_set_bit(nr,addr)
696 #define minix_set_bit(nr,addr)                  __set_bit(nr,addr)
697 #define minix_test_and_clear_bit(nr,addr)       __test_and_clear_bit(nr,addr)
698 #define minix_test_bit(nr,addr) test_bit(nr,addr)
699 #define minix_find_first_zero_bit(addr,size)    find_first_zero_bit(addr,size)
700
701 #endif /* __KERNEL__ */
702
703 #endif /* _ASM_M32R_BITOPS_H */