git.oblomov.eu Git - linux-2.6/blob - include/asm-xtensa/bitops.h

   1 /*
   2  * include/asm-xtensa/bitops.h
   3  *
   4  * Atomic operations that C can't guarantee us.Useful for resource counting etc.
   5  *
   6  * This file is subject to the terms and conditions of the GNU General Public
   7  * License.  See the file "COPYING" in the main directory of this archive
   8  * for more details.
   9  *
  10  * Copyright (C) 2001 - 2005 Tensilica Inc.
  11  */
  12
  13 #ifndef _XTENSA_BITOPS_H
  14 #define _XTENSA_BITOPS_H
  15
  16 #ifdef __KERNEL__
  17
  18 #include <asm/processor.h>
  19 #include <asm/byteorder.h>
  20 #include <asm/system.h>
  21
  22 #ifdef CONFIG_SMP
  23 # error SMP not supported on this architecture
  24 #endif
  25
  26 static __inline__ void set_bit(int nr, volatile void * addr)
  27 {
  28         unsigned long mask = 1 << (nr & 0x1f);
  29         unsigned long *a = ((unsigned long *)addr) + (nr >> 5);
  30         unsigned long flags;
  31
  32         local_irq_save(flags);
  33         *a |= mask;
  34         local_irq_restore(flags);
  35 }
  36
  37 static __inline__ void __set_bit(int nr, volatile unsigned long * addr)
  38 {
  39         unsigned long mask = 1 << (nr & 0x1f);
  40         unsigned long *a = ((unsigned long *)addr) + (nr >> 5);
  41
  42         *a |= mask;
  43 }
  44
  45 static __inline__ void clear_bit(int nr, volatile void * addr)
  46 {
  47         unsigned long mask = 1 << (nr & 0x1f);
  48         unsigned long *a = ((unsigned long *)addr) + (nr >> 5);
  49         unsigned long flags;
  50
  51         local_irq_save(flags);
  52         *a &= ~mask;
  53         local_irq_restore(flags);
  54 }
  55
  56 static __inline__ void __clear_bit(int nr, volatile unsigned long *addr)
  57 {
  58         unsigned long mask = 1 << (nr & 0x1f);
  59         unsigned long *a = ((unsigned long *)addr) + (nr >> 5);
  60
  61         *a &= ~mask;
  62 }
  63
  64 /*
  65  * clear_bit() doesn't provide any barrier for the compiler.
  66  */
  67
  68 #define smp_mb__before_clear_bit()      barrier()
  69 #define smp_mb__after_clear_bit()       barrier()
  70
  71 static __inline__ void change_bit(int nr, volatile void * addr)
  72 {
  73         unsigned long mask = 1 << (nr & 0x1f);
  74         unsigned long *a = ((unsigned long *)addr) + (nr >> 5);
  75         unsigned long flags;
  76
  77         local_irq_save(flags);
  78         *a ^= mask;
  79         local_irq_restore(flags);
  80 }
  81
  82 static __inline__ void __change_bit(int nr, volatile void * addr)
  83 {
  84         unsigned long mask = 1 << (nr & 0x1f);
  85         unsigned long *a = ((unsigned long *)addr) + (nr >> 5);
  86
  87         *a ^= mask;
  88 }
  89
  90 static __inline__ int test_and_set_bit(int nr, volatile void * addr)
  91 {
  92         unsigned long retval;
  93         unsigned long mask = 1 << (nr & 0x1f);
  94         unsigned long *a = ((unsigned long *)addr) + (nr >> 5);
  95         unsigned long flags;
  96
  97         local_irq_save(flags);
  98         retval = (mask & *a) != 0;
  99         *a |= mask;
 100         local_irq_restore(flags);
 101
 102         return retval;
 103 }
 104
 105 static __inline__ int __test_and_set_bit(int nr, volatile void * addr)
 106 {
 107         unsigned long retval;
 108         unsigned long mask = 1 << (nr & 0x1f);
 109         unsigned long *a = ((unsigned long *)addr) + (nr >> 5);
 110
 111         retval = (mask & *a) != 0;
 112         *a |= mask;
 113
 114         return retval;
 115 }
 116
 117 static __inline__ int test_and_clear_bit(int nr, volatile void * addr)
 118 {
 119         unsigned long retval;
 120         unsigned long mask = 1 << (nr & 0x1f);
 121         unsigned long *a = ((unsigned long *)addr) + (nr >> 5);
 122         unsigned long flags;
 123
 124         local_irq_save(flags);
 125         retval = (mask & *a) != 0;
 126         *a &= ~mask;
 127         local_irq_restore(flags);
 128
 129         return retval;
 130 }
 131
 132 static __inline__ int __test_and_clear_bit(int nr, volatile void * addr)
 133 {
 134         unsigned long mask = 1 << (nr & 0x1f);
 135         unsigned long *a = ((unsigned long *)addr) + (nr >> 5);
 136         unsigned long old = *a;
 137
 138         *a = old & ~mask;
 139         return (old & mask) != 0;
 140 }
 141
 142 static __inline__ int test_and_change_bit(int nr, volatile void * addr)
 143 {
 144         unsigned long retval;
 145         unsigned long mask = 1 << (nr & 0x1f);
 146         unsigned long *a = ((unsigned long *)addr) + (nr >> 5);
 147         unsigned long flags;
 148
 149         local_irq_save(flags);
 150
 151         retval = (mask & *a) != 0;
 152         *a ^= mask;
 153         local_irq_restore(flags);
 154
 155         return retval;
 156 }
 157
 158 /*
 159  * non-atomic version; can be reordered
 160  */
 161
 162 static __inline__ int __test_and_change_bit(int nr, volatile void *addr)
 163 {
 164         unsigned long mask = 1 << (nr & 0x1f);
 165         unsigned long *a = ((unsigned long *)addr) + (nr >> 5);
 166         unsigned long old = *a;
 167
 168         *a = old ^ mask;
 169         return (old & mask) != 0;
 170 }
 171
 172 static __inline__ int test_bit(int nr, const volatile void *addr)
 173 {
 174         return 1UL & (((const volatile unsigned int *)addr)[nr>>5] >> (nr&31));
 175 }
 176
 177 #if XCHAL_HAVE_NSA
 178
 179 static __inline__ int __cntlz (unsigned long x)
 180 {
 181         int lz;
 182         asm ("nsau %0, %1" : "=r" (lz) : "r" (x));
 183         return 31 - lz;
 184 }
 185
 186 #else
 187
 188 static __inline__ int __cntlz (unsigned long x)
 189 {
 190         unsigned long sum, x1, x2, x4, x8, x16;
 191         x1  = x & 0xAAAAAAAA;
 192         x2  = x & 0xCCCCCCCC;
 193         x4  = x & 0xF0F0F0F0;
 194         x8  = x & 0xFF00FF00;
 195         x16 = x & 0xFFFF0000;
 196         sum = x2 ? 2 : 0;
 197         sum += (x16 != 0) * 16;
 198         sum += (x8 != 0) * 8;
 199         sum += (x4 != 0) * 4;
 200         sum += (x1 != 0);
 201
 202         return sum;
 203 }
 204
 205 #endif
 206
 207 /*
 208  * ffz: Find first zero in word. Undefined if no zero exists.
 209  * bit 0 is the LSB of addr; bit 32 is the LSB of (addr+1).
 210  */
 211
 212 static __inline__ int ffz(unsigned long x)
 213 {
 214         if ((x = ~x) == 0)
 215                 return 32;
 216         return __cntlz(x & -x);
 217 }
 218
 219 /*
 220  * __ffs: Find first bit set in word. Return 0 for bit 0
 221  */
 222
 223 static __inline__ int __ffs(unsigned long x)
 224 {
 225         return __cntlz(x & -x);
 226 }
 227
 228 /*
 229  * ffs: Find first bit set in word. This is defined the same way as
 230  * the libc and compiler builtin ffs routines, therefore
 231  * differs in spirit from the above ffz (man ffs).
 232  */
 233
 234 static __inline__ int ffs(unsigned long x)
 235 {
 236         return __cntlz(x & -x) + 1;
 237 }
 238
 239 /*
 240  * fls: Find last (most-significant) bit set in word.
 241  * Note fls(0) = 0, fls(1) = 1, fls(0x80000000) = 32.
 242  */
 243
 244 static __inline__ int fls (unsigned int x)
 245 {
 246         return __cntlz(x);
 247 }
 248
 249 static __inline__ int
 250 find_next_bit(const unsigned long *addr, int size, int offset)
 251 {
 252         const unsigned long *p = addr + (offset >> 5);
 253         unsigned long result = offset & ~31UL;
 254         unsigned long tmp;
 255
 256         if (offset >= size)
 257                 return size;
 258         size -= result;
 259         offset &= 31UL;
 260         if (offset) {
 261                 tmp = *p++;
 262                 tmp &= ~0UL << offset;
 263                 if (size < 32)
 264                         goto found_first;
 265                 if (tmp)
 266                         goto found_middle;
 267                 size -= 32;
 268                 result += 32;
 269         }
 270         while (size >= 32) {
 271                 if ((tmp = *p++) != 0)
 272                         goto found_middle;
 273                 result += 32;
 274                 size -= 32;
 275         }
 276         if (!size)
 277                 return result;
 278         tmp = *p;
 279
 280 found_first:
 281         tmp &= ~0UL >> (32 - size);
 282         if (tmp == 0UL) /* Are any bits set? */
 283                 return result + size;   /* Nope. */
 284 found_middle:
 285         return result + __ffs(tmp);
 286 }
 287
 288 /**
 289  * find_first_bit - find the first set bit in a memory region
 290  * @addr: The address to start the search at
 291  * @size: The maximum size to search
 292  *
 293  * Returns the bit-number of the first set bit, not the number of the byte
 294  * containing a bit.
 295  */
 296
 297 #define find_first_bit(addr, size) \
 298         find_next_bit((addr), (size), 0)
 299
 300 static __inline__ int
 301 find_next_zero_bit(const unsigned long *addr, int size, int offset)
 302 {
 303         const unsigned long *p = addr + (offset >> 5);
 304         unsigned long result = offset & ~31UL;
 305         unsigned long tmp;
 306
 307         if (offset >= size)
 308                 return size;
 309         size -= result;
 310         offset &= 31UL;
 311         if (offset) {
 312                 tmp = *p++;
 313                 tmp |= ~0UL >> (32-offset);
 314                 if (size < 32)
 315                         goto found_first;
 316                 if (~tmp)
 317                         goto found_middle;
 318                 size -= 32;
 319                 result += 32;
 320         }
 321         while (size & ~31UL) {
 322                 if (~(tmp = *p++))
 323                         goto found_middle;
 324                 result += 32;
 325                 size -= 32;
 326         }
 327         if (!size)
 328                 return result;
 329         tmp = *p;
 330
 331 found_first:
 332         tmp |= ~0UL << size;
 333 found_middle:
 334         return result + ffz(tmp);
 335 }
 336
 337 #define find_first_zero_bit(addr, size) \
 338         find_next_zero_bit((addr), (size), 0)
 339
 340 #ifdef __XTENSA_EL__
 341 # define ext2_set_bit(nr,addr) __test_and_set_bit((nr), (addr))
 342 # define ext2_set_bit_atomic(lock,nr,addr) test_and_set_bit((nr),(addr))
 343 # define ext2_clear_bit(nr,addr) __test_and_clear_bit((nr), (addr))
 344 # define ext2_clear_bit_atomic(lock,nr,addr) test_and_clear_bit((nr),(addr))
 345 # define ext2_test_bit(nr,addr) test_bit((nr), (addr))
 346 # define ext2_find_first_zero_bit(addr, size) find_first_zero_bit((addr),(size))
 347 # define ext2_find_next_zero_bit(addr, size, offset) \
 348                 find_next_zero_bit((addr), (size), (offset))
 349 #elif defined(__XTENSA_EB__)
 350 # define ext2_set_bit(nr,addr) __test_and_set_bit((nr) ^ 0x18, (addr))
 351 # define ext2_set_bit_atomic(lock,nr,addr) test_and_set_bit((nr) ^ 0x18, (addr))
 352 # define ext2_clear_bit(nr,addr) __test_and_clear_bit((nr) ^ 18, (addr))
 353 # define ext2_clear_bit_atomic(lock,nr,addr) test_and_clear_bit((nr)^0x18,(addr))
 354 # define ext2_test_bit(nr,addr) test_bit((nr) ^ 0x18, (addr))
 355 # define ext2_find_first_zero_bit(addr, size) \
 356         ext2_find_next_zero_bit((addr), (size), 0)
 357
 358 static __inline__ unsigned long ext2_find_next_zero_bit(void *addr, unsigned long size, unsigned long offset)
 359 {
 360         unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
 361         unsigned long result = offset & ~31UL;
 362         unsigned long tmp;
 363
 364         if (offset >= size)
 365                 return size;
 366         size -= result;
 367         offset &= 31UL;
 368         if(offset) {
 369                 /* We hold the little endian value in tmp, but then the
 370                  * shift is illegal. So we could keep a big endian value
 371                  * in tmp, like this:
 372                  *
 373                  * tmp = __swab32(*(p++));
 374                  * tmp |= ~0UL >> (32-offset);
 375                  *
 376                  * but this would decrease preformance, so we change the
 377                  * shift:
 378                  */
 379                 tmp = *(p++);
 380                 tmp |= __swab32(~0UL >> (32-offset));
 381                 if(size < 32)
 382                         goto found_first;
 383                 if(~tmp)
 384                         goto found_middle;
 385                 size -= 32;
 386                 result += 32;
 387         }
 388         while(size & ~31UL) {
 389                 if(~(tmp = *(p++)))
 390                         goto found_middle;
 391                 result += 32;
 392                 size -= 32;
 393         }
 394         if(!size)
 395                 return result;
 396         tmp = *p;
 397
 398 found_first:
 399         /* tmp is little endian, so we would have to swab the shift,
 400          * see above. But then we have to swab tmp below for ffz, so
 401          * we might as well do this here.
 402          */
 403         return result + ffz(__swab32(tmp) | (~0UL << size));
 404 found_middle:
 405         return result + ffz(__swab32(tmp));
 406 }
 407
 408 #else
 409 # error processor byte order undefined!
 410 #endif
 411
 412
 413 #define hweight32(x)    generic_hweight32(x)
 414 #define hweight16(x)    generic_hweight16(x)
 415 #define hweight8(x)     generic_hweight8(x)
 416
 417 /*
 418  * Find the first bit set in a 140-bit bitmap.
 419  * The first 100 bits are unlikely to be set.
 420  */
 421
 422 static inline int sched_find_first_bit(const unsigned long *b)
 423 {
 424         if (unlikely(b[0]))
 425                 return __ffs(b[0]);
 426         if (unlikely(b[1]))
 427                 return __ffs(b[1]) + 32;
 428         if (unlikely(b[2]))
 429                 return __ffs(b[2]) + 64;
 430         if (b[3])
 431                 return __ffs(b[3]) + 96;
 432         return __ffs(b[4]) + 128;
 433 }
 434
 435
 436 /* Bitmap functions for the minix filesystem.  */
 437
 438 #define minix_test_and_set_bit(nr,addr) test_and_set_bit(nr,addr)
 439 #define minix_set_bit(nr,addr) set_bit(nr,addr)
 440 #define minix_test_and_clear_bit(nr,addr) test_and_clear_bit(nr,addr)
 441 #define minix_test_bit(nr,addr) test_bit(nr,addr)
 442 #define minix_find_first_zero_bit(addr,size) find_first_zero_bit(addr,size)
 443
 444 #endif  /* __KERNEL__ */
 445
 446 #endif  /* _XTENSA_BITOPS_H */