diff options
Diffstat (limited to 'include/asm-sh')
-rw-r--r-- | include/asm-sh/addrspace.h | 2 | ||||
-rw-r--r-- | include/asm-sh/bitops.h | 348 | ||||
-rw-r--r-- | include/asm-sh/io.h | 14 | ||||
-rw-r--r-- | include/asm-sh/page.h | 5 | ||||
-rw-r--r-- | include/asm-sh/poll.h | 1 | ||||
-rw-r--r-- | include/asm-sh/stat.h | 8 | ||||
-rw-r--r-- | include/asm-sh/thread_info.h | 2 | ||||
-rw-r--r-- | include/asm-sh/types.h | 5 |
8 files changed, 21 insertions, 364 deletions
diff --git a/include/asm-sh/addrspace.h b/include/asm-sh/addrspace.h index dbb05d1a26d1..720afc11c2ca 100644 --- a/include/asm-sh/addrspace.h +++ b/include/asm-sh/addrspace.h | |||
@@ -13,7 +13,7 @@ | |||
13 | 13 | ||
14 | #include <asm/cpu/addrspace.h> | 14 | #include <asm/cpu/addrspace.h> |
15 | 15 | ||
16 | /* Memory segments (32bit Priviledged mode addresses) */ | 16 | /* Memory segments (32bit Privileged mode addresses) */ |
17 | #define P0SEG 0x00000000 | 17 | #define P0SEG 0x00000000 |
18 | #define P1SEG 0x80000000 | 18 | #define P1SEG 0x80000000 |
19 | #define P2SEG 0xa0000000 | 19 | #define P2SEG 0xa0000000 |
diff --git a/include/asm-sh/bitops.h b/include/asm-sh/bitops.h index 1c5260860045..e34f82508568 100644 --- a/include/asm-sh/bitops.h +++ b/include/asm-sh/bitops.h | |||
@@ -19,16 +19,6 @@ static __inline__ void set_bit(int nr, volatile void * addr) | |||
19 | local_irq_restore(flags); | 19 | local_irq_restore(flags); |
20 | } | 20 | } |
21 | 21 | ||
22 | static __inline__ void __set_bit(int nr, volatile void * addr) | ||
23 | { | ||
24 | int mask; | ||
25 | volatile unsigned int *a = addr; | ||
26 | |||
27 | a += nr >> 5; | ||
28 | mask = 1 << (nr & 0x1f); | ||
29 | *a |= mask; | ||
30 | } | ||
31 | |||
32 | /* | 22 | /* |
33 | * clear_bit() doesn't provide any barrier for the compiler. | 23 | * clear_bit() doesn't provide any barrier for the compiler. |
34 | */ | 24 | */ |
@@ -47,16 +37,6 @@ static __inline__ void clear_bit(int nr, volatile void * addr) | |||
47 | local_irq_restore(flags); | 37 | local_irq_restore(flags); |
48 | } | 38 | } |
49 | 39 | ||
50 | static __inline__ void __clear_bit(int nr, volatile void * addr) | ||
51 | { | ||
52 | int mask; | ||
53 | volatile unsigned int *a = addr; | ||
54 | |||
55 | a += nr >> 5; | ||
56 | mask = 1 << (nr & 0x1f); | ||
57 | *a &= ~mask; | ||
58 | } | ||
59 | |||
60 | static __inline__ void change_bit(int nr, volatile void * addr) | 40 | static __inline__ void change_bit(int nr, volatile void * addr) |
61 | { | 41 | { |
62 | int mask; | 42 | int mask; |
@@ -70,16 +50,6 @@ static __inline__ void change_bit(int nr, volatile void * addr) | |||
70 | local_irq_restore(flags); | 50 | local_irq_restore(flags); |
71 | } | 51 | } |
72 | 52 | ||
73 | static __inline__ void __change_bit(int nr, volatile void * addr) | ||
74 | { | ||
75 | int mask; | ||
76 | volatile unsigned int *a = addr; | ||
77 | |||
78 | a += nr >> 5; | ||
79 | mask = 1 << (nr & 0x1f); | ||
80 | *a ^= mask; | ||
81 | } | ||
82 | |||
83 | static __inline__ int test_and_set_bit(int nr, volatile void * addr) | 53 | static __inline__ int test_and_set_bit(int nr, volatile void * addr) |
84 | { | 54 | { |
85 | int mask, retval; | 55 | int mask, retval; |
@@ -96,19 +66,6 @@ static __inline__ int test_and_set_bit(int nr, volatile void * addr) | |||
96 | return retval; | 66 | return retval; |
97 | } | 67 | } |
98 | 68 | ||
99 | static __inline__ int __test_and_set_bit(int nr, volatile void * addr) | ||
100 | { | ||
101 | int mask, retval; | ||
102 | volatile unsigned int *a = addr; | ||
103 | |||
104 | a += nr >> 5; | ||
105 | mask = 1 << (nr & 0x1f); | ||
106 | retval = (mask & *a) != 0; | ||
107 | *a |= mask; | ||
108 | |||
109 | return retval; | ||
110 | } | ||
111 | |||
112 | static __inline__ int test_and_clear_bit(int nr, volatile void * addr) | 69 | static __inline__ int test_and_clear_bit(int nr, volatile void * addr) |
113 | { | 70 | { |
114 | int mask, retval; | 71 | int mask, retval; |
@@ -125,19 +82,6 @@ static __inline__ int test_and_clear_bit(int nr, volatile void * addr) | |||
125 | return retval; | 82 | return retval; |
126 | } | 83 | } |
127 | 84 | ||
128 | static __inline__ int __test_and_clear_bit(int nr, volatile void * addr) | ||
129 | { | ||
130 | int mask, retval; | ||
131 | volatile unsigned int *a = addr; | ||
132 | |||
133 | a += nr >> 5; | ||
134 | mask = 1 << (nr & 0x1f); | ||
135 | retval = (mask & *a) != 0; | ||
136 | *a &= ~mask; | ||
137 | |||
138 | return retval; | ||
139 | } | ||
140 | |||
141 | static __inline__ int test_and_change_bit(int nr, volatile void * addr) | 85 | static __inline__ int test_and_change_bit(int nr, volatile void * addr) |
142 | { | 86 | { |
143 | int mask, retval; | 87 | int mask, retval; |
@@ -154,23 +98,7 @@ static __inline__ int test_and_change_bit(int nr, volatile void * addr) | |||
154 | return retval; | 98 | return retval; |
155 | } | 99 | } |
156 | 100 | ||
157 | static __inline__ int __test_and_change_bit(int nr, volatile void * addr) | 101 | #include <asm-generic/bitops/non-atomic.h> |
158 | { | ||
159 | int mask, retval; | ||
160 | volatile unsigned int *a = addr; | ||
161 | |||
162 | a += nr >> 5; | ||
163 | mask = 1 << (nr & 0x1f); | ||
164 | retval = (mask & *a) != 0; | ||
165 | *a ^= mask; | ||
166 | |||
167 | return retval; | ||
168 | } | ||
169 | |||
170 | static __inline__ int test_bit(int nr, const volatile void *addr) | ||
171 | { | ||
172 | return 1UL & (((const volatile unsigned int *) addr)[nr >> 5] >> (nr & 31)); | ||
173 | } | ||
174 | 102 | ||
175 | static __inline__ unsigned long ffz(unsigned long word) | 103 | static __inline__ unsigned long ffz(unsigned long word) |
176 | { | 104 | { |
@@ -206,271 +134,15 @@ static __inline__ unsigned long __ffs(unsigned long word) | |||
206 | return result; | 134 | return result; |
207 | } | 135 | } |
208 | 136 | ||
209 | /** | 137 | #include <asm-generic/bitops/find.h> |
210 | * find_next_bit - find the next set bit in a memory region | 138 | #include <asm-generic/bitops/ffs.h> |
211 | * @addr: The address to base the search on | 139 | #include <asm-generic/bitops/hweight.h> |
212 | * @offset: The bitnumber to start searching at | 140 | #include <asm-generic/bitops/sched.h> |
213 | * @size: The maximum size to search | 141 | #include <asm-generic/bitops/ext2-non-atomic.h> |
214 | */ | 142 | #include <asm-generic/bitops/ext2-atomic.h> |
215 | static __inline__ unsigned long find_next_bit(const unsigned long *addr, | 143 | #include <asm-generic/bitops/minix.h> |
216 | unsigned long size, unsigned long offset) | 144 | #include <asm-generic/bitops/fls.h> |
217 | { | 145 | #include <asm-generic/bitops/fls64.h> |
218 | unsigned int *p = ((unsigned int *) addr) + (offset >> 5); | ||
219 | unsigned int result = offset & ~31UL; | ||
220 | unsigned int tmp; | ||
221 | |||
222 | if (offset >= size) | ||
223 | return size; | ||
224 | size -= result; | ||
225 | offset &= 31UL; | ||
226 | if (offset) { | ||
227 | tmp = *p++; | ||
228 | tmp &= ~0UL << offset; | ||
229 | if (size < 32) | ||
230 | goto found_first; | ||
231 | if (tmp) | ||
232 | goto found_middle; | ||
233 | size -= 32; | ||
234 | result += 32; | ||
235 | } | ||
236 | while (size >= 32) { | ||
237 | if ((tmp = *p++) != 0) | ||
238 | goto found_middle; | ||
239 | result += 32; | ||
240 | size -= 32; | ||
241 | } | ||
242 | if (!size) | ||
243 | return result; | ||
244 | tmp = *p; | ||
245 | |||
246 | found_first: | ||
247 | tmp &= ~0UL >> (32 - size); | ||
248 | if (tmp == 0UL) /* Are any bits set? */ | ||
249 | return result + size; /* Nope. */ | ||
250 | found_middle: | ||
251 | return result + __ffs(tmp); | ||
252 | } | ||
253 | |||
254 | /** | ||
255 | * find_first_bit - find the first set bit in a memory region | ||
256 | * @addr: The address to start the search at | ||
257 | * @size: The maximum size to search | ||
258 | * | ||
259 | * Returns the bit-number of the first set bit, not the number of the byte | ||
260 | * containing a bit. | ||
261 | */ | ||
262 | #define find_first_bit(addr, size) \ | ||
263 | find_next_bit((addr), (size), 0) | ||
264 | |||
265 | static __inline__ int find_next_zero_bit(const unsigned long *addr, int size, int offset) | ||
266 | { | ||
267 | const unsigned long *p = ((unsigned long *) addr) + (offset >> 5); | ||
268 | unsigned long result = offset & ~31UL; | ||
269 | unsigned long tmp; | ||
270 | |||
271 | if (offset >= size) | ||
272 | return size; | ||
273 | size -= result; | ||
274 | offset &= 31UL; | ||
275 | if (offset) { | ||
276 | tmp = *(p++); | ||
277 | tmp |= ~0UL >> (32-offset); | ||
278 | if (size < 32) | ||
279 | goto found_first; | ||
280 | if (~tmp) | ||
281 | goto found_middle; | ||
282 | size -= 32; | ||
283 | result += 32; | ||
284 | } | ||
285 | while (size & ~31UL) { | ||
286 | if (~(tmp = *(p++))) | ||
287 | goto found_middle; | ||
288 | result += 32; | ||
289 | size -= 32; | ||
290 | } | ||
291 | if (!size) | ||
292 | return result; | ||
293 | tmp = *p; | ||
294 | |||
295 | found_first: | ||
296 | tmp |= ~0UL << size; | ||
297 | found_middle: | ||
298 | return result + ffz(tmp); | ||
299 | } | ||
300 | |||
301 | #define find_first_zero_bit(addr, size) \ | ||
302 | find_next_zero_bit((addr), (size), 0) | ||
303 | |||
304 | /* | ||
305 | * ffs: find first bit set. This is defined the same way as | ||
306 | * the libc and compiler builtin ffs routines, therefore | ||
307 | * differs in spirit from the above ffz (man ffs). | ||
308 | */ | ||
309 | |||
310 | #define ffs(x) generic_ffs(x) | ||
311 | |||
312 | /* | ||
313 | * hweightN: returns the hamming weight (i.e. the number | ||
314 | * of bits set) of a N-bit word | ||
315 | */ | ||
316 | |||
317 | #define hweight32(x) generic_hweight32(x) | ||
318 | #define hweight16(x) generic_hweight16(x) | ||
319 | #define hweight8(x) generic_hweight8(x) | ||
320 | |||
321 | /* | ||
322 | * Every architecture must define this function. It's the fastest | ||
323 | * way of searching a 140-bit bitmap where the first 100 bits are | ||
324 | * unlikely to be set. It's guaranteed that at least one of the 140 | ||
325 | * bits is cleared. | ||
326 | */ | ||
327 | |||
328 | static inline int sched_find_first_bit(const unsigned long *b) | ||
329 | { | ||
330 | if (unlikely(b[0])) | ||
331 | return __ffs(b[0]); | ||
332 | if (unlikely(b[1])) | ||
333 | return __ffs(b[1]) + 32; | ||
334 | if (unlikely(b[2])) | ||
335 | return __ffs(b[2]) + 64; | ||
336 | if (b[3]) | ||
337 | return __ffs(b[3]) + 96; | ||
338 | return __ffs(b[4]) + 128; | ||
339 | } | ||
340 | |||
341 | #ifdef __LITTLE_ENDIAN__ | ||
342 | #define ext2_set_bit(nr, addr) test_and_set_bit((nr), (addr)) | ||
343 | #define ext2_clear_bit(nr, addr) test_and_clear_bit((nr), (addr)) | ||
344 | #define ext2_test_bit(nr, addr) test_bit((nr), (addr)) | ||
345 | #define ext2_find_first_zero_bit(addr, size) find_first_zero_bit((addr), (size)) | ||
346 | #define ext2_find_next_zero_bit(addr, size, offset) \ | ||
347 | find_next_zero_bit((unsigned long *)(addr), (size), (offset)) | ||
348 | #else | ||
349 | static __inline__ int ext2_set_bit(int nr, volatile void * addr) | ||
350 | { | ||
351 | int mask, retval; | ||
352 | unsigned long flags; | ||
353 | volatile unsigned char *ADDR = (unsigned char *) addr; | ||
354 | |||
355 | ADDR += nr >> 3; | ||
356 | mask = 1 << (nr & 0x07); | ||
357 | local_irq_save(flags); | ||
358 | retval = (mask & *ADDR) != 0; | ||
359 | *ADDR |= mask; | ||
360 | local_irq_restore(flags); | ||
361 | return retval; | ||
362 | } | ||
363 | |||
364 | static __inline__ int ext2_clear_bit(int nr, volatile void * addr) | ||
365 | { | ||
366 | int mask, retval; | ||
367 | unsigned long flags; | ||
368 | volatile unsigned char *ADDR = (unsigned char *) addr; | ||
369 | |||
370 | ADDR += nr >> 3; | ||
371 | mask = 1 << (nr & 0x07); | ||
372 | local_irq_save(flags); | ||
373 | retval = (mask & *ADDR) != 0; | ||
374 | *ADDR &= ~mask; | ||
375 | local_irq_restore(flags); | ||
376 | return retval; | ||
377 | } | ||
378 | |||
379 | static __inline__ int ext2_test_bit(int nr, const volatile void * addr) | ||
380 | { | ||
381 | int mask; | ||
382 | const volatile unsigned char *ADDR = (const unsigned char *) addr; | ||
383 | |||
384 | ADDR += nr >> 3; | ||
385 | mask = 1 << (nr & 0x07); | ||
386 | return ((mask & *ADDR) != 0); | ||
387 | } | ||
388 | |||
389 | #define ext2_find_first_zero_bit(addr, size) \ | ||
390 | ext2_find_next_zero_bit((addr), (size), 0) | ||
391 | |||
392 | static __inline__ unsigned long ext2_find_next_zero_bit(void *addr, unsigned long size, unsigned long offset) | ||
393 | { | ||
394 | unsigned long *p = ((unsigned long *) addr) + (offset >> 5); | ||
395 | unsigned long result = offset & ~31UL; | ||
396 | unsigned long tmp; | ||
397 | |||
398 | if (offset >= size) | ||
399 | return size; | ||
400 | size -= result; | ||
401 | offset &= 31UL; | ||
402 | if(offset) { | ||
403 | /* We hold the little endian value in tmp, but then the | ||
404 | * shift is illegal. So we could keep a big endian value | ||
405 | * in tmp, like this: | ||
406 | * | ||
407 | * tmp = __swab32(*(p++)); | ||
408 | * tmp |= ~0UL >> (32-offset); | ||
409 | * | ||
410 | * but this would decrease preformance, so we change the | ||
411 | * shift: | ||
412 | */ | ||
413 | tmp = *(p++); | ||
414 | tmp |= __swab32(~0UL >> (32-offset)); | ||
415 | if(size < 32) | ||
416 | goto found_first; | ||
417 | if(~tmp) | ||
418 | goto found_middle; | ||
419 | size -= 32; | ||
420 | result += 32; | ||
421 | } | ||
422 | while(size & ~31UL) { | ||
423 | if(~(tmp = *(p++))) | ||
424 | goto found_middle; | ||
425 | result += 32; | ||
426 | size -= 32; | ||
427 | } | ||
428 | if(!size) | ||
429 | return result; | ||
430 | tmp = *p; | ||
431 | |||
432 | found_first: | ||
433 | /* tmp is little endian, so we would have to swab the shift, | ||
434 | * see above. But then we have to swab tmp below for ffz, so | ||
435 | * we might as well do this here. | ||
436 | */ | ||
437 | return result + ffz(__swab32(tmp) | (~0UL << size)); | ||
438 | found_middle: | ||
439 | return result + ffz(__swab32(tmp)); | ||
440 | } | ||
441 | #endif | ||
442 | |||
443 | #define ext2_set_bit_atomic(lock, nr, addr) \ | ||
444 | ({ \ | ||
445 | int ret; \ | ||
446 | spin_lock(lock); \ | ||
447 | ret = ext2_set_bit((nr), (addr)); \ | ||
448 | spin_unlock(lock); \ | ||
449 | ret; \ | ||
450 | }) | ||
451 | |||
452 | #define ext2_clear_bit_atomic(lock, nr, addr) \ | ||
453 | ({ \ | ||
454 | int ret; \ | ||
455 | spin_lock(lock); \ | ||
456 | ret = ext2_clear_bit((nr), (addr)); \ | ||
457 | spin_unlock(lock); \ | ||
458 | ret; \ | ||
459 | }) | ||
460 | |||
461 | /* Bitmap functions for the minix filesystem. */ | ||
462 | #define minix_test_and_set_bit(nr,addr) test_and_set_bit(nr,addr) | ||
463 | #define minix_set_bit(nr,addr) set_bit(nr,addr) | ||
464 | #define minix_test_and_clear_bit(nr,addr) test_and_clear_bit(nr,addr) | ||
465 | #define minix_test_bit(nr,addr) test_bit(nr,addr) | ||
466 | #define minix_find_first_zero_bit(addr,size) find_first_zero_bit(addr,size) | ||
467 | |||
468 | /* | ||
469 | * fls: find last bit set. | ||
470 | */ | ||
471 | |||
472 | #define fls(x) generic_fls(x) | ||
473 | #define fls64(x) generic_fls64(x) | ||
474 | 146 | ||
475 | #endif /* __KERNEL__ */ | 147 | #endif /* __KERNEL__ */ |
476 | 148 | ||
diff --git a/include/asm-sh/io.h b/include/asm-sh/io.h index b0b2937b6f83..2c3afe71323d 100644 --- a/include/asm-sh/io.h +++ b/include/asm-sh/io.h | |||
@@ -174,20 +174,6 @@ static inline void __set_io_port_base(unsigned long pbase) | |||
174 | generic_io_base = pbase; | 174 | generic_io_base = pbase; |
175 | } | 175 | } |
176 | 176 | ||
177 | #define isa_readb(a) readb(ioport_map(a, 1)) | ||
178 | #define isa_readw(a) readw(ioport_map(a, 2)) | ||
179 | #define isa_readl(a) readl(ioport_map(a, 4)) | ||
180 | #define isa_writeb(b,a) writeb(b,ioport_map(a, 1)) | ||
181 | #define isa_writew(w,a) writew(w,ioport_map(a, 2)) | ||
182 | #define isa_writel(l,a) writel(l,ioport_map(a, 4)) | ||
183 | |||
184 | #define isa_memset_io(a,b,c) \ | ||
185 | memset((void *)(ioport_map((unsigned long)(a), 1)),(b),(c)) | ||
186 | #define isa_memcpy_fromio(a,b,c) \ | ||
187 | memcpy((a),(void *)(ioport_map((unsigned long)(b), 1)),(c)) | ||
188 | #define isa_memcpy_toio(a,b,c) \ | ||
189 | memcpy((void *)(ioport_map((unsigned long)(a), 1)),(b),(c)) | ||
190 | |||
191 | /* We really want to try and get these to memcpy etc */ | 177 | /* We really want to try and get these to memcpy etc */ |
192 | extern void memcpy_fromio(void *, volatile void __iomem *, unsigned long); | 178 | extern void memcpy_fromio(void *, volatile void __iomem *, unsigned long); |
193 | extern void memcpy_toio(volatile void __iomem *, const void *, unsigned long); | 179 | extern void memcpy_toio(volatile void __iomem *, const void *, unsigned long); |
diff --git a/include/asm-sh/page.h b/include/asm-sh/page.h index 972c3f655b2a..9c89287c3e56 100644 --- a/include/asm-sh/page.h +++ b/include/asm-sh/page.h | |||
@@ -105,9 +105,7 @@ typedef struct { unsigned long pgprot; } pgprot_t; | |||
105 | 105 | ||
106 | /* PFN start number, because of __MEMORY_START */ | 106 | /* PFN start number, because of __MEMORY_START */ |
107 | #define PFN_START (__MEMORY_START >> PAGE_SHIFT) | 107 | #define PFN_START (__MEMORY_START >> PAGE_SHIFT) |
108 | 108 | #define ARCH_PFN_OFFSET (FPN_START) | |
109 | #define pfn_to_page(pfn) (mem_map + (pfn) - PFN_START) | ||
110 | #define page_to_pfn(page) ((unsigned long)((page) - mem_map) + PFN_START) | ||
111 | #define virt_to_page(kaddr) pfn_to_page(__pa(kaddr) >> PAGE_SHIFT) | 109 | #define virt_to_page(kaddr) pfn_to_page(__pa(kaddr) >> PAGE_SHIFT) |
112 | #define pfn_valid(pfn) (((pfn) - PFN_START) < max_mapnr) | 110 | #define pfn_valid(pfn) (((pfn) - PFN_START) < max_mapnr) |
113 | #define virt_addr_valid(kaddr) pfn_valid(__pa(kaddr) >> PAGE_SHIFT) | 111 | #define virt_addr_valid(kaddr) pfn_valid(__pa(kaddr) >> PAGE_SHIFT) |
@@ -117,6 +115,7 @@ typedef struct { unsigned long pgprot; } pgprot_t; | |||
117 | 115 | ||
118 | #endif /* __KERNEL__ */ | 116 | #endif /* __KERNEL__ */ |
119 | 117 | ||
118 | #include <asm-generic/memory_model.h> | ||
120 | #include <asm-generic/page.h> | 119 | #include <asm-generic/page.h> |
121 | 120 | ||
122 | #endif /* __ASM_SH_PAGE_H */ | 121 | #endif /* __ASM_SH_PAGE_H */ |
diff --git a/include/asm-sh/poll.h b/include/asm-sh/poll.h index 52f95b9188dc..dbca9b32f4a6 100644 --- a/include/asm-sh/poll.h +++ b/include/asm-sh/poll.h | |||
@@ -16,6 +16,7 @@ | |||
16 | #define POLLWRBAND 0x0200 | 16 | #define POLLWRBAND 0x0200 |
17 | #define POLLMSG 0x0400 | 17 | #define POLLMSG 0x0400 |
18 | #define POLLREMOVE 0x1000 | 18 | #define POLLREMOVE 0x1000 |
19 | #define POLLRDHUP 0x2000 | ||
19 | 20 | ||
20 | struct pollfd { | 21 | struct pollfd { |
21 | int fd; | 22 | int fd; |
diff --git a/include/asm-sh/stat.h b/include/asm-sh/stat.h index 914e3fcbbd37..6c41a60657f1 100644 --- a/include/asm-sh/stat.h +++ b/include/asm-sh/stat.h | |||
@@ -60,13 +60,7 @@ struct stat64 { | |||
60 | long long st_size; | 60 | long long st_size; |
61 | unsigned long st_blksize; | 61 | unsigned long st_blksize; |
62 | 62 | ||
63 | #if defined(__BIG_ENDIAN__) | 63 | unsigned long long st_blocks; /* Number 512-byte blocks allocated. */ |
64 | unsigned long __pad4; /* Future possible st_blocks hi bits */ | ||
65 | unsigned long st_blocks; /* Number 512-byte blocks allocated. */ | ||
66 | #else /* Must be little */ | ||
67 | unsigned long st_blocks; /* Number 512-byte blocks allocated. */ | ||
68 | unsigned long __pad4; /* Future possible st_blocks hi bits */ | ||
69 | #endif | ||
70 | 64 | ||
71 | unsigned long st_atime; | 65 | unsigned long st_atime; |
72 | unsigned long st_atime_nsec; | 66 | unsigned long st_atime_nsec; |
diff --git a/include/asm-sh/thread_info.h b/include/asm-sh/thread_info.h index 85f0c11b4319..7345350d98c0 100644 --- a/include/asm-sh/thread_info.h +++ b/include/asm-sh/thread_info.h | |||
@@ -18,7 +18,7 @@ | |||
18 | struct thread_info { | 18 | struct thread_info { |
19 | struct task_struct *task; /* main task structure */ | 19 | struct task_struct *task; /* main task structure */ |
20 | struct exec_domain *exec_domain; /* execution domain */ | 20 | struct exec_domain *exec_domain; /* execution domain */ |
21 | __u32 flags; /* low level flags */ | 21 | unsigned long flags; /* low level flags */ |
22 | __u32 cpu; | 22 | __u32 cpu; |
23 | int preempt_count; /* 0 => preemptable, <0 => BUG */ | 23 | int preempt_count; /* 0 => preemptable, <0 => BUG */ |
24 | struct restart_block restart_block; | 24 | struct restart_block restart_block; |
diff --git a/include/asm-sh/types.h b/include/asm-sh/types.h index cb7e183a0a6b..488552f43b2a 100644 --- a/include/asm-sh/types.h +++ b/include/asm-sh/types.h | |||
@@ -58,6 +58,11 @@ typedef u64 sector_t; | |||
58 | #define HAVE_SECTOR_T | 58 | #define HAVE_SECTOR_T |
59 | #endif | 59 | #endif |
60 | 60 | ||
61 | #ifdef CONFIG_LSF | ||
62 | typedef u64 blkcnt_t; | ||
63 | #define HAVE_BLKCNT_T | ||
64 | #endif | ||
65 | |||
61 | #endif /* __ASSEMBLY__ */ | 66 | #endif /* __ASSEMBLY__ */ |
62 | 67 | ||
63 | #endif /* __KERNEL__ */ | 68 | #endif /* __KERNEL__ */ |