diff options
Diffstat (limited to 'include/asm-x86/bitops_32.h')
-rw-r--r-- | include/asm-x86/bitops_32.h | 166 |
1 files changed, 0 insertions, 166 deletions
diff --git a/include/asm-x86/bitops_32.h b/include/asm-x86/bitops_32.h deleted file mode 100644 index 2513a81f82aa..000000000000 --- a/include/asm-x86/bitops_32.h +++ /dev/null | |||
@@ -1,166 +0,0 @@ | |||
1 | #ifndef _I386_BITOPS_H | ||
2 | #define _I386_BITOPS_H | ||
3 | |||
4 | /* | ||
5 | * Copyright 1992, Linus Torvalds. | ||
6 | */ | ||
7 | |||
8 | /** | ||
9 | * find_first_zero_bit - find the first zero bit in a memory region | ||
10 | * @addr: The address to start the search at | ||
11 | * @size: The maximum size to search | ||
12 | * | ||
13 | * Returns the bit number of the first zero bit, not the number of the byte | ||
14 | * containing a bit. | ||
15 | */ | ||
16 | static inline int find_first_zero_bit(const unsigned long *addr, unsigned size) | ||
17 | { | ||
18 | int d0, d1, d2; | ||
19 | int res; | ||
20 | |||
21 | if (!size) | ||
22 | return 0; | ||
23 | /* This looks at memory. | ||
24 | * Mark it volatile to tell gcc not to move it around | ||
25 | */ | ||
26 | asm volatile("movl $-1,%%eax\n\t" | ||
27 | "xorl %%edx,%%edx\n\t" | ||
28 | "repe; scasl\n\t" | ||
29 | "je 1f\n\t" | ||
30 | "xorl -4(%%edi),%%eax\n\t" | ||
31 | "subl $4,%%edi\n\t" | ||
32 | "bsfl %%eax,%%edx\n" | ||
33 | "1:\tsubl %%ebx,%%edi\n\t" | ||
34 | "shll $3,%%edi\n\t" | ||
35 | "addl %%edi,%%edx" | ||
36 | : "=d" (res), "=&c" (d0), "=&D" (d1), "=&a" (d2) | ||
37 | : "1" ((size + 31) >> 5), "2" (addr), | ||
38 | "b" (addr) : "memory"); | ||
39 | return res; | ||
40 | } | ||
41 | |||
42 | /** | ||
43 | * find_next_zero_bit - find the first zero bit in a memory region | ||
44 | * @addr: The address to base the search on | ||
45 | * @offset: The bit number to start searching at | ||
46 | * @size: The maximum size to search | ||
47 | */ | ||
48 | int find_next_zero_bit(const unsigned long *addr, int size, int offset); | ||
49 | |||
50 | /** | ||
51 | * __ffs - find first bit in word. | ||
52 | * @word: The word to search | ||
53 | * | ||
54 | * Undefined if no bit exists, so code should check against 0 first. | ||
55 | */ | ||
56 | static inline unsigned long __ffs(unsigned long word) | ||
57 | { | ||
58 | __asm__("bsfl %1,%0" | ||
59 | :"=r" (word) | ||
60 | :"rm" (word)); | ||
61 | return word; | ||
62 | } | ||
63 | |||
64 | /** | ||
65 | * find_first_bit - find the first set bit in a memory region | ||
66 | * @addr: The address to start the search at | ||
67 | * @size: The maximum size to search | ||
68 | * | ||
69 | * Returns the bit number of the first set bit, not the number of the byte | ||
70 | * containing a bit. | ||
71 | */ | ||
72 | static inline unsigned find_first_bit(const unsigned long *addr, unsigned size) | ||
73 | { | ||
74 | unsigned x = 0; | ||
75 | |||
76 | while (x < size) { | ||
77 | unsigned long val = *addr++; | ||
78 | if (val) | ||
79 | return __ffs(val) + x; | ||
80 | x += sizeof(*addr) << 3; | ||
81 | } | ||
82 | return x; | ||
83 | } | ||
84 | |||
85 | /** | ||
86 | * find_next_bit - find the first set bit in a memory region | ||
87 | * @addr: The address to base the search on | ||
88 | * @offset: The bit number to start searching at | ||
89 | * @size: The maximum size to search | ||
90 | */ | ||
91 | int find_next_bit(const unsigned long *addr, int size, int offset); | ||
92 | |||
93 | /** | ||
94 | * ffz - find first zero in word. | ||
95 | * @word: The word to search | ||
96 | * | ||
97 | * Undefined if no zero exists, so code should check against ~0UL first. | ||
98 | */ | ||
99 | static inline unsigned long ffz(unsigned long word) | ||
100 | { | ||
101 | __asm__("bsfl %1,%0" | ||
102 | :"=r" (word) | ||
103 | :"r" (~word)); | ||
104 | return word; | ||
105 | } | ||
106 | |||
107 | #ifdef __KERNEL__ | ||
108 | |||
109 | #include <asm-generic/bitops/sched.h> | ||
110 | |||
111 | /** | ||
112 | * ffs - find first bit set | ||
113 | * @x: the word to search | ||
114 | * | ||
115 | * This is defined the same way as | ||
116 | * the libc and compiler builtin ffs routines, therefore | ||
117 | * differs in spirit from the above ffz() (man ffs). | ||
118 | */ | ||
119 | static inline int ffs(int x) | ||
120 | { | ||
121 | int r; | ||
122 | |||
123 | __asm__("bsfl %1,%0\n\t" | ||
124 | "jnz 1f\n\t" | ||
125 | "movl $-1,%0\n" | ||
126 | "1:" : "=r" (r) : "rm" (x)); | ||
127 | return r+1; | ||
128 | } | ||
129 | |||
130 | /** | ||
131 | * fls - find last bit set | ||
132 | * @x: the word to search | ||
133 | * | ||
134 | * This is defined the same way as ffs(). | ||
135 | */ | ||
136 | static inline int fls(int x) | ||
137 | { | ||
138 | int r; | ||
139 | |||
140 | __asm__("bsrl %1,%0\n\t" | ||
141 | "jnz 1f\n\t" | ||
142 | "movl $-1,%0\n" | ||
143 | "1:" : "=r" (r) : "rm" (x)); | ||
144 | return r+1; | ||
145 | } | ||
146 | |||
147 | #include <asm-generic/bitops/hweight.h> | ||
148 | |||
149 | #endif /* __KERNEL__ */ | ||
150 | |||
151 | #include <asm-generic/bitops/fls64.h> | ||
152 | |||
153 | #ifdef __KERNEL__ | ||
154 | |||
155 | #include <asm-generic/bitops/ext2-non-atomic.h> | ||
156 | |||
157 | #define ext2_set_bit_atomic(lock, nr, addr) \ | ||
158 | test_and_set_bit((nr), (unsigned long *)(addr)) | ||
159 | #define ext2_clear_bit_atomic(lock, nr, addr) \ | ||
160 | test_and_clear_bit((nr), (unsigned long *)(addr)) | ||
161 | |||
162 | #include <asm-generic/bitops/minix.h> | ||
163 | |||
164 | #endif /* __KERNEL__ */ | ||
165 | |||
166 | #endif /* _I386_BITOPS_H */ | ||