include/asm-microblaze/bitops.h

   1 #ifndef _MICROBLAZE_BITOPS_H
   2 #define _MICROBLAZE_BITOPS_H
   3
   4 /*
   5  * Copyright 1992, Linus Torvalds.
   6  */
   7
   8 #include <linux/config.h>
   9 #include <asm/byteorder.h>      /* swab32 */
  10 #include <asm/system.h>         /* save_flags */
  11
  12 #ifdef __KERNEL__
  13 /*
  14  * Function prototypes to keep gcc -Wall happy
  15  */
  16
  17 /*
  18  * The __ functions are not atomic
  19  */
  20
  21 extern void set_bit(int nr, volatile void * addr);
  22 extern void __set_bit(int nr, volatile void * addr);
  23
  24 extern void clear_bit(int nr, volatile void * addr);
  25 #define __clear_bit(nr, addr) clear_bit(nr, addr)
  26 #define PLATFORM__CLEAR_BIT
  27
  28 extern void change_bit(int nr, volatile void * addr);
  29 extern void __change_bit(int nr, volatile void * addr);
  30 extern int test_and_set_bit(int nr, volatile void * addr);
  31 extern int __test_and_set_bit(int nr, volatile void * addr);
  32 extern int test_and_clear_bit(int nr, volatile void * addr);
  33 extern int __test_and_clear_bit(int nr, volatile void * addr);
  34 extern int test_and_change_bit(int nr, volatile void * addr);
  35 extern int __test_and_change_bit(int nr, volatile void * addr);
  36 extern int __constant_test_bit(int nr, const volatile void * addr);
  37 extern int __test_bit(int nr, volatile void * addr);
  38 extern int find_first_zero_bit(void * addr, unsigned size);
  39 extern int find_next_zero_bit (void * addr, int size, int offset);
  40
  41 /*
  42  * ffz = Find First Zero in word. Undefined if no zero exists,
  43  * so code should check against ~0UL first..
  44  */
  45 extern __inline__ unsigned long ffz(unsigned long word)
  46 {
  47         unsigned long result = 0;
  48
  49         while(word & 1) {
  50                 result++;
  51                 word >>= 1;
  52         }
  53         return result;
  54 }
  55
  56
  57 extern __inline__ void set_bit(int nr, volatile void * addr)
  58 {
  59         int     * a = (int *) addr;
  60         int     mask;
  61         unsigned long flags;
  62
  63         a += nr >> 5;
  64         mask = 1 << (nr & 0x1f);
  65         save_flags_cli(flags);
  66         *a |= mask;
  67         restore_flags(flags);
  68 }
  69
  70 extern __inline__ void __set_bit(int nr, volatile void * addr)
  71 {
  72         int     * a = (int *) addr;
  73         int     mask;
  74
  75         a += nr >> 5;
  76         mask = 1 << (nr & 0x1f);
  77         *a |= mask;
  78 }
  79 #define PLATFORM__SET_BIT
  80
  81 /*
  82  * clear_bit() doesn't provide any barrier for the compiler.
  83  */
  84 #define smp_mb__before_clear_bit()      barrier()
  85 #define smp_mb__after_clear_bit()       barrier()
  86
  87 extern __inline__ void clear_bit(int nr, volatile void * addr)
  88 {
  89         int     * a = (int *) addr;
  90         int     mask;
  91         unsigned long flags;
  92
  93         a += nr >> 5;
  94         mask = 1 << (nr & 0x1f);
  95         save_flags_cli(flags);
  96         *a &= ~mask;
  97         restore_flags(flags);
  98 }
  99
 100 extern __inline__ void change_bit(int nr, volatile void * addr)
 101 {
 102         int mask;
 103         unsigned long flags;
 104         unsigned long *ADDR = (unsigned long *) addr;
 105
 106         ADDR += nr >> 5;
 107         mask = 1 << (nr & 31);
 108         save_flags_cli(flags);
 109         *ADDR ^= mask;
 110         restore_flags(flags);
 111 }
 112
 113 extern __inline__ void __change_bit(int nr, volatile void * addr)
 114 {
 115         int mask;
 116         unsigned long *ADDR = (unsigned long *) addr;
 117
 118         ADDR += nr >> 5;
 119         mask = 1 << (nr & 31);
 120         *ADDR ^= mask;
 121 }
 122
 123 extern __inline__ int test_and_set_bit(int nr, volatile void * addr)
 124 {
 125         int     mask, retval;
 126         volatile unsigned int *a = (volatile unsigned int *) addr;
 127         unsigned long flags;
 128
 129         a += nr >> 5;
 130         mask = 1 << (nr & 0x1f);
 131         save_flags_cli(flags);
 132         retval = (mask & *a) != 0;
 133         *a |= mask;
 134         restore_flags(flags);
 135
 136         return retval;
 137 }
 138
 139 extern __inline__ int __test_and_set_bit(int nr, volatile void * addr)
 140 {
 141         int     mask, retval;
 142         volatile unsigned int *a = (volatile unsigned int *) addr;
 143
 144         a += nr >> 5;
 145         mask = 1 << (nr & 0x1f);
 146         retval = (mask & *a) != 0;
 147         *a |= mask;
 148         return retval;
 149 }
 150
 151 extern __inline__ int test_and_clear_bit(int nr, volatile void * addr)
 152 {
 153         int     mask, retval;
 154         volatile unsigned int *a = (volatile unsigned int *) addr;
 155         unsigned long flags;
 156
 157         a += nr >> 5;
 158         mask = 1 << (nr & 0x1f);
 159         save_flags_cli(flags);
 160         retval = (mask & *a) != 0;
 161         *a &= ~mask;
 162         restore_flags(flags);
 163
 164         return retval;
 165 }
 166
 167 extern __inline__ int __test_and_clear_bit(int nr, volatile void * addr)
 168 {
 169         int     mask, retval;
 170         volatile unsigned int *a = (volatile unsigned int *) addr;
 171
 172         a += nr >> 5;
 173         mask = 1 << (nr & 0x1f);
 174         retval = (mask & *a) != 0;
 175         *a &= ~mask;
 176         return retval;
 177 }
 178
 179 extern __inline__ int test_and_change_bit(int nr, volatile void * addr)
 180 {
 181         int     mask, retval;
 182         volatile unsigned int *a = (volatile unsigned int *) addr;
 183         unsigned long flags;
 184
 185         a += nr >> 5;
 186         mask = 1 << (nr & 0x1f);
 187         save_flags_cli(flags);
 188         retval = (mask & *a) != 0;
 189         *a ^= mask;
 190         restore_flags(flags);
 191
 192         return retval;
 193 }
 194
 195 extern __inline__ int __test_and_change_bit(int nr, volatile void * addr)
 196 {
 197         int     mask, retval;
 198         volatile unsigned int *a = (volatile unsigned int *) addr;
 199
 200         a += nr >> 5;
 201         mask = 1 << (nr & 0x1f);
 202         retval = (mask & *a) != 0;
 203         *a ^= mask;
 204         return retval;
 205 }
 206
 207 /*
 208  * This routine doesn't need to be atomic.
 209  */
 210 extern __inline__ int __constant_test_bit(int nr, const volatile void * addr)
 211 {
 212         return ((1UL << (nr & 31)) & (((const volatile unsigned int *) addr)[nr >> 5])) != 0;
 213 }
 214
 215 extern __inline__ int __test_bit(int nr, volatile void * addr)
 216 {
 217         int     * a = (int *) addr;
 218         int     mask;
 219
 220         a += nr >> 5;
 221         mask = 1 << (nr & 0x1f);
 222         return ((mask & *a) != 0);
 223 }
 224
 225 #define test_bit(nr,addr) \
 226 (__builtin_constant_p(nr) ? \
 227  __constant_test_bit((nr),(addr)) : \
 228  __test_bit((nr),(addr)))
 229
 230 #define find_first_zero_bit(addr, size) \
 231         find_next_zero_bit((addr), (size), 0)
 232
 233 extern __inline__ int find_next_zero_bit (void * addr, int size, int offset)
 234 {
 235         unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
 236         unsigned long result = offset & ~31UL;
 237         unsigned long tmp;
 238
 239         if (offset >= size)
 240                 return size;
 241         size -= result;
 242         offset &= 31UL;
 243         if (offset) {
 244                 tmp = *(p++);
 245                 tmp |= ~0UL >> (32-offset);
 246                 if (size < 32)
 247                         goto found_first;
 248                 if (~tmp)
 249                         goto found_middle;
 250                 size -= 32;
 251                 result += 32;
 252         }
 253         while (size & ~31UL) {
 254                 if (~(tmp = *(p++)))
 255                         goto found_middle;
 256                 result += 32;
 257                 size -= 32;
 258         }
 259         if (!size)
 260                 return result;
 261         tmp = *p;
 262
 263 found_first:
 264         tmp |= ~0UL >> size;
 265 found_middle:
 266         return result + ffz(tmp);
 267 }
 268
 269 #define ffs(x) generic_ffs(x)
 270
 271 /*
 272  * hweightN: returns the hamming weight (i.e. the number
 273  * of bits set) of a N-bit word
 274  */
 275
 276 #define hweight32(x) generic_hweight32(x)
 277 #define hweight16(x) generic_hweight16(x)
 278 #define hweight8(x) generic_hweight8(x)
 279
 280
 281 extern __inline__ int ext2_set_bit(int nr, volatile void * addr)
 282 {
 283         int             mask, retval;
 284         unsigned long   flags;
 285         volatile unsigned char  *ADDR = (unsigned char *) addr;
 286
 287         ADDR += nr >> 3;
 288         mask = 1 << (nr & 0x07);
 289         save_flags_cli(flags);
 290         retval = (mask & *ADDR) != 0;
 291         *ADDR |= mask;
 292         restore_flags(flags);
 293         return retval;
 294 }
 295
 296 extern __inline__ int ext2_clear_bit(int nr, volatile void * addr)
 297 {
 298         int             mask, retval;
 299         unsigned long   flags;
 300         volatile unsigned char  *ADDR = (unsigned char *) addr;
 301
 302         ADDR += nr >> 3;
 303         mask = 1 << (nr & 0x07);
 304         save_flags_cli(flags);
 305         retval = (mask & *ADDR) != 0;
 306         *ADDR &= ~mask;
 307         restore_flags(flags);
 308         return retval;
 309 }
 310
 311 extern __inline__ int ext2_test_bit(int nr, const volatile void * addr)
 312 {
 313         int                     mask;
 314         const volatile unsigned char    *ADDR = (const unsigned char *) addr;
 315
 316         ADDR += nr >> 3;
 317         mask = 1 << (nr & 0x07);
 318         return ((mask & *ADDR) != 0);
 319 }
 320
 321 #define ext2_find_first_zero_bit(addr, size) \
 322         ext2_find_next_zero_bit((addr), (size), 0)
 323
 324 extern __inline__ unsigned long ext2_find_next_zero_bit(void *addr, unsigned long size, unsigned long offset)
 325 {
 326         unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
 327         unsigned long result = offset & ~31UL;
 328         unsigned long tmp;
 329
 330         if (offset >= size)
 331                 return size;
 332         size -= result;
 333         offset &= 31UL;
 334         if(offset) {
 335                 /* We hold the little endian value in tmp, but then the
 336                  * shift is illegal. So we could keep a big endian value
 337                  * in tmp, like this:
 338                  *
 339                  * tmp = __swab32(*(p++));
 340                  * tmp |= ~0UL >> (32-offset);
 341                  *
 342                  * but this would decrease preformance, so we change the
 343                  * shift:
 344                  */
 345                 tmp = *(p++);
 346                 tmp |= __swab32(~0UL >> (32-offset));
 347                 if(size < 32)
 348                         goto found_first;
 349                 if(~tmp)
 350                         goto found_middle;
 351                 size -= 32;
 352                 result += 32;
 353         }
 354         while(size & ~31UL) {
 355                 if(~(tmp = *(p++)))
 356                         goto found_middle;
 357                 result += 32;
 358                 size -= 32;
 359         }
 360         if(!size)
 361                 return result;
 362         tmp = *p;
 363
 364 found_first:
 365         /* tmp is little endian, so we would have to swab the shift,
 366          * see above. But then we have to swab tmp below for ffz, so
 367          * we might as well do this here.
 368          */
 369         return result + ffz(__swab32(tmp) | (~0UL << size));
 370 found_middle:
 371         return result + ffz(__swab32(tmp));
 372 }
 373
 374 /* Bitmap functions for the minix filesystem.  */
 375 #define minix_test_and_set_bit(nr,addr) test_and_set_bit(nr,addr)
 376 #define minix_set_bit(nr,addr) set_bit(nr,addr)
 377 #define minix_test_and_clear_bit(nr,addr) test_and_clear_bit(nr,addr)
 378 #define minix_test_bit(nr,addr) test_bit(nr,addr)
 379 #define minix_find_first_zero_bit(addr,size) find_first_zero_bit(addr,size)
 380
 381 /**
 382  * hweightN - returns the hamming weight of a N-bit word
 383  * @x: the word to weigh
 384  *
 385  * The Hamming Weight of a number is the total number of bits set in it.
 386  */
 387
 388 #define hweight32(x) generic_hweight32(x)
 389 #define hweight16(x) generic_hweight16(x)
 390 #define hweight8(x) generic_hweight8(x)
 391
 392 #endif /* __KERNEL__ */
 393
 394 #endif /* _MICROBLAZE_BITOPS_H */