include/asm-s390/bitops.h

   1 #ifndef _S390_BITOPS_H
   2 #define _S390_BITOPS_H
   3
   4 /*
   5  *  include/asm-s390/bitops.h
   6  *
   7  *  S390 version
   8  *    Copyright (C) 1999 IBM Deutschland Entwicklung GmbH, IBM Corporation
   9  *    Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
  10  *
  11  *  Derived from "include/asm-i386/bitops.h"
  12  *    Copyright (C) 1992, Linus Torvalds
  13  *
  14  */
  15 #include <linux/config.h>
  16 #include <linux/compiler.h>
  17
  18 /*
  19  * 32 bit bitops format:
  20  * bit 0 is the LSB of *addr; bit 31 is the MSB of *addr;
  21  * bit 32 is the LSB of *(addr+4). That combined with the
  22  * big endian byte order on S390 give the following bit
  23  * order in memory:
  24  *    1f 1e 1d 1c 1b 1a 19 18 17 16 15 14 13 12 11 10 \
  25  *    0f 0e 0d 0c 0b 0a 09 08 07 06 05 04 03 02 01 00
  26  * after that follows the next long with bit numbers
  27  *    3f 3e 3d 3c 3b 3a 39 38 37 36 35 34 33 32 31 30
  28  *    2f 2e 2d 2c 2b 2a 29 28 27 26 25 24 23 22 21 20
  29  * The reason for this bit ordering is the fact that
  30  * in the architecture independent code bits operations
  31  * of the form "flags |= (1 << bitnr)" are used INTERMIXED
  32  * with operation of the form "set_bit(bitnr, flags)".
  33  *
  34  * 64 bit bitops format:
  35  * bit 0 is the LSB of *addr; bit 63 is the MSB of *addr;
  36  * bit 64 is the LSB of *(addr+8). That combined with the
  37  * big endian byte order on S390 give the following bit
  38  * order in memory:
  39  *    3f 3e 3d 3c 3b 3a 39 38 37 36 35 34 33 32 31 30
  40  *    2f 2e 2d 2c 2b 2a 29 28 27 26 25 24 23 22 21 20
  41  *    1f 1e 1d 1c 1b 1a 19 18 17 16 15 14 13 12 11 10
  42  *    0f 0e 0d 0c 0b 0a 09 08 07 06 05 04 03 02 01 00
  43  * after that follows the next long with bit numbers
  44  *    7f 7e 7d 7c 7b 7a 79 78 77 76 75 74 73 72 71 70
  45  *    6f 6e 6d 6c 6b 6a 69 68 67 66 65 64 63 62 61 60
  46  *    5f 5e 5d 5c 5b 5a 59 58 57 56 55 54 53 52 51 50
  47  *    4f 4e 4d 4c 4b 4a 49 48 47 46 45 44 43 42 41 40
  48  * The reason for this bit ordering is the fact that
  49  * in the architecture independent code bits operations
  50  * of the form "flags |= (1 << bitnr)" are used INTERMIXED
  51  * with operation of the form "set_bit(bitnr, flags)".
  52  */
  53
  54 /* set ALIGN_CS to 1 if the SMP safe bit operations should
  55  * align the address to 4 byte boundary. It seems to work
  56  * without the alignment.
  57  */
  58 #ifdef __KERNEL__
  59 #define ALIGN_CS 0
  60 #else
  61 #define ALIGN_CS 1
  62 #ifndef CONFIG_SMP
  63 #error "bitops won't work without CONFIG_SMP"
  64 #endif
  65 #endif
  66
  67 /* bitmap tables from arch/S390/kernel/bitmap.S */
  68 extern const char _oi_bitmap[];
  69 extern const char _ni_bitmap[];
  70 extern const char _zb_findmap[];
  71 extern const char _sb_findmap[];
  72
  73 #ifndef __s390x__
  74
  75 #define __BITOPS_ALIGN          3
  76 #define __BITOPS_WORDSIZE       32
  77 #define __BITOPS_OR             "or"
  78 #define __BITOPS_AND            "nr"
  79 #define __BITOPS_XOR            "xr"
  80
  81 #define __BITOPS_LOOP(__old, __new, __addr, __val, __op_string)         \
  82         __asm__ __volatile__("   l   %0,0(%4)\n"                        \
  83                              "0: lr  %1,%0\n"                           \
  84                              __op_string "  %1,%3\n"                    \
  85                              "   cs  %0,%1,0(%4)\n"                     \
  86                              "   jl  0b"                                \
  87                              : "=&d" (__old), "=&d" (__new),            \
  88                                "=m" (*(unsigned long *) __addr)         \
  89                              : "d" (__val), "a" (__addr),               \
  90                                "m" (*(unsigned long *) __addr) : "cc" );
  91
  92 #else /* __s390x__ */
  93
  94 #define __BITOPS_ALIGN          7
  95 #define __BITOPS_WORDSIZE       64
  96 #define __BITOPS_OR             "ogr"
  97 #define __BITOPS_AND            "ngr"
  98 #define __BITOPS_XOR            "xgr"
  99
 100 #define __BITOPS_LOOP(__old, __new, __addr, __val, __op_string)         \
 101         __asm__ __volatile__("   lg  %0,0(%4)\n"                        \
 102                              "0: lgr %1,%0\n"                           \
 103                              __op_string "  %1,%3\n"                    \
 104                              "   csg %0,%1,0(%4)\n"                     \
 105                              "   jl  0b"                                \
 106                              : "=&d" (__old), "=&d" (__new),            \
 107                                "=m" (*(unsigned long *) __addr)         \
 108                              : "d" (__val), "a" (__addr),               \
 109                                "m" (*(unsigned long *) __addr) : "cc" );
 110
 111 #endif /* __s390x__ */
 112
 113 #define __BITOPS_WORDS(bits) (((bits)+__BITOPS_WORDSIZE-1)/__BITOPS_WORDSIZE)
 114 #define __BITOPS_BARRIER() __asm__ __volatile__ ( "" : : : "memory" )
 115
 116 #ifdef CONFIG_SMP
 117 /*
 118  * SMP safe set_bit routine based on compare and swap (CS)
 119  */
 120 static inline void set_bit_cs(unsigned long nr, volatile unsigned long *ptr)
 121 {
 122         unsigned long addr, old, new, mask;
 123
 124         addr = (unsigned long) ptr;
 125 #if ALIGN_CS == 1
 126         nr += (addr & __BITOPS_ALIGN) << 3;    /* add alignment to bit number */
 127         addr ^= addr & __BITOPS_ALIGN;         /* align address to 8 */
 128 #endif
 129         /* calculate address for CS */
 130         addr += (nr ^ (nr & (__BITOPS_WORDSIZE - 1))) >> 3;
 131         /* make OR mask */
 132         mask = 1UL << (nr & (__BITOPS_WORDSIZE - 1));
 133         /* Do the atomic update. */
 134         __BITOPS_LOOP(old, new, addr, mask, __BITOPS_OR);
 135 }
 136
 137 /*
 138  * SMP safe clear_bit routine based on compare and swap (CS)
 139  */
 140 static inline void clear_bit_cs(unsigned long nr, volatile unsigned long *ptr)
 141 {
 142         unsigned long addr, old, new, mask;
 143
 144         addr = (unsigned long) ptr;
 145 #if ALIGN_CS == 1
 146         nr += (addr & __BITOPS_ALIGN) << 3;    /* add alignment to bit number */
 147         addr ^= addr & __BITOPS_ALIGN;         /* align address to 8 */
 148 #endif
 149         /* calculate address for CS */
 150         addr += (nr ^ (nr & (__BITOPS_WORDSIZE - 1))) >> 3;
 151         /* make AND mask */
 152         mask = ~(1UL << (nr & (__BITOPS_WORDSIZE - 1)));
 153         /* Do the atomic update. */
 154         __BITOPS_LOOP(old, new, addr, mask, __BITOPS_AND);
 155 }
 156
 157 /*
 158  * SMP safe change_bit routine based on compare and swap (CS)
 159  */
 160 static inline void change_bit_cs(unsigned long nr, volatile unsigned long *ptr)
 161 {
 162         unsigned long addr, old, new, mask;
 163
 164         addr = (unsigned long) ptr;
 165 #if ALIGN_CS == 1
 166         nr += (addr & __BITOPS_ALIGN) << 3;    /* add alignment to bit number */
 167         addr ^= addr & __BITOPS_ALIGN;         /* align address to 8 */
 168 #endif
 169         /* calculate address for CS */
 170         addr += (nr ^ (nr & (__BITOPS_WORDSIZE - 1))) >> 3;
 171         /* make XOR mask */
 172         mask = 1UL << (nr & (__BITOPS_WORDSIZE - 1));
 173         /* Do the atomic update. */
 174         __BITOPS_LOOP(old, new, addr, mask, __BITOPS_XOR);
 175 }
 176
 177 /*
 178  * SMP safe test_and_set_bit routine based on compare and swap (CS)
 179  */
 180 static inline int
 181 test_and_set_bit_cs(unsigned long nr, volatile unsigned long *ptr)
 182 {
 183         unsigned long addr, old, new, mask;
 184
 185         addr = (unsigned long) ptr;
 186 #if ALIGN_CS == 1
 187         nr += (addr & __BITOPS_ALIGN) << 3;    /* add alignment to bit number */
 188         addr ^= addr & __BITOPS_ALIGN;         /* align address to 8 */
 189 #endif
 190         /* calculate address for CS */
 191         addr += (nr ^ (nr & (__BITOPS_WORDSIZE - 1))) >> 3;
 192         /* make OR/test mask */
 193         mask = 1UL << (nr & (__BITOPS_WORDSIZE - 1));
 194         /* Do the atomic update. */
 195         __BITOPS_LOOP(old, new, addr, mask, __BITOPS_OR);
 196         __BITOPS_BARRIER();
 197         return (old & mask) != 0;
 198 }
 199
 200 /*
 201  * SMP safe test_and_clear_bit routine based on compare and swap (CS)
 202  */
 203 static inline int
 204 test_and_clear_bit_cs(unsigned long nr, volatile unsigned long *ptr)
 205 {
 206         unsigned long addr, old, new, mask;
 207
 208         addr = (unsigned long) ptr;
 209 #if ALIGN_CS == 1
 210         nr += (addr & __BITOPS_ALIGN) << 3;    /* add alignment to bit number */
 211         addr ^= addr & __BITOPS_ALIGN;         /* align address to 8 */
 212 #endif
 213         /* calculate address for CS */
 214         addr += (nr ^ (nr & (__BITOPS_WORDSIZE - 1))) >> 3;
 215         /* make AND/test mask */
 216         mask = ~(1UL << (nr & (__BITOPS_WORDSIZE - 1)));
 217         /* Do the atomic update. */
 218         __BITOPS_LOOP(old, new, addr, mask, __BITOPS_AND);
 219         __BITOPS_BARRIER();
 220         return (old ^ new) != 0;
 221 }
 222
 223 /*
 224  * SMP safe test_and_change_bit routine based on compare and swap (CS)
 225  */
 226 static inline int
 227 test_and_change_bit_cs(unsigned long nr, volatile unsigned long *ptr)
 228 {
 229         unsigned long addr, old, new, mask;
 230
 231         addr = (unsigned long) ptr;
 232 #if ALIGN_CS == 1
 233         nr += (addr & __BITOPS_ALIGN) << 3;  /* add alignment to bit number */
 234         addr ^= addr & __BITOPS_ALIGN;       /* align address to 8 */
 235 #endif
 236         /* calculate address for CS */
 237         addr += (nr ^ (nr & (__BITOPS_WORDSIZE - 1))) >> 3;
 238         /* make XOR/test mask */
 239         mask = 1UL << (nr & (__BITOPS_WORDSIZE - 1));
 240         /* Do the atomic update. */
 241         __BITOPS_LOOP(old, new, addr, mask, __BITOPS_XOR);
 242         __BITOPS_BARRIER();
 243         return (old & mask) != 0;
 244 }
 245 #endif /* CONFIG_SMP */
 246
 247 /*
 248  * fast, non-SMP set_bit routine
 249  */
 250 static inline void __set_bit(unsigned long nr, volatile unsigned long *ptr)
 251 {
 252         unsigned long addr;
 253
 254         addr = (unsigned long) ptr + ((nr ^ (__BITOPS_WORDSIZE - 8)) >> 3);
 255         asm volatile("oc 0(1,%1),0(%2)"
 256                      : "=m" (*(char *) addr)
 257                      : "a" (addr), "a" (_oi_bitmap + (nr & 7)),
 258                        "m" (*(char *) addr) : "cc" );
 259 }
 260
 261 static inline void
 262 __constant_set_bit(const unsigned long nr, volatile unsigned long *ptr)
 263 {
 264         unsigned long addr;
 265
 266         addr = ((unsigned long) ptr) + ((nr ^ (__BITOPS_WORDSIZE - 8)) >> 3);
 267         switch (nr&7) {
 268         case 0:
 269                 asm volatile ("oi 0(%1),0x01" : "=m" (*(char *) addr)
 270                               : "a" (addr), "m" (*(char *) addr) : "cc" );
 271                 break;
 272         case 1:
 273                 asm volatile ("oi 0(%1),0x02" : "=m" (*(char *) addr)
 274                               : "a" (addr), "m" (*(char *) addr) : "cc" );
 275                 break;
 276         case 2:
 277                 asm volatile ("oi 0(%1),0x04" : "=m" (*(char *) addr)
 278                               : "a" (addr), "m" (*(char *) addr) : "cc" );
 279                 break;
 280         case 3:
 281                 asm volatile ("oi 0(%1),0x08" : "=m" (*(char *) addr)
 282                               : "a" (addr), "m" (*(char *) addr) : "cc" );
 283                 break;
 284         case 4:
 285                 asm volatile ("oi 0(%1),0x10" : "=m" (*(char *) addr)
 286                               : "a" (addr), "m" (*(char *) addr) : "cc" );
 287                 break;
 288         case 5:
 289                 asm volatile ("oi 0(%1),0x20" : "=m" (*(char *) addr)
 290                               : "a" (addr), "m" (*(char *) addr) : "cc" );
 291                 break;
 292         case 6:
 293                 asm volatile ("oi 0(%1),0x40" : "=m" (*(char *) addr)
 294                               : "a" (addr), "m" (*(char *) addr) : "cc" );
 295                 break;
 296         case 7:
 297                 asm volatile ("oi 0(%1),0x80" : "=m" (*(char *) addr)
 298                               : "a" (addr), "m" (*(char *) addr) : "cc" );
 299                 break;
 300         }
 301 }
 302
 303 #define set_bit_simple(nr,addr) \
 304 (__builtin_constant_p((nr)) ? \
 305  __constant_set_bit((nr),(addr)) : \
 306  __set_bit((nr),(addr)) )
 307
 308 /*
 309  * fast, non-SMP clear_bit routine
 310  */
 311 static inline void
 312 __clear_bit(unsigned long nr, volatile unsigned long *ptr)
 313 {
 314         unsigned long addr;
 315
 316         addr = (unsigned long) ptr + ((nr ^ (__BITOPS_WORDSIZE - 8)) >> 3);
 317         asm volatile("nc 0(1,%1),0(%2)"
 318                      : "=m" (*(char *) addr)
 319                      : "a" (addr), "a" (_ni_bitmap + (nr & 7)),
 320                        "m" (*(char *) addr) : "cc" );
 321 }
 322
 323 static inline void
 324 __constant_clear_bit(const unsigned long nr, volatile unsigned long *ptr)
 325 {
 326         unsigned long addr;
 327
 328         addr = ((unsigned long) ptr) + ((nr ^ (__BITOPS_WORDSIZE - 8)) >> 3);
 329         switch (nr&7) {
 330         case 0:
 331                 asm volatile ("ni 0(%1),0xFE" : "=m" (*(char *) addr)
 332                               : "a" (addr), "m" (*(char *) addr) : "cc" );
 333                 break;
 334         case 1:
 335                 asm volatile ("ni 0(%1),0xFD": "=m" (*(char *) addr)
 336                               : "a" (addr), "m" (*(char *) addr) : "cc" );
 337                 break;
 338         case 2:
 339                 asm volatile ("ni 0(%1),0xFB" : "=m" (*(char *) addr)
 340                               : "a" (addr), "m" (*(char *) addr) : "cc" );
 341                 break;
 342         case 3:
 343                 asm volatile ("ni 0(%1),0xF7" : "=m" (*(char *) addr)
 344                               : "a" (addr), "m" (*(char *) addr) : "cc" );
 345                 break;
 346         case 4:
 347                 asm volatile ("ni 0(%1),0xEF" : "=m" (*(char *) addr)
 348                               : "a" (addr), "m" (*(char *) addr) : "cc" );
 349                 break;
 350         case 5:
 351                 asm volatile ("ni 0(%1),0xDF" : "=m" (*(char *) addr)
 352                               : "a" (addr), "m" (*(char *) addr) : "cc" );
 353                 break;
 354         case 6:
 355                 asm volatile ("ni 0(%1),0xBF" : "=m" (*(char *) addr)
 356                               : "a" (addr), "m" (*(char *) addr) : "cc" );
 357                 break;
 358         case 7:
 359                 asm volatile ("ni 0(%1),0x7F" : "=m" (*(char *) addr)
 360                               : "a" (addr), "m" (*(char *) addr) : "cc" );
 361                 break;
 362         }
 363 }
 364
 365 #define clear_bit_simple(nr,addr) \
 366 (__builtin_constant_p((nr)) ? \
 367  __constant_clear_bit((nr),(addr)) : \
 368  __clear_bit((nr),(addr)) )
 369
 370 /*
 371  * fast, non-SMP change_bit routine
 372  */
 373 static inline void __change_bit(unsigned long nr, volatile unsigned long *ptr)
 374 {
 375         unsigned long addr;
 376
 377         addr = (unsigned long) ptr + ((nr ^ (__BITOPS_WORDSIZE - 8)) >> 3);
 378         asm volatile("xc 0(1,%1),0(%2)"
 379                      :  "=m" (*(char *) addr)
 380                      : "a" (addr), "a" (_oi_bitmap + (nr & 7)),
 381                        "m" (*(char *) addr) : "cc" );
 382 }
 383
 384 static inline void
 385 __constant_change_bit(const unsigned long nr, volatile unsigned long *ptr)
 386 {
 387         unsigned long addr;
 388
 389         addr = ((unsigned long) ptr) + ((nr ^ (__BITOPS_WORDSIZE - 8)) >> 3);
 390         switch (nr&7) {
 391         case 0:
 392                 asm volatile ("xi 0(%1),0x01" : "=m" (*(char *) addr)
 393                               : "a" (addr), "m" (*(char *) addr) : "cc" );
 394                 break;
 395         case 1:
 396                 asm volatile ("xi 0(%1),0x02" : "=m" (*(char *) addr)
 397                               : "a" (addr), "m" (*(char *) addr) : "cc" );
 398                 break;
 399         case 2:
 400                 asm volatile ("xi 0(%1),0x04" : "=m" (*(char *) addr)
 401                               : "a" (addr), "m" (*(char *) addr) : "cc" );
 402                 break;
 403         case 3:
 404                 asm volatile ("xi 0(%1),0x08" : "=m" (*(char *) addr)
 405                               : "a" (addr), "m" (*(char *) addr) : "cc" );
 406                 break;
 407         case 4:
 408                 asm volatile ("xi 0(%1),0x10" : "=m" (*(char *) addr)
 409                               : "a" (addr), "m" (*(char *) addr) : "cc" );
 410                 break;
 411         case 5:
 412                 asm volatile ("xi 0(%1),0x20" : "=m" (*(char *) addr)
 413                               : "a" (addr), "m" (*(char *) addr) : "cc" );
 414                 break;
 415         case 6:
 416                 asm volatile ("xi 0(%1),0x40" : "=m" (*(char *) addr)
 417                               : "a" (addr), "m" (*(char *) addr) : "cc" );
 418                 break;
 419         case 7:
 420                 asm volatile ("xi 0(%1),0x80" : "=m" (*(char *) addr)
 421                               : "a" (addr), "m" (*(char *) addr) : "cc" );
 422                 break;
 423         }
 424 }
 425
 426 #define change_bit_simple(nr,addr) \
 427 (__builtin_constant_p((nr)) ? \
 428  __constant_change_bit((nr),(addr)) : \
 429  __change_bit((nr),(addr)) )
 430
 431 /*
 432  * fast, non-SMP test_and_set_bit routine
 433  */
 434 static inline int
 435 test_and_set_bit_simple(unsigned long nr, volatile unsigned long *ptr)
 436 {
 437         unsigned long addr;
 438         unsigned char ch;
 439
 440         addr = (unsigned long) ptr + ((nr ^ (__BITOPS_WORDSIZE - 8)) >> 3);
 441         ch = *(unsigned char *) addr;
 442         asm volatile("oc 0(1,%1),0(%2)"
 443                      : "=m" (*(char *) addr)
 444                      : "a" (addr), "a" (_oi_bitmap + (nr & 7)),
 445                        "m" (*(char *) addr) : "cc", "memory" );
 446         return (ch >> (nr & 7)) & 1;
 447 }
 448 #define __test_and_set_bit(X,Y)         test_and_set_bit_simple(X,Y)
 449
 450 /*
 451  * fast, non-SMP test_and_clear_bit routine
 452  */
 453 static inline int
 454 test_and_clear_bit_simple(unsigned long nr, volatile unsigned long *ptr)
 455 {
 456         unsigned long addr;
 457         unsigned char ch;
 458
 459         addr = (unsigned long) ptr + ((nr ^ (__BITOPS_WORDSIZE - 8)) >> 3);
 460         ch = *(unsigned char *) addr;
 461         asm volatile("nc 0(1,%1),0(%2)"
 462                      : "=m" (*(char *) addr)
 463                      : "a" (addr), "a" (_ni_bitmap + (nr & 7)),
 464                        "m" (*(char *) addr) : "cc", "memory" );
 465         return (ch >> (nr & 7)) & 1;
 466 }
 467 #define __test_and_clear_bit(X,Y)       test_and_clear_bit_simple(X,Y)
 468
 469 /*
 470  * fast, non-SMP test_and_change_bit routine
 471  */
 472 static inline int
 473 test_and_change_bit_simple(unsigned long nr, volatile unsigned long *ptr)
 474 {
 475         unsigned long addr;
 476         unsigned char ch;
 477
 478         addr = (unsigned long) ptr + ((nr ^ (__BITOPS_WORDSIZE - 8)) >> 3);
 479         ch = *(unsigned char *) addr;
 480         asm volatile("xc 0(1,%1),0(%2)"
 481                      : "=m" (*(char *) addr)
 482                      : "a" (addr), "a" (_oi_bitmap + (nr & 7)),
 483                        "m" (*(char *) addr) : "cc", "memory" );
 484         return (ch >> (nr & 7)) & 1;
 485 }
 486 #define __test_and_change_bit(X,Y)      test_and_change_bit_simple(X,Y)
 487
 488 #ifdef CONFIG_SMP
 489 #define set_bit             set_bit_cs
 490 #define clear_bit           clear_bit_cs
 491 #define change_bit          change_bit_cs
 492 #define test_and_set_bit    test_and_set_bit_cs
 493 #define test_and_clear_bit  test_and_clear_bit_cs
 494 #define test_and_change_bit test_and_change_bit_cs
 495 #else
 496 #define set_bit             set_bit_simple
 497 #define clear_bit           clear_bit_simple
 498 #define change_bit          change_bit_simple
 499 #define test_and_set_bit    test_and_set_bit_simple
 500 #define test_and_clear_bit  test_and_clear_bit_simple
 501 #define test_and_change_bit test_and_change_bit_simple
 502 #endif
 503
 504
 505 /*
 506  * This routine doesn't need to be atomic.
 507  */
 508
 509 static inline int __test_bit(unsigned long nr, const volatile unsigned long *ptr)
 510 {
 511         unsigned long addr;
 512         unsigned char ch;
 513
 514         addr = (unsigned long) ptr + ((nr ^ (__BITOPS_WORDSIZE - 8)) >> 3);
 515         ch = *(volatile unsigned char *) addr;
 516         return (ch >> (nr & 7)) & 1;
 517 }
 518
 519 static inline int
 520 __constant_test_bit(unsigned long nr, const volatile unsigned long *addr) {
 521     return (((volatile char *) addr)
 522             [(nr^(__BITOPS_WORDSIZE-8))>>3] & (1<<(nr&7)));
 523 }
 524
 525 #define test_bit(nr,addr) \
 526 (__builtin_constant_p((nr)) ? \
 527  __constant_test_bit((nr),(addr)) : \
 528  __test_bit((nr),(addr)) )
 529
 530 /*
 531  * ffz = Find First Zero in word. Undefined if no zero exists,
 532  * so code should check against ~0UL first..
 533  */
 534 static inline unsigned long ffz(unsigned long word)
 535 {
 536         unsigned long bit = 0;
 537
 538 #ifdef __s390x__
 539         if (likely((word & 0xffffffff) == 0xffffffff)) {
 540                 word >>= 32;
 541                 bit += 32;
 542         }
 543 #endif
 544         if (likely((word & 0xffff) == 0xffff)) {
 545                 word >>= 16;
 546                 bit += 16;
 547         }
 548         if (likely((word & 0xff) == 0xff)) {
 549                 word >>= 8;
 550                 bit += 8;
 551         }
 552         return bit + _zb_findmap[word & 0xff];
 553 }
 554
 555 /*
 556  * __ffs = find first bit in word. Undefined if no bit exists,
 557  * so code should check against 0UL first..
 558  */
 559 static inline unsigned long __ffs (unsigned long word)
 560 {
 561         unsigned long bit = 0;
 562
 563 #ifdef __s390x__
 564         if (likely((word & 0xffffffff) == 0)) {
 565                 word >>= 32;
 566                 bit += 32;
 567         }
 568 #endif
 569         if (likely((word & 0xffff) == 0)) {
 570                 word >>= 16;
 571                 bit += 16;
 572         }
 573         if (likely((word & 0xff) == 0)) {
 574                 word >>= 8;
 575                 bit += 8;
 576         }
 577         return bit + _sb_findmap[word & 0xff];
 578 }
 579
 580 /*
 581  * Find-bit routines..
 582  */
 583
 584 #ifndef __s390x__
 585
 586 static inline int
 587 find_first_zero_bit(const unsigned long * addr, unsigned long size)
 588 {
 589         typedef struct { long _[__BITOPS_WORDS(size)]; } addrtype;
 590         unsigned long cmp, count;
 591         unsigned int res;
 592
 593         if (!size)
 594                 return 0;
 595         __asm__("   lhi  %1,-1\n"
 596                 "   lr   %2,%3\n"
 597                 "   slr  %0,%0\n"
 598                 "   ahi  %2,31\n"
 599                 "   srl  %2,5\n"
 600                 "0: c    %1,0(%0,%4)\n"
 601                 "   jne  1f\n"
 602                 "   la   %0,4(%0)\n"
 603                 "   brct %2,0b\n"
 604                 "   lr   %0,%3\n"
 605                 "   j    4f\n"
 606                 "1: l    %2,0(%0,%4)\n"
 607                 "   sll  %0,3\n"
 608                 "   lhi  %1,0xff\n"
 609                 "   tml  %2,0xffff\n"
 610                 "   jno  2f\n"
 611                 "   ahi  %0,16\n"
 612                 "   srl  %2,16\n"
 613                 "2: tml  %2,0x00ff\n"
 614                 "   jno  3f\n"
 615                 "   ahi  %0,8\n"
 616                 "   srl  %2,8\n"
 617                 "3: nr   %2,%1\n"
 618                 "   ic   %2,0(%2,%5)\n"
 619                 "   alr  %0,%2\n"
 620                 "4:"
 621                 : "=&a" (res), "=&d" (cmp), "=&a" (count)
 622                 : "a" (size), "a" (addr), "a" (&_zb_findmap),
 623                   "m" (*(addrtype *) addr) : "cc" );
 624         return (res < size) ? res : size;
 625 }
 626
 627 static inline int
 628 find_first_bit(const unsigned long * addr, unsigned long size)
 629 {
 630         typedef struct { long _[__BITOPS_WORDS(size)]; } addrtype;
 631         unsigned long cmp, count;
 632         unsigned int res;
 633
 634         if (!size)
 635                 return 0;
 636         __asm__("   slr  %1,%1\n"
 637                 "   lr   %2,%3\n"
 638                 "   slr  %0,%0\n"
 639                 "   ahi  %2,31\n"
 640                 "   srl  %2,5\n"
 641                 "0: c    %1,0(%0,%4)\n"
 642                 "   jne  1f\n"
 643                 "   la   %0,4(%0)\n"
 644                 "   brct %2,0b\n"
 645                 "   lr   %0,%3\n"
 646                 "   j    4f\n"
 647                 "1: l    %2,0(%0,%4)\n"
 648                 "   sll  %0,3\n"
 649                 "   lhi  %1,0xff\n"
 650                 "   tml  %2,0xffff\n"
 651                 "   jnz  2f\n"
 652                 "   ahi  %0,16\n"
 653                 "   srl  %2,16\n"
 654                 "2: tml  %2,0x00ff\n"
 655                 "   jnz  3f\n"
 656                 "   ahi  %0,8\n"
 657                 "   srl  %2,8\n"
 658                 "3: nr   %2,%1\n"
 659                 "   ic   %2,0(%2,%5)\n"
 660                 "   alr  %0,%2\n"
 661                 "4:"
 662                 : "=&a" (res), "=&d" (cmp), "=&a" (count)
 663                 : "a" (size), "a" (addr), "a" (&_sb_findmap),
 664                   "m" (*(addrtype *) addr) : "cc" );
 665         return (res < size) ? res : size;
 666 }
 667
 668 #else /* __s390x__ */
 669
 670 static inline unsigned long
 671 find_first_zero_bit(const unsigned long * addr, unsigned long size)
 672 {
 673         typedef struct { long _[__BITOPS_WORDS(size)]; } addrtype;
 674         unsigned long res, cmp, count;
 675
 676         if (!size)
 677                 return 0;
 678         __asm__("   lghi  %1,-1\n"
 679                 "   lgr   %2,%3\n"
 680                 "   slgr  %0,%0\n"
 681                 "   aghi  %2,63\n"
 682                 "   srlg  %2,%2,6\n"
 683                 "0: cg    %1,0(%0,%4)\n"
 684                 "   jne   1f\n"
 685                 "   la    %0,8(%0)\n"
 686                 "   brct  %2,0b\n"
 687                 "   lgr   %0,%3\n"
 688                 "   j     5f\n"
 689                 "1: lg    %2,0(%0,%4)\n"
 690                 "   sllg  %0,%0,3\n"
 691                 "   clr   %2,%1\n"
 692                 "   jne   2f\n"
 693                 "   aghi  %0,32\n"
 694                 "   srlg  %2,%2,32\n"
 695                 "2: lghi  %1,0xff\n"
 696                 "   tmll  %2,0xffff\n"
 697                 "   jno   3f\n"
 698                 "   aghi  %0,16\n"
 699                 "   srl   %2,16\n"
 700                 "3: tmll  %2,0x00ff\n"
 701                 "   jno   4f\n"
 702                 "   aghi  %0,8\n"
 703                 "   srl   %2,8\n"
 704                 "4: ngr   %2,%1\n"
 705                 "   ic    %2,0(%2,%5)\n"
 706                 "   algr  %0,%2\n"
 707                 "5:"
 708                 : "=&a" (res), "=&d" (cmp), "=&a" (count)
 709                 : "a" (size), "a" (addr), "a" (&_zb_findmap),
 710                   "m" (*(addrtype *) addr) : "cc" );
 711         return (res < size) ? res : size;
 712 }
 713
 714 static inline unsigned long
 715 find_first_bit(const unsigned long * addr, unsigned long size)
 716 {
 717         typedef struct { long _[__BITOPS_WORDS(size)]; } addrtype;
 718         unsigned long res, cmp, count;
 719
 720         if (!size)
 721                 return 0;
 722         __asm__("   slgr  %1,%1\n"
 723                 "   lgr   %2,%3\n"
 724                 "   slgr  %0,%0\n"
 725                 "   aghi  %2,63\n"
 726                 "   srlg  %2,%2,6\n"
 727                 "0: cg    %1,0(%0,%4)\n"
 728                 "   jne   1f\n"
 729                 "   aghi  %0,8\n"
 730                 "   brct  %2,0b\n"
 731                 "   lgr   %0,%3\n"
 732                 "   j     5f\n"
 733                 "1: lg    %2,0(%0,%4)\n"
 734                 "   sllg  %0,%0,3\n"
 735                 "   clr   %2,%1\n"
 736                 "   jne   2f\n"
 737                 "   aghi  %0,32\n"
 738                 "   srlg  %2,%2,32\n"
 739                 "2: lghi  %1,0xff\n"
 740                 "   tmll  %2,0xffff\n"
 741                 "   jnz   3f\n"
 742                 "   aghi  %0,16\n"
 743                 "   srl   %2,16\n"
 744                 "3: tmll  %2,0x00ff\n"
 745                 "   jnz   4f\n"
 746                 "   aghi  %0,8\n"
 747                 "   srl   %2,8\n"
 748                 "4: ngr   %2,%1\n"
 749                 "   ic    %2,0(%2,%5)\n"
 750                 "   algr  %0,%2\n"
 751                 "5:"
 752                 : "=&a" (res), "=&d" (cmp), "=&a" (count)
 753                 : "a" (size), "a" (addr), "a" (&_sb_findmap),
 754                   "m" (*(addrtype *) addr) : "cc" );
 755         return (res < size) ? res : size;
 756 }
 757
 758 #endif /* __s390x__ */
 759
 760 static inline int
 761 find_next_zero_bit (const unsigned long * addr, unsigned long size,
 762                     unsigned long offset)
 763 {
 764         const unsigned long *p;
 765         unsigned long bit, set;
 766
 767         if (offset >= size)
 768                 return size;
 769         bit = offset & (__BITOPS_WORDSIZE - 1);
 770         offset -= bit;
 771         size -= offset;
 772         p = addr + offset / __BITOPS_WORDSIZE;
 773         if (bit) {
 774                 /*
 775                  * s390 version of ffz returns __BITOPS_WORDSIZE
 776                  * if no zero bit is present in the word.
 777                  */
 778                 set = ffz(*p >> bit) + bit;
 779                 if (set >= size)
 780                         return size + offset;
 781                 if (set < __BITOPS_WORDSIZE)
 782                         return set + offset;
 783                 offset += __BITOPS_WORDSIZE;
 784                 size -= __BITOPS_WORDSIZE;
 785                 p++;
 786         }
 787         return offset + find_first_zero_bit(p, size);
 788 }
 789
 790 static inline int
 791 find_next_bit (const unsigned long * addr, unsigned long size,
 792                unsigned long offset)
 793 {
 794         const unsigned long *p;
 795         unsigned long bit, set;
 796
 797         if (offset >= size)
 798                 return size;
 799         bit = offset & (__BITOPS_WORDSIZE - 1);
 800         offset -= bit;
 801         size -= offset;
 802         p = addr + offset / __BITOPS_WORDSIZE;
 803         if (bit) {
 804                 /*
 805                  * s390 version of __ffs returns __BITOPS_WORDSIZE
 806                  * if no one bit is present in the word.
 807                  */
 808                 set = __ffs(*p & (~0UL << bit));
 809                 if (set >= size)
 810                         return size + offset;
 811                 if (set < __BITOPS_WORDSIZE)
 812                         return set + offset;
 813                 offset += __BITOPS_WORDSIZE;
 814                 size -= __BITOPS_WORDSIZE;
 815                 p++;
 816         }
 817         return offset + find_first_bit(p, size);
 818 }
 819
 820 /*
 821  * Every architecture must define this function. It's the fastest
 822  * way of searching a 140-bit bitmap where the first 100 bits are
 823  * unlikely to be set. It's guaranteed that at least one of the 140
 824  * bits is cleared.
 825  */
 826 static inline int sched_find_first_bit(unsigned long *b)
 827 {
 828         return find_first_bit(b, 140);
 829 }
 830
 831 /*
 832  * ffs: find first bit set. This is defined the same way as
 833  * the libc and compiler builtin ffs routines, therefore
 834  * differs in spirit from the above ffz (man ffs).
 835  */
 836 #define ffs(x) generic_ffs(x)
 837
 838 /*
 839  * fls: find last bit set.
 840  */
 841 #define fls(x) generic_fls(x)
 842
 843 /*
 844  * hweightN: returns the hamming weight (i.e. the number
 845  * of bits set) of a N-bit word
 846  */
 847 #define hweight64(x)                                            \
 848 ({                                                              \
 849         unsigned long __x = (x);                                \
 850         unsigned int __w;                                       \
 851         __w = generic_hweight32((unsigned int) __x);            \
 852         __w += generic_hweight32((unsigned int) (__x>>32));     \
 853         __w;                                                    \
 854 })
 855 #define hweight32(x) generic_hweight32(x)
 856 #define hweight16(x) generic_hweight16(x)
 857 #define hweight8(x) generic_hweight8(x)
 858
 859
 860 #ifdef __KERNEL__
 861
 862 /*
 863  * ATTENTION: intel byte ordering convention for ext2 and minix !!
 864  * bit 0 is the LSB of addr; bit 31 is the MSB of addr;
 865  * bit 32 is the LSB of (addr+4).
 866  * That combined with the little endian byte order of Intel gives the
 867  * following bit order in memory:
 868  *    07 06 05 04 03 02 01 00 15 14 13 12 11 10 09 08 \
 869  *    23 22 21 20 19 18 17 16 31 30 29 28 27 26 25 24
 870  */
 871
 872 #define ext2_set_bit(nr, addr)       \
 873         test_and_set_bit((nr)^(__BITOPS_WORDSIZE - 8), (unsigned long *)addr)
 874 #define ext2_set_bit_atomic(lock, nr, addr)       \
 875         test_and_set_bit((nr)^(__BITOPS_WORDSIZE - 8), (unsigned long *)addr)
 876 #define ext2_clear_bit(nr, addr)     \
 877         test_and_clear_bit((nr)^(__BITOPS_WORDSIZE - 8), (unsigned long *)addr)
 878 #define ext2_clear_bit_atomic(lock, nr, addr)     \
 879         test_and_clear_bit((nr)^(__BITOPS_WORDSIZE - 8), (unsigned long *)addr)
 880 #define ext2_test_bit(nr, addr)      \
 881         test_bit((nr)^(__BITOPS_WORDSIZE - 8), (unsigned long *)addr)
 882
 883 #ifndef __s390x__
 884
 885 static inline int
 886 ext2_find_first_zero_bit(void *vaddr, unsigned int size)
 887 {
 888         typedef struct { long _[__BITOPS_WORDS(size)]; } addrtype;
 889         unsigned long cmp, count;
 890         unsigned int res;
 891
 892         if (!size)
 893                 return 0;
 894         __asm__("   lhi  %1,-1\n"
 895                 "   lr   %2,%3\n"
 896                 "   ahi  %2,31\n"
 897                 "   srl  %2,5\n"
 898                 "   slr  %0,%0\n"
 899                 "0: cl   %1,0(%0,%4)\n"
 900                 "   jne  1f\n"
 901                 "   ahi  %0,4\n"
 902                 "   brct %2,0b\n"
 903                 "   lr   %0,%3\n"
 904                 "   j    4f\n"
 905                 "1: l    %2,0(%0,%4)\n"
 906                 "   sll  %0,3\n"
 907                 "   ahi  %0,24\n"
 908                 "   lhi  %1,0xff\n"
 909                 "   tmh  %2,0xffff\n"
 910                 "   jo   2f\n"
 911                 "   ahi  %0,-16\n"
 912                 "   srl  %2,16\n"
 913                 "2: tml  %2,0xff00\n"
 914                 "   jo   3f\n"
 915                 "   ahi  %0,-8\n"
 916                 "   srl  %2,8\n"
 917                 "3: nr   %2,%1\n"
 918                 "   ic   %2,0(%2,%5)\n"
 919                 "   alr  %0,%2\n"
 920                 "4:"
 921                 : "=&a" (res), "=&d" (cmp), "=&a" (count)
 922                 : "a" (size), "a" (vaddr), "a" (&_zb_findmap),
 923                   "m" (*(addrtype *) vaddr) : "cc" );
 924         return (res < size) ? res : size;
 925 }
 926
 927 #else /* __s390x__ */
 928
 929 static inline unsigned long
 930 ext2_find_first_zero_bit(void *vaddr, unsigned long size)
 931 {
 932         typedef struct { long _[__BITOPS_WORDS(size)]; } addrtype;
 933         unsigned long res, cmp, count;
 934
 935         if (!size)
 936                 return 0;
 937         __asm__("   lghi  %1,-1\n"
 938                 "   lgr   %2,%3\n"
 939                 "   aghi  %2,63\n"
 940                 "   srlg  %2,%2,6\n"
 941                 "   slgr  %0,%0\n"
 942                 "0: clg   %1,0(%0,%4)\n"
 943                 "   jne   1f\n"
 944                 "   aghi  %0,8\n"
 945                 "   brct  %2,0b\n"
 946                 "   lgr   %0,%3\n"
 947                 "   j     5f\n"
 948                 "1: cl    %1,0(%0,%4)\n"
 949                 "   jne   2f\n"
 950                 "   aghi  %0,4\n"
 951                 "2: l     %2,0(%0,%4)\n"
 952                 "   sllg  %0,%0,3\n"
 953                 "   aghi  %0,24\n"
 954                 "   lghi  %1,0xff\n"
 955                 "   tmlh  %2,0xffff\n"
 956                 "   jo    3f\n"
 957                 "   aghi  %0,-16\n"
 958                 "   srl   %2,16\n"
 959                 "3: tmll  %2,0xff00\n"
 960                 "   jo    4f\n"
 961                 "   aghi  %0,-8\n"
 962                 "   srl   %2,8\n"
 963                 "4: ngr   %2,%1\n"
 964                 "   ic    %2,0(%2,%5)\n"
 965                 "   algr  %0,%2\n"
 966                 "5:"
 967                 : "=&a" (res), "=&d" (cmp), "=&a" (count)
 968                 : "a" (size), "a" (vaddr), "a" (&_zb_findmap),
 969                   "m" (*(addrtype *) vaddr) : "cc" );
 970         return (res < size) ? res : size;
 971 }
 972
 973 #endif /* __s390x__ */
 974
 975 static inline int
 976 ext2_find_next_zero_bit(void *vaddr, unsigned long size, unsigned long offset)
 977 {
 978         unsigned long *addr = vaddr, *p;
 979         unsigned long word, bit, set;
 980
 981         if (offset >= size)
 982                 return size;
 983         bit = offset & (__BITOPS_WORDSIZE - 1);
 984         offset -= bit;
 985         size -= offset;
 986         p = addr + offset / __BITOPS_WORDSIZE;
 987         if (bit) {
 988 #ifndef __s390x__
 989                 asm("   ic   %0,0(%1)\n"
 990                     "   icm  %0,2,1(%1)\n"
 991                     "   icm  %0,4,2(%1)\n"
 992                     "   icm  %0,8,3(%1)"
 993                     : "=&a" (word) : "a" (p), "m" (*p) : "cc" );
 994 #else
 995                 asm("   lrvg %0,%1" : "=a" (word) : "m" (*p) );
 996 #endif
 997                 /*
 998                  * s390 version of ffz returns __BITOPS_WORDSIZE
 999                  * if no zero bit is present in the word.
1000                  */
1001                 set = ffz(word >> bit) + bit;
1002                 if (set >= size)
1003                         return size + offset;
1004                 if (set < __BITOPS_WORDSIZE)
1005                         return set + offset;
1006                 offset += __BITOPS_WORDSIZE;
1007                 size -= __BITOPS_WORDSIZE;
1008                 p++;
1009         }
1010         return offset + ext2_find_first_zero_bit(p, size);
1011 }
1012
1013 /* Bitmap functions for the minix filesystem.  */
1014 /* FIXME !!! */
1015 #define minix_test_and_set_bit(nr,addr) \
1016         test_and_set_bit(nr,(unsigned long *)addr)
1017 #define minix_set_bit(nr,addr) \
1018         set_bit(nr,(unsigned long *)addr)
1019 #define minix_test_and_clear_bit(nr,addr) \
1020         test_and_clear_bit(nr,(unsigned long *)addr)
1021 #define minix_test_bit(nr,addr) \
1022         test_bit(nr,(unsigned long *)addr)
1023 #define minix_find_first_zero_bit(addr,size) \
1024         find_first_zero_bit(addr,size)
1025
1026 #endif /* __KERNEL__ */
1027
1028 #endif /* _S390_BITOPS_H */