include/asm-sparc64/bitops.h

   1 /* $Id: bitops.h,v 1.39 2002/01/30 01:40:00 davem Exp $
   2  * bitops.h: Bit string operations on the V9.
   3  *
   4  * Copyright 1996, 1997 David S. Miller (davem@caip.rutgers.edu)
   5  */
   6
   7 #ifndef _SPARC64_BITOPS_H
   8 #define _SPARC64_BITOPS_H
   9
  10 #include <linux/compiler.h>
  11 #include <asm/byteorder.h>
  12
  13 extern long ___test_and_set_bit(unsigned long nr, volatile unsigned long *addr);
  14 extern long ___test_and_clear_bit(unsigned long nr, volatile unsigned long *addr);
  15 extern long ___test_and_change_bit(unsigned long nr, volatile unsigned long *addr);
  16
  17 #define test_and_set_bit(nr,addr)       ({___test_and_set_bit(nr,addr)!=0;})
  18 #define test_and_clear_bit(nr,addr)     ({___test_and_clear_bit(nr,addr)!=0;})
  19 #define test_and_change_bit(nr,addr)    ({___test_and_change_bit(nr,addr)!=0;})
  20 #define set_bit(nr,addr)                ((void)___test_and_set_bit(nr,addr))
  21 #define clear_bit(nr,addr)              ((void)___test_and_clear_bit(nr,addr))
  22 #define change_bit(nr,addr)             ((void)___test_and_change_bit(nr,addr))
  23
  24 /* "non-atomic" versions... */
  25
  26 static __inline__ void __set_bit(int nr, volatile unsigned long *addr)
  27 {
  28         volatile unsigned long *m = addr + (nr >> 6);
  29
  30         *m |= (1UL << (nr & 63));
  31 }
  32
  33 static __inline__ void __clear_bit(int nr, volatile unsigned long *addr)
  34 {
  35         volatile unsigned long *m = addr + (nr >> 6);
  36
  37         *m &= ~(1UL << (nr & 63));
  38 }
  39
  40 static __inline__ void __change_bit(int nr, volatile unsigned long *addr)
  41 {
  42         volatile unsigned long *m = addr + (nr >> 6);
  43
  44         *m ^= (1UL << (nr & 63));
  45 }
  46
  47 static __inline__ int __test_and_set_bit(int nr, volatile unsigned long *addr)
  48 {
  49         volatile unsigned long *m = addr + (nr >> 6);
  50         long old = *m;
  51         long mask = (1UL << (nr & 63));
  52
  53         *m = (old | mask);
  54         return ((old & mask) != 0);
  55 }
  56
  57 static __inline__ int __test_and_clear_bit(int nr, volatile unsigned long *addr)
  58 {
  59         volatile unsigned long *m = addr + (nr >> 6);
  60         long old = *m;
  61         long mask = (1UL << (nr & 63));
  62
  63         *m = (old & ~mask);
  64         return ((old & mask) != 0);
  65 }
  66
  67 static __inline__ int __test_and_change_bit(int nr, volatile unsigned long *addr)
  68 {
  69         volatile unsigned long *m = addr + (nr >> 6);
  70         long old = *m;
  71         long mask = (1UL << (nr & 63));
  72
  73         *m = (old ^ mask);
  74         return ((old & mask) != 0);
  75 }
  76
  77 #define smp_mb__before_clear_bit()      do { } while(0)
  78 #define smp_mb__after_clear_bit()       do { } while(0)
  79
  80 static __inline__ int test_bit(int nr, __const__ volatile unsigned long *addr)
  81 {
  82         return (1UL & ((addr)[nr >> 6] >> (nr & 63))) != 0UL;
  83 }
  84
  85 /* The easy/cheese version for now. */
  86 static __inline__ unsigned long ffz(unsigned long word)
  87 {
  88         unsigned long result;
  89
  90         result = 0;
  91         while(word & 1) {
  92                 result++;
  93                 word >>= 1;
  94         }
  95         return result;
  96 }
  97
  98 /**
  99  * __ffs - find first bit in word.
 100  * @word: The word to search
 101  *
 102  * Undefined if no bit exists, so code should check against 0 first.
 103  */
 104 static __inline__ unsigned long __ffs(unsigned long word)
 105 {
 106         unsigned long result = 0;
 107
 108         while (!(word & 1UL)) {
 109                 result++;
 110                 word >>= 1;
 111         }
 112         return result;
 113 }
 114
 115 /*
 116  * fls: find last bit set.
 117  */
 118
 119 #define fls(x) generic_fls(x)
 120
 121 #ifdef __KERNEL__
 122
 123 /*
 124  * Every architecture must define this function. It's the fastest
 125  * way of searching a 140-bit bitmap where the first 100 bits are
 126  * unlikely to be set. It's guaranteed that at least one of the 140
 127  * bits is cleared.
 128  */
 129 static inline int sched_find_first_bit(unsigned long *b)
 130 {
 131         if (unlikely(b[0]))
 132                 return __ffs(b[0]);
 133         if (unlikely(((unsigned int)b[1])))
 134                 return __ffs(b[1]) + 64;
 135         if (b[1] >> 32)
 136                 return __ffs(b[1] >> 32) + 96;
 137         return __ffs(b[2]) + 128;
 138 }
 139
 140 /*
 141  * ffs: find first bit set. This is defined the same way as
 142  * the libc and compiler builtin ffs routines, therefore
 143  * differs in spirit from the above ffz (man ffs).
 144  */
 145 static __inline__ int ffs(int x)
 146 {
 147         if (!x)
 148                 return 0;
 149         return __ffs((unsigned long)x) + 1;
 150 }
 151
 152 /*
 153  * hweightN: returns the hamming weight (i.e. the number
 154  * of bits set) of a N-bit word
 155  */
 156
 157 #ifdef ULTRA_HAS_POPULATION_COUNT
 158
 159 static __inline__ unsigned int hweight64(unsigned long w)
 160 {
 161         unsigned int res;
 162
 163         __asm__ ("popc %1,%0" : "=r" (res) : "r" (w));
 164         return res;
 165 }
 166
 167 static __inline__ unsigned int hweight32(unsigned int w)
 168 {
 169         unsigned int res;
 170
 171         __asm__ ("popc %1,%0" : "=r" (res) : "r" (w & 0xffffffff));
 172         return res;
 173 }
 174
 175 static __inline__ unsigned int hweight16(unsigned int w)
 176 {
 177         unsigned int res;
 178
 179         __asm__ ("popc %1,%0" : "=r" (res) : "r" (w & 0xffff));
 180         return res;
 181 }
 182
 183 static __inline__ unsigned int hweight8(unsigned int w)
 184 {
 185         unsigned int res;
 186
 187         __asm__ ("popc %1,%0" : "=r" (res) : "r" (w & 0xff));
 188         return res;
 189 }
 190
 191 #else
 192
 193 #define hweight64(x) generic_hweight64(x)
 194 #define hweight32(x) generic_hweight32(x)
 195 #define hweight16(x) generic_hweight16(x)
 196 #define hweight8(x) generic_hweight8(x)
 197
 198 #endif
 199 #endif /* __KERNEL__ */
 200
 201 /**
 202  * find_next_bit - find the next set bit in a memory region
 203  * @addr: The address to base the search on
 204  * @offset: The bitnumber to start searching at
 205  * @size: The maximum size to search
 206  */
 207 static __inline__ unsigned long find_next_bit(unsigned long *addr, unsigned long size, unsigned long offset)
 208 {
 209         unsigned long *p = addr + (offset >> 6);
 210         unsigned long result = offset & ~63UL;
 211         unsigned long tmp;
 212
 213         if (offset >= size)
 214                 return size;
 215         size -= result;
 216         offset &= 63UL;
 217         if (offset) {
 218                 tmp = *(p++);
 219                 tmp &= (~0UL << offset);
 220                 if (size < 64)
 221                         goto found_first;
 222                 if (tmp)
 223                         goto found_middle;
 224                 size -= 64;
 225                 result += 64;
 226         }
 227         while (size & ~63UL) {
 228                 if ((tmp = *(p++)))
 229                         goto found_middle;
 230                 result += 64;
 231                 size -= 64;
 232         }
 233         if (!size)
 234                 return result;
 235         tmp = *p;
 236
 237 found_first:
 238         tmp &= (~0UL >> (64 - size));
 239         if (tmp == 0UL)        /* Are any bits set? */
 240                 return result + size; /* Nope. */
 241 found_middle:
 242         return result + __ffs(tmp);
 243 }
 244
 245 /**
 246  * find_first_bit - find the first set bit in a memory region
 247  * @addr: The address to start the search at
 248  * @size: The maximum size to search
 249  *
 250  * Returns the bit-number of the first set bit, not the number of the byte
 251  * containing a bit.
 252  */
 253 #define find_first_bit(addr, size) \
 254         find_next_bit((addr), (size), 0)
 255
 256 /* find_next_zero_bit() finds the first zero bit in a bit string of length
 257  * 'size' bits, starting the search at bit 'offset'. This is largely based
 258  * on Linus's ALPHA routines, which are pretty portable BTW.
 259  */
 260
 261 static __inline__ unsigned long find_next_zero_bit(unsigned long *addr, unsigned long size, unsigned long offset)
 262 {
 263         unsigned long *p = addr + (offset >> 6);
 264         unsigned long result = offset & ~63UL;
 265         unsigned long tmp;
 266
 267         if (offset >= size)
 268                 return size;
 269         size -= result;
 270         offset &= 63UL;
 271         if (offset) {
 272                 tmp = *(p++);
 273                 tmp |= ~0UL >> (64-offset);
 274                 if (size < 64)
 275                         goto found_first;
 276                 if (~tmp)
 277                         goto found_middle;
 278                 size -= 64;
 279                 result += 64;
 280         }
 281         while (size & ~63UL) {
 282                 if (~(tmp = *(p++)))
 283                         goto found_middle;
 284                 result += 64;
 285                 size -= 64;
 286         }
 287         if (!size)
 288                 return result;
 289         tmp = *p;
 290
 291 found_first:
 292         tmp |= ~0UL << size;
 293         if (tmp == ~0UL)        /* Are any bits zero? */
 294                 return result + size; /* Nope. */
 295 found_middle:
 296         return result + ffz(tmp);
 297 }
 298
 299 #define find_first_zero_bit(addr, size) \
 300         find_next_zero_bit((addr), (size), 0)
 301
 302 extern long ___test_and_set_le_bit(int nr, volatile unsigned long *addr);
 303 extern long ___test_and_clear_le_bit(int nr, volatile unsigned long *addr);
 304
 305 #define test_and_set_le_bit(nr,addr)    ({___test_and_set_le_bit(nr,addr)!=0;})
 306 #define test_and_clear_le_bit(nr,addr)  ({___test_and_clear_le_bit(nr,addr)!=0;})
 307 #define set_le_bit(nr,addr)             ((void)___test_and_set_le_bit(nr,addr))
 308 #define clear_le_bit(nr,addr)           ((void)___test_and_clear_le_bit(nr,addr))
 309
 310 static __inline__ int test_le_bit(int nr, __const__ unsigned long * addr)
 311 {
 312         int                     mask;
 313         __const__ unsigned char *ADDR = (__const__ unsigned char *) addr;
 314
 315         ADDR += nr >> 3;
 316         mask = 1 << (nr & 0x07);
 317         return ((mask & *ADDR) != 0);
 318 }
 319
 320 #define find_first_zero_le_bit(addr, size) \
 321         find_next_zero_le_bit((addr), (size), 0)
 322
 323 static __inline__ unsigned long find_next_zero_le_bit(unsigned long *addr, unsigned long size, unsigned long offset)
 324 {
 325         unsigned long *p = addr + (offset >> 6);
 326         unsigned long result = offset & ~63UL;
 327         unsigned long tmp;
 328
 329         if (offset >= size)
 330                 return size;
 331         size -= result;
 332         offset &= 63UL;
 333         if(offset) {
 334                 tmp = __swab64p(p++);
 335                 tmp |= (~0UL >> (64-offset));
 336                 if(size < 64)
 337                         goto found_first;
 338                 if(~tmp)
 339                         goto found_middle;
 340                 size -= 64;
 341                 result += 64;
 342         }
 343         while(size & ~63) {
 344                 if(~(tmp = __swab64p(p++)))
 345                         goto found_middle;
 346                 result += 64;
 347                 size -= 64;
 348         }
 349         if(!size)
 350                 return result;
 351         tmp = __swab64p(p);
 352 found_first:
 353         tmp |= (~0UL << size);
 354         if (tmp == ~0UL)        /* Are any bits zero? */
 355                 return result + size; /* Nope. */
 356 found_middle:
 357         return result + ffz(tmp);
 358 }
 359
 360 #ifdef __KERNEL__
 361
 362 #define ext2_set_bit(nr,addr)           test_and_set_le_bit((nr),(unsigned long *)(addr))
 363 #define ext2_set_bit_atomic(lock,nr,addr) test_and_set_le_bit((nr),(unsigned long *)(addr))
 364 #define ext2_clear_bit(nr,addr)         test_and_clear_le_bit((nr),(unsigned long *)(addr))
 365 #define ext2_clear_bit_atomic(lock,nr,addr) test_and_clear_le_bit((nr),(unsigned long *)(addr))
 366 #define ext2_test_bit(nr,addr)          test_le_bit((nr),(unsigned long *)(addr))
 367 #define ext2_find_first_zero_bit(addr, size) \
 368         find_first_zero_le_bit((unsigned long *)(addr), (size))
 369 #define ext2_find_next_zero_bit(addr, size, off) \
 370         find_next_zero_le_bit((unsigned long *)(addr), (size), (off))
 371
 372 /* Bitmap functions for the minix filesystem.  */
 373 #define minix_test_and_set_bit(nr,addr) test_and_set_bit((nr),(unsigned long *)(addr))
 374 #define minix_set_bit(nr,addr)          set_bit((nr),(unsigned long *)(addr))
 375 #define minix_test_and_clear_bit(nr,addr) \
 376         test_and_clear_bit((nr),(unsigned long *)(addr))
 377 #define minix_test_bit(nr,addr)         test_bit((nr),(unsigned long *)(addr))
 378 #define minix_find_first_zero_bit(addr,size) \
 379         find_first_zero_bit((unsigned long *)(addr),(size))
 380
 381 #endif /* __KERNEL__ */
 382
 383 #endif /* defined(_SPARC64_BITOPS_H) */