home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / src / linux-headers-2.6.17-6 / include / asm-powerpc / bitops.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  9.3 KB  |  333 lines
  1. /*
  2.  * PowerPC atomic bit operations.
  3.  *
  4.  * Merged version by David Gibson <david@gibson.dropbear.id.au>.
  5.  * Based on ppc64 versions by: Dave Engebretsen, Todd Inglett, Don
  6.  * Reed, Pat McCarthy, Peter Bergner, Anton Blanchard.  They
  7.  * originally took it from the ppc32 code.
  8.  *
  9.  * Within a word, bits are numbered LSB first.  Lot's of places make
  10.  * this assumption by directly testing bits with (val & (1<<nr)).
  11.  * This can cause confusion for large (> 1 word) bitmaps on a
  12.  * big-endian system because, unlike little endian, the number of each
  13.  * bit depends on the word size.
  14.  *
  15.  * The bitop functions are defined to work on unsigned longs, so for a
  16.  * ppc64 system the bits end up numbered:
  17.  *   |63..............0|127............64|191...........128|255...........196|
  18.  * and on ppc32:
  19.  *   |31.....0|63....31|95....64|127...96|159..128|191..160|223..192|255..224|
  20.  *
  21.  * There are a few little-endian macros used mostly for filesystem
  22.  * bitmaps, these work on similar bit arrays layouts, but
  23.  * byte-oriented:
  24.  *   |7...0|15...8|23...16|31...24|39...32|47...40|55...48|63...56|
  25.  *
  26.  * The main difference is that bit 3-5 (64b) or 3-4 (32b) in the bit
  27.  * number field needs to be reversed compared to the big-endian bit
  28.  * fields. This can be achieved by XOR with 0x38 (64b) or 0x18 (32b).
  29.  *
  30.  * This program is free software; you can redistribute it and/or
  31.  * modify it under the terms of the GNU General Public License
  32.  * as published by the Free Software Foundation; either version
  33.  * 2 of the License, or (at your option) any later version.
  34.  */
  35.  
  36. #ifndef _ASM_POWERPC_BITOPS_H
  37. #define _ASM_POWERPC_BITOPS_H
  38.  
  39. #ifdef __KERNEL__
  40.  
  41. #include <linux/compiler.h>
  42. #include <asm/atomic.h>
  43. #include <asm/asm-compat.h>
  44. #include <asm/synch.h>
  45.  
  46. /*
  47.  * clear_bit doesn't imply a memory barrier
  48.  */
  49. #define smp_mb__before_clear_bit()    smp_mb()
  50. #define smp_mb__after_clear_bit()    smp_mb()
  51.  
  52. #define BITOP_MASK(nr)        (1UL << ((nr) % BITS_PER_LONG))
  53. #define BITOP_WORD(nr)        ((nr) / BITS_PER_LONG)
  54. #define BITOP_LE_SWIZZLE    ((BITS_PER_LONG-1) & ~0x7)
  55.  
  56. static __inline__ void set_bit(int nr, volatile unsigned long *addr)
  57. {
  58.     unsigned long old;
  59.     unsigned long mask = BITOP_MASK(nr);
  60.     unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);
  61.  
  62.     __asm__ __volatile__(
  63. "1:"    PPC_LLARX "%0,0,%3    # set_bit\n"
  64.     "or    %0,%0,%2\n"
  65.     PPC405_ERR77(0,%3)
  66.     PPC_STLCX "%0,0,%3\n"
  67.     "bne-    1b"
  68.     : "=&r"(old), "=m"(*p)
  69.     : "r"(mask), "r"(p), "m"(*p)
  70.     : "cc" );
  71. }
  72.  
  73. static __inline__ void clear_bit(int nr, volatile unsigned long *addr)
  74. {
  75.     unsigned long old;
  76.     unsigned long mask = BITOP_MASK(nr);
  77.     unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);
  78.  
  79.     __asm__ __volatile__(
  80. "1:"    PPC_LLARX "%0,0,%3    # clear_bit\n"
  81.     "andc    %0,%0,%2\n"
  82.     PPC405_ERR77(0,%3)
  83.     PPC_STLCX "%0,0,%3\n"
  84.     "bne-    1b"
  85.     : "=&r"(old), "=m"(*p)
  86.     : "r"(mask), "r"(p), "m"(*p)
  87.     : "cc" );
  88. }
  89.  
  90. static __inline__ void change_bit(int nr, volatile unsigned long *addr)
  91. {
  92.     unsigned long old;
  93.     unsigned long mask = BITOP_MASK(nr);
  94.     unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);
  95.  
  96.     __asm__ __volatile__(
  97. "1:"    PPC_LLARX "%0,0,%3    # change_bit\n"
  98.     "xor    %0,%0,%2\n"
  99.     PPC405_ERR77(0,%3)
  100.     PPC_STLCX "%0,0,%3\n"
  101.     "bne-    1b"
  102.     : "=&r"(old), "=m"(*p)
  103.     : "r"(mask), "r"(p), "m"(*p)
  104.     : "cc" );
  105. }
  106.  
  107. static __inline__ int test_and_set_bit(unsigned long nr,
  108.                        volatile unsigned long *addr)
  109. {
  110.     unsigned long old, t;
  111.     unsigned long mask = BITOP_MASK(nr);
  112.     unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);
  113.  
  114.     __asm__ __volatile__(
  115.     LWSYNC_ON_SMP
  116. "1:"    PPC_LLARX "%0,0,%3        # test_and_set_bit\n"
  117.     "or    %1,%0,%2 \n"
  118.     PPC405_ERR77(0,%3)
  119.     PPC_STLCX "%1,0,%3 \n"
  120.     "bne-    1b"
  121.     ISYNC_ON_SMP
  122.     : "=&r" (old), "=&r" (t)
  123.     : "r" (mask), "r" (p)
  124.     : "cc", "memory");
  125.  
  126.     return (old & mask) != 0;
  127. }
  128.  
  129. static __inline__ int test_and_clear_bit(unsigned long nr,
  130.                      volatile unsigned long *addr)
  131. {
  132.     unsigned long old, t;
  133.     unsigned long mask = BITOP_MASK(nr);
  134.     unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);
  135.  
  136.     __asm__ __volatile__(
  137.     LWSYNC_ON_SMP
  138. "1:"    PPC_LLARX "%0,0,%3        # test_and_clear_bit\n"
  139.     "andc    %1,%0,%2 \n"
  140.     PPC405_ERR77(0,%3)
  141.     PPC_STLCX "%1,0,%3 \n"
  142.     "bne-    1b"
  143.     ISYNC_ON_SMP
  144.     : "=&r" (old), "=&r" (t)
  145.     : "r" (mask), "r" (p)
  146.     : "cc", "memory");
  147.  
  148.     return (old & mask) != 0;
  149. }
  150.  
  151. static __inline__ int test_and_change_bit(unsigned long nr,
  152.                       volatile unsigned long *addr)
  153. {
  154.     unsigned long old, t;
  155.     unsigned long mask = BITOP_MASK(nr);
  156.     unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);
  157.  
  158.     __asm__ __volatile__(
  159.     LWSYNC_ON_SMP
  160. "1:"    PPC_LLARX "%0,0,%3        # test_and_change_bit\n"
  161.     "xor    %1,%0,%2 \n"
  162.     PPC405_ERR77(0,%3)
  163.     PPC_STLCX "%1,0,%3 \n"
  164.     "bne-    1b"
  165.     ISYNC_ON_SMP
  166.     : "=&r" (old), "=&r" (t)
  167.     : "r" (mask), "r" (p)
  168.     : "cc", "memory");
  169.  
  170.     return (old & mask) != 0;
  171. }
  172.  
  173. static __inline__ void set_bits(unsigned long mask, unsigned long *addr)
  174. {
  175.         unsigned long old;
  176.  
  177.     __asm__ __volatile__(
  178. "1:"    PPC_LLARX "%0,0,%3         # set_bits\n"
  179.     "or    %0,%0,%2\n"
  180.     PPC_STLCX "%0,0,%3\n"
  181.     "bne-    1b"
  182.     : "=&r" (old), "=m" (*addr)
  183.     : "r" (mask), "r" (addr), "m" (*addr)
  184.     : "cc");
  185. }
  186.  
  187. #include <asm-generic/bitops/non-atomic.h>
  188.  
  189. /*
  190.  * Return the zero-based bit position (LE, not IBM bit numbering) of
  191.  * the most significant 1-bit in a double word.
  192.  */
  193. static __inline__ int __ilog2(unsigned long x)
  194. {
  195.     int lz;
  196.  
  197.     asm (PPC_CNTLZL "%0,%1" : "=r" (lz) : "r" (x));
  198.     return BITS_PER_LONG - 1 - lz;
  199. }
  200.  
  201. /*
  202.  * Determines the bit position of the least significant 0 bit in the
  203.  * specified double word. The returned bit position will be
  204.  * zero-based, starting from the right side (63/31 - 0).
  205.  */
  206. static __inline__ unsigned long ffz(unsigned long x)
  207. {
  208.     /* no zero exists anywhere in the 8 byte area. */
  209.     if ((x = ~x) == 0)
  210.         return BITS_PER_LONG;
  211.  
  212.     /*
  213.      * Calculate the bit position of the least signficant '1' bit in x
  214.      * (since x has been changed this will actually be the least signficant
  215.      * '0' bit in * the original x).  Note: (x & -x) gives us a mask that
  216.      * is the least significant * (RIGHT-most) 1-bit of the value in x.
  217.      */
  218.     return __ilog2(x & -x);
  219. }
  220.  
  221. static __inline__ int __ffs(unsigned long x)
  222. {
  223.     return __ilog2(x & -x);
  224. }
  225.  
  226. /*
  227.  * ffs: find first bit set. This is defined the same way as
  228.  * the libc and compiler builtin ffs routines, therefore
  229.  * differs in spirit from the above ffz (man ffs).
  230.  */
  231. static __inline__ int ffs(int x)
  232. {
  233.     unsigned long i = (unsigned long)x;
  234.     return __ilog2(i & -i) + 1;
  235. }
  236.  
  237. /*
  238.  * fls: find last (most-significant) bit set.
  239.  * Note fls(0) = 0, fls(1) = 1, fls(0x80000000) = 32.
  240.  */
  241. static __inline__ int fls(unsigned int x)
  242. {
  243.     int lz;
  244.  
  245.     asm ("cntlzw %0,%1" : "=r" (lz) : "r" (x));
  246.     return 32 - lz;
  247. }
  248. #include <asm-generic/bitops/fls64.h>
  249.  
  250. #include <asm-generic/bitops/hweight.h>
  251.  
  252. #define find_first_zero_bit(addr, size) find_next_zero_bit((addr), (size), 0)
  253. unsigned long find_next_zero_bit(const unsigned long *addr,
  254.                  unsigned long size, unsigned long offset);
  255. /**
  256.  * find_first_bit - find the first set bit in a memory region
  257.  * @addr: The address to start the search at
  258.  * @size: The maximum size to search
  259.  *
  260.  * Returns the bit-number of the first set bit, not the number of the byte
  261.  * containing a bit.
  262.  */
  263. #define find_first_bit(addr, size) find_next_bit((addr), (size), 0)
  264. unsigned long find_next_bit(const unsigned long *addr,
  265.                 unsigned long size, unsigned long offset);
  266.  
  267. /* Little-endian versions */
  268.  
  269. static __inline__ int test_le_bit(unsigned long nr,
  270.                   __const__ unsigned long *addr)
  271. {
  272.     __const__ unsigned char    *tmp = (__const__ unsigned char *) addr;
  273.     return (tmp[nr >> 3] >> (nr & 7)) & 1;
  274. }
  275.  
  276. #define __set_le_bit(nr, addr) \
  277.     __set_bit((nr) ^ BITOP_LE_SWIZZLE, (addr))
  278. #define __clear_le_bit(nr, addr) \
  279.     __clear_bit((nr) ^ BITOP_LE_SWIZZLE, (addr))
  280.  
  281. #define test_and_set_le_bit(nr, addr) \
  282.     test_and_set_bit((nr) ^ BITOP_LE_SWIZZLE, (addr))
  283. #define test_and_clear_le_bit(nr, addr) \
  284.     test_and_clear_bit((nr) ^ BITOP_LE_SWIZZLE, (addr))
  285.  
  286. #define __test_and_set_le_bit(nr, addr) \
  287.     __test_and_set_bit((nr) ^ BITOP_LE_SWIZZLE, (addr))
  288. #define __test_and_clear_le_bit(nr, addr) \
  289.     __test_and_clear_bit((nr) ^ BITOP_LE_SWIZZLE, (addr))
  290.  
  291. #define find_first_zero_le_bit(addr, size) find_next_zero_le_bit((addr), (size), 0)
  292. unsigned long find_next_zero_le_bit(const unsigned long *addr,
  293.                     unsigned long size, unsigned long offset);
  294.  
  295. /* Bitmap functions for the ext2 filesystem */
  296.  
  297. #define ext2_set_bit(nr,addr) \
  298.     __test_and_set_le_bit((nr), (unsigned long*)addr)
  299. #define ext2_clear_bit(nr, addr) \
  300.     __test_and_clear_le_bit((nr), (unsigned long*)addr)
  301.  
  302. #define ext2_set_bit_atomic(lock, nr, addr) \
  303.     test_and_set_le_bit((nr), (unsigned long*)addr)
  304. #define ext2_clear_bit_atomic(lock, nr, addr) \
  305.     test_and_clear_le_bit((nr), (unsigned long*)addr)
  306.  
  307. #define ext2_test_bit(nr, addr)      test_le_bit((nr),(unsigned long*)addr)
  308.  
  309. #define ext2_find_first_zero_bit(addr, size) \
  310.     find_first_zero_le_bit((unsigned long*)addr, size)
  311. #define ext2_find_next_zero_bit(addr, size, off) \
  312.     find_next_zero_le_bit((unsigned long*)addr, size, off)
  313.  
  314. /* Bitmap functions for the minix filesystem.  */
  315.  
  316. #define minix_test_and_set_bit(nr,addr) \
  317.     __test_and_set_le_bit(nr, (unsigned long *)addr)
  318. #define minix_set_bit(nr,addr) \
  319.     __set_le_bit(nr, (unsigned long *)addr)
  320. #define minix_test_and_clear_bit(nr,addr) \
  321.     __test_and_clear_le_bit(nr, (unsigned long *)addr)
  322. #define minix_test_bit(nr,addr) \
  323.     test_le_bit(nr, (unsigned long *)addr)
  324.  
  325. #define minix_find_first_zero_bit(addr,size) \
  326.     find_first_zero_le_bit((unsigned long *)addr, size)
  327.  
  328. #include <asm-generic/bitops/sched.h>
  329.  
  330. #endif /* __KERNEL__ */
  331.  
  332. #endif /* _ASM_POWERPC_BITOPS_H */
  333.