include/asm-sparc/bitops.h

   1 /* $Id: bitops.h,v 1.59 2000/07/13 01:51:50 davem Exp $
   2  * bitops.h: Bit string operations on the Sparc.
   3  *
   4  * Copyright 1995 David S. Miller (davem@caip.rutgers.edu)
   5  * Copyright 1996 Eddie C. Dost   (ecd@skynet.be)
   6  */
   7
   8 #ifndef _SPARC_BITOPS_H
   9 #define _SPARC_BITOPS_H
  10
  11 #include <linux/kernel.h>
  12 #include <asm/byteorder.h>
  13
  14 #ifndef __KERNEL__
  15
  16 /* User mode bitops, defined here for convenience. Note: these are not
  17  * atomic, so packages like nthreads should do some locking around these
  18  * themself.
  19  */
  20
  21 extern __inline__ unsigned long set_bit(unsigned long nr, void *addr)
  22 {
  23         int mask;
  24         unsigned long *ADDR = (unsigned long *) addr;
  25
  26         ADDR += nr >> 5;
  27         mask = 1 << (nr & 31);
  28         __asm__ __volatile__("
  29         ld      [%0], %%g3
  30         or      %%g3, %2, %%g2
  31         st      %%g2, [%0]
  32         and     %%g3, %2, %0
  33         "
  34         : "=&r" (ADDR)
  35         : "0" (ADDR), "r" (mask)
  36         : "g2", "g3");
  37
  38         return (unsigned long) ADDR;
  39 }
  40
  41 extern __inline__ unsigned long clear_bit(unsigned long nr, void *addr)
  42 {
  43         int mask;
  44         unsigned long *ADDR = (unsigned long *) addr;
  45
  46         ADDR += nr >> 5;
  47         mask = 1 << (nr & 31);
  48         __asm__ __volatile__("
  49         ld      [%0], %%g3
  50         andn    %%g3, %2, %%g2
  51         st      %%g2, [%0]
  52         and     %%g3, %2, %0
  53         "
  54         : "=&r" (ADDR)
  55         : "0" (ADDR), "r" (mask)
  56         : "g2", "g3");
  57
  58         return (unsigned long) ADDR;
  59 }
  60
  61 extern __inline__ void change_bit(unsigned long nr, void *addr)
  62 {
  63         int mask;
  64         unsigned long *ADDR = (unsigned long *) addr;
  65
  66         ADDR += nr >> 5;
  67         mask = 1 << (nr & 31);
  68         __asm__ __volatile__("
  69         ld      [%0], %%g3
  70         xor     %%g3, %2, %%g2
  71         st      %%g2, [%0]
  72         and     %%g3, %2, %0
  73         "
  74         : "=&r" (ADDR)
  75         : "0" (ADDR), "r" (mask)
  76         : "g2", "g3");
  77 }
  78
  79 #else /* __KERNEL__ */
  80
  81 #include <asm/system.h>
  82
  83 /* Set bit 'nr' in 32-bit quantity at address 'addr' where bit '0'
  84  * is in the highest of the four bytes and bit '31' is the high bit
  85  * within the first byte. Sparc is BIG-Endian. Unless noted otherwise
  86  * all bit-ops return 0 if bit was previously clear and != 0 otherwise.
  87  */
  88
  89 extern __inline__ int test_and_set_bit(unsigned long nr, volatile void *addr)
  90 {
  91         register unsigned long mask asm("g2");
  92         register unsigned long *ADDR asm("g1");
  93         ADDR = ((unsigned long *) addr) + (nr >> 5);
  94         mask = 1 << (nr & 31);
  95         __asm__ __volatile__("
  96         mov     %%o7, %%g4
  97         call    ___set_bit
  98          add    %%o7, 8, %%o7
  99 "       : "=&r" (mask)
 100         : "0" (mask), "r" (ADDR)
 101         : "g3", "g4", "g5", "g7", "cc");
 102
 103         return mask != 0;
 104 }
 105
 106 extern __inline__ void set_bit(unsigned long nr, volatile void *addr)
 107 {
 108         (void) test_and_set_bit(nr, addr);
 109 }
 110
 111 extern __inline__ int test_and_clear_bit(unsigned long nr, volatile void *addr)
 112 {
 113         register unsigned long mask asm("g2");
 114         register unsigned long *ADDR asm("g1");
 115
 116         ADDR = ((unsigned long *) addr) + (nr >> 5);
 117         mask = 1 << (nr & 31);
 118         __asm__ __volatile__("
 119         mov     %%o7, %%g4
 120         call    ___clear_bit
 121          add    %%o7, 8, %%o7
 122 "       : "=&r" (mask)
 123         : "0" (mask), "r" (ADDR)
 124         : "g3", "g4", "g5", "g7", "cc");
 125
 126         return mask != 0;
 127 }
 128
 129 extern __inline__ void clear_bit(unsigned long nr, volatile void *addr)
 130 {
 131         (void) test_and_clear_bit(nr, addr);
 132 }
 133
 134 extern __inline__ int test_and_change_bit(unsigned long nr, volatile void *addr)
 135 {
 136         register unsigned long mask asm("g2");
 137         register unsigned long *ADDR asm("g1");
 138
 139         ADDR = ((unsigned long *) addr) + (nr >> 5);
 140         mask = 1 << (nr & 31);
 141         __asm__ __volatile__("
 142         mov     %%o7, %%g4
 143         call    ___change_bit
 144          add    %%o7, 8, %%o7
 145 "       : "=&r" (mask)
 146         : "0" (mask), "r" (ADDR)
 147         : "g3", "g4", "g5", "g7", "cc");
 148
 149         return mask != 0;
 150 }
 151
 152 extern __inline__ void change_bit(unsigned long nr, volatile void *addr)
 153 {
 154         (void) test_and_change_bit(nr, addr);
 155 }
 156
 157 #endif /* __KERNEL__ */
 158
 159 /* The following routine need not be atomic. */
 160 extern __inline__ int test_bit(int nr, __const__ void *addr)
 161 {
 162         return (1 & (((__const__ unsigned int *) addr)[nr >> 5] >> (nr & 31))) != 0;
 163 }
 164
 165 /* The easy/cheese version for now. */
 166 extern __inline__ unsigned long ffz(unsigned long word)
 167 {
 168         unsigned long result = 0;
 169
 170         while(word & 1) {
 171                 result++;
 172                 word >>= 1;
 173         }
 174         return result;
 175 }
 176
 177 #ifdef __KERNEL__
 178
 179 /*
 180  * ffs: find first bit set. This is defined the same way as
 181  * the libc and compiler builtin ffs routines, therefore
 182  * differs in spirit from the above ffz (man ffs).
 183  */
 184
 185 #define ffs(x) generic_ffs(x)
 186
 187 /*
 188  * hweightN: returns the hamming weight (i.e. the number
 189  * of bits set) of a N-bit word
 190  */
 191
 192 #define hweight32(x) generic_hweight32(x)
 193 #define hweight16(x) generic_hweight16(x)
 194 #define hweight8(x) generic_hweight8(x)
 195
 196 #endif /* __KERNEL__ */
 197
 198 /* find_next_zero_bit() finds the first zero bit in a bit string of length
 199  * 'size' bits, starting the search at bit 'offset'. This is largely based
 200  * on Linus's ALPHA routines, which are pretty portable BTW.
 201  */
 202
 203 extern __inline__ unsigned long find_next_zero_bit(void *addr, unsigned long size, unsigned long offset)
 204 {
 205         unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
 206         unsigned long result = offset & ~31UL;
 207         unsigned long tmp;
 208
 209         if (offset >= size)
 210                 return size;
 211         size -= result;
 212         offset &= 31UL;
 213         if (offset) {
 214                 tmp = *(p++);
 215                 tmp |= ~0UL >> (32-offset);
 216                 if (size < 32)
 217                         goto found_first;
 218                 if (~tmp)
 219                         goto found_middle;
 220                 size -= 32;
 221                 result += 32;
 222         }
 223         while (size & ~31UL) {
 224                 if (~(tmp = *(p++)))
 225                         goto found_middle;
 226                 result += 32;
 227                 size -= 32;
 228         }
 229         if (!size)
 230                 return result;
 231         tmp = *p;
 232
 233 found_first:
 234         tmp |= ~0UL << size;
 235 found_middle:
 236         return result + ffz(tmp);
 237 }
 238
 239 /* Linus sez that gcc can optimize the following correctly, we'll see if this
 240  * holds on the Sparc as it does for the ALPHA.
 241  */
 242
 243 #define find_first_zero_bit(addr, size) \
 244         find_next_zero_bit((addr), (size), 0)
 245
 246 #ifndef __KERNEL__
 247
 248 extern __inline__ int set_le_bit(int nr, void *addr)
 249 {
 250         int             mask;
 251         unsigned char   *ADDR = (unsigned char *) addr;
 252
 253         ADDR += nr >> 3;
 254         mask = 1 << (nr & 0x07);
 255         __asm__ __volatile__("
 256         ldub    [%0], %%g3
 257         or      %%g3, %2, %%g2
 258         stb     %%g2, [%0]
 259         and     %%g3, %2, %0
 260         "
 261         : "=&r" (ADDR)
 262         : "0" (ADDR), "r" (mask)
 263         : "g2", "g3");
 264
 265         return (int) ADDR;
 266 }
 267
 268 extern __inline__ int clear_le_bit(int nr, void *addr)
 269 {
 270         int             mask;
 271         unsigned char   *ADDR = (unsigned char *) addr;
 272
 273         ADDR += nr >> 3;
 274         mask = 1 << (nr & 0x07);
 275         __asm__ __volatile__("
 276         ldub    [%0], %%g3
 277         andn    %%g3, %2, %%g2
 278         stb     %%g2, [%0]
 279         and     %%g3, %2, %0
 280         "
 281         : "=&r" (ADDR)
 282         : "0" (ADDR), "r" (mask)
 283         : "g2", "g3");
 284
 285         return (int) ADDR;
 286 }
 287
 288 #else /* __KERNEL__ */
 289
 290 /* Now for the ext2 filesystem bit operations and helper routines. */
 291
 292 extern __inline__ int set_le_bit(int nr, volatile void * addr)
 293 {
 294         register int mask asm("g2");
 295         register unsigned char *ADDR asm("g1");
 296
 297         ADDR = ((unsigned char *) addr) + (nr >> 3);
 298         mask = 1 << (nr & 0x07);
 299         __asm__ __volatile__("
 300         mov     %%o7, %%g4
 301         call    ___set_le_bit
 302          add    %%o7, 8, %%o7
 303 "       : "=&r" (mask)
 304         : "0" (mask), "r" (ADDR)
 305         : "g3", "g4", "g5", "g7", "cc");
 306
 307         return mask;
 308 }
 309
 310 extern __inline__ int clear_le_bit(int nr, volatile void * addr)
 311 {
 312         register int mask asm("g2");
 313         register unsigned char *ADDR asm("g1");
 314
 315         ADDR = ((unsigned char *) addr) + (nr >> 3);
 316         mask = 1 << (nr & 0x07);
 317         __asm__ __volatile__("
 318         mov     %%o7, %%g4
 319         call    ___clear_le_bit
 320          add    %%o7, 8, %%o7
 321 "       : "=&r" (mask)
 322         : "0" (mask), "r" (ADDR)
 323         : "g3", "g4", "g5", "g7", "cc");
 324
 325         return mask;
 326 }
 327
 328 #endif /* __KERNEL__ */
 329
 330 extern __inline__ int test_le_bit(int nr, __const__ void * addr)
 331 {
 332         int                     mask;
 333         __const__ unsigned char *ADDR = (__const__ unsigned char *) addr;
 334
 335         ADDR += nr >> 3;
 336         mask = 1 << (nr & 0x07);
 337         return ((mask & *ADDR) != 0);
 338 }
 339
 340 #ifdef __KERNEL__
 341
 342 #define ext2_set_bit   set_le_bit
 343 #define ext2_clear_bit clear_le_bit
 344 #define ext2_test_bit  test_le_bit
 345
 346 #endif /* __KERNEL__ */
 347
 348 #define find_first_zero_le_bit(addr, size) \
 349         find_next_zero_le_bit((addr), (size), 0)
 350
 351 extern __inline__ unsigned long find_next_zero_le_bit(void *addr, unsigned long size, unsigned long offset)
 352 {
 353         unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
 354         unsigned long result = offset & ~31UL;
 355         unsigned long tmp;
 356
 357         if (offset >= size)
 358                 return size;
 359         size -= result;
 360         offset &= 31UL;
 361         if(offset) {
 362                 tmp = *(p++);
 363                 tmp |= __swab32(~0UL >> (32-offset));
 364                 if(size < 32)
 365                         goto found_first;
 366                 if(~tmp)
 367                         goto found_middle;
 368                 size -= 32;
 369                 result += 32;
 370         }
 371         while(size & ~31UL) {
 372                 if(~(tmp = *(p++)))
 373                         goto found_middle;
 374                 result += 32;
 375                 size -= 32;
 376         }
 377         if(!size)
 378                 return result;
 379         tmp = *p;
 380
 381 found_first:
 382         return result + ffz(__swab32(tmp) | (~0UL << size));
 383 found_middle:
 384         return result + ffz(__swab32(tmp));
 385 }
 386
 387 #ifdef __KERNEL__
 388
 389 #define ext2_find_first_zero_bit     find_first_zero_le_bit
 390 #define ext2_find_next_zero_bit      find_next_zero_le_bit
 391
 392 /* Bitmap functions for the minix filesystem.  */
 393 #define minix_test_and_set_bit(nr,addr) test_and_set_bit(nr,addr)
 394 #define minix_set_bit(nr,addr) set_bit(nr,addr)
 395 #define minix_test_and_clear_bit(nr,addr) test_and_clear_bit(nr,addr)
 396 #define minix_test_bit(nr,addr) test_bit(nr,addr)
 397 #define minix_find_first_zero_bit(addr,size) find_first_zero_bit(addr,size)
 398
 399 #endif /* __KERNEL__ */
 400
 401 #endif /* defined(_SPARC_BITOPS_H) */