开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
bitops.h
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：30k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

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