Eric Lee / smarc-uboot

Download as
Browse Code ยป

Commit 386118a896554b13f14ad0f82356276988f7de82

Authored by Michal Simek
1 parent 8fe7b29f98
Exists in master and in 54 other branches 8qm-imx_v2020.04_5.4.70_2.3.0, emb_lf_v2022.04, imx_v2015.04_4.1.15_1.0.0_ga, pitx_8mp_lf_v2020.04, smarc-8m-android-10.0.0_2.6.0, smarc-8m-android-11.0.0_2.0.0, smarc-8mp-android-11.0.0_2.0.0, smarc-emmc-imx_v2014.04_3.10.53_1.1.0_ga, smarc-emmc-imx_v2014.04_3.14.28_1.0.0_ga, smarc-imx-l5.0.0_1.0.0-ga, smarc-imx6_v2018.03_4.14.98_2.0.0_ga, smarc-imx7_v2017.03_4.9.11_1.0.0_ga, smarc-imx7_v2018.03_4.14.98_2.0.0_ga, smarc-imx_v2014.04_3.14.28_1.0.0_ga, smarc-imx_v2015.04_4.1.15_1.0.0_ga, smarc-imx_v2017.03_4.9.11_1.0.0_ga, smarc-imx_v2017.03_4.9.88_2.0.0_ga, smarc-imx_v2017.03_o8.1.0_1.3.0_8m, smarc-imx_v2018.03_4.14.78_1.0.0_ga, smarc-m6.0.1_2.1.0-ga, smarc-n7.1.2_2.0.0-ga, smarc-rel_imx_4.1.15_2.0.0_ga, smarc_8m-imx_v2018.03_4.14.98_2.0.0_ga, smarc_8m-imx_v2019.04_4.19.35_1.1.0, smarc_8m_00d0-imx_v2018.03_4.14.98_2.0.0_ga, smarc_8mm-imx_v2018.03_4.14.98_2.0.0_ga, smarc_8mm-imx_v2019.04_4.19.35_1.1.0, smarc_8mm-imx_v2020.04_5.4.24_2.1.0, smarc_8mp_lf_v2020.04, smarc_8mq-imx_v2020.04_5.4.24_2.1.0, smarc_8mq_lf_v2020.04, ti-u-boot-2015.07, u-boot-2013.01.y, v2013.10, v2013.10-smarct33, v2013.10-smartmen, v2014.01, v2014.04, v2014.04-smarct33, v2014.04-smarct33-emmc, v2014.04-smartmen, v2014.07, v2014.07-smarct33, v2014.07-smartmen, v2015.07-smarct33, v2015.07-smarct33-emmc, v2015.07-smarct4x, v2016.05-dlt, v2016.05-smarct3x, v2016.05-smarct3x-emmc, v2016.05-smarct4x, v2017.01-smarct3x, v2017.01-smarct3x-emmc, v2017.01-smarct4x

microblaze: Correct ffs regression for Microblaze 

We are using generic implementation of ffs. This should
be part of Simon's commit 0413cfecea350000eab5e591a0965c3e3ee0ff00

Here is warning message which this patch removes.

In file included from /tmp/u-boot-microblaze/include/common.h:38,
                 from cmd_mtdparts.c:87:
/tmp/u-boot-microblaze/include/linux/bitops.h:123:1: warning: "ffs" redefined
In file included from /tmp/u-boot-microblaze/include/linux/bitops.h:110,
                 from /tmp/u-boot-microblaze/include/common.h:38,
                 from cmd_mtdparts.c:87:
/tmp/u-boot-microblaze/include/asm/bitops.h:269:1:
warning: this is the location of the previous definition

Signed-off-by: Michal Simek <monstr@monstr.eu>

Showing 1 changed file with 0 additions and 2 deletions Inline Diff

include/asm-microblaze/bitops.h
Diff comments   View file @ 386118a
1 #ifndef _MICROBLAZE_BITOPS_H 1 #ifndef _MICROBLAZE_BITOPS_H
2 #define _MICROBLAZE_BITOPS_H 2 #define _MICROBLAZE_BITOPS_H
3 3
4 /* 4 /*
5 * Copyright 1992, Linus Torvalds. 5 * Copyright 1992, Linus Torvalds.
6 */ 6 */
7 7
8 #include <linux/config.h> 8 #include <linux/config.h>
9 #include <asm/byteorder.h> /* swab32 */ 9 #include <asm/byteorder.h> /* swab32 */
10 #include <asm/system.h> /* save_flags */ 10 #include <asm/system.h> /* save_flags */
11 11
12 #ifdef __KERNEL__ 12 #ifdef __KERNEL__
13 /* 13 /*
14 * Function prototypes to keep gcc -Wall happy 14 * Function prototypes to keep gcc -Wall happy
15 */ 15 */
16 16
17 /* 17 /*
18 * The __ functions are not atomic 18 * The __ functions are not atomic
19 */ 19 */
20 20
21 extern void set_bit(int nr, volatile void * addr); 21 extern void set_bit(int nr, volatile void * addr);
22 extern void __set_bit(int nr, volatile void * addr); 22 extern void __set_bit(int nr, volatile void * addr);
23 23
24 extern void clear_bit(int nr, volatile void * addr); 24 extern void clear_bit(int nr, volatile void * addr);
25 #define __clear_bit(nr, addr) clear_bit(nr, addr) 25 #define __clear_bit(nr, addr) clear_bit(nr, addr)
26 #define PLATFORM__CLEAR_BIT 26 #define PLATFORM__CLEAR_BIT
27 27
28 extern void change_bit(int nr, volatile void * addr); 28 extern void change_bit(int nr, volatile void * addr);
29 extern void __change_bit(int nr, volatile void * addr); 29 extern void __change_bit(int nr, volatile void * addr);
30 extern int test_and_set_bit(int nr, volatile void * addr); 30 extern int test_and_set_bit(int nr, volatile void * addr);
31 extern int __test_and_set_bit(int nr, volatile void * addr); 31 extern int __test_and_set_bit(int nr, volatile void * addr);
32 extern int test_and_clear_bit(int nr, volatile void * addr); 32 extern int test_and_clear_bit(int nr, volatile void * addr);
33 extern int __test_and_clear_bit(int nr, volatile void * addr); 33 extern int __test_and_clear_bit(int nr, volatile void * addr);
34 extern int test_and_change_bit(int nr, volatile void * addr); 34 extern int test_and_change_bit(int nr, volatile void * addr);
35 extern int __test_and_change_bit(int nr, volatile void * addr); 35 extern int __test_and_change_bit(int nr, volatile void * addr);
36 extern int __constant_test_bit(int nr, const volatile void * addr); 36 extern int __constant_test_bit(int nr, const volatile void * addr);
37 extern int __test_bit(int nr, volatile void * addr); 37 extern int __test_bit(int nr, volatile void * addr);
38 extern int find_first_zero_bit(void * addr, unsigned size); 38 extern int find_first_zero_bit(void * addr, unsigned size);
39 extern int find_next_zero_bit (void * addr, int size, int offset); 39 extern int find_next_zero_bit (void * addr, int size, int offset);
40 40
41 /* 41 /*
42 * ffz = Find First Zero in word. Undefined if no zero exists, 42 * ffz = Find First Zero in word. Undefined if no zero exists,
43 * so code should check against ~0UL first.. 43 * so code should check against ~0UL first..
44 */ 44 */
45 extern __inline__ unsigned long ffz(unsigned long word) 45 extern __inline__ unsigned long ffz(unsigned long word)
46 { 46 {
47 unsigned long result = 0; 47 unsigned long result = 0;
48 48
49 while(word & 1) { 49 while(word & 1) {
50 result++; 50 result++;
51 word >>= 1; 51 word >>= 1;
52 } 52 }
53 return result; 53 return result;
54 } 54 }
55 55
56 56
57 extern __inline__ void set_bit(int nr, volatile void * addr) 57 extern __inline__ void set_bit(int nr, volatile void * addr)
58 { 58 {
59 int * a = (int *) addr; 59 int * a = (int *) addr;
60 int mask; 60 int mask;
61 unsigned long flags; 61 unsigned long flags;
62 62
63 a += nr >> 5; 63 a += nr >> 5;
64 mask = 1 << (nr & 0x1f); 64 mask = 1 << (nr & 0x1f);
65 save_flags_cli(flags); 65 save_flags_cli(flags);
66 *a |= mask; 66 *a |= mask;
67 restore_flags(flags); 67 restore_flags(flags);
68 } 68 }
69 69
70 extern __inline__ void __set_bit(int nr, volatile void * addr) 70 extern __inline__ void __set_bit(int nr, volatile void * addr)
71 { 71 {
72 int * a = (int *) addr; 72 int * a = (int *) addr;
73 int mask; 73 int mask;
74 74
75 a += nr >> 5; 75 a += nr >> 5;
76 mask = 1 << (nr & 0x1f); 76 mask = 1 << (nr & 0x1f);
77 *a |= mask; 77 *a |= mask;
78 } 78 }
79 #define PLATFORM__SET_BIT 79 #define PLATFORM__SET_BIT
80 80
81 /* 81 /*
82 * clear_bit() doesn't provide any barrier for the compiler. 82 * clear_bit() doesn't provide any barrier for the compiler.
83 */ 83 */
84 #define smp_mb__before_clear_bit() barrier() 84 #define smp_mb__before_clear_bit() barrier()
85 #define smp_mb__after_clear_bit() barrier() 85 #define smp_mb__after_clear_bit() barrier()
86 86
87 extern __inline__ void clear_bit(int nr, volatile void * addr) 87 extern __inline__ void clear_bit(int nr, volatile void * addr)
88 { 88 {
89 int * a = (int *) addr; 89 int * a = (int *) addr;
90 int mask; 90 int mask;
91 unsigned long flags; 91 unsigned long flags;
92 92
93 a += nr >> 5; 93 a += nr >> 5;
94 mask = 1 << (nr & 0x1f); 94 mask = 1 << (nr & 0x1f);
95 save_flags_cli(flags); 95 save_flags_cli(flags);
96 *a &= ~mask; 96 *a &= ~mask;
97 restore_flags(flags); 97 restore_flags(flags);
98 } 98 }
99 99
100 extern __inline__ void change_bit(int nr, volatile void * addr) 100 extern __inline__ void change_bit(int nr, volatile void * addr)
101 { 101 {
102 int mask; 102 int mask;
103 unsigned long flags; 103 unsigned long flags;
104 unsigned long *ADDR = (unsigned long *) addr; 104 unsigned long *ADDR = (unsigned long *) addr;
105 105
106 ADDR += nr >> 5; 106 ADDR += nr >> 5;
107 mask = 1 << (nr & 31); 107 mask = 1 << (nr & 31);
108 save_flags_cli(flags); 108 save_flags_cli(flags);
109 *ADDR ^= mask; 109 *ADDR ^= mask;
110 restore_flags(flags); 110 restore_flags(flags);
111 } 111 }
112 112
113 extern __inline__ void __change_bit(int nr, volatile void * addr) 113 extern __inline__ void __change_bit(int nr, volatile void * addr)
114 { 114 {
115 int mask; 115 int mask;
116 unsigned long *ADDR = (unsigned long *) addr; 116 unsigned long *ADDR = (unsigned long *) addr;
117 117
118 ADDR += nr >> 5; 118 ADDR += nr >> 5;
119 mask = 1 << (nr & 31); 119 mask = 1 << (nr & 31);
120 *ADDR ^= mask; 120 *ADDR ^= mask;
121 } 121 }
122 122
123 extern __inline__ int test_and_set_bit(int nr, volatile void * addr) 123 extern __inline__ int test_and_set_bit(int nr, volatile void * addr)
124 { 124 {
125 int mask, retval; 125 int mask, retval;
126 volatile unsigned int *a = (volatile unsigned int *) addr; 126 volatile unsigned int *a = (volatile unsigned int *) addr;
127 unsigned long flags; 127 unsigned long flags;
128 128
129 a += nr >> 5; 129 a += nr >> 5;
130 mask = 1 << (nr & 0x1f); 130 mask = 1 << (nr & 0x1f);
131 save_flags_cli(flags); 131 save_flags_cli(flags);
132 retval = (mask & *a) != 0; 132 retval = (mask & *a) != 0;
133 *a |= mask; 133 *a |= mask;
134 restore_flags(flags); 134 restore_flags(flags);
135 135
136 return retval; 136 return retval;
137 } 137 }
138 138
139 extern __inline__ int __test_and_set_bit(int nr, volatile void * addr) 139 extern __inline__ int __test_and_set_bit(int nr, volatile void * addr)
140 { 140 {
141 int mask, retval; 141 int mask, retval;
142 volatile unsigned int *a = (volatile unsigned int *) addr; 142 volatile unsigned int *a = (volatile unsigned int *) addr;
143 143
144 a += nr >> 5; 144 a += nr >> 5;
145 mask = 1 << (nr & 0x1f); 145 mask = 1 << (nr & 0x1f);
146 retval = (mask & *a) != 0; 146 retval = (mask & *a) != 0;
147 *a |= mask; 147 *a |= mask;
148 return retval; 148 return retval;
149 } 149 }
150 150
151 extern __inline__ int test_and_clear_bit(int nr, volatile void * addr) 151 extern __inline__ int test_and_clear_bit(int nr, volatile void * addr)
152 { 152 {
153 int mask, retval; 153 int mask, retval;
154 volatile unsigned int *a = (volatile unsigned int *) addr; 154 volatile unsigned int *a = (volatile unsigned int *) addr;
155 unsigned long flags; 155 unsigned long flags;
156 156
157 a += nr >> 5; 157 a += nr >> 5;
158 mask = 1 << (nr & 0x1f); 158 mask = 1 << (nr & 0x1f);
159 save_flags_cli(flags); 159 save_flags_cli(flags);
160 retval = (mask & *a) != 0; 160 retval = (mask & *a) != 0;
161 *a &= ~mask; 161 *a &= ~mask;
162 restore_flags(flags); 162 restore_flags(flags);
163 163
164 return retval; 164 return retval;
165 } 165 }
166 166
167 extern __inline__ int __test_and_clear_bit(int nr, volatile void * addr) 167 extern __inline__ int __test_and_clear_bit(int nr, volatile void * addr)
168 { 168 {
169 int mask, retval; 169 int mask, retval;
170 volatile unsigned int *a = (volatile unsigned int *) addr; 170 volatile unsigned int *a = (volatile unsigned int *) addr;
171 171
172 a += nr >> 5; 172 a += nr >> 5;
173 mask = 1 << (nr & 0x1f); 173 mask = 1 << (nr & 0x1f);
174 retval = (mask & *a) != 0; 174 retval = (mask & *a) != 0;
175 *a &= ~mask; 175 *a &= ~mask;
176 return retval; 176 return retval;
177 } 177 }
178 178
179 extern __inline__ int test_and_change_bit(int nr, volatile void * addr) 179 extern __inline__ int test_and_change_bit(int nr, volatile void * addr)
180 { 180 {
181 int mask, retval; 181 int mask, retval;
182 volatile unsigned int *a = (volatile unsigned int *) addr; 182 volatile unsigned int *a = (volatile unsigned int *) addr;
183 unsigned long flags; 183 unsigned long flags;
184 184
185 a += nr >> 5; 185 a += nr >> 5;
186 mask = 1 << (nr & 0x1f); 186 mask = 1 << (nr & 0x1f);
187 save_flags_cli(flags); 187 save_flags_cli(flags);
188 retval = (mask & *a) != 0; 188 retval = (mask & *a) != 0;
189 *a ^= mask; 189 *a ^= mask;
190 restore_flags(flags); 190 restore_flags(flags);
191 191
192 return retval; 192 return retval;
193 } 193 }
194 194
195 extern __inline__ int __test_and_change_bit(int nr, volatile void * addr) 195 extern __inline__ int __test_and_change_bit(int nr, volatile void * addr)
196 { 196 {
197 int mask, retval; 197 int mask, retval;
198 volatile unsigned int *a = (volatile unsigned int *) addr; 198 volatile unsigned int *a = (volatile unsigned int *) addr;
199 199
200 a += nr >> 5; 200 a += nr >> 5;
201 mask = 1 << (nr & 0x1f); 201 mask = 1 << (nr & 0x1f);
202 retval = (mask & *a) != 0; 202 retval = (mask & *a) != 0;
203 *a ^= mask; 203 *a ^= mask;
204 return retval; 204 return retval;
205 } 205 }
206 206
207 /* 207 /*
208 * This routine doesn't need to be atomic. 208 * This routine doesn't need to be atomic.
209 */ 209 */
210 extern __inline__ int __constant_test_bit(int nr, const volatile void * addr) 210 extern __inline__ int __constant_test_bit(int nr, const volatile void * addr)
211 { 211 {
212 return ((1UL << (nr & 31)) & (((const volatile unsigned int *) addr)[nr >> 5])) != 0; 212 return ((1UL << (nr & 31)) & (((const volatile unsigned int *) addr)[nr >> 5])) != 0;
213 } 213 }
214 214
215 extern __inline__ int __test_bit(int nr, volatile void * addr) 215 extern __inline__ int __test_bit(int nr, volatile void * addr)
216 { 216 {
217 int * a = (int *) addr; 217 int * a = (int *) addr;
218 int mask; 218 int mask;
219 219
220 a += nr >> 5; 220 a += nr >> 5;
221 mask = 1 << (nr & 0x1f); 221 mask = 1 << (nr & 0x1f);
222 return ((mask & *a) != 0); 222 return ((mask & *a) != 0);
223 } 223 }
224 224
225 #define test_bit(nr,addr) \ 225 #define test_bit(nr,addr) \
226 (__builtin_constant_p(nr) ? \ 226 (__builtin_constant_p(nr) ? \
227 __constant_test_bit((nr),(addr)) : \ 227 __constant_test_bit((nr),(addr)) : \
228 __test_bit((nr),(addr))) 228 __test_bit((nr),(addr)))
229 229
230 #define find_first_zero_bit(addr, size) \ 230 #define find_first_zero_bit(addr, size) \
231 find_next_zero_bit((addr), (size), 0) 231 find_next_zero_bit((addr), (size), 0)
232 232
233 extern __inline__ int find_next_zero_bit (void * addr, int size, int offset) 233 extern __inline__ int find_next_zero_bit (void * addr, int size, int offset)
234 { 234 {
235 unsigned long *p = ((unsigned long *) addr) + (offset >> 5); 235 unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
236 unsigned long result = offset & ~31UL; 236 unsigned long result = offset & ~31UL;
237 unsigned long tmp; 237 unsigned long tmp;
238 238
239 if (offset >= size) 239 if (offset >= size)
240 return size; 240 return size;
241 size -= result; 241 size -= result;
242 offset &= 31UL; 242 offset &= 31UL;
243 if (offset) { 243 if (offset) {
244 tmp = *(p++); 244 tmp = *(p++);
245 tmp |= ~0UL >> (32-offset); 245 tmp |= ~0UL >> (32-offset);
246 if (size < 32) 246 if (size < 32)
247 goto found_first; 247 goto found_first;
248 if (~tmp) 248 if (~tmp)
249 goto found_middle; 249 goto found_middle;
250 size -= 32; 250 size -= 32;
251 result += 32; 251 result += 32;
252 } 252 }
253 while (size & ~31UL) { 253 while (size & ~31UL) {
254 if (~(tmp = *(p++))) 254 if (~(tmp = *(p++)))
255 goto found_middle; 255 goto found_middle;
256 result += 32; 256 result += 32;
257 size -= 32; 257 size -= 32;
258 } 258 }
259 if (!size) 259 if (!size)
260 return result; 260 return result;
261 tmp = *p; 261 tmp = *p;
262 262
263 found_first: 263 found_first:
264 tmp |= ~0UL >> size; 264 tmp |= ~0UL >> size;
265 found_middle: 265 found_middle:
266 return result + ffz(tmp); 266 return result + ffz(tmp);
267 } 267 }
268 268
269 #define ffs(x) generic_ffs(x)
270
271 /* 269 /*
272 * hweightN: returns the hamming weight (i.e. the number 270 * hweightN: returns the hamming weight (i.e. the number
273 * of bits set) of a N-bit word 271 * of bits set) of a N-bit word
274 */ 272 */
275 273
276 #define hweight32(x) generic_hweight32(x) 274 #define hweight32(x) generic_hweight32(x)
277 #define hweight16(x) generic_hweight16(x) 275 #define hweight16(x) generic_hweight16(x)
278 #define hweight8(x) generic_hweight8(x) 276 #define hweight8(x) generic_hweight8(x)
279 277
280 278
281 extern __inline__ int ext2_set_bit(int nr, volatile void * addr) 279 extern __inline__ int ext2_set_bit(int nr, volatile void * addr)
282 { 280 {
283 int mask, retval; 281 int mask, retval;
284 unsigned long flags; 282 unsigned long flags;
285 volatile unsigned char *ADDR = (unsigned char *) addr; 283 volatile unsigned char *ADDR = (unsigned char *) addr;
286 284
287 ADDR += nr >> 3; 285 ADDR += nr >> 3;
288 mask = 1 << (nr & 0x07); 286 mask = 1 << (nr & 0x07);
289 save_flags_cli(flags); 287 save_flags_cli(flags);
290 retval = (mask & *ADDR) != 0; 288 retval = (mask & *ADDR) != 0;
291 *ADDR |= mask; 289 *ADDR |= mask;
292 restore_flags(flags); 290 restore_flags(flags);
293 return retval; 291 return retval;
294 } 292 }
295 293
296 extern __inline__ int ext2_clear_bit(int nr, volatile void * addr) 294 extern __inline__ int ext2_clear_bit(int nr, volatile void * addr)
297 { 295 {
298 int mask, retval; 296 int mask, retval;
299 unsigned long flags; 297 unsigned long flags;
300 volatile unsigned char *ADDR = (unsigned char *) addr; 298 volatile unsigned char *ADDR = (unsigned char *) addr;
301 299
302 ADDR += nr >> 3; 300 ADDR += nr >> 3;
303 mask = 1 << (nr & 0x07); 301 mask = 1 << (nr & 0x07);
304 save_flags_cli(flags); 302 save_flags_cli(flags);
305 retval = (mask & *ADDR) != 0; 303 retval = (mask & *ADDR) != 0;
306 *ADDR &= ~mask; 304 *ADDR &= ~mask;
307 restore_flags(flags); 305 restore_flags(flags);
308 return retval; 306 return retval;
309 } 307 }
310 308
311 extern __inline__ int ext2_test_bit(int nr, const volatile void * addr) 309 extern __inline__ int ext2_test_bit(int nr, const volatile void * addr)
312 { 310 {
313 int mask; 311 int mask;
314 const volatile unsigned char *ADDR = (const unsigned char *) addr; 312 const volatile unsigned char *ADDR = (const unsigned char *) addr;
315 313
316 ADDR += nr >> 3; 314 ADDR += nr >> 3;
317 mask = 1 << (nr & 0x07); 315 mask = 1 << (nr & 0x07);
318 return ((mask & *ADDR) != 0); 316 return ((mask & *ADDR) != 0);
319 } 317 }
320 318
321 #define ext2_find_first_zero_bit(addr, size) \ 319 #define ext2_find_first_zero_bit(addr, size) \
322 ext2_find_next_zero_bit((addr), (size), 0) 320 ext2_find_next_zero_bit((addr), (size), 0)
323 321
324 extern __inline__ unsigned long ext2_find_next_zero_bit(void *addr, unsigned long size, unsigned long offset) 322 extern __inline__ unsigned long ext2_find_next_zero_bit(void *addr, unsigned long size, unsigned long offset)
325 { 323 {
326 unsigned long *p = ((unsigned long *) addr) + (offset >> 5); 324 unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
327 unsigned long result = offset & ~31UL; 325 unsigned long result = offset & ~31UL;
328 unsigned long tmp; 326 unsigned long tmp;
329 327
330 if (offset >= size) 328 if (offset >= size)
331 return size; 329 return size;
332 size -= result; 330 size -= result;
333 offset &= 31UL; 331 offset &= 31UL;
334 if(offset) { 332 if(offset) {
335 /* We hold the little endian value in tmp, but then the 333 /* We hold the little endian value in tmp, but then the
336 * shift is illegal. So we could keep a big endian value 334 * shift is illegal. So we could keep a big endian value
337 * in tmp, like this: 335 * in tmp, like this:
338 * 336 *
339 * tmp = __swab32(*(p++)); 337 * tmp = __swab32(*(p++));
340 * tmp |= ~0UL >> (32-offset); 338 * tmp |= ~0UL >> (32-offset);
341 * 339 *
342 * but this would decrease preformance, so we change the 340 * but this would decrease preformance, so we change the
343 * shift: 341 * shift:
344 */ 342 */
345 tmp = *(p++); 343 tmp = *(p++);
346 tmp |= __swab32(~0UL >> (32-offset)); 344 tmp |= __swab32(~0UL >> (32-offset));
347 if(size < 32) 345 if(size < 32)
348 goto found_first; 346 goto found_first;
349 if(~tmp) 347 if(~tmp)
350 goto found_middle; 348 goto found_middle;
351 size -= 32; 349 size -= 32;
352 result += 32; 350 result += 32;
353 } 351 }
354 while(size & ~31UL) { 352 while(size & ~31UL) {
355 if(~(tmp = *(p++))) 353 if(~(tmp = *(p++)))
356 goto found_middle; 354 goto found_middle;
357 result += 32; 355 result += 32;
358 size -= 32; 356 size -= 32;
359 } 357 }
360 if(!size) 358 if(!size)
361 return result; 359 return result;
362 tmp = *p; 360 tmp = *p;
363 361
364 found_first: 362 found_first:
365 /* tmp is little endian, so we would have to swab the shift, 363 /* tmp is little endian, so we would have to swab the shift,
366 * see above. But then we have to swab tmp below for ffz, so 364 * see above. But then we have to swab tmp below for ffz, so
367 * we might as well do this here. 365 * we might as well do this here.
368 */ 366 */
369 return result + ffz(__swab32(tmp) | (~0UL << size)); 367 return result + ffz(__swab32(tmp) | (~0UL << size));
370 found_middle: 368 found_middle:
371 return result + ffz(__swab32(tmp)); 369 return result + ffz(__swab32(tmp));
372 } 370 }
373 371
374 /* Bitmap functions for the minix filesystem. */ 372 /* Bitmap functions for the minix filesystem. */
375 #define minix_test_and_set_bit(nr,addr) test_and_set_bit(nr,addr) 373 #define minix_test_and_set_bit(nr,addr) test_and_set_bit(nr,addr)
376 #define minix_set_bit(nr,addr) set_bit(nr,addr) 374 #define minix_set_bit(nr,addr) set_bit(nr,addr)
377 #define minix_test_and_clear_bit(nr,addr) test_and_clear_bit(nr,addr) 375 #define minix_test_and_clear_bit(nr,addr) test_and_clear_bit(nr,addr)
378 #define minix_test_bit(nr,addr) test_bit(nr,addr) 376 #define minix_test_bit(nr,addr) test_bit(nr,addr)
379 #define minix_find_first_zero_bit(addr,size) find_first_zero_bit(addr,size) 377 #define minix_find_first_zero_bit(addr,size) find_first_zero_bit(addr,size)
380 378
381 /** 379 /**
382 * hweightN - returns the hamming weight of a N-bit word 380 * hweightN - returns the hamming weight of a N-bit word
383 * @x: the word to weigh 381 * @x: the word to weigh
384 * 382 *
385 * The Hamming Weight of a number is the total number of bits set in it. 383 * The Hamming Weight of a number is the total number of bits set in it.
386 */ 384 */
387 385
388 #define hweight32(x) generic_hweight32(x) 386 #define hweight32(x) generic_hweight32(x)
389 #define hweight16(x) generic_hweight16(x) 387 #define hweight16(x) generic_hweight16(x)
390 #define hweight8(x) generic_hweight8(x) 388 #define hweight8(x) generic_hweight8(x)
391 389
392 #endif /* __KERNEL__ */ 390 #endif /* __KERNEL__ */
393 391
394 #endif /* _MICROBLAZE_BITOPS_H */ 392 #endif /* _MICROBLAZE_BITOPS_H */
395 393