include/asm-m68knommu/bitops.h

   1 #ifndef _M68KNOMMU_BITOPS_H
   2 #define _M68KNOMMU_BITOPS_H
   3
   4 /*
   5  * Copyright 1992, Linus Torvalds.
   6  */
   7
   8 #include <linux/config.h>
   9 #include <linux/compiler.h>
  10 #include <asm/byteorder.h>      /* swab32 */
  11 #include <asm/system.h>         /* save_flags */
  12
  13 #ifdef __KERNEL__
  14
  15 #include <asm-generic/bitops/ffs.h>
  16 #include <asm-generic/bitops/__ffs.h>
  17 #include <asm-generic/bitops/sched.h>
  18 #include <asm-generic/bitops/ffz.h>
  19
  20 static __inline__ void set_bit(int nr, volatile unsigned long * addr)
  21 {
  22 #ifdef CONFIG_COLDFIRE
  23         __asm__ __volatile__ ("lea %0,%%a0; bset %1,(%%a0)"
  24              : "+m" (((volatile char *)addr)[(nr^31) >> 3])
  25              : "d" (nr)
  26              : "%a0", "cc");
  27 #else
  28         __asm__ __volatile__ ("bset %1,%0"
  29              : "+m" (((volatile char *)addr)[(nr^31) >> 3])
  30              : "di" (nr)
  31              : "cc");
  32 #endif
  33 }
  34
  35 #define __set_bit(nr, addr) set_bit(nr, addr)
  36
  37 /*
  38  * clear_bit() doesn't provide any barrier for the compiler.
  39  */
  40 #define smp_mb__before_clear_bit()      barrier()
  41 #define smp_mb__after_clear_bit()       barrier()
  42
  43 static __inline__ void clear_bit(int nr, volatile unsigned long * addr)
  44 {
  45 #ifdef CONFIG_COLDFIRE
  46         __asm__ __volatile__ ("lea %0,%%a0; bclr %1,(%%a0)"
  47              : "+m" (((volatile char *)addr)[(nr^31) >> 3])
  48              : "d" (nr)
  49              : "%a0", "cc");
  50 #else
  51         __asm__ __volatile__ ("bclr %1,%0"
  52              : "+m" (((volatile char *)addr)[(nr^31) >> 3])
  53              : "di" (nr)
  54              : "cc");
  55 #endif
  56 }
  57
  58 #define __clear_bit(nr, addr) clear_bit(nr, addr)
  59
  60 static __inline__ void change_bit(int nr, volatile unsigned long * addr)
  61 {
  62 #ifdef CONFIG_COLDFIRE
  63         __asm__ __volatile__ ("lea %0,%%a0; bchg %1,(%%a0)"
  64              : "+m" (((volatile char *)addr)[(nr^31) >> 3])
  65              : "d" (nr)
  66              : "%a0", "cc");
  67 #else
  68         __asm__ __volatile__ ("bchg %1,%0"
  69              : "+m" (((volatile char *)addr)[(nr^31) >> 3])
  70              : "di" (nr)
  71              : "cc");
  72 #endif
  73 }
  74
  75 #define __change_bit(nr, addr) change_bit(nr, addr)
  76
  77 static __inline__ int test_and_set_bit(int nr, volatile unsigned long * addr)
  78 {
  79         char retval;
  80
  81 #ifdef CONFIG_COLDFIRE
  82         __asm__ __volatile__ ("lea %1,%%a0; bset %2,(%%a0); sne %0"
  83              : "=d" (retval), "+m" (((volatile char *)addr)[(nr^31) >> 3])
  84              : "d" (nr)
  85              : "%a0");
  86 #else
  87         __asm__ __volatile__ ("bset %2,%1; sne %0"
  88              : "=d" (retval), "+m" (((volatile char *)addr)[(nr^31) >> 3])
  89              : "di" (nr)
  90              /* No clobber */);
  91 #endif
  92
  93         return retval;
  94 }
  95
  96 #define __test_and_set_bit(nr, addr) test_and_set_bit(nr, addr)
  97
  98 static __inline__ int test_and_clear_bit(int nr, volatile unsigned long * addr)
  99 {
 100         char retval;
 101
 102 #ifdef CONFIG_COLDFIRE
 103         __asm__ __volatile__ ("lea %1,%%a0; bclr %2,(%%a0); sne %0"
 104              : "=d" (retval), "+m" (((volatile char *)addr)[(nr^31) >> 3])
 105              : "d" (nr)
 106              : "%a0");
 107 #else
 108         __asm__ __volatile__ ("bclr %2,%1; sne %0"
 109              : "=d" (retval), "+m" (((volatile char *)addr)[(nr^31) >> 3])
 110              : "di" (nr)
 111              /* No clobber */);
 112 #endif
 113
 114         return retval;
 115 }
 116
 117 #define __test_and_clear_bit(nr, addr) test_and_clear_bit(nr, addr)
 118
 119 static __inline__ int test_and_change_bit(int nr, volatile unsigned long * addr)
 120 {
 121         char retval;
 122
 123 #ifdef CONFIG_COLDFIRE
 124         __asm__ __volatile__ ("lea %1,%%a0\n\tbchg %2,(%%a0)\n\tsne %0"
 125              : "=d" (retval), "+m" (((volatile char *)addr)[(nr^31) >> 3])
 126              : "d" (nr)
 127              : "%a0");
 128 #else
 129         __asm__ __volatile__ ("bchg %2,%1; sne %0"
 130              : "=d" (retval), "+m" (((volatile char *)addr)[(nr^31) >> 3])
 131              : "di" (nr)
 132              /* No clobber */);
 133 #endif
 134
 135         return retval;
 136 }
 137
 138 #define __test_and_change_bit(nr, addr) test_and_change_bit(nr, addr)
 139
 140 /*
 141  * This routine doesn't need to be atomic.
 142  */
 143 static __inline__ int __constant_test_bit(int nr, const volatile unsigned long * addr)
 144 {
 145         return ((1UL << (nr & 31)) & (((const volatile unsigned int *) addr)[nr >> 5])) != 0;
 146 }
 147
 148 static __inline__ int __test_bit(int nr, const volatile unsigned long * addr)
 149 {
 150         int     * a = (int *) addr;
 151         int     mask;
 152
 153         a += nr >> 5;
 154         mask = 1 << (nr & 0x1f);
 155         return ((mask & *a) != 0);
 156 }
 157
 158 #define test_bit(nr,addr) \
 159 (__builtin_constant_p(nr) ? \
 160  __constant_test_bit((nr),(addr)) : \
 161  __test_bit((nr),(addr)))
 162
 163 #include <asm-generic/bitops/find.h>
 164 #include <asm-generic/bitops/hweight.h>
 165
 166 static __inline__ int ext2_set_bit(int nr, volatile void * addr)
 167 {
 168         char retval;
 169
 170 #ifdef CONFIG_COLDFIRE
 171         __asm__ __volatile__ ("lea %1,%%a0; bset %2,(%%a0); sne %0"
 172              : "=d" (retval), "+m" (((volatile char *)addr)[nr >> 3])
 173              : "d" (nr)
 174              : "%a0");
 175 #else
 176         __asm__ __volatile__ ("bset %2,%1; sne %0"
 177              : "=d" (retval), "+m" (((volatile char *)addr)[nr >> 3])
 178              : "di" (nr)
 179              /* No clobber */);
 180 #endif
 181
 182         return retval;
 183 }
 184
 185 static __inline__ int ext2_clear_bit(int nr, volatile void * addr)
 186 {
 187         char retval;
 188
 189 #ifdef CONFIG_COLDFIRE
 190         __asm__ __volatile__ ("lea %1,%%a0; bclr %2,(%%a0); sne %0"
 191              : "=d" (retval), "+m" (((volatile char *)addr)[nr >> 3])
 192              : "d" (nr)
 193              : "%a0");
 194 #else
 195         __asm__ __volatile__ ("bclr %2,%1; sne %0"
 196              : "=d" (retval), "+m" (((volatile char *)addr)[nr >> 3])
 197              : "di" (nr)
 198              /* No clobber */);
 199 #endif
 200
 201         return retval;
 202 }
 203
 204 #define ext2_set_bit_atomic(lock, nr, addr)             \
 205         ({                                              \
 206                 int ret;                                \
 207                 spin_lock(lock);                        \
 208                 ret = ext2_set_bit((nr), (addr));       \
 209                 spin_unlock(lock);                      \
 210                 ret;                                    \
 211         })
 212
 213 #define ext2_clear_bit_atomic(lock, nr, addr)           \
 214         ({                                              \
 215                 int ret;                                \
 216                 spin_lock(lock);                        \
 217                 ret = ext2_clear_bit((nr), (addr));     \
 218                 spin_unlock(lock);                      \
 219                 ret;                                    \
 220         })
 221
 222 static __inline__ int ext2_test_bit(int nr, const volatile void * addr)
 223 {
 224         char retval;
 225
 226 #ifdef CONFIG_COLDFIRE
 227         __asm__ __volatile__ ("lea %1,%%a0; btst %2,(%%a0); sne %0"
 228              : "=d" (retval)
 229              : "m" (((const volatile char *)addr)[nr >> 3]), "d" (nr)
 230              : "%a0");
 231 #else
 232         __asm__ __volatile__ ("btst %2,%1; sne %0"
 233              : "=d" (retval)
 234              : "m" (((const volatile char *)addr)[nr >> 3]), "di" (nr)
 235              /* No clobber */);
 236 #endif
 237
 238         return retval;
 239 }
 240
 241 #define ext2_find_first_zero_bit(addr, size) \
 242         ext2_find_next_zero_bit((addr), (size), 0)
 243
 244 static __inline__ unsigned long ext2_find_next_zero_bit(void *addr, unsigned long size, unsigned long offset)
 245 {
 246         unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
 247         unsigned long result = offset & ~31UL;
 248         unsigned long tmp;
 249
 250         if (offset >= size)
 251                 return size;
 252         size -= result;
 253         offset &= 31UL;
 254         if(offset) {
 255                 /* We hold the little endian value in tmp, but then the
 256                  * shift is illegal. So we could keep a big endian value
 257                  * in tmp, like this:
 258                  *
 259                  * tmp = __swab32(*(p++));
 260                  * tmp |= ~0UL >> (32-offset);
 261                  *
 262                  * but this would decrease preformance, so we change the
 263                  * shift:
 264                  */
 265                 tmp = *(p++);
 266                 tmp |= __swab32(~0UL >> (32-offset));
 267                 if(size < 32)
 268                         goto found_first;
 269                 if(~tmp)
 270                         goto found_middle;
 271                 size -= 32;
 272                 result += 32;
 273         }
 274         while(size & ~31UL) {
 275                 if(~(tmp = *(p++)))
 276                         goto found_middle;
 277                 result += 32;
 278                 size -= 32;
 279         }
 280         if(!size)
 281                 return result;
 282         tmp = *p;
 283
 284 found_first:
 285         /* tmp is little endian, so we would have to swab the shift,
 286          * see above. But then we have to swab tmp below for ffz, so
 287          * we might as well do this here.
 288          */
 289         return result + ffz(__swab32(tmp) | (~0UL << size));
 290 found_middle:
 291         return result + ffz(__swab32(tmp));
 292 }
 293
 294 #include <asm-generic/bitops/minix.h>
 295
 296 #endif /* __KERNEL__ */
 297
 298 #include <asm-generic/bitops/fls.h>
 299 #include <asm-generic/bitops/fls64.h>
 300
 301 #endif /* _M68KNOMMU_BITOPS_H */