include/asm-mips64/bitops.h

   1 /* $Id: bitops.h,v 1.3 1999/08/20 21:59:08 ralf Exp $
   2  *
   3  * This file is subject to the terms and conditions of the GNU General Public
   4  * License.  See the file "COPYING" in the main directory of this archive
   5  * for more details.
   6  *
   7  * Copyright (c) 1994 - 1999  Ralf Baechle (ralf@gnu.org)
   8  * Copyright (c) 1999  Silicon Graphics, Inc.
   9  */
  10 #ifndef _ASM_BITOPS_H
  11 #define _ASM_BITOPS_H
  12
  13 #include <linux/types.h>
  14 #include <linux/byteorder/swab.h>               /* sigh ... */
  15
  16 #ifndef __KERNEL__
  17 #error "Don't do this, sucker ..."
  18 #endif
  19
  20 #include <asm/system.h>
  21 #include <asm/sgidefs.h>
  22 #include <asm/mipsregs.h>
  23
  24 /*
  25  * These functions for MIPS ISA > 1 are interrupt and SMP proof and
  26  * interrupt friendly
  27  */
  28
  29 extern __inline__ void
  30 set_bit(unsigned long nr, void *addr)
  31 {
  32         unsigned long *m = ((unsigned long *) addr) + (nr >> 6);
  33         unsigned long temp;
  34
  35         __asm__ __volatile__(
  36                 "1:\tlld\t%0, %1\t\t# set_bit\n\t"
  37                 "or\t%0, %2\n\t"
  38                 "scd\t%0, %1\n\t"
  39                 "beqz\t%0, 1b"
  40                 :"=&r" (temp), "=m" (*m)
  41                 :"ir" (1UL << (nr & 0x3f)), "m" (*m));
  42 }
  43
  44 extern __inline__ void
  45 clear_bit(unsigned long nr, void *addr)
  46 {
  47         unsigned long *m = ((unsigned long *) addr) + (nr >> 6);
  48         unsigned long temp;
  49
  50         __asm__ __volatile__(
  51                 "1:\tlld\t%0, %1\t\t# clear_bit\n\t"
  52                 "and\t%0, %2\n\t"
  53                 "scd\t%0, %1\n\t"
  54                 "beqz\t%0, 1b\n\t"
  55                 :"=&r" (temp), "=m" (*m)
  56                 :"ir" (~(1UL << (nr & 0x3f))), "m" (*m));
  57 }
  58
  59 extern __inline__ void
  60 change_bit(unsigned long nr, void *addr)
  61 {
  62         unsigned long *m = ((unsigned long *) addr) + (nr >> 6);
  63         unsigned long temp;
  64
  65         __asm__ __volatile__(
  66                 "1:\tlld\t%0, %1\t\t# change_bit\n\t"
  67                 "xor\t%0, %2\n\t"
  68                 "scd\t%0, %1\n\t"
  69                 "beqz\t%0, 1b"
  70                 :"=&r" (temp), "=m" (*m)
  71                 :"ir" (1UL << (nr & 0x3f)), "m" (*m));
  72 }
  73
  74 extern __inline__ unsigned long
  75 test_and_set_bit(unsigned long nr, void *addr)
  76 {
  77         unsigned long *m = ((unsigned long *) addr) + (nr >> 6);
  78         unsigned long temp, res;
  79
  80         __asm__ __volatile__(
  81                 ".set\tnoreorder\t\t# test_and_set_bit\n"
  82                 "1:\tlld\t%0, %1\n\t"
  83                 "or\t%2, %0, %3\n\t"
  84                 "scd\t%2, %1\n\t"
  85                 "beqz\t%2, 1b\n\t"
  86                 " and\t%2, %0, %3\n\t"
  87                 ".set\treorder"
  88                 :"=&r" (temp), "=m" (*m), "=&r" (res)
  89                 :"r" (1UL << (nr & 0x3f)), "m" (*m));
  90
  91         return res != 0;
  92 }
  93
  94 extern __inline__ unsigned long
  95 test_and_clear_bit(unsigned long nr, void *addr)
  96 {
  97         unsigned long *m = ((unsigned long *) addr) + (nr >> 6);
  98         unsigned long temp, res;
  99
 100         __asm__ __volatile__(
 101                 ".set\tnoreorder\t\t# test_and_clear_bit\n"
 102                 "1:\tlld\t%0, %1\n\t"
 103                 "or\t%2, %0, %3\n\t"
 104                 "xor\t%2, %3\n\t"
 105                 "scd\t%2, %1\n\t"
 106                 "beqz\t%2, 1b\n\t"
 107                 " and\t%2, %0, %3\n\t"
 108                 ".set\treorder"
 109                 :"=&r" (temp), "=m" (*m), "=&r" (res)
 110                 :"r" (1UL << (nr & 0x3f)), "m" (*m));
 111
 112         return res != 0;
 113 }
 114
 115 extern __inline__ unsigned long
 116 test_and_change_bit(unsigned long nr, void *addr)
 117 {
 118         unsigned long *m = ((unsigned long *) addr) + (nr >> 6);
 119         unsigned long temp, res;
 120
 121         __asm__ __volatile__(
 122                 ".set\tnoreorder\t\t# test_and_change_bit\n"
 123                 "1:\tlld\t%0, %1\n\t"
 124                 "xor\t%2, %0, %3\n\t"
 125                 "scd\t%2, %1\n\t"
 126                 "beqz\t%2, 1b\n\t"
 127                 " and\t%2, %0, %3\n\t"
 128                 ".set\treorder"
 129                 :"=&r" (temp), "=m" (*m), "=&r" (res)
 130                 :"r" (1UL << (nr & 0x3f)), "m" (*m));
 131
 132         return res != 0;
 133 }
 134
 135 extern __inline__ unsigned long
 136 test_bit(int nr, volatile void * addr)
 137 {
 138         return 1UL & (((const long *) addr)[nr >> 6] >> (nr & 0x3f));
 139 }
 140
 141 #ifndef __MIPSEB__
 142
 143 /* Little endian versions. */
 144
 145 extern __inline__ int
 146 find_first_zero_bit (void *addr, unsigned size)
 147 {
 148         unsigned long dummy;
 149         int res;
 150
 151         if (!size)
 152                 return 0;
 153
 154         __asm__ (".set\tnoreorder\n\t"
 155                 ".set\tnoat\n"
 156                 "1:\tsubu\t$1,%6,%0\n\t"
 157                 "blez\t$1,2f\n\t"
 158                 "lw\t$1,(%5)\n\t"
 159                 "addiu\t%5,4\n\t"
 160 #if (_MIPS_ISA == _MIPS_ISA_MIPS2) || (_MIPS_ISA == _MIPS_ISA_MIPS3) || \
 161     (_MIPS_ISA == _MIPS_ISA_MIPS4) || (_MIPS_ISA == _MIPS_ISA_MIPS5)
 162                 "beql\t%1,$1,1b\n\t"
 163                 "addiu\t%0,32\n\t"
 164 #else
 165                 "addiu\t%0,32\n\t"
 166                 "beq\t%1,$1,1b\n\t"
 167                 "nop\n\t"
 168                 "subu\t%0,32\n\t"
 169 #endif
 170 #ifdef __MIPSEB__
 171 #error "Fix this for big endian"
 172 #endif /* __MIPSEB__ */
 173                 "li\t%1,1\n"
 174                 "1:\tand\t%2,$1,%1\n\t"
 175                 "beqz\t%2,2f\n\t"
 176                 "sll\t%1,%1,1\n\t"
 177                 "bnez\t%1,1b\n\t"
 178                 "add\t%0,%0,1\n\t"
 179                 ".set\tat\n\t"
 180                 ".set\treorder\n"
 181                 "2:"
 182                 : "=r" (res),
 183                   "=r" (dummy),
 184                   "=r" (addr)
 185                 : "0" ((signed int) 0),
 186                   "1" ((unsigned int) 0xffffffff),
 187                   "2" (addr),
 188                   "r" (size)
 189                 : "$1");
 190
 191         return res;
 192 }
 193
 194 extern __inline__ int
 195 find_next_zero_bit (void * addr, int size, int offset)
 196 {
 197         unsigned int *p = ((unsigned int *) addr) + (offset >> 5);
 198         int set = 0, bit = offset & 31, res;
 199         unsigned long dummy;
 200
 201         if (bit) {
 202                 /*
 203                  * Look for zero in first byte
 204                  */
 205 #ifdef __MIPSEB__
 206 #error "Fix this for big endian byte order"
 207 #endif
 208                 __asm__(".set\tnoreorder\n\t"
 209                         ".set\tnoat\n"
 210                         "1:\tand\t$1,%4,%1\n\t"
 211                         "beqz\t$1,1f\n\t"
 212                         "sll\t%1,%1,1\n\t"
 213                         "bnez\t%1,1b\n\t"
 214                         "addiu\t%0,1\n\t"
 215                         ".set\tat\n\t"
 216                         ".set\treorder\n"
 217                         "1:"
 218                         : "=r" (set),
 219                           "=r" (dummy)
 220                         : "0" (0),
 221                           "1" (1 << bit),
 222                           "r" (*p)
 223                         : "$1");
 224                 if (set < (32 - bit))
 225                         return set + offset;
 226                 set = 32 - bit;
 227                 p++;
 228         }
 229         /*
 230          * No zero yet, search remaining full bytes for a zero
 231          */
 232         res = find_first_zero_bit(p, size - 32 * (p - (unsigned int *) addr));
 233         return offset + set + res;
 234 }
 235
 236 #endif /* !(__MIPSEB__) */
 237
 238 /*
 239  * ffz = Find First Zero in word. Undefined if no zero exists,
 240  * so code should check against ~0UL first..
 241  */
 242 extern __inline__ unsigned long ffz(unsigned long word)
 243 {
 244         unsigned long k;
 245
 246         word = ~word;
 247         k = 63;
 248         if (word & 0x00000000ffffffffUL) { k -= 32; word <<= 32; }
 249         if (word & 0x0000ffff00000000UL) { k -= 16; word <<= 16; }
 250         if (word & 0x00ff000000000000UL) { k -= 8;  word <<= 8;  }
 251         if (word & 0x0f00000000000000UL) { k -= 4;  word <<= 4;  }
 252         if (word & 0x3000000000000000UL) { k -= 2;  word <<= 2;  }
 253         if (word & 0x4000000000000000UL) { k -= 1; }
 254
 255         return k;
 256 }
 257
 258 #ifdef __KERNEL__
 259
 260 /*
 261  * ffs: find first bit set. This is defined the same way as
 262  * the libc and compiler builtin ffs routines, therefore
 263  * differs in spirit from the above ffz (man ffs).
 264  */
 265
 266 #define ffs(x) generic_ffs(x)
 267
 268 /*
 269  * hweightN: returns the hamming weight (i.e. the number
 270  * of bits set) of a N-bit word
 271  */
 272
 273 #define hweight32(x) generic_hweight32(x)
 274 #define hweight16(x) generic_hweight16(x)
 275 #define hweight8(x)  generic_hweight8(x)
 276
 277 #endif /* __KERNEL__ */
 278
 279 #ifdef __MIPSEB__
 280
 281 /*
 282  * find_next_zero_bit() finds the first zero bit in a bit string of length
 283  * 'size' bits, starting the search at bit 'offset'. This is largely based
 284  * on Linus's ALPHA routines, which are pretty portable BTW.
 285  */
 286
 287 extern __inline__ unsigned long
 288 find_next_zero_bit(void *addr, unsigned long size, unsigned long offset)
 289 {
 290         unsigned long *p = ((unsigned long *) addr) + (offset >> 6);
 291         unsigned long result = offset & ~63UL;
 292         unsigned long tmp;
 293
 294         if (offset >= size)
 295                 return size;
 296         size -= result;
 297         offset &= 63UL;
 298         if (offset) {
 299                 tmp = *(p++);
 300                 tmp |= ~0UL >> (64-offset);
 301                 if (size < 64)
 302                         goto found_first;
 303                 if (~tmp)
 304                         goto found_middle;
 305                 size -= 64;
 306                 result += 64;
 307         }
 308         while (size & ~63UL) {
 309                 if (~(tmp = *(p++)))
 310                         goto found_middle;
 311                 result += 64;
 312                 size -= 64;
 313         }
 314         if (!size)
 315                 return result;
 316         tmp = *p;
 317
 318 found_first:
 319         tmp |= ~0UL << size;
 320 found_middle:
 321         return result + ffz(tmp);
 322 }
 323
 324 #define find_first_zero_bit(addr, size) \
 325         find_next_zero_bit((addr), (size), 0)
 326
 327 #endif /* (__MIPSEB__) */
 328
 329 #ifdef __KERNEL__
 330
 331 /* Now for the ext2 filesystem bit operations and helper routines. */
 332
 333 #ifdef __MIPSEB__
 334
 335 extern inline int
 336 ext2_set_bit(int nr,void * addr)
 337 {
 338         int             mask, retval, flags;
 339         unsigned char   *ADDR = (unsigned char *) addr;
 340
 341         ADDR += nr >> 3;
 342         mask = 1 << (nr & 0x07);
 343         save_and_cli(flags);
 344         retval = (mask & *ADDR) != 0;
 345         *ADDR |= mask;
 346         restore_flags(flags);
 347         return retval;
 348 }
 349
 350 extern inline int
 351 ext2_clear_bit(int nr, void * addr)
 352 {
 353         int             mask, retval, flags;
 354         unsigned char   *ADDR = (unsigned char *) addr;
 355
 356         ADDR += nr >> 3;
 357         mask = 1 << (nr & 0x07);
 358         save_and_cli(flags);
 359         retval = (mask & *ADDR) != 0;
 360         *ADDR &= ~mask;
 361         restore_flags(flags);
 362         return retval;
 363 }
 364
 365 extern inline int
 366 ext2_test_bit(int nr, const void * addr)
 367 {
 368         int                     mask;
 369         const unsigned char     *ADDR = (const unsigned char *) addr;
 370
 371         ADDR += nr >> 3;
 372         mask = 1 << (nr & 0x07);
 373         return ((mask & *ADDR) != 0);
 374 }
 375
 376 #define ext2_find_first_zero_bit(addr, size) \
 377         ext2_find_next_zero_bit((addr), (size), 0)
 378
 379 extern inline unsigned int
 380 ext2_find_next_zero_bit(void *addr, unsigned long size, unsigned long offset)
 381 {
 382         unsigned int *p = ((unsigned int *) addr) + (offset >> 5);
 383         unsigned int result = offset & ~31UL;
 384         unsigned int tmp;
 385
 386         if (offset >= size)
 387                 return size;
 388         size -= result;
 389         offset &= 31UL;
 390         if(offset) {
 391                 /* We hold the little endian value in tmp, but then the
 392                  * shift is illegal. So we could keep a big endian value
 393                  * in tmp, like this:
 394                  *
 395                  * tmp = __swab32(*(p++));
 396                  * tmp |= ~0UL >> (32-offset);
 397                  *
 398                  * but this would decrease preformance, so we change the
 399                  * shift:
 400                  */
 401                 tmp = *(p++);
 402                 tmp |= __swab32(~0UL >> (32-offset));
 403                 if(size < 32)
 404                         goto found_first;
 405                 if(~tmp)
 406                         goto found_middle;
 407                 size -= 32;
 408                 result += 32;
 409         }
 410         while(size & ~31UL) {
 411                 if(~(tmp = *(p++)))
 412                         goto found_middle;
 413                 result += 32;
 414                 size -= 32;
 415         }
 416         if(!size)
 417                 return result;
 418         tmp = *p;
 419
 420 found_first:
 421         /* tmp is little endian, so we would have to swab the shift,
 422          * see above. But then we have to swab tmp below for ffz, so
 423          * we might as well do this here.
 424          */
 425         return result + ffz(__swab32(tmp) | (~0UL << size));
 426 found_middle:
 427         return result + ffz(__swab32(tmp));
 428 }
 429 #else /* !(__MIPSEB__) */
 430
 431 /* Native ext2 byte ordering, just collapse using defines. */
 432 #define ext2_set_bit(nr, addr) test_and_set_bit((nr), (addr))
 433 #define ext2_clear_bit(nr, addr) test_and_clear_bit((nr), (addr))
 434 #define ext2_test_bit(nr, addr) test_bit((nr), (addr))
 435 #define ext2_find_first_zero_bit(addr, size) find_first_zero_bit((addr), (size))
 436 #define ext2_find_next_zero_bit(addr, size, offset) \
 437                 find_next_zero_bit((addr), (size), (offset))
 438
 439 #endif /* !(__MIPSEB__) */
 440
 441 /*
 442  * Bitmap functions for the minix filesystem.
 443  * FIXME: These assume that Minix uses the native byte/bitorder.
 444  * This limits the Minix filesystem's value for data exchange very much.
 445  */
 446 #define minix_test_and_set_bit(nr,addr) test_and_set_bit(nr,addr)
 447 #define minix_set_bit(nr,addr) set_bit(nr,addr)
 448 #define minix_test_and_clear_bit(nr,addr) test_and_clear_bit(nr,addr)
 449 #define minix_test_bit(nr,addr) test_bit(nr,addr)
 450 #define minix_find_first_zero_bit(addr,size) find_first_zero_bit(addr,size)
 451
 452 #endif /* __KERNEL__ */
 453
 454 #endif /* _ASM_BITOPS_H */