arch/alpha/include/asm/bitops.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef _ALPHA_BITOPS_H
   3 #define _ALPHA_BITOPS_H
   4
   5 #ifndef _LINUX_BITOPS_H
   6 #error only <linux/bitops.h> can be included directly
   7 #endif
   8
   9 #include <asm/compiler.h>
  10 #include <asm/barrier.h>
  11
  12 /*
  13  * Copyright 1994, Linus Torvalds.
  14  */
  15
  16 /*
  17  * These have to be done with inline assembly: that way the bit-setting
  18  * is guaranteed to be atomic. All bit operations return 0 if the bit
  19  * was cleared before the operation and != 0 if it was not.
  20  *
  21  * To get proper branch prediction for the main line, we must branch
  22  * forward to code at the end of this object's .text section, then
  23  * branch back to restart the operation.
  24  *
  25  * bit 0 is the LSB of addr; bit 64 is the LSB of (addr+1).
  26  */
  27
  28 static inline void
  29 set_bit(unsigned long nr, volatile void * addr)
  30 {
  31         unsigned long temp;
  32         int *m = ((int *) addr) + (nr >> 5);
  33
  34         __asm__ __volatile__(
  35         "1:     ldl_l %0,%3\n"
  36         "       bis %0,%2,%0\n"
  37         "       stl_c %0,%1\n"
  38         "       beq %0,2f\n"
  39         ".subsection 2\n"
  40         "2:     br 1b\n"
  41         ".previous"
  42         :"=&r" (temp), "=m" (*m)
  43         :"Ir" (1UL << (nr & 31)), "m" (*m));
  44 }
  45
  46 /*
  47  * WARNING: non atomic version.
  48  */
  49 static __always_inline void
  50 arch___set_bit(unsigned long nr, volatile unsigned long *addr)
  51 {
  52         int *m = ((int *) addr) + (nr >> 5);
  53
  54         *m |= 1 << (nr & 31);
  55 }
  56
  57 static inline void
  58 clear_bit(unsigned long nr, volatile void * addr)
  59 {
  60         unsigned long temp;
  61         int *m = ((int *) addr) + (nr >> 5);
  62
  63         __asm__ __volatile__(
  64         "1:     ldl_l %0,%3\n"
  65         "       bic %0,%2,%0\n"
  66         "       stl_c %0,%1\n"
  67         "       beq %0,2f\n"
  68         ".subsection 2\n"
  69         "2:     br 1b\n"
  70         ".previous"
  71         :"=&r" (temp), "=m" (*m)
  72         :"Ir" (1UL << (nr & 31)), "m" (*m));
  73 }
  74
  75 static inline void
  76 clear_bit_unlock(unsigned long nr, volatile void * addr)
  77 {
  78         smp_mb();
  79         clear_bit(nr, addr);
  80 }
  81
  82 /*
  83  * WARNING: non atomic version.
  84  */
  85 static __always_inline void
  86 arch___clear_bit(unsigned long nr, volatile unsigned long *addr)
  87 {
  88         int *m = ((int *) addr) + (nr >> 5);
  89
  90         *m &= ~(1 << (nr & 31));
  91 }
  92
  93 static inline void
  94 __clear_bit_unlock(unsigned long nr, volatile void * addr)
  95 {
  96         smp_mb();
  97         arch___clear_bit(nr, addr);
  98 }
  99
 100 static inline void
 101 change_bit(unsigned long nr, volatile void * addr)
 102 {
 103         unsigned long temp;
 104         int *m = ((int *) addr) + (nr >> 5);
 105
 106         __asm__ __volatile__(
 107         "1:     ldl_l %0,%3\n"
 108         "       xor %0,%2,%0\n"
 109         "       stl_c %0,%1\n"
 110         "       beq %0,2f\n"
 111         ".subsection 2\n"
 112         "2:     br 1b\n"
 113         ".previous"
 114         :"=&r" (temp), "=m" (*m)
 115         :"Ir" (1UL << (nr & 31)), "m" (*m));
 116 }
 117
 118 /*
 119  * WARNING: non atomic version.
 120  */
 121 static __always_inline void
 122 arch___change_bit(unsigned long nr, volatile unsigned long *addr)
 123 {
 124         int *m = ((int *) addr) + (nr >> 5);
 125
 126         *m ^= 1 << (nr & 31);
 127 }
 128
 129 static inline int
 130 test_and_set_bit(unsigned long nr, volatile void *addr)
 131 {
 132         unsigned long oldbit;
 133         unsigned long temp;
 134         int *m = ((int *) addr) + (nr >> 5);
 135
 136         __asm__ __volatile__(
 137 #ifdef CONFIG_SMP
 138         "       mb\n"
 139 #endif
 140         "1:     ldl_l %0,%4\n"
 141         "       and %0,%3,%2\n"
 142         "       bne %2,2f\n"
 143         "       xor %0,%3,%0\n"
 144         "       stl_c %0,%1\n"
 145         "       beq %0,3f\n"
 146         "2:\n"
 147 #ifdef CONFIG_SMP
 148         "       mb\n"
 149 #endif
 150         ".subsection 2\n"
 151         "3:     br 1b\n"
 152         ".previous"
 153         :"=&r" (temp), "=m" (*m), "=&r" (oldbit)
 154         :"Ir" (1UL << (nr & 31)), "m" (*m) : "memory");
 155
 156         return oldbit != 0;
 157 }
 158
 159 static inline int
 160 test_and_set_bit_lock(unsigned long nr, volatile void *addr)
 161 {
 162         unsigned long oldbit;
 163         unsigned long temp;
 164         int *m = ((int *) addr) + (nr >> 5);
 165
 166         __asm__ __volatile__(
 167         "1:     ldl_l %0,%4\n"
 168         "       and %0,%3,%2\n"
 169         "       bne %2,2f\n"
 170         "       xor %0,%3,%0\n"
 171         "       stl_c %0,%1\n"
 172         "       beq %0,3f\n"
 173         "2:\n"
 174 #ifdef CONFIG_SMP
 175         "       mb\n"
 176 #endif
 177         ".subsection 2\n"
 178         "3:     br 1b\n"
 179         ".previous"
 180         :"=&r" (temp), "=m" (*m), "=&r" (oldbit)
 181         :"Ir" (1UL << (nr & 31)), "m" (*m) : "memory");
 182
 183         return oldbit != 0;
 184 }
 185
 186 /*
 187  * WARNING: non atomic version.
 188  */
 189 static __always_inline bool
 190 arch___test_and_set_bit(unsigned long nr, volatile unsigned long *addr)
 191 {
 192         unsigned long mask = 1 << (nr & 0x1f);
 193         int *m = ((int *) addr) + (nr >> 5);
 194         int old = *m;
 195
 196         *m = old | mask;
 197         return (old & mask) != 0;
 198 }
 199
 200 static inline int
 201 test_and_clear_bit(unsigned long nr, volatile void * addr)
 202 {
 203         unsigned long oldbit;
 204         unsigned long temp;
 205         int *m = ((int *) addr) + (nr >> 5);
 206
 207         __asm__ __volatile__(
 208 #ifdef CONFIG_SMP
 209         "       mb\n"
 210 #endif
 211         "1:     ldl_l %0,%4\n"
 212         "       and %0,%3,%2\n"
 213         "       beq %2,2f\n"
 214         "       xor %0,%3,%0\n"
 215         "       stl_c %0,%1\n"
 216         "       beq %0,3f\n"
 217         "2:\n"
 218 #ifdef CONFIG_SMP
 219         "       mb\n"
 220 #endif
 221         ".subsection 2\n"
 222         "3:     br 1b\n"
 223         ".previous"
 224         :"=&r" (temp), "=m" (*m), "=&r" (oldbit)
 225         :"Ir" (1UL << (nr & 31)), "m" (*m) : "memory");
 226
 227         return oldbit != 0;
 228 }
 229
 230 /*
 231  * WARNING: non atomic version.
 232  */
 233 static __always_inline bool
 234 arch___test_and_clear_bit(unsigned long nr, volatile unsigned long *addr)
 235 {
 236         unsigned long mask = 1 << (nr & 0x1f);
 237         int *m = ((int *) addr) + (nr >> 5);
 238         int old = *m;
 239
 240         *m = old & ~mask;
 241         return (old & mask) != 0;
 242 }
 243
 244 static inline int
 245 test_and_change_bit(unsigned long nr, volatile void * addr)
 246 {
 247         unsigned long oldbit;
 248         unsigned long temp;
 249         int *m = ((int *) addr) + (nr >> 5);
 250
 251         __asm__ __volatile__(
 252 #ifdef CONFIG_SMP
 253         "       mb\n"
 254 #endif
 255         "1:     ldl_l %0,%4\n"
 256         "       and %0,%3,%2\n"
 257         "       xor %0,%3,%0\n"
 258         "       stl_c %0,%1\n"
 259         "       beq %0,3f\n"
 260 #ifdef CONFIG_SMP
 261         "       mb\n"
 262 #endif
 263         ".subsection 2\n"
 264         "3:     br 1b\n"
 265         ".previous"
 266         :"=&r" (temp), "=m" (*m), "=&r" (oldbit)
 267         :"Ir" (1UL << (nr & 31)), "m" (*m) : "memory");
 268
 269         return oldbit != 0;
 270 }
 271
 272 /*
 273  * WARNING: non atomic version.
 274  */
 275 static __always_inline bool
 276 arch___test_and_change_bit(unsigned long nr, volatile unsigned long *addr)
 277 {
 278         unsigned long mask = 1 << (nr & 0x1f);
 279         int *m = ((int *) addr) + (nr >> 5);
 280         int old = *m;
 281
 282         *m = old ^ mask;
 283         return (old & mask) != 0;
 284 }
 285
 286 #define arch_test_bit generic_test_bit
 287 #define arch_test_bit_acquire generic_test_bit_acquire
 288
 289 /*
 290  * ffz = Find First Zero in word. Undefined if no zero exists,
 291  * so code should check against ~0UL first..
 292  *
 293  * Do a binary search on the bits.  Due to the nature of large
 294  * constants on the alpha, it is worthwhile to split the search.
 295  */
 296 static inline unsigned long ffz_b(unsigned long x)
 297 {
 298         unsigned long sum, x1, x2, x4;
 299
 300         x = ~x & -~x;           /* set first 0 bit, clear others */
 301         x1 = x & 0xAA;
 302         x2 = x & 0xCC;
 303         x4 = x & 0xF0;
 304         sum = x2 ? 2 : 0;
 305         sum += (x4 != 0) * 4;
 306         sum += (x1 != 0);
 307
 308         return sum;
 309 }
 310
 311 static inline unsigned long ffz(unsigned long word)
 312 {
 313 #if defined(CONFIG_ALPHA_EV6) && defined(CONFIG_ALPHA_EV67)
 314         /* Whee.  EV67 can calculate it directly.  */
 315         return __kernel_cttz(~word);
 316 #else
 317         unsigned long bits, qofs, bofs;
 318
 319         bits = __kernel_cmpbge(word, ~0UL);
 320         qofs = ffz_b(bits);
 321         bits = __kernel_extbl(word, qofs);
 322         bofs = ffz_b(bits);
 323
 324         return qofs*8 + bofs;
 325 #endif
 326 }
 327
 328 /*
 329  * __ffs = Find First set bit in word.  Undefined if no set bit exists.
 330  */
 331 static inline unsigned long __ffs(unsigned long word)
 332 {
 333 #if defined(CONFIG_ALPHA_EV6) && defined(CONFIG_ALPHA_EV67)
 334         /* Whee.  EV67 can calculate it directly.  */
 335         return __kernel_cttz(word);
 336 #else
 337         unsigned long bits, qofs, bofs;
 338
 339         bits = __kernel_cmpbge(0, word);
 340         qofs = ffz_b(bits);
 341         bits = __kernel_extbl(word, qofs);
 342         bofs = ffz_b(~bits);
 343
 344         return qofs*8 + bofs;
 345 #endif
 346 }
 347
 348 #ifdef __KERNEL__
 349
 350 /*
 351  * ffs: find first bit set. This is defined the same way as
 352  * the libc and compiler builtin ffs routines, therefore
 353  * differs in spirit from the above __ffs.
 354  */
 355
 356 static inline int ffs(int word)
 357 {
 358         int result = __ffs(word) + 1;
 359         return word ? result : 0;
 360 }
 361
 362 /*
 363  * fls: find last bit set.
 364  */
 365 #if defined(CONFIG_ALPHA_EV6) && defined(CONFIG_ALPHA_EV67)
 366 static inline int fls64(unsigned long word)
 367 {
 368         return 64 - __kernel_ctlz(word);
 369 }
 370 #else
 371 extern const unsigned char __flsm1_tab[256];
 372
 373 static inline int fls64(unsigned long x)
 374 {
 375         unsigned long t, a, r;
 376
 377         t = __kernel_cmpbge (x, 0x0101010101010101UL);
 378         a = __flsm1_tab[t];
 379         t = __kernel_extbl (x, a);
 380         r = a*8 + __flsm1_tab[t] + (x != 0);
 381
 382         return r;
 383 }
 384 #endif
 385
 386 static inline unsigned long __fls(unsigned long x)
 387 {
 388         return fls64(x) - 1;
 389 }
 390
 391 static inline int fls(unsigned int x)
 392 {
 393         return fls64(x);
 394 }
 395
 396 /*
 397  * hweightN: returns the hamming weight (i.e. the number
 398  * of bits set) of a N-bit word
 399  */
 400
 401 #if defined(CONFIG_ALPHA_EV6) && defined(CONFIG_ALPHA_EV67)
 402 /* Whee.  EV67 can calculate it directly.  */
 403 static inline unsigned long __arch_hweight64(unsigned long w)
 404 {
 405         return __kernel_ctpop(w);
 406 }
 407
 408 static inline unsigned int __arch_hweight32(unsigned int w)
 409 {
 410         return __arch_hweight64(w);
 411 }
 412
 413 static inline unsigned int __arch_hweight16(unsigned int w)
 414 {
 415         return __arch_hweight64(w & 0xffff);
 416 }
 417
 418 static inline unsigned int __arch_hweight8(unsigned int w)
 419 {
 420         return __arch_hweight64(w & 0xff);
 421 }
 422 #else
 423 #include <asm-generic/bitops/arch_hweight.h>
 424 #endif
 425
 426 #include <asm-generic/bitops/const_hweight.h>
 427
 428 #endif /* __KERNEL__ */
 429
 430 #ifdef __KERNEL__
 431
 432 /*
 433  * Every architecture must define this function. It's the fastest
 434  * way of searching a 100-bit bitmap.  It's guaranteed that at least
 435  * one of the 100 bits is cleared.
 436  */
 437 static inline unsigned long
 438 sched_find_first_bit(const unsigned long b[2])
 439 {
 440         unsigned long b0, b1, ofs, tmp;
 441
 442         b0 = b[0];
 443         b1 = b[1];
 444         ofs = (b0 ? 0 : 64);
 445         tmp = (b0 ? b0 : b1);
 446
 447         return __ffs(tmp) + ofs;
 448 }
 449
 450 #include <asm-generic/bitops/non-instrumented-non-atomic.h>
 451
 452 #include <asm-generic/bitops/le.h>
 453
 454 #include <asm-generic/bitops/ext2-atomic-setbit.h>
 455
 456 #endif /* __KERNEL__ */
 457
 458 #endif /* _ALPHA_BITOPS_H */