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

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

Linux/Unix编程

开发平台：

Unix_Linux

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