root/include/asm-m68k/bitops.h

/* */

INCLUDED FROM

DEFINITIONS

1. set_bit
2. clear_bit
3. change_bit
4. test_bit
5. find_first_zero_bit
6. find_next_zero_bit
7. ffz
8. minix_find_first_zero_bit
9. minix_set_bit
10. minix_clear_bit
11. minix_test_bit
12. ext2_set_bit
13. ext2_clear_bit
14. ext2_test_bit
15. ext2_find_first_zero_bit
16. ext2_find_next_zero_bit

   1 #ifndef _M68K_BITOPS_H
   2 #define _M68K_BITOPS_H
   3 /*
   4  * Copyright 1992, Linus Torvalds.
   5  *
   6  * This file is subject to the terms and conditions of the GNU General Public
   7  * License.  See the file README.legal in the main directory of this archive
   8  * for more details.
   9  */
  10 
  11 /*
  12  * Require 68020 or better.
  13  *
  14  * They use the standard big-endian m680x0 bit ordering.
  15  */
  16 
  17 extern __inline__ int set_bit(int nr,void * vaddr)
     /*  */
  18 {
  19         char retval;
  20 
  21         __asm__ __volatile__ ("bfset %2@{%1:#1}; sne %0"
  22              : "=d" (retval) : "d" (nr^31), "a" (vaddr));
  23 
  24         return retval;
  25 }
  26 
  27 extern __inline__ int clear_bit(int nr, void * vaddr)
     /*  */
  28 {
  29         char retval;
  30 
  31         __asm__ __volatile__ ("bfclr %2@{%1:#1}; sne %0"
  32              : "=d" (retval) : "d" (nr^31), "a" (vaddr));
  33 
  34         return retval;
  35 }
  36 
  37 extern __inline__ int change_bit(int nr, void * vaddr)
     /*  */
  38 {
  39         char retval;
  40 
  41         __asm__ __volatile__ ("bfchg %2@{%1:#1}; sne %0"
  42              : "=d" (retval) : "d" (nr^31), "a" (vaddr));
  43 
  44         return retval;
  45 }
  46 
  47 extern __inline__ int test_bit(int nr, const void * vaddr)
     /*  */
  48 {
  49         char retval;
  50 
  51         __asm__ __volatile__ ("bftst %2@{%1:#1}; sne %0"
  52              : "=d" (retval) : "d" (nr^31), "a" (vaddr));
  53 
  54         return retval;
  55 }
  56 
  57 extern __inline__ int find_first_zero_bit(void * vaddr, unsigned size)
     /*  */
  58 {
  59         unsigned long *p = vaddr, *addr = vaddr;
  60         unsigned long allones = ~0UL;
  61         int res;
  62         unsigned long num;
  63 
  64         if (!size)
  65                 return 0;
  66 
  67         while (*p++ == allones)
  68         {
  69                 if (size <= 32)
  70                         return (p - addr) << 5;
  71                 size -= 32;
  72         }
  73 
  74         num = ~*--p;
  75         __asm__ __volatile__ ("bfffo %1{#0,#0},%0"
  76                               : "=d" (res) : "d" (num & -num));
  77         return ((p - addr) << 5) + (res ^ 31);
  78 }
  79 
  80 extern __inline__ int find_next_zero_bit (void *vaddr, int size,
     /*  */
  81                                       int offset)
  82 {
  83         unsigned long *addr = vaddr;
  84         unsigned long *p = addr + (offset >> 5);
  85         int set = 0, bit = offset & 31UL, res;
  86 
  87         if (offset >= size)
  88                 return size;
  89 
  90         if (bit) {
  91                 unsigned long num = ~*p & (~0UL << bit);
  92 
  93                 /* Look for zero in first longword */
  94                 __asm__ __volatile__ ("bfffo %1{#0,#0},%0"
  95                                       : "=d" (res) : "d" (num & -num));
  96                 if (res < 32)
  97                         return (offset & ~31UL) + (res ^ 31);
  98                 set = 32 - bit;
  99                 p++;
 100         }
 101         /* No zero yet, search remaining full bytes for a zero */
 102         res = find_first_zero_bit (p, size - 32 * (p - addr));
 103         return (offset + set + res);
 104 }
 105 
 106 /*
 107  * ffz = Find First Zero in word. Undefined if no zero exists,
 108  * so code should check against ~0UL first..
 109  */
 110 extern __inline__ unsigned long ffz(unsigned long word)
     /*  */
 111 {
 112         int res;
 113 
 114         __asm__ __volatile__ ("bfffo %1{#0,#0},%0"
 115                               : "=d" (res) : "d" (~word & -~word));
 116         return res ^ 31;
 117 }
 118 
 119 /* Bitmap functions for the minix filesystem */
 120 
 121 extern __inline__ int
 122 minix_find_first_zero_bit (const void *vaddr, unsigned size)
     /*  */
 123 {
 124         const unsigned short *p = vaddr, *addr = vaddr;
 125         int res;
 126         unsigned short num;
 127 
 128         if (!size)
 129                 return 0;
 130 
 131         while (*p++ == 0xffff)
 132         {
 133                 if (size <= 16)
 134                         return (p - addr) << 4;
 135                 size -= 16;
 136         }
 137 
 138         num = ~*--p;
 139         __asm__ __volatile__ ("bfffo %1{#16,#16},%0"
 140                               : "=d" (res) : "d" (num & -num));
 141         return ((p - addr) << 4) + (res ^ 31);
 142 }
 143 
 144 extern __inline__ int
 145 minix_set_bit (int nr, void *vaddr)
     /*  */
 146 {
 147         char retval;
 148 
 149         __asm__ __volatile__ ("bfset %2{%1:#1}; sne %0"
 150              : "=d" (retval) : "d" (nr^15), "m" (*(char *)vaddr));
 151 
 152         return retval;
 153 }
 154 
 155 extern __inline__ int
 156 minix_clear_bit (int nr, void *vaddr)
     /*  */
 157 {
 158         char retval;
 159 
 160         __asm__ __volatile__ ("bfclr %2{%1:#1}; sne %0"
 161              : "=d" (retval) : "d" (nr^15), "m" (*(char *) vaddr));
 162 
 163         return retval;
 164 }
 165 
 166 extern __inline__ int
 167 minix_test_bit (int nr, const void *vaddr)
     /*  */
 168 {
 169         char retval;
 170 
 171         __asm__ __volatile__ ("bftst %2{%1:#1}; sne %0"
 172              : "=d" (retval) : "d" (nr^15), "m" (*(const char *) vaddr));
 173 
 174         return retval;
 175 }
 176 
 177 /* Bitmap functions for the ext2 filesystem. */
 178 
 179 extern __inline__ int
 180 ext2_set_bit (int nr, void *vaddr)
     /*  */
 181 {
 182         char retval;
 183 
 184         __asm__ __volatile__ ("bfset %2{%1,#1}; sne %0"
 185              : "=d" (retval) : "d" (nr^7), "m" (*(char *) vaddr));
 186 
 187         return retval;
 188 }
 189 
 190 extern __inline__ int
 191 ext2_clear_bit (int nr, void *vaddr)
     /*  */
 192 {
 193         char retval;
 194 
 195         __asm__ __volatile__ ("bfclr %2{%1,#1}; sne %0"
 196              : "=d" (retval) : "d" (nr^7), "m" (*(char *) vaddr));
 197 
 198         return retval;
 199 }
 200 
 201 extern __inline__ int
 202 ext2_test_bit (int nr, const void *vaddr)
     /*  */
 203 {
 204         char retval;
 205 
 206         __asm__ __volatile__ ("bftst %2{%1,#1}; sne %0"
 207              : "=d" (retval) : "d" (nr^7), "m" (*(const char *) vaddr));
 208 
 209         return retval;
 210 }
 211 
 212 extern __inline__ int
 213 ext2_find_first_zero_bit (const void *vaddr, unsigned size)
     /*  */
 214 {
 215         const unsigned long *p = vaddr, *addr = vaddr;
 216         int res;
 217 
 218         if (!size)
 219                 return 0;
 220 
 221         while (*p++ == ~0UL)
 222         {
 223                 if (size <= 32)
 224                         return (p - addr) << 5;
 225                 size -= 32;
 226         }
 227 
 228         --p;
 229         for (res = 0; res < 32; res++)
 230                 if (!ext2_test_bit (res, p))
 231                         break;
 232         return (p - addr) * 32 + res;
 233 }
 234 
 235 extern __inline__ int
 236 ext2_find_next_zero_bit (const void *vaddr, unsigned size, unsigned offset)
     /*  */
 237 {
 238         const unsigned long *addr = vaddr;
 239         const unsigned long *p = addr + (offset >> 5);
 240         int bit = offset & 31UL, res;
 241 
 242         if (offset >= size)
 243                 return size;
 244 
 245         if (bit) {
 246                 /* Look for zero in first longword */
 247                 for (res = bit; res < 32; res++)
 248                         if (!ext2_test_bit (res, p))
 249                                 return (p - addr) * 32 + res;
 250                 p++;
 251         }
 252         /* No zero yet, search remaining full bytes for a zero */
 253         res = ext2_find_first_zero_bit (p, size - 32 * (p - addr));
 254         return (p - addr) * 32 + res;
 255 }
 256 
 257 #endif /* _M68K_BITOPS_H */

/* */