incorporate patches from marc in bug #273 to add support for nios2

3 files changed, 12940 insertions, 1 deletions

diff --git a/toolchain/kernel-headers/Config.in b/toolchain/kernel-headers/Config.in
index af0237f6d..e0303836d 100644
--- a/toolchain/kernel-headers/Config.in
+++ b/toolchain/kernel-headers/Config.in
@@ -13,21 +13,30 @@ choice
 	  the kernel you intend to use on your target system.
 
 	config BR2_KERNEL_HEADERS_2_4_25
+		depends !BR2_nios2
 		bool "Linux 2.4.25 kernel headers"
 
 	config BR2_KERNEL_HEADERS_2_4_27
+		depends !BR2_nios2
 		bool "Linux 2.4.27 kernel headers"
 
 	config BR2_KERNEL_HEADERS_2_4_29
+		depends !BR2_nios2
 		bool "Linux 2.4.29 kernel headers"
 
 	config BR2_KERNEL_HEADERS_2_4_31
+		depends !BR2_nios2
 		bool "Linux 2.4.31 kernel headers"
 
+	config BR2_KERNEL_HEADERS_2_6_9
+		bool "Linux 2.6.9 kernel headers"
+
 	config BR2_KERNEL_HEADERS_2_6_11
+		depends !BR2_nios2
 		bool "Linux 2.6.11 kernel headers"
 
 	config BR2_KERNEL_HEADERS_2_6_12
+		depends !BR2_nios2
 		bool "Linux 2.6.12 kernel headers"
 
 endchoice
@@ -38,6 +47,6 @@ config BR2_DEFAULT_KERNEL_HEADERS
 	default "2.4.27"    if BR2_KERNEL_HEADERS_2_4_27
 	default "2.4.29"    if BR2_KERNEL_HEADERS_2_4_29
 	default "2.4.31"    if BR2_KERNEL_HEADERS_2_4_31
+	default "2.6.9"     if BR2_KERNEL_HEADERS_2_6_9
 	default "2.6.11"    if BR2_KERNEL_HEADERS_2_6_11
 	default "2.6.12"    if BR2_KERNEL_HEADERS_2_6_12
-
diff --git a/toolchain/kernel-headers/kernel-headers.mk b/toolchain/kernel-headers/kernel-headers.mk
index 64b88dd7e..f77afa058 100644
--- a/toolchain/kernel-headers/kernel-headers.mk
+++ b/toolchain/kernel-headers/kernel-headers.mk
@@ -106,6 +106,9 @@ endif
 
 $(LINUX_HEADERS_DIR)/.patched: $(LINUX_HEADERS_DIR)/.unpacked
 	toolchain/patch-kernel.sh $(LINUX_HEADERS_DIR) toolchain/kernel-headers linux-libc-headers-$(LINUX_VERSION)\*.patch
+ifeq ($(strip $(ARCH)),nios2)
+	toolchain/patch-kernel.sh $(LINUX_HEADERS_DIR) toolchain/kernel-headers linux-libc-headers-$(LINUX_VERSION)-nios2nommu.patch.conditional
+endif
 	touch $(LINUX_HEADERS_DIR)/.patched
 
 $(LINUX_HEADERS_DIR)/.configured: $(LINUX_HEADERS_DIR)/.patched
@@ -124,6 +127,8 @@ $(LINUX_HEADERS_DIR)/.configured: $(LINUX_HEADERS_DIR)/.patched
 	    (cd $(LINUX_HEADERS_DIR)/include; ln -fs asm-mips$(NOMMU) asm;) \
 	elif [ "$(ARCH)" = "mipsel" ];then \
 	    (cd $(LINUX_HEADERS_DIR)/include; ln -fs asm-mips$(NOMMU) asm;) \
+	elif [ "$(ARCH)" = "nios2" ];then \
+	    (cd $(LINUX_HEADERS_DIR)/include; ln -fs asm-nios2nommu asm;) \
 	elif [ "$(ARCH)" = "arm" ];then \
 	    (cd $(LINUX_HEADERS_DIR)/include; ln -fs asm-arm$(NOMMU) asm; \
 	     cd asm; \
diff --git a/toolchain/kernel-headers/linux-libc-headers-2.6.9-nios2nommu.patch.conditional b/toolchain/kernel-headers/linux-libc-headers-2.6.9-nios2nommu.patch.conditional
new file mode 100644
index 000000000..820868ffb
--- /dev/null
+++ b/toolchain/kernel-headers/linux-libc-headers-2.6.9-nios2nommu.patch.conditional
@@ -0,0 +1,12925 @@
+--- linux-libc-headers-2.6.9.1/include/asm-generic/bitops.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/bitops.h	2004-12-08 17:39:48.000000000 +0100
+@@ -0,0 +1,81 @@
++#ifndef _ASM_GENERIC_BITOPS_H_
++#define _ASM_GENERIC_BITOPS_H_
++
++/*
++ * For the benefit of those who are trying to port Linux to another
++ * architecture, here are some C-language equivalents.  You should
++ * recode these in the native assembly language, if at all possible.
++ * To guarantee atomicity, these routines call cli() and sti() to
++ * disable interrupts while they operate.  (You have to provide inline
++ * routines to cli() and sti().)
++ *
++ * Also note, these routines assume that you have 32 bit longs.
++ * You will have to change this if you are trying to port Linux to the
++ * Alpha architecture or to a Cray.  :-)
++ * 
++ * C language equivalents written by Theodore Ts'o, 9/26/92
++ */
++
++extern __inline__ int set_bit(int nr,long * addr)
++{
++	int	mask, retval;
++
++	addr += nr >> 5;
++	mask = 1 << (nr & 0x1f);
++	cli();
++	retval = (mask & *addr) != 0;
++	*addr |= mask;
++	sti();
++	return retval;
++}
++
++extern __inline__ int clear_bit(int nr, long * addr)
++{
++	int	mask, retval;
++
++	addr += nr >> 5;
++	mask = 1 << (nr & 0x1f);
++	cli();
++	retval = (mask & *addr) != 0;
++	*addr &= ~mask;
++	sti();
++	return retval;
++}
++
++extern __inline__ int test_bit(int nr, const unsigned long * addr)
++{
++	int	mask;
++
++	addr += nr >> 5;
++	mask = 1 << (nr & 0x1f);
++	return ((mask & *addr) != 0);
++}
++
++/*
++ * fls: find last bit set.
++ */
++
++#define fls(x) generic_fls(x)
++
++#ifdef __KERNEL__
++
++/*
++ * ffs: find first bit set. This is defined the same way as
++ * the libc and compiler builtin ffs routines, therefore
++ * differs in spirit from the above ffz (man ffs).
++ */
++
++#define ffs(x) generic_ffs(x)
++
++/*
++ * hweightN: returns the hamming weight (i.e. the number
++ * of bits set) of a N-bit word
++ */
++
++#define hweight32(x) generic_hweight32(x)
++#define hweight16(x) generic_hweight16(x)
++#define hweight8(x) generic_hweight8(x)
++
++#endif /* __KERNEL__ */
++
++#endif /* _ASM_GENERIC_BITOPS_H */
+--- linux-libc-headers-2.6.9.1/include/asm-generic/bug.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/bug.h	2005-05-18 20:34:55.000000000 +0200
+@@ -0,0 +1,34 @@
++#ifndef _ASM_GENERIC_BUG_H
++#define _ASM_GENERIC_BUG_H
++
++#include <linux/compiler.h>
++// #include <linux/config.h>
++
++#ifndef HAVE_ARCH_BUG
++#define BUG() do { \
++	printk("kernel BUG at %s:%d!\n", __FILE__, __LINE__); \
++	panic("BUG!"); \
++} while (0)
++#endif
++
++#ifndef HAVE_ARCH_PAGE_BUG
++#define PAGE_BUG(page) do { \
++	printk("page BUG for page at %p\n", page); \
++	BUG(); \
++} while (0)
++#endif
++
++#ifndef HAVE_ARCH_BUG_ON
++#define BUG_ON(condition) do { if (unlikely((condition)!=0)) BUG(); } while(0)
++#endif
++
++#ifndef HAVE_ARCH_WARN_ON
++#define WARN_ON(condition) do { \
++	if (unlikely((condition)!=0)) { \
++		printk("Badness in %s at %s:%d\n", __FUNCTION__, __FILE__, __LINE__); \
++		dump_stack(); \
++	} \
++} while (0)
++#endif
++
++#endif
+--- linux-libc-headers-2.6.9.1/include/asm-generic/cpumask.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/cpumask.h	2005-05-18 20:35:01.000000000 +0200
+@@ -0,0 +1,40 @@
++#ifndef __ASM_GENERIC_CPUMASK_H
++#define __ASM_GENERIC_CPUMASK_H
++
++// #include <linux/config.h>
++#include <linux/kernel.h>
++#include <linux/threads.h>
++#include <linux/types.h>
++#include <linux/bitmap.h>
++
++#if NR_CPUS > BITS_PER_LONG && NR_CPUS != 1
++#define CPU_ARRAY_SIZE		BITS_TO_LONGS(NR_CPUS)
++
++struct cpumask
++{
++	unsigned long mask[CPU_ARRAY_SIZE];
++};
++
++typedef struct cpumask cpumask_t;
++
++#else
++typedef unsigned long cpumask_t;
++#endif
++
++#ifdef CONFIG_SMP
++#if NR_CPUS > BITS_PER_LONG
++#include <asm-generic/cpumask_array.h>
++#else
++#include <asm-generic/cpumask_arith.h>
++#endif
++#else
++#include <asm-generic/cpumask_up.h>
++#endif
++
++#if NR_CPUS <= 4*BITS_PER_LONG
++#include <asm-generic/cpumask_const_value.h>
++#else
++#include <asm-generic/cpumask_const_reference.h>
++#endif
++
++#endif /* __ASM_GENERIC_CPUMASK_H */
+--- linux-libc-headers-2.6.9.1/include/asm-generic/cpumask_arith.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/cpumask_arith.h	2004-01-25 14:35:16.000000000 +0100
+@@ -0,0 +1,49 @@
++#ifndef __ASM_GENERIC_CPUMASK_ARITH_H
++#define __ASM_GENERIC_CPUMASK_ARITH_H
++
++/*
++ * Arithmetic type -based cpu bitmaps. A single unsigned long is used
++ * to contain the whole cpu bitmap.
++ */
++
++#define cpu_set(cpu, map)		set_bit(cpu, &(map))
++#define cpu_clear(cpu, map)		clear_bit(cpu, &(map))
++#define cpu_isset(cpu, map)		test_bit(cpu, &(map))
++#define cpu_test_and_set(cpu, map)	test_and_set_bit(cpu, &(map))
++
++#define cpus_and(dst,src1,src2)		do { dst = (src1) & (src2); } while (0)
++#define cpus_or(dst,src1,src2)		do { dst = (src1) | (src2); } while (0)
++#define cpus_clear(map)			do { map = 0; } while (0)
++#define cpus_complement(map)		do { map = ~(map); } while (0)
++#define cpus_equal(map1, map2)		((map1) == (map2))
++#define cpus_empty(map)			((map) == 0)
++#define cpus_addr(map)			(&(map))
++
++#if BITS_PER_LONG == 32
++#define cpus_weight(map)		hweight32(map)
++#elif BITS_PER_LONG == 64
++#define cpus_weight(map)		hweight64(map)
++#endif
++
++#define cpus_shift_right(dst, src, n)	do { dst = (src) >> (n); } while (0)
++#define cpus_shift_left(dst, src, n)	do { dst = (src) << (n); } while (0)
++
++#define any_online_cpu(map)			\
++({						\
++	cpumask_t __tmp__;			\
++	cpus_and(__tmp__, map, cpu_online_map);	\
++	__tmp__ ? first_cpu(__tmp__) : NR_CPUS;	\
++})
++
++#define CPU_MASK_ALL	(~((cpumask_t)0) >> (8*sizeof(cpumask_t) - NR_CPUS))
++#define CPU_MASK_NONE	((cpumask_t)0)
++
++/* only ever use this for things that are _never_ used on large boxen */
++#define cpus_coerce(map)		((unsigned long)(map))
++#define cpus_promote(map)		({ map; })
++#define cpumask_of_cpu(cpu)		({ ((cpumask_t)1) << (cpu); })
++
++#define first_cpu(map)			__ffs(map)
++#define next_cpu(cpu, map)		find_next_bit(&(map), NR_CPUS, cpu + 1)
++
++#endif /* __ASM_GENERIC_CPUMASK_ARITH_H */
+--- linux-libc-headers-2.6.9.1/include/asm-generic/cpumask_array.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/cpumask_array.h	2004-01-25 14:35:16.000000000 +0100
+@@ -0,0 +1,54 @@
++#ifndef __ASM_GENERIC_CPUMASK_ARRAY_H
++#define __ASM_GENERIC_CPUMASK_ARRAY_H
++
++/*
++ * Array-based cpu bitmaps. An array of unsigned longs is used to contain
++ * the bitmap, and then contained in a structure so it may be passed by
++ * value.
++ */
++
++#define CPU_ARRAY_SIZE		BITS_TO_LONGS(NR_CPUS)
++
++#define cpu_set(cpu, map)		set_bit(cpu, (map).mask)
++#define cpu_clear(cpu, map)		clear_bit(cpu, (map).mask)
++#define cpu_isset(cpu, map)		test_bit(cpu, (map).mask)
++#define cpu_test_and_set(cpu, map)	test_and_set_bit(cpu, (map).mask)
++
++#define cpus_and(dst,src1,src2)	bitmap_and((dst).mask,(src1).mask, (src2).mask, NR_CPUS)
++#define cpus_or(dst,src1,src2)	bitmap_or((dst).mask, (src1).mask, (src2).mask, NR_CPUS)
++#define cpus_clear(map)		bitmap_clear((map).mask, NR_CPUS)
++#define cpus_complement(map)	bitmap_complement((map).mask, NR_CPUS)
++#define cpus_equal(map1, map2)	bitmap_equal((map1).mask, (map2).mask, NR_CPUS)
++#define cpus_empty(map)		bitmap_empty(map.mask, NR_CPUS)
++#define cpus_addr(map)		((map).mask)
++#define cpus_weight(map)		bitmap_weight((map).mask, NR_CPUS)
++#define cpus_shift_right(d, s, n)	bitmap_shift_right((d).mask, (s).mask, n, NR_CPUS)
++#define cpus_shift_left(d, s, n)	bitmap_shift_left((d).mask, (s).mask, n, NR_CPUS)
++#define first_cpu(map)		find_first_bit((map).mask, NR_CPUS)
++#define next_cpu(cpu, map)	find_next_bit((map).mask, NR_CPUS, cpu + 1)
++
++/* only ever use this for things that are _never_ used on large boxen */
++#define cpus_coerce(map)	((map).mask[0])
++#define cpus_promote(map)	({ cpumask_t __cpu_mask = CPU_MASK_NONE;\
++					__cpu_mask.mask[0] = map;	\
++					__cpu_mask;			\
++				})
++#define cpumask_of_cpu(cpu)	({ cpumask_t __cpu_mask = CPU_MASK_NONE;\
++					cpu_set(cpu, __cpu_mask);	\
++					__cpu_mask;			\
++				})
++#define any_online_cpu(map)			\
++({						\
++	cpumask_t __tmp__;			\
++	cpus_and(__tmp__, map, cpu_online_map);	\
++	find_first_bit(__tmp__.mask, NR_CPUS);	\
++})
++
++
++/*
++ * um, these need to be usable as static initializers
++ */
++#define CPU_MASK_ALL	{ {[0 ... CPU_ARRAY_SIZE-1] = ~0UL} }
++#define CPU_MASK_NONE	{ {[0 ... CPU_ARRAY_SIZE-1] =  0UL} }
++
++#endif /* __ASM_GENERIC_CPUMASK_ARRAY_H */
+--- linux-libc-headers-2.6.9.1/include/asm-generic/cpumask_const_reference.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/cpumask_const_reference.h	2004-01-16 16:00:38.000000000 +0100
+@@ -0,0 +1,29 @@
++#ifndef __ASM_GENERIC_CPUMASK_CONST_REFERENCE_H
++#define __ASM_GENERIC_CPUMASK_CONST_REFERENCE_H
++
++struct cpumask_ref {
++	const cpumask_t *val;
++};
++
++typedef const struct cpumask_ref cpumask_const_t;
++
++#define mk_cpumask_const(map)		((cpumask_const_t){ &(map) })
++#define cpu_isset_const(cpu, map)	cpu_isset(cpu, *(map).val)
++
++#define cpus_and_const(dst,src1,src2)	cpus_and(dst,*(src1).val,*(src2).val)
++#define cpus_or_const(dst,src1,src2)	cpus_or(dst,*(src1).val,*(src2).val)
++
++#define cpus_equal_const(map1, map2)	cpus_equal(*(map1).val, *(map2).val)
++
++#define cpus_copy_const(map1, map2)	bitmap_copy((map1).mask, (map2).val->mask, NR_CPUS)
++
++#define cpus_empty_const(map)		cpus_empty(*(map).val)
++#define cpus_weight_const(map)		cpus_weight(*(map).val)
++#define first_cpu_const(map)		first_cpu(*(map).val)
++#define next_cpu_const(cpu, map)	next_cpu(cpu, *(map).val)
++
++/* only ever use this for things that are _never_ used on large boxen */
++#define cpus_coerce_const(map)		cpus_coerce(*(map).val)
++#define any_online_cpu_const(map)	any_online_cpu(*(map).val)
++
++#endif /* __ASM_GENERIC_CPUMASK_CONST_REFERENCE_H */
+--- linux-libc-headers-2.6.9.1/include/asm-generic/cpumask_const_value.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/cpumask_const_value.h	2004-01-25 14:35:16.000000000 +0100
+@@ -0,0 +1,21 @@
++#ifndef __ASM_GENERIC_CPUMASK_CONST_VALUE_H
++#define __ASM_GENERIC_CPUMASK_CONST_VALUE_H
++
++typedef const cpumask_t cpumask_const_t;
++
++#define mk_cpumask_const(map)		(map)
++#define cpu_isset_const(cpu, map)	cpu_isset(cpu, map)
++#define cpus_and_const(dst,src1,src2)	cpus_and(dst, src1, src2)
++#define cpus_or_const(dst,src1,src2)	cpus_or(dst, src1, src2)
++#define cpus_equal_const(map1, map2)	cpus_equal(map1, map2)
++#define cpus_empty_const(map)		cpus_empty(map)
++#define cpus_copy_const(map1, map2)	do { map1 = (cpumask_t)map2; } while (0)
++#define cpus_weight_const(map)		cpus_weight(map)
++#define first_cpu_const(map)		first_cpu(map)
++#define next_cpu_const(cpu, map)	next_cpu(cpu, map)
++
++/* only ever use this for things that are _never_ used on large boxen */
++#define cpus_coerce_const(map)		cpus_coerce(map)
++#define any_online_cpu_const(map)	any_online_cpu(map)
++
++#endif /* __ASM_GENERIC_CPUMASK_CONST_VALUE_H */
+--- linux-libc-headers-2.6.9.1/include/asm-generic/cpumask_up.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/cpumask_up.h	2004-01-25 14:35:16.000000000 +0100
+@@ -0,0 +1,59 @@
++#ifndef __ASM_GENERIC_CPUMASK_UP_H
++#define __ASM_GENERIC_CPUMASK_UP_H
++
++#define cpus_coerce(map)	(map)
++
++#define cpu_set(cpu, map)		do { (void)(cpu); cpus_coerce(map) = 1UL; } while (0)
++#define cpu_clear(cpu, map)		do { (void)(cpu); cpus_coerce(map) = 0UL; } while (0)
++#define cpu_isset(cpu, map)		((void)(cpu), cpus_coerce(map) != 0UL)
++#define cpu_test_and_set(cpu, map)	((void)(cpu), test_and_set_bit(0, &(map)))
++
++#define cpus_and(dst, src1, src2)					\
++	do {								\
++		if (cpus_coerce(src1) && cpus_coerce(src2))		\
++			cpus_coerce(dst) = 1UL;				\
++		else							\
++			cpus_coerce(dst) = 0UL;				\
++	} while (0)
++
++#define cpus_or(dst, src1, src2)					\
++	do {								\
++		if (cpus_coerce(src1) || cpus_coerce(src2))		\
++			cpus_coerce(dst) = 1UL;				\
++		else							\
++			cpus_coerce(dst) = 0UL;				\
++	} while (0)
++
++#define cpus_clear(map)			do { cpus_coerce(map) = 0UL; } while (0)
++
++#define cpus_complement(map)						\
++	do {								\
++		cpus_coerce(map) = !cpus_coerce(map);			\
++	} while (0)
++
++#define cpus_equal(map1, map2)		(cpus_coerce(map1) == cpus_coerce(map2))
++#define cpus_empty(map)			(cpus_coerce(map) == 0UL)
++#define cpus_addr(map)			(&(map))
++#define cpus_weight(map)		(cpus_coerce(map) ? 1UL : 0UL)
++#define cpus_shift_right(d, s, n)	do { cpus_coerce(d) = 0UL; } while (0)
++#define cpus_shift_left(d, s, n)	do { cpus_coerce(d) = 0UL; } while (0)
++#define first_cpu(map)			(cpus_coerce(map) ? 0 : 1)
++#define next_cpu(cpu, map)		1
++
++/* only ever use this for things that are _never_ used on large boxen */
++#define cpus_promote(map)						\
++	({								\
++		cpumask_t __tmp__;					\
++		cpus_coerce(__tmp__) = map;				\
++		__tmp__;						\
++	})
++#define cpumask_of_cpu(cpu)		((void)(cpu), cpus_promote(1))
++#define any_online_cpu(map)		(cpus_coerce(map) ? 0 : 1)
++
++/*
++ * um, these need to be usable as static initializers
++ */
++#define CPU_MASK_ALL	1UL
++#define CPU_MASK_NONE	0UL
++
++#endif /* __ASM_GENERIC_CPUMASK_UP_H */
+--- linux-libc-headers-2.6.9.1/include/asm-generic/div64.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/div64.h	2004-01-16 16:00:38.000000000 +0100
+@@ -0,0 +1,58 @@
++#ifndef _ASM_GENERIC_DIV64_H
++#define _ASM_GENERIC_DIV64_H
++/*
++ * Copyright (C) 2003 Bernardo Innocenti <bernie@develer.com>
++ * Based on former asm-ppc/div64.h and asm-m68knommu/div64.h
++ *
++ * The semantics of do_div() are:
++ *
++ * uint32_t do_div(uint64_t *n, uint32_t base)
++ * {
++ * 	uint32_t remainder = *n % base;
++ * 	*n = *n / base;
++ * 	return remainder;
++ * }
++ *
++ * NOTE: macro parameter n is evaluated multiple times,
++ *       beware of side effects!
++ */
++
++#include <linux/types.h>
++#include <linux/compiler.h>
++
++#if BITS_PER_LONG == 64
++
++# define do_div(n,base) ({					\
++	uint32_t __base = (base);				\
++	uint32_t __rem;						\
++	__rem = ((uint64_t)(n)) % __base;			\
++	(n) = ((uint64_t)(n)) / __base;				\
++	__rem;							\
++ })
++
++#elif BITS_PER_LONG == 32
++
++extern uint32_t __div64_32(uint64_t *dividend, uint32_t divisor);
++
++/* The unnecessary pointer compare is there
++ * to check for type safety (n must be 64bit)
++ */
++# define do_div(n,base) ({				\
++	uint32_t __base = (base);			\
++	uint32_t __rem;					\
++	(void)(((typeof((n)) *)0) == ((uint64_t *)0));	\
++	if (likely(((n) >> 32) == 0)) {			\
++		__rem = (uint32_t)(n) % __base;		\
++		(n) = (uint32_t)(n) / __base;		\
++	} else 						\
++		__rem = __div64_32(&(n), __base);	\
++	__rem;						\
++ })
++
++#else /* BITS_PER_LONG == ?? */
++
++# error do_div() does not yet support the C64
++
++#endif /* BITS_PER_LONG */
++
++#endif /* _ASM_GENERIC_DIV64_H */
+--- linux-libc-headers-2.6.9.1/include/asm-generic/dma-mapping-broken.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/dma-mapping-broken.h	2004-05-01 15:23:26.000000000 +0200
+@@ -0,0 +1,22 @@
++#ifndef _ASM_GENERIC_DMA_MAPPING_H
++#define _ASM_GENERIC_DMA_MAPPING_H
++
++/* This is used for archs that do not support DMA */
++
++
++static inline void *
++dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
++		   int flag)
++{
++	BUG();
++	return 0;
++}
++
++static inline void
++dma_free_coherent(struct device *dev, size_t size, void *cpu_addr,
++		    dma_addr_t dma_handle)
++{
++	BUG();
++}
++
++#endif /* _ASM_GENERIC_DMA_MAPPING_H */
+--- linux-libc-headers-2.6.9.1/include/asm-generic/dma-mapping.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/dma-mapping.h	2005-05-18 20:35:06.000000000 +0200
+@@ -0,0 +1,309 @@
++/* Copyright (C) 2002 by James.Bottomley@HansenPartnership.com 
++ *
++ * Implements the generic device dma API via the existing pci_ one
++ * for unconverted architectures
++ */
++
++#ifndef _ASM_GENERIC_DMA_MAPPING_H
++#define _ASM_GENERIC_DMA_MAPPING_H
++
++// #include <linux/config.h>
++
++#ifdef CONFIG_PCI
++
++/* we implement the API below in terms of the existing PCI one,
++ * so include it */
++#include <linux/pci.h>
++/* need struct page definitions */
++#include <linux/mm.h>
++
++static inline int
++dma_supported(struct device *dev, u64 mask)
++{
++	BUG_ON(dev->bus != &pci_bus_type);
++
++	return pci_dma_supported(to_pci_dev(dev), mask);
++}
++
++static inline int
++dma_set_mask(struct device *dev, u64 dma_mask)
++{
++	BUG_ON(dev->bus != &pci_bus_type);
++
++	return pci_set_dma_mask(to_pci_dev(dev), dma_mask);
++}
++
++static inline void *
++dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
++		   int flag)
++{
++	BUG_ON(dev->bus != &pci_bus_type);
++
++	return pci_alloc_consistent(to_pci_dev(dev), size, dma_handle);
++}
++
++static inline void
++dma_free_coherent(struct device *dev, size_t size, void *cpu_addr,
++		    dma_addr_t dma_handle)
++{
++	BUG_ON(dev->bus != &pci_bus_type);
++
++	pci_free_consistent(to_pci_dev(dev), size, cpu_addr, dma_handle);
++}
++
++static inline dma_addr_t
++dma_map_single(struct device *dev, void *cpu_addr, size_t size,
++	       enum dma_data_direction direction)
++{
++	BUG_ON(dev->bus != &pci_bus_type);
++
++	return pci_map_single(to_pci_dev(dev), cpu_addr, size, (int)direction);
++}
++
++static inline void
++dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size,
++		 enum dma_data_direction direction)
++{
++	BUG_ON(dev->bus != &pci_bus_type);
++
++	pci_unmap_single(to_pci_dev(dev), dma_addr, size, (int)direction);
++}
++
++static inline dma_addr_t
++dma_map_page(struct device *dev, struct page *page,
++	     unsigned long offset, size_t size,
++	     enum dma_data_direction direction)
++{
++	BUG_ON(dev->bus != &pci_bus_type);
++
++	return pci_map_page(to_pci_dev(dev), page, offset, size, (int)direction);
++}
++
++static inline void
++dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size,
++	       enum dma_data_direction direction)
++{
++	BUG_ON(dev->bus != &pci_bus_type);
++
++	pci_unmap_page(to_pci_dev(dev), dma_address, size, (int)direction);
++}
++
++static inline int
++dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
++	   enum dma_data_direction direction)
++{
++	BUG_ON(dev->bus != &pci_bus_type);
++
++	return pci_map_sg(to_pci_dev(dev), sg, nents, (int)direction);
++}
++
++static inline void
++dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries,
++	     enum dma_data_direction direction)
++{
++	BUG_ON(dev->bus != &pci_bus_type);
++
++	pci_unmap_sg(to_pci_dev(dev), sg, nhwentries, (int)direction);
++}
++
++static inline void
++dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size,
++			enum dma_data_direction direction)
++{
++	BUG_ON(dev->bus != &pci_bus_type);
++
++	pci_dma_sync_single_for_cpu(to_pci_dev(dev), dma_handle,
++				    size, (int)direction);
++}
++
++static inline void
++dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size,
++			   enum dma_data_direction direction)
++{
++	BUG_ON(dev->bus != &pci_bus_type);
++
++	pci_dma_sync_single_for_device(to_pci_dev(dev), dma_handle,
++				       size, (int)direction);
++}
++
++static inline void
++dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems,
++		    enum dma_data_direction direction)
++{
++	BUG_ON(dev->bus != &pci_bus_type);
++
++	pci_dma_sync_sg_for_cpu(to_pci_dev(dev), sg, nelems, (int)direction);
++}
++
++static inline void
++dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems,
++		       enum dma_data_direction direction)
++{
++	BUG_ON(dev->bus != &pci_bus_type);
++
++	pci_dma_sync_sg_for_device(to_pci_dev(dev), sg, nelems, (int)direction);
++}
++
++static inline int
++dma_mapping_error(dma_addr_t dma_addr)
++{
++	return pci_dma_mapping_error(dma_addr);
++}
++
++
++#else
++
++static inline int
++dma_supported(struct device *dev, u64 mask)
++{
++	return 0;
++}
++
++static inline int
++dma_set_mask(struct device *dev, u64 dma_mask)
++{
++	BUG();
++	return 0;
++}
++
++static inline void *
++dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
++		   int flag)
++{
++	BUG();
++	return NULL;
++}
++
++static inline void
++dma_free_coherent(struct device *dev, size_t size, void *cpu_addr,
++		    dma_addr_t dma_handle)
++{
++	BUG();
++}
++
++static inline dma_addr_t
++dma_map_single(struct device *dev, void *cpu_addr, size_t size,
++	       enum dma_data_direction direction)
++{
++	BUG();
++	return 0;
++}
++
++static inline void
++dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size,
++		 enum dma_data_direction direction)
++{
++	BUG();
++}
++
++static inline dma_addr_t
++dma_map_page(struct device *dev, struct page *page,
++	     unsigned long offset, size_t size,
++	     enum dma_data_direction direction)
++{
++	BUG();
++	return 0;
++}
++
++static inline void
++dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size,
++	       enum dma_data_direction direction)
++{
++	BUG();
++}
++
++static inline int
++dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
++	   enum dma_data_direction direction)
++{
++	BUG();
++	return 0;
++}
++
++static inline void
++dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries,
++	     enum dma_data_direction direction)
++{
++	BUG();
++}
++
++static inline void
++dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size,
++			enum dma_data_direction direction)
++{
++	BUG();
++}
++
++static inline void
++dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size,
++			   enum dma_data_direction direction)
++{
++	BUG();
++}
++
++static inline void
++dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems,
++		    enum dma_data_direction direction)
++{
++	BUG();
++}
++
++static inline void
++dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems,
++		       enum dma_data_direction direction)
++{
++	BUG();
++}
++
++static inline int
++dma_error(dma_addr_t dma_addr)
++{
++	return 0;
++}
++
++#endif
++
++/* Now for the API extensions over the pci_ one */
++
++#define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f)
++#define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h)
++#define dma_is_consistent(d)	(1)
++
++static inline int
++dma_get_cache_alignment(void)
++{
++	/* no easy way to get cache size on all processors, so return
++	 * the maximum possible, to be safe */
++	return (1 << L1_CACHE_SHIFT_MAX);
++}
++
++static inline void
++dma_sync_single_range_for_cpu(struct device *dev, dma_addr_t dma_handle,
++			      unsigned long offset, size_t size,
++			      enum dma_data_direction direction)
++{
++	/* just sync everything, that's all the pci API can do */
++	dma_sync_single_for_cpu(dev, dma_handle, offset+size, direction);
++}
++
++static inline void
++dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle,
++				 unsigned long offset, size_t size,
++				 enum dma_data_direction direction)
++{
++	/* just sync everything, that's all the pci API can do */
++	dma_sync_single_for_device(dev, dma_handle, offset+size, direction);
++}
++
++static inline void
++dma_cache_sync(void *vaddr, size_t size,
++	       enum dma_data_direction direction)
++{
++	/* could define this in terms of the dma_cache ... operations,
++	 * but if you get this on a platform, you should convert the platform
++	 * to using the generic device DMA API */
++	BUG();
++}
++
++#endif
++
+--- linux-libc-headers-2.6.9.1/include/asm-generic/errno-base.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/errno-base.h	2004-01-16 16:00:38.000000000 +0100
+@@ -0,0 +1,39 @@
++#ifndef _ASM_GENERIC_ERRNO_BASE_H
++#define _ASM_GENERIC_ERRNO_BASE_H
++
++#define	EPERM		 1	/* Operation not permitted */
++#define	ENOENT		 2	/* No such file or directory */
++#define	ESRCH		 3	/* No such process */
++#define	EINTR		 4	/* Interrupted system call */
++#define	EIO		 5	/* I/O error */
++#define	ENXIO		 6	/* No such device or address */
++#define	E2BIG		 7	/* Argument list too long */
++#define	ENOEXEC		 8	/* Exec format error */
++#define	EBADF		 9	/* Bad file number */
++#define	ECHILD		10	/* No child processes */
++#define	EAGAIN		11	/* Try again */
++#define	ENOMEM		12	/* Out of memory */
++#define	EACCES		13	/* Permission denied */
++#define	EFAULT		14	/* Bad address */
++#define	ENOTBLK		15	/* Block device required */
++#define	EBUSY		16	/* Device or resource busy */
++#define	EEXIST		17	/* File exists */
++#define	EXDEV		18	/* Cross-device link */
++#define	ENODEV		19	/* No such device */
++#define	ENOTDIR		20	/* Not a directory */
++#define	EISDIR		21	/* Is a directory */
++#define	EINVAL		22	/* Invalid argument */
++#define	ENFILE		23	/* File table overflow */
++#define	EMFILE		24	/* Too many open files */
++#define	ENOTTY		25	/* Not a typewriter */
++#define	ETXTBSY		26	/* Text file busy */
++#define	EFBIG		27	/* File too large */
++#define	ENOSPC		28	/* No space left on device */
++#define	ESPIPE		29	/* Illegal seek */
++#define	EROFS		30	/* Read-only file system */
++#define	EMLINK		31	/* Too many links */
++#define	EPIPE		32	/* Broken pipe */
++#define	EDOM		33	/* Math argument out of domain of func */
++#define	ERANGE		34	/* Math result not representable */
++
++#endif
+--- linux-libc-headers-2.6.9.1/include/asm-generic/errno.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/errno.h	2004-01-16 16:00:38.000000000 +0100
+@@ -0,0 +1,100 @@
++#ifndef _ASM_GENERIC_ERRNO_H
++#define _ASM_GENERIC_ERRNO_H
++
++#include <asm-generic/errno-base.h>
++
++#define	EDEADLK		35	/* Resource deadlock would occur */
++#define	ENAMETOOLONG	36	/* File name too long */
++#define	ENOLCK		37	/* No record locks available */
++#define	ENOSYS		38	/* Function not implemented */
++#define	ENOTEMPTY	39	/* Directory not empty */
++#define	ELOOP		40	/* Too many symbolic links encountered */
++#define	EWOULDBLOCK	EAGAIN	/* Operation would block */
++#define	ENOMSG		42	/* No message of desired type */
++#define	EIDRM		43	/* Identifier removed */
++#define	ECHRNG		44	/* Channel number out of range */
++#define	EL2NSYNC	45	/* Level 2 not synchronized */
++#define	EL3HLT		46	/* Level 3 halted */
++#define	EL3RST		47	/* Level 3 reset */
++#define	ELNRNG		48	/* Link number out of range */
++#define	EUNATCH		49	/* Protocol driver not attached */
++#define	ENOCSI		50	/* No CSI structure available */
++#define	EL2HLT		51	/* Level 2 halted */
++#define	EBADE		52	/* Invalid exchange */
++#define	EBADR		53	/* Invalid request descriptor */
++#define	EXFULL		54	/* Exchange full */
++#define	ENOANO		55	/* No anode */
++#define	EBADRQC		56	/* Invalid request code */
++#define	EBADSLT		57	/* Invalid slot */
++
++#define	EDEADLOCK	EDEADLK
++
++#define	EBFONT		59	/* Bad font file format */
++#define	ENOSTR		60	/* Device not a stream */
++#define	ENODATA		61	/* No data available */
++#define	ETIME		62	/* Timer expired */
++#define	ENOSR		63	/* Out of streams resources */
++#define	ENONET		64	/* Machine is not on the network */
++#define	ENOPKG		65	/* Package not installed */
++#define	EREMOTE		66	/* Object is remote */
++#define	ENOLINK		67	/* Link has been severed */
++#define	EADV		68	/* Advertise error */
++#define	ESRMNT		69	/* Srmount error */
++#define	ECOMM		70	/* Communication error on send */
++#define	EPROTO		71	/* Protocol error */
++#define	EMULTIHOP	72	/* Multihop attempted */
++#define	EDOTDOT		73	/* RFS specific error */
++#define	EBADMSG		74	/* Not a data message */
++#define	EOVERFLOW	75	/* Value too large for defined data type */
++#define	ENOTUNIQ	76	/* Name not unique on network */
++#define	EBADFD		77	/* File descriptor in bad state */
++#define	EREMCHG		78	/* Remote address changed */
++#define	ELIBACC		79	/* Can not access a needed shared library */
++#define	ELIBBAD		80	/* Accessing a corrupted shared library */
++#define	ELIBSCN		81	/* .lib section in a.out corrupted */
++#define	ELIBMAX		82	/* Attempting to link in too many shared libraries */
++#define	ELIBEXEC	83	/* Cannot exec a shared library directly */
++#define	EILSEQ		84	/* Illegal byte sequence */
++#define	ERESTART	85	/* Interrupted system call should be restarted */
++#define	ESTRPIPE	86	/* Streams pipe error */
++#define	EUSERS		87	/* Too many users */
++#define	ENOTSOCK	88	/* Socket operation on non-socket */
++#define	EDESTADDRREQ	89	/* Destination address required */
++#define	EMSGSIZE	90	/* Message too long */
++#define	EPROTOTYPE	91	/* Protocol wrong type for socket */
++#define	ENOPROTOOPT	92	/* Protocol not available */
++#define	EPROTONOSUPPORT	93	/* Protocol not supported */
++#define	ESOCKTNOSUPPORT	94	/* Socket type not supported */
++#define	EOPNOTSUPP	95	/* Operation not supported on transport endpoint */
++#define	EPFNOSUPPORT	96	/* Protocol family not supported */
++#define	EAFNOSUPPORT	97	/* Address family not supported by protocol */
++#define	EADDRINUSE	98	/* Address already in use */
++#define	EADDRNOTAVAIL	99	/* Cannot assign requested address */
++#define	ENETDOWN	100	/* Network is down */
++#define	ENETUNREACH	101	/* Network is unreachable */
++#define	ENETRESET	102	/* Network dropped connection because of reset */
++#define	ECONNABORTED	103	/* Software caused connection abort */
++#define	ECONNRESET	104	/* Connection reset by peer */
++#define	ENOBUFS		105	/* No buffer space available */
++#define	EISCONN		106	/* Transport endpoint is already connected */
++#define	ENOTCONN	107	/* Transport endpoint is not connected */
++#define	ESHUTDOWN	108	/* Cannot send after transport endpoint shutdown */
++#define	ETOOMANYREFS	109	/* Too many references: cannot splice */
++#define	ETIMEDOUT	110	/* Connection timed out */
++#define	ECONNREFUSED	111	/* Connection refused */
++#define	EHOSTDOWN	112	/* Host is down */
++#define	EHOSTUNREACH	113	/* No route to host */
++#define	EALREADY	114	/* Operation already in progress */
++#define	EINPROGRESS	115	/* Operation now in progress */
++#define	ESTALE		116	/* Stale NFS file handle */
++#define	EUCLEAN		117	/* Structure needs cleaning */
++#define	ENOTNAM		118	/* Not a XENIX named type file */
++#define	ENAVAIL		119	/* No XENIX semaphores available */
++#define	EISNAM		120	/* Is a named type file */
++#define	EREMOTEIO	121	/* Remote I/O error */
++#define	EDQUOT		122	/* Quota exceeded */
++
++#define	ENOMEDIUM	123	/* No medium found */
++#define	EMEDIUMTYPE	124	/* Wrong medium type */
++
++#endif
+--- linux-libc-headers-2.6.9.1/include/asm-generic/hdreg.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/hdreg.h	2004-11-27 15:04:26.000000000 +0100
+@@ -0,0 +1,8 @@
++#warning <asm/hdreg.h> is obsolete, please do not use it
++
++#ifndef __ASM_GENERIC_HDREG_H
++#define __ASM_GENERIC_HDREG_H
++
++typedef unsigned long ide_ioreg_t;
++
++#endif /* __ASM_GENERIC_HDREG_H */
+--- linux-libc-headers-2.6.9.1/include/asm-generic/ide_iops.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/ide_iops.h	2004-12-08 17:39:48.000000000 +0100
+@@ -0,0 +1,38 @@
++/* Generic I/O and MEMIO string operations.  */
++
++#define __ide_insw	insw
++#define __ide_insl	insl
++#define __ide_outsw	outsw
++#define __ide_outsl	outsl
++
++static __inline__ void __ide_mm_insw(void __iomem *port, void *addr, u32 count)
++{
++	while (count--) {
++		*(u16 *)addr = readw(port);
++		addr += 2;
++	}
++}
++
++static __inline__ void __ide_mm_insl(void __iomem *port, void *addr, u32 count)
++{
++	while (count--) {
++		*(u32 *)addr = readl(port);
++		addr += 4;
++	}
++}
++
++static __inline__ void __ide_mm_outsw(void __iomem *port, void *addr, u32 count)
++{
++	while (count--) {
++		writew(*(u16 *)addr, port);
++		addr += 2;
++	}
++}
++
++static __inline__ void __ide_mm_outsl(void __iomem * port, void *addr, u32 count)
++{
++	while (count--) {
++		writel(*(u32 *)addr, port);
++		addr += 4;
++	}
++}
+--- linux-libc-headers-2.6.9.1/include/asm-generic/iomap.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/iomap.h	2004-11-27 15:04:26.000000000 +0100
+@@ -0,0 +1,63 @@
++#ifndef __GENERIC_IO_H
++#define __GENERIC_IO_H
++
++#include <linux/linkage.h>
++
++/*
++ * These are the "generic" interfaces for doing new-style
++ * memory-mapped or PIO accesses. Architectures may do
++ * their own arch-optimized versions, these just act as
++ * wrappers around the old-style IO register access functions:
++ * read[bwl]/write[bwl]/in[bwl]/out[bwl]
++ *
++ * Don't include this directly, include it from <asm/io.h>.
++ */
++
++/*
++ * Read/write from/to an (offsettable) iomem cookie. It might be a PIO
++ * access or a MMIO access, these functions don't care. The info is
++ * encoded in the hardware mapping set up by the mapping functions
++ * (or the cookie itself, depending on implementation and hw).
++ *
++ * The generic routines just encode the PIO/MMIO as part of the
++ * cookie, and coldly assume that the MMIO IO mappings are not
++ * in the low address range. Architectures for which this is not
++ * true can't use this generic implementation.
++ */
++extern unsigned int fastcall ioread8(void __iomem *);
++extern unsigned int fastcall ioread16(void __iomem *);
++extern unsigned int fastcall ioread32(void __iomem *);
++
++extern void fastcall iowrite8(u8, void __iomem *);
++extern void fastcall iowrite16(u16, void __iomem *);
++extern void fastcall iowrite32(u32, void __iomem *);
++
++/*
++ * "string" versions of the above. Note that they
++ * use native byte ordering for the accesses (on
++ * the assumption that IO and memory agree on a
++ * byte order, and CPU byteorder is irrelevant).
++ *
++ * They do _not_ update the port address. If you
++ * want MMIO that copies stuff laid out in MMIO
++ * memory across multiple ports, use "memcpy_toio()"
++ * and friends.
++ */
++extern void fastcall ioread8_rep(void __iomem *port, void *buf, unsigned long count);
++extern void fastcall ioread16_rep(void __iomem *port, void *buf, unsigned long count);
++extern void fastcall ioread32_rep(void __iomem *port, void *buf, unsigned long count);
++
++extern void fastcall iowrite8_rep(void __iomem *port, const void *buf, unsigned long count);
++extern void fastcall iowrite16_rep(void __iomem *port, const void *buf, unsigned long count);
++extern void fastcall iowrite32_rep(void __iomem *port, const void *buf, unsigned long count);
++
++/* Create a virtual mapping cookie for an IO port range */
++extern void __iomem *ioport_map(unsigned long port, unsigned int nr);
++extern void ioport_unmap(void __iomem *);
++
++/* Create a virtual mapping cookie for a PCI BAR (memory or IO) */
++struct pci_dev;
++extern void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long max);
++extern void pci_iounmap(struct pci_dev *dev, void __iomem *);
++
++#endif
+--- linux-libc-headers-2.6.9.1/include/asm-generic/local.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/local.h	2005-05-18 20:35:10.000000000 +0200
+@@ -0,0 +1,118 @@
++#ifndef _ASM_GENERIC_LOCAL_H
++#define _ASM_GENERIC_LOCAL_H
++
++// #include <linux/config.h>
++#include <linux/percpu.h>
++#include <linux/hardirq.h>
++#include <asm/types.h>
++
++/* An unsigned long type for operations which are atomic for a single
++ * CPU.  Usually used in combination with per-cpu variables. */
++
++#if BITS_PER_LONG == 32
++/* Implement in terms of atomics. */
++
++/* Don't use typedef: don't want them to be mixed with atomic_t's. */
++typedef struct
++{
++	atomic_t a;
++} local_t;
++
++#define LOCAL_INIT(i)	{ ATOMIC_INIT(i) }
++
++#define local_read(l)	((unsigned long)atomic_read(&(l)->a))
++#define local_set(l,i)	atomic_set((&(l)->a),(i))
++#define local_inc(l)	atomic_inc(&(l)->a)
++#define local_dec(l)	atomic_dec(&(l)->a)
++#define local_add(i,l)	atomic_add((i),(&(l)->a))
++#define local_sub(i,l)	atomic_sub((i),(&(l)->a))
++
++/* Non-atomic variants, ie. preemption disabled and won't be touched
++ * in interrupt, etc.  Some archs can optimize this case well. */
++#define __local_inc(l)		local_set((l), local_read(l) + 1)
++#define __local_dec(l)		local_set((l), local_read(l) - 1)
++#define __local_add(i,l)	local_set((l), local_read(l) + (i))
++#define __local_sub(i,l)	local_set((l), local_read(l) - (i))
++
++#else /* ... can't use atomics. */
++/* Implement in terms of three variables.
++   Another option would be to use local_irq_save/restore. */
++
++typedef struct
++{
++	/* 0 = in hardirq, 1 = in softirq, 2 = usermode. */
++	unsigned long v[3];
++} local_t;
++
++#define _LOCAL_VAR(l)	((l)->v[!in_interrupt() + !in_irq()])
++
++#define LOCAL_INIT(i)	{ { (i), 0, 0 } }
++
++static inline unsigned long local_read(local_t *l)
++{
++	return l->v[0] + l->v[1] + l->v[2];
++}
++
++static inline void local_set(local_t *l, unsigned long v)
++{
++	l->v[0] = v;
++	l->v[1] = l->v[2] = 0;
++}
++
++static inline void local_inc(local_t *l)
++{
++	preempt_disable();
++	_LOCAL_VAR(l)++;
++	preempt_enable();
++}
++
++static inline void local_dec(local_t *l)
++{
++	preempt_disable();
++	_LOCAL_VAR(l)--;
++	preempt_enable();
++}
++
++static inline void local_add(unsigned long v, local_t *l)
++{
++	preempt_disable();
++	_LOCAL_VAR(l) += v;
++	preempt_enable();
++}
++
++static inline void local_sub(unsigned long v, local_t *l)
++{
++	preempt_disable();
++	_LOCAL_VAR(l) -= v;
++	preempt_enable();
++}
++
++/* Non-atomic variants, ie. preemption disabled and won't be touched
++ * in interrupt, etc.  Some archs can optimize this case well. */
++#define __local_inc(l)		((l)->v[0]++)
++#define __local_dec(l)		((l)->v[0]--)
++#define __local_add(i,l)	((l)->v[0] += (i))
++#define __local_sub(i,l)	((l)->v[0] -= (i))
++
++#endif /* Non-atomic implementation */
++
++/* Use these for per-cpu local_t variables: on some archs they are
++ * much more efficient than these naive implementations.  Note they take
++ * a variable (eg. mystruct.foo), not an address.
++ */
++#define cpu_local_read(v)	local_read(&__get_cpu_var(v))
++#define cpu_local_set(v, i)	local_set(&__get_cpu_var(v), (i))
++#define cpu_local_inc(v)	local_inc(&__get_cpu_var(v))
++#define cpu_local_dec(v)	local_dec(&__get_cpu_var(v))
++#define cpu_local_add(i, v)	local_add((i), &__get_cpu_var(v))
++#define cpu_local_sub(i, v)	local_sub((i), &__get_cpu_var(v))
++
++/* Non-atomic increments, ie. preemption disabled and won't be touched
++ * in interrupt, etc.  Some archs can optimize this case well.
++ */
++#define __cpu_local_inc(v)	__local_inc(&__get_cpu_var(v))
++#define __cpu_local_dec(v)	__local_dec(&__get_cpu_var(v))
++#define __cpu_local_add(i, v)	__local_add((i), &__get_cpu_var(v))
++#define __cpu_local_sub(i, v)	__local_sub((i), &__get_cpu_var(v))
++
++#endif /* _ASM_GENERIC_LOCAL_H */
+--- linux-libc-headers-2.6.9.1/include/asm-generic/pci-dma-compat.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/pci-dma-compat.h	2004-05-07 15:36:24.000000000 +0200
+@@ -0,0 +1,107 @@
++/* include this file if the platform implements the dma_ DMA Mapping API
++ * and wants to provide the pci_ DMA Mapping API in terms of it */
++
++#ifndef _ASM_GENERIC_PCI_DMA_COMPAT_H
++#define _ASM_GENERIC_PCI_DMA_COMPAT_H
++
++#include <linux/dma-mapping.h>
++
++/* note pci_set_dma_mask isn't here, since it's a public function
++ * exported from drivers/pci, use dma_supported instead */
++
++static inline int
++pci_dma_supported(struct pci_dev *hwdev, u64 mask)
++{
++	return dma_supported(hwdev == NULL ? NULL : &hwdev->dev, mask);
++}
++
++static inline void *
++pci_alloc_consistent(struct pci_dev *hwdev, size_t size,
++		     dma_addr_t *dma_handle)
++{
++	return dma_alloc_coherent(hwdev == NULL ? NULL : &hwdev->dev, size, dma_handle, GFP_ATOMIC);
++}
++
++static inline void
++pci_free_consistent(struct pci_dev *hwdev, size_t size,
++		    void *vaddr, dma_addr_t dma_handle)
++{
++	dma_free_coherent(hwdev == NULL ? NULL : &hwdev->dev, size, vaddr, dma_handle);
++}
++
++static inline dma_addr_t
++pci_map_single(struct pci_dev *hwdev, void *ptr, size_t size, int direction)
++{
++	return dma_map_single(hwdev == NULL ? NULL : &hwdev->dev, ptr, size, (enum dma_data_direction)direction);
++}
++
++static inline void
++pci_unmap_single(struct pci_dev *hwdev, dma_addr_t dma_addr,
++		 size_t size, int direction)
++{
++	dma_unmap_single(hwdev == NULL ? NULL : &hwdev->dev, dma_addr, size, (enum dma_data_direction)direction);
++}
++
++static inline dma_addr_t
++pci_map_page(struct pci_dev *hwdev, struct page *page,
++	     unsigned long offset, size_t size, int direction)
++{
++	return dma_map_page(hwdev == NULL ? NULL : &hwdev->dev, page, offset, size, (enum dma_data_direction)direction);
++}
++
++static inline void
++pci_unmap_page(struct pci_dev *hwdev, dma_addr_t dma_address,
++	       size_t size, int direction)
++{
++	dma_unmap_page(hwdev == NULL ? NULL : &hwdev->dev, dma_address, size, (enum dma_data_direction)direction);
++}
++
++static inline int
++pci_map_sg(struct pci_dev *hwdev, struct scatterlist *sg,
++	   int nents, int direction)
++{
++	return dma_map_sg(hwdev == NULL ? NULL : &hwdev->dev, sg, nents, (enum dma_data_direction)direction);
++}
++
++static inline void
++pci_unmap_sg(struct pci_dev *hwdev, struct scatterlist *sg,
++	     int nents, int direction)
++{
++	dma_unmap_sg(hwdev == NULL ? NULL : &hwdev->dev, sg, nents, (enum dma_data_direction)direction);
++}
++
++static inline void
++pci_dma_sync_single_for_cpu(struct pci_dev *hwdev, dma_addr_t dma_handle,
++		    size_t size, int direction)
++{
++	dma_sync_single_for_cpu(hwdev == NULL ? NULL : &hwdev->dev, dma_handle, size, (enum dma_data_direction)direction);
++}
++
++static inline void
++pci_dma_sync_single_for_device(struct pci_dev *hwdev, dma_addr_t dma_handle,
++		    size_t size, int direction)
++{
++	dma_sync_single_for_device(hwdev == NULL ? NULL : &hwdev->dev, dma_handle, size, (enum dma_data_direction)direction);
++}
++
++static inline void
++pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev, struct scatterlist *sg,
++		int nelems, int direction)
++{
++	dma_sync_sg_for_cpu(hwdev == NULL ? NULL : &hwdev->dev, sg, nelems, (enum dma_data_direction)direction);
++}
++
++static inline void
++pci_dma_sync_sg_for_device(struct pci_dev *hwdev, struct scatterlist *sg,
++		int nelems, int direction)
++{
++	dma_sync_sg_for_device(hwdev == NULL ? NULL : &hwdev->dev, sg, nelems, (enum dma_data_direction)direction);
++}
++
++static inline int
++pci_dma_mapping_error(dma_addr_t dma_addr)
++{
++	return dma_mapping_error(dma_addr);
++}
++
++#endif
+--- linux-libc-headers-2.6.9.1/include/asm-generic/pci.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/pci.h	2004-05-07 15:36:24.000000000 +0200
+@@ -0,0 +1,27 @@
++/*
++ * linux/include/asm-generic/pci.h
++ *
++ *  Copyright (C) 2003 Russell King
++ */
++#ifndef _ASM_GENERIC_PCI_H
++#define _ASM_GENERIC_PCI_H
++
++/**
++ * pcibios_resource_to_bus - convert resource to PCI bus address
++ * @dev: device which owns this resource
++ * @region: converted bus-centric region (start,end)
++ * @res: resource to convert
++ *
++ * Convert a resource to a PCI device bus address or bus window.
++ */
++static inline void
++pcibios_resource_to_bus(struct pci_dev *dev, struct pci_bus_region *region,
++			 struct resource *res)
++{
++	region->start = res->start;
++	region->end = res->end;
++}
++
++#define pcibios_scan_all_fns(a, b)	0
++
++#endif
+--- linux-libc-headers-2.6.9.1/include/asm-generic/percpu.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/percpu.h	2004-02-08 17:04:22.000000000 +0100
+@@ -0,0 +1,42 @@
++#ifndef _ASM_GENERIC_PERCPU_H_
++#define _ASM_GENERIC_PERCPU_H_
++#include <linux/compiler.h>
++
++#define __GENERIC_PER_CPU
++#ifdef CONFIG_SMP
++
++extern unsigned long __per_cpu_offset[NR_CPUS];
++
++/* Separate out the type, so (int[3], foo) works. */
++#define DEFINE_PER_CPU(type, name) \
++    __attribute__((__section__(".data.percpu"))) __typeof__(type) per_cpu__##name
++
++/* var is in discarded region: offset to particular copy we want */
++#define per_cpu(var, cpu) (*RELOC_HIDE(&per_cpu__##var, __per_cpu_offset[cpu]))
++#define __get_cpu_var(var) per_cpu(var, smp_processor_id())
++
++/* A macro to avoid #include hell... */
++#define percpu_modcopy(pcpudst, src, size)			\
++do {								\
++	unsigned int __i;					\
++	for (__i = 0; __i < NR_CPUS; __i++)			\
++		if (cpu_possible(__i))				\
++			memcpy((pcpudst)+__per_cpu_offset[__i],	\
++			       (src), (size));			\
++} while (0)
++#else /* ! SMP */
++
++#define DEFINE_PER_CPU(type, name) \
++    __typeof__(type) per_cpu__##name
++
++#define per_cpu(var, cpu)			(*((void)cpu, &per_cpu__##var))
++#define __get_cpu_var(var)			per_cpu__##var
++
++#endif	/* SMP */
++
++#define DECLARE_PER_CPU(type, name) extern __typeof__(type) per_cpu__##name
++
++#define EXPORT_PER_CPU_SYMBOL(var) EXPORT_SYMBOL(per_cpu__##var)
++#define EXPORT_PER_CPU_SYMBOL_GPL(var) EXPORT_SYMBOL_GPL(per_cpu__##var)
++
++#endif /* _ASM_GENERIC_PERCPU_H_ */
+--- linux-libc-headers-2.6.9.1/include/asm-generic/pgtable.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/pgtable.h	2004-12-08 17:39:48.000000000 +0100
+@@ -0,0 +1,137 @@
++#ifndef _ASM_GENERIC_PGTABLE_H
++#define _ASM_GENERIC_PGTABLE_H
++
++#ifndef __HAVE_ARCH_PTEP_ESTABLISH
++/*
++ * Establish a new mapping:
++ *  - flush the old one
++ *  - update the page tables
++ *  - inform the TLB about the new one
++ *
++ * We hold the mm semaphore for reading and vma->vm_mm->page_table_lock.
++ *
++ * Note: the old pte is known to not be writable, so we don't need to
++ * worry about dirty bits etc getting lost.
++ */
++#ifndef __HAVE_ARCH_SET_PTE_ATOMIC
++#define ptep_establish(__vma, __address, __ptep, __entry)		\
++do {				  					\
++	set_pte(__ptep, __entry);					\
++	flush_tlb_page(__vma, __address);				\
++} while (0)
++#else /* __HAVE_ARCH_SET_PTE_ATOMIC */
++#define ptep_establish(__vma, __address, __ptep, __entry)		\
++do {				  					\
++	set_pte_atomic(__ptep, __entry);				\
++	flush_tlb_page(__vma, __address);				\
++} while (0)
++#endif /* __HAVE_ARCH_SET_PTE_ATOMIC */
++#endif
++
++#ifndef __HAVE_ARCH_PTEP_SET_ACCESS_FLAGS
++/*
++ * Largely same as above, but only sets the access flags (dirty,
++ * accessed, and writable). Furthermore, we know it always gets set
++ * to a "more permissive" setting, which allows most architectures
++ * to optimize this.
++ */
++#define ptep_set_access_flags(__vma, __address, __ptep, __entry, __dirty) \
++do {				  					  \
++	set_pte(__ptep, __entry);					  \
++	flush_tlb_page(__vma, __address);				  \
++} while (0)
++#endif
++
++#ifndef __HAVE_ARCH_PTEP_TEST_AND_CLEAR_YOUNG
++static inline int ptep_test_and_clear_young(pte_t *ptep)
++{
++	pte_t pte = *ptep;
++	if (!pte_young(pte))
++		return 0;
++	set_pte(ptep, pte_mkold(pte));
++	return 1;
++}
++#endif
++
++#ifndef __HAVE_ARCH_PTEP_CLEAR_YOUNG_FLUSH
++#define ptep_clear_flush_young(__vma, __address, __ptep)		\
++({									\
++	int __young = ptep_test_and_clear_young(__ptep);		\
++	if (__young)							\
++		flush_tlb_page(__vma, __address);			\
++	__young;							\
++})
++#endif
++
++#ifndef __HAVE_ARCH_PTEP_TEST_AND_CLEAR_DIRTY
++static inline int ptep_test_and_clear_dirty(pte_t *ptep)
++{
++	pte_t pte = *ptep;
++	if (!pte_dirty(pte))
++		return 0;
++	set_pte(ptep, pte_mkclean(pte));
++	return 1;
++}
++#endif
++
++#ifndef __HAVE_ARCH_PTEP_CLEAR_DIRTY_FLUSH
++#define ptep_clear_flush_dirty(__vma, __address, __ptep)		\
++({									\
++	int __dirty = ptep_test_and_clear_dirty(__ptep);		\
++	if (__dirty)							\
++		flush_tlb_page(__vma, __address);			\
++	__dirty;							\
++})
++#endif
++
++#ifndef __HAVE_ARCH_PTEP_GET_AND_CLEAR
++static inline pte_t ptep_get_and_clear(pte_t *ptep)
++{
++	pte_t pte = *ptep;
++	pte_clear(ptep);
++	return pte;
++}
++#endif
++
++#ifndef __HAVE_ARCH_PTEP_CLEAR_FLUSH
++#define ptep_clear_flush(__vma, __address, __ptep)			\
++({									\
++	pte_t __pte = ptep_get_and_clear(__ptep);			\
++	flush_tlb_page(__vma, __address);				\
++	__pte;								\
++})
++#endif
++
++#ifndef __HAVE_ARCH_PTEP_SET_WRPROTECT
++static inline void ptep_set_wrprotect(pte_t *ptep)
++{
++	pte_t old_pte = *ptep;
++	set_pte(ptep, pte_wrprotect(old_pte));
++}
++#endif
++
++#ifndef __HAVE_ARCH_PTEP_MKDIRTY
++static inline void ptep_mkdirty(pte_t *ptep)
++{
++	pte_t old_pte = *ptep;
++	set_pte(ptep, pte_mkdirty(old_pte));
++}
++#endif
++
++#ifndef __HAVE_ARCH_PTE_SAME
++#define pte_same(A,B)	(pte_val(A) == pte_val(B))
++#endif
++
++#ifndef __HAVE_ARCH_PAGE_TEST_AND_CLEAR_DIRTY
++#define page_test_and_clear_dirty(page) (0)
++#endif
++
++#ifndef __HAVE_ARCH_PAGE_TEST_AND_CLEAR_YOUNG
++#define page_test_and_clear_young(page) (0)
++#endif
++
++#ifndef __HAVE_ARCH_PGD_OFFSET_GATE
++#define pgd_offset_gate(mm, addr)	pgd_offset(mm, addr)
++#endif
++
++#endif /* _ASM_GENERIC_PGTABLE_H */
+--- linux-libc-headers-2.6.9.1/include/asm-generic/rmap.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/rmap.h	2004-01-16 16:00:38.000000000 +0100
+@@ -0,0 +1,90 @@
++#ifndef _GENERIC_RMAP_H
++#define _GENERIC_RMAP_H
++/*
++ * linux/include/asm-generic/rmap.h
++ *
++ * Architecture dependent parts of the reverse mapping code,
++ * this version should work for most architectures with a
++ * 'normal' page table layout.
++ *
++ * We use the struct page of the page table page to find out
++ * the process and full address of a page table entry:
++ * - page->mapping points to the process' mm_struct
++ * - page->index has the high bits of the address
++ * - the lower bits of the address are calculated from the
++ *   offset of the page table entry within the page table page
++ *
++ * For CONFIG_HIGHPTE, we need to represent the address of a pte in a
++ * scalar pte_addr_t.  The pfn of the pte's page is shifted left by PAGE_SIZE
++ * bits and is then ORed with the byte offset of the pte within its page.
++ *
++ * For CONFIG_HIGHMEM4G, the pte_addr_t is 32 bits.  20 for the pfn, 12 for
++ * the offset.
++ *
++ * For CONFIG_HIGHMEM64G, the pte_addr_t is 64 bits.  52 for the pfn, 12 for
++ * the offset.
++ */
++#include <linux/mm.h>
++
++static inline void pgtable_add_rmap(struct page * page, struct mm_struct * mm, unsigned long address)
++{
++#ifdef BROKEN_PPC_PTE_ALLOC_ONE
++	/* OK, so PPC calls pte_alloc() before mem_map[] is setup ... ;( */
++	extern int mem_init_done;
++
++	if (!mem_init_done)
++		return;
++#endif
++	page->mapping = (void *)mm;
++	page->index = address & ~((PTRS_PER_PTE * PAGE_SIZE) - 1);
++	inc_page_state(nr_page_table_pages);
++}
++
++static inline void pgtable_remove_rmap(struct page * page)
++{
++	page->mapping = NULL;
++	page->index = 0;
++	dec_page_state(nr_page_table_pages);
++}
++
++static inline struct mm_struct * ptep_to_mm(pte_t * ptep)
++{
++	struct page * page = kmap_atomic_to_page(ptep);
++	return (struct mm_struct *) page->mapping;
++}
++
++static inline unsigned long ptep_to_address(pte_t * ptep)
++{
++	struct page * page = kmap_atomic_to_page(ptep);
++	unsigned long low_bits;
++	low_bits = ((unsigned long)ptep & ~PAGE_MASK) * PTRS_PER_PTE;
++	return page->index + low_bits;
++}
++
++#ifdef CONFIG_HIGHPTE
++static inline pte_addr_t ptep_to_paddr(pte_t *ptep)
++{
++	pte_addr_t paddr;
++	paddr = ((pte_addr_t)page_to_pfn(kmap_atomic_to_page(ptep))) << PAGE_SHIFT;
++	return paddr + (pte_addr_t)((unsigned long)ptep & ~PAGE_MASK);
++}
++#else
++static inline pte_addr_t ptep_to_paddr(pte_t *ptep)
++{
++	return (pte_addr_t)ptep;
++}
++#endif
++
++#ifndef CONFIG_HIGHPTE
++static inline pte_t *rmap_ptep_map(pte_addr_t pte_paddr)
++{
++	return (pte_t *)pte_paddr;
++}
++
++static inline void rmap_ptep_unmap(pte_t *pte)
++{
++	return;
++}
++#endif
++
++#endif /* _GENERIC_RMAP_H */
+--- linux-libc-headers-2.6.9.1/include/asm-generic/rtc.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/rtc.h	2004-12-08 17:39:48.000000000 +0100
+@@ -0,0 +1,213 @@
++/* 
++ * inclue/asm-generic/rtc.h
++ *
++ * Author: Tom Rini <trini@mvista.com>
++ *
++ * Based on:
++ * drivers/char/rtc.c
++ *
++ * Please read the COPYING file for all license details.
++ */
++
++#ifndef __ASM_RTC_H__
++#define __ASM_RTC_H__
++
++#ifdef __KERNEL__
++
++#include <linux/mc146818rtc.h>
++#include <linux/rtc.h>
++#include <linux/bcd.h>
++
++#define RTC_PIE 0x40		/* periodic interrupt enable */
++#define RTC_AIE 0x20		/* alarm interrupt enable */
++#define RTC_UIE 0x10		/* update-finished interrupt enable */
++
++/* some dummy definitions */
++#define RTC_BATT_BAD 0x100	/* battery bad */
++#define RTC_SQWE 0x08		/* enable square-wave output */
++#define RTC_DM_BINARY 0x04	/* all time/date values are BCD if clear */
++#define RTC_24H 0x02		/* 24 hour mode - else hours bit 7 means pm */
++#define RTC_DST_EN 0x01	        /* auto switch DST - works f. USA only */
++
++/*
++ * Returns true if a clock update is in progress
++ */
++static inline unsigned char rtc_is_updating(void)
++{
++	unsigned char uip;
++
++	spin_lock_irq(&rtc_lock);
++	uip = (CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP);
++	spin_unlock_irq(&rtc_lock);
++	return uip;
++}
++
++static inline unsigned int get_rtc_time(struct rtc_time *time)
++{
++	unsigned long uip_watchdog = jiffies;
++	unsigned char ctrl;
++#ifdef CONFIG_MACH_DECSTATION
++	unsigned int real_year;
++#endif
++
++	/*
++	 * read RTC once any update in progress is done. The update
++	 * can take just over 2ms. We wait 10 to 20ms. There is no need to
++	 * to poll-wait (up to 1s - eeccch) for the falling edge of RTC_UIP.
++	 * If you need to know *exactly* when a second has started, enable
++	 * periodic update complete interrupts, (via ioctl) and then 
++	 * immediately read /dev/rtc which will block until you get the IRQ.
++	 * Once the read clears, read the RTC time (again via ioctl). Easy.
++	 */
++
++	if (rtc_is_updating() != 0)
++		while (jiffies - uip_watchdog < 2*HZ/100) {
++			barrier();
++			cpu_relax();
++		}
++
++	/*
++	 * Only the values that we read from the RTC are set. We leave
++	 * tm_wday, tm_yday and tm_isdst untouched. Even though the
++	 * RTC has RTC_DAY_OF_WEEK, we ignore it, as it is only updated
++	 * by the RTC when initially set to a non-zero value.
++	 */
++	spin_lock_irq(&rtc_lock);
++	time->tm_sec = CMOS_READ(RTC_SECONDS);
++	time->tm_min = CMOS_READ(RTC_MINUTES);
++	time->tm_hour = CMOS_READ(RTC_HOURS);
++	time->tm_mday = CMOS_READ(RTC_DAY_OF_MONTH);
++	time->tm_mon = CMOS_READ(RTC_MONTH);
++	time->tm_year = CMOS_READ(RTC_YEAR);
++#ifdef CONFIG_MACH_DECSTATION
++	real_year = CMOS_READ(RTC_DEC_YEAR);
++#endif
++	ctrl = CMOS_READ(RTC_CONTROL);
++	spin_unlock_irq(&rtc_lock);
++
++	if (!(ctrl & RTC_DM_BINARY) || RTC_ALWAYS_BCD)
++	{
++		BCD_TO_BIN(time->tm_sec);
++		BCD_TO_BIN(time->tm_min);
++		BCD_TO_BIN(time->tm_hour);
++		BCD_TO_BIN(time->tm_mday);
++		BCD_TO_BIN(time->tm_mon);
++		BCD_TO_BIN(time->tm_year);
++	}
++
++#ifdef CONFIG_MACH_DECSTATION
++	time->tm_year += real_year - 72;
++#endif
++
++	/*
++	 * Account for differences between how the RTC uses the values
++	 * and how they are defined in a struct rtc_time;
++	 */
++	if (time->tm_year <= 69)
++		time->tm_year += 100;
++
++	time->tm_mon--;
++
++	return RTC_24H;
++}
++
++/* Set the current date and time in the real time clock. */
++static inline int set_rtc_time(struct rtc_time *time)
++{
++	unsigned char mon, day, hrs, min, sec;
++	unsigned char save_control, save_freq_select;
++	unsigned int yrs;
++#ifdef CONFIG_MACH_DECSTATION
++	unsigned int real_yrs, leap_yr;
++#endif
++
++	yrs = time->tm_year;
++	mon = time->tm_mon + 1;   /* tm_mon starts at zero */
++	day = time->tm_mday;
++	hrs = time->tm_hour;
++	min = time->tm_min;
++	sec = time->tm_sec;
++
++	if (yrs > 255)	/* They are unsigned */
++		return -EINVAL;
++
++	spin_lock_irq(&rtc_lock);
++#ifdef CONFIG_MACH_DECSTATION
++	real_yrs = yrs;
++	leap_yr = ((!((yrs + 1900) % 4) && ((yrs + 1900) % 100)) ||
++			!((yrs + 1900) % 400));
++	yrs = 72;
++
++	/*
++	 * We want to keep the year set to 73 until March
++	 * for non-leap years, so that Feb, 29th is handled
++	 * correctly.
++	 */
++	if (!leap_yr && mon < 3) {
++		real_yrs--;
++		yrs = 73;
++	}
++#endif
++	/* These limits and adjustments are independent of
++	 * whether the chip is in binary mode or not.
++	 */
++	if (yrs > 169) {
++		spin_unlock_irq(&rtc_lock);
++		return -EINVAL;
++	}
++
++	if (yrs >= 100)
++		yrs -= 100;
++
++	if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY)
++	    || RTC_ALWAYS_BCD) {
++		BIN_TO_BCD(sec);
++		BIN_TO_BCD(min);
++		BIN_TO_BCD(hrs);
++		BIN_TO_BCD(day);
++		BIN_TO_BCD(mon);
++		BIN_TO_BCD(yrs);
++	}
++
++	save_control = CMOS_READ(RTC_CONTROL);
++	CMOS_WRITE((save_control|RTC_SET), RTC_CONTROL);
++	save_freq_select = CMOS_READ(RTC_FREQ_SELECT);
++	CMOS_WRITE((save_freq_select|RTC_DIV_RESET2), RTC_FREQ_SELECT);
++
++#ifdef CONFIG_MACH_DECSTATION
++	CMOS_WRITE(real_yrs, RTC_DEC_YEAR);
++#endif
++	CMOS_WRITE(yrs, RTC_YEAR);
++	CMOS_WRITE(mon, RTC_MONTH);
++	CMOS_WRITE(day, RTC_DAY_OF_MONTH);
++	CMOS_WRITE(hrs, RTC_HOURS);
++	CMOS_WRITE(min, RTC_MINUTES);
++	CMOS_WRITE(sec, RTC_SECONDS);
++
++	CMOS_WRITE(save_control, RTC_CONTROL);
++	CMOS_WRITE(save_freq_select, RTC_FREQ_SELECT);
++
++	spin_unlock_irq(&rtc_lock);
++
++	return 0;
++}
++
++static inline unsigned int get_rtc_ss(void)
++{
++	struct rtc_time h;
++
++	get_rtc_time(&h);
++	return h.tm_sec;
++}
++
++static inline int get_rtc_pll(struct rtc_pll_info *pll)
++{
++	return -EINVAL;
++}
++static inline int set_rtc_pll(struct rtc_pll_info *pll)
++{
++	return -EINVAL;
++}
++
++#endif /* __KERNEL__ */
++#endif /* __ASM_RTC_H__ */
+--- linux-libc-headers-2.6.9.1/include/asm-generic/sections.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/sections.h	2004-01-25 14:35:16.000000000 +0100
+@@ -0,0 +1,12 @@
++#ifndef _ASM_GENERIC_SECTIONS_H_
++#define _ASM_GENERIC_SECTIONS_H_
++
++/* References to section boundaries */
++
++extern char _text[], _stext[], _etext[];
++extern char _data[], _sdata[], _edata[];
++extern char __bss_start[], __bss_stop[];
++extern char __init_begin[], __init_end[];
++extern char _sinittext[], _einittext[];
++
++#endif /* _ASM_GENERIC_SECTIONS_H_ */
+--- linux-libc-headers-2.6.9.1/include/asm-generic/siginfo.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/siginfo.h	2004-12-08 17:39:48.000000000 +0100
+@@ -0,0 +1,295 @@
++#ifndef _ASM_GENERIC_SIGINFO_H
++#define _ASM_GENERIC_SIGINFO_H
++
++#include <linux/compiler.h>
++#include <linux/types.h>
++#include <linux/resource.h>
++
++typedef union sigval {
++	int sival_int;
++	void __user *sival_ptr;
++} sigval_t;
++
++/*
++ * This is the size (including padding) of the part of the
++ * struct siginfo that is before the union.
++ */
++#ifndef __ARCH_SI_PREAMBLE_SIZE
++#define __ARCH_SI_PREAMBLE_SIZE	(3 * sizeof(int))
++#endif
++
++#define SI_MAX_SIZE	128
++#ifndef SI_PAD_SIZE
++#define SI_PAD_SIZE	((SI_MAX_SIZE - __ARCH_SI_PREAMBLE_SIZE) / sizeof(int))
++#endif
++
++#ifndef __ARCH_SI_UID_T
++#define __ARCH_SI_UID_T	uid_t
++#endif
++
++/*
++ * The default "si_band" type is "long", as specified by POSIX.
++ * However, some architectures want to override this to "int"
++ * for historical compatibility reasons, so we allow that.
++ */
++#ifndef __ARCH_SI_BAND_T
++#define __ARCH_SI_BAND_T long
++#endif
++
++#ifndef HAVE_ARCH_SIGINFO_T
++
++typedef struct siginfo {
++	int si_signo;
++	int si_errno;
++	int si_code;
++
++	union {
++		int _pad[SI_PAD_SIZE];
++
++		/* kill() */
++		struct {
++			pid_t _pid;		/* sender's pid */
++			__ARCH_SI_UID_T _uid;	/* sender's uid */
++		} _kill;
++
++		/* POSIX.1b timers */
++		struct {
++			timer_t _tid;		/* timer id */
++			int _overrun;		/* overrun count */
++			char _pad[sizeof( __ARCH_SI_UID_T) - sizeof(int)];
++			sigval_t _sigval;	/* same as below */
++			int _sys_private;       /* not to be passed to user */
++		} _timer;
++
++		/* POSIX.1b signals */
++		struct {
++			pid_t _pid;		/* sender's pid */
++			__ARCH_SI_UID_T _uid;	/* sender's uid */
++			sigval_t _sigval;
++		} _rt;
++
++		/* SIGCHLD */
++		struct {
++			pid_t _pid;		/* which child */
++			__ARCH_SI_UID_T _uid;	/* sender's uid */
++			int _status;		/* exit code */
++			clock_t _utime;
++			clock_t _stime;
++		} _sigchld;
++
++		/* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
++		struct {
++			void __user *_addr; /* faulting insn/memory ref. */
++#ifdef __ARCH_SI_TRAPNO
++			int _trapno;	/* TRAP # which caused the signal */
++#endif
++		} _sigfault;
++
++		/* SIGPOLL */
++		struct {
++			__ARCH_SI_BAND_T _band;	/* POLL_IN, POLL_OUT, POLL_MSG */
++			int _fd;
++		} _sigpoll;
++	} _sifields;
++} siginfo_t;
++
++#endif
++
++/*
++ * How these fields are to be accessed.
++ */
++#define si_pid		_sifields._kill._pid
++#define si_uid		_sifields._kill._uid
++#define si_tid		_sifields._timer._tid
++#define si_overrun	_sifields._timer._overrun
++#define si_sys_private  _sifields._timer._sys_private
++#define si_status	_sifields._sigchld._status
++#define si_utime	_sifields._sigchld._utime
++#define si_stime	_sifields._sigchld._stime
++#define si_value	_sifields._rt._sigval
++#define si_int		_sifields._rt._sigval.sival_int
++#define si_ptr		_sifields._rt._sigval.sival_ptr
++#define si_addr		_sifields._sigfault._addr
++#ifdef __ARCH_SI_TRAPNO
++#define si_trapno	_sifields._sigfault._trapno
++#endif
++#define si_band		_sifields._sigpoll._band
++#define si_fd		_sifields._sigpoll._fd
++
++#ifdef __KERNEL__
++#define __SI_MASK	0xffff0000u
++#define __SI_KILL	(0 << 16)
++#define __SI_TIMER	(1 << 16)
++#define __SI_POLL	(2 << 16)
++#define __SI_FAULT	(3 << 16)
++#define __SI_CHLD	(4 << 16)
++#define __SI_RT		(5 << 16)
++#define __SI_MESGQ	(6 << 16)
++#define __SI_CODE(T,N)	((T) | ((N) & 0xffff))
++#else
++#define __SI_KILL	0
++#define __SI_TIMER	0
++#define __SI_POLL	0
++#define __SI_FAULT	0
++#define __SI_CHLD	0
++#define __SI_RT		0
++#define __SI_MESGQ	0
++#define __SI_CODE(T,N)	(N)
++#endif
++
++/*
++ * si_code values
++ * Digital reserves positive values for kernel-generated signals.
++ */
++#define SI_USER		0		/* sent by kill, sigsend, raise */
++#define SI_KERNEL	0x80		/* sent by the kernel from somewhere */
++#define SI_QUEUE	-1		/* sent by sigqueue */
++#define SI_TIMER __SI_CODE(__SI_TIMER,-2) /* sent by timer expiration */
++#define SI_MESGQ __SI_CODE(__SI_MESGQ,-3) /* sent by real time mesq state change */
++#define SI_ASYNCIO	-4		/* sent by AIO completion */
++#define SI_SIGIO	-5		/* sent by queued SIGIO */
++#define SI_TKILL	-6		/* sent by tkill system call */
++#define SI_DETHREAD	-7		/* sent by execve() killing subsidiary threads */
++
++#define SI_FROMUSER(siptr)	((siptr)->si_code <= 0)
++#define SI_FROMKERNEL(siptr)	((siptr)->si_code > 0)
++
++#ifndef HAVE_ARCH_SI_CODES
++/*
++ * SIGILL si_codes
++ */
++#define ILL_ILLOPC	(__SI_FAULT|1)	/* illegal opcode */
++#define ILL_ILLOPN	(__SI_FAULT|2)	/* illegal operand */
++#define ILL_ILLADR	(__SI_FAULT|3)	/* illegal addressing mode */
++#define ILL_ILLTRP	(__SI_FAULT|4)	/* illegal trap */
++#define ILL_PRVOPC	(__SI_FAULT|5)	/* privileged opcode */
++#define ILL_PRVREG	(__SI_FAULT|6)	/* privileged register */
++#define ILL_COPROC	(__SI_FAULT|7)	/* coprocessor error */
++#define ILL_BADSTK	(__SI_FAULT|8)	/* internal stack error */
++#define NSIGILL		8
++
++/*
++ * SIGFPE si_codes
++ */
++#define FPE_INTDIV	(__SI_FAULT|1)	/* integer divide by zero */
++#define FPE_INTOVF	(__SI_FAULT|2)	/* integer overflow */
++#define FPE_FLTDIV	(__SI_FAULT|3)	/* floating point divide by zero */
++#define FPE_FLTOVF	(__SI_FAULT|4)	/* floating point overflow */
++#define FPE_FLTUND	(__SI_FAULT|5)	/* floating point underflow */
++#define FPE_FLTRES	(__SI_FAULT|6)	/* floating point inexact result */
++#define FPE_FLTINV	(__SI_FAULT|7)	/* floating point invalid operation */
++#define FPE_FLTSUB	(__SI_FAULT|8)	/* subscript out of range */
++#define NSIGFPE		8
++
++/*
++ * SIGSEGV si_codes
++ */
++#define SEGV_MAPERR	(__SI_FAULT|1)	/* address not mapped to object */
++#define SEGV_ACCERR	(__SI_FAULT|2)	/* invalid permissions for mapped object */
++#define NSIGSEGV	2
++
++/*
++ * SIGBUS si_codes
++ */
++#define BUS_ADRALN	(__SI_FAULT|1)	/* invalid address alignment */
++#define BUS_ADRERR	(__SI_FAULT|2)	/* non-existant physical address */
++#define BUS_OBJERR	(__SI_FAULT|3)	/* object specific hardware error */
++#define NSIGBUS		3
++
++/*
++ * SIGTRAP si_codes
++ */
++#define TRAP_BRKPT	(__SI_FAULT|1)	/* process breakpoint */
++#define TRAP_TRACE	(__SI_FAULT|2)	/* process trace trap */
++#define NSIGTRAP	2
++
++/*
++ * SIGCHLD si_codes
++ */
++#define CLD_EXITED	(__SI_CHLD|1)	/* child has exited */
++#define CLD_KILLED	(__SI_CHLD|2)	/* child was killed */
++#define CLD_DUMPED	(__SI_CHLD|3)	/* child terminated abnormally */
++#define CLD_TRAPPED	(__SI_CHLD|4)	/* traced child has trapped */
++#define CLD_STOPPED	(__SI_CHLD|5)	/* child has stopped */
++#define CLD_CONTINUED	(__SI_CHLD|6)	/* stopped child has continued */
++#define NSIGCHLD	6
++
++/*
++ * SIGPOLL si_codes
++ */
++#define POLL_IN		(__SI_POLL|1)	/* data input available */
++#define POLL_OUT	(__SI_POLL|2)	/* output buffers available */
++#define POLL_MSG	(__SI_POLL|3)	/* input message available */
++#define POLL_ERR	(__SI_POLL|4)	/* i/o error */
++#define POLL_PRI	(__SI_POLL|5)	/* high priority input available */
++#define POLL_HUP	(__SI_POLL|6)	/* device disconnected */
++#define NSIGPOLL	6
++
++#endif
++
++/*
++ * sigevent definitions
++ * 
++ * It seems likely that SIGEV_THREAD will have to be handled from 
++ * userspace, libpthread transmuting it to SIGEV_SIGNAL, which the
++ * thread manager then catches and does the appropriate nonsense.
++ * However, everything is written out here so as to not get lost.
++ */
++#define SIGEV_SIGNAL	0	/* notify via signal */
++#define SIGEV_NONE	1	/* other notification: meaningless */
++#define SIGEV_THREAD	2	/* deliver via thread creation */
++#define SIGEV_THREAD_ID 4	/* deliver to thread */
++
++#define SIGEV_MAX_SIZE	64
++#ifndef SIGEV_PAD_SIZE
++#define SIGEV_PAD_SIZE	((SIGEV_MAX_SIZE/sizeof(int)) - 3)
++#endif
++
++#ifndef HAVE_ARCH_SIGEVENT_T
++
++typedef struct sigevent {
++	sigval_t sigev_value;
++	int sigev_signo;
++	int sigev_notify;
++	union {
++		int _pad[SIGEV_PAD_SIZE];
++		 int _tid;
++
++		struct {
++			void (*_function)(sigval_t);
++			void *_attribute;	/* really pthread_attr_t */
++		} _sigev_thread;
++	} _sigev_un;
++} sigevent_t;
++
++#endif
++
++#define sigev_notify_function	_sigev_un._sigev_thread._function
++#define sigev_notify_attributes	_sigev_un._sigev_thread._attribute
++#define sigev_notify_thread_id	 _sigev_un._tid
++
++#ifdef __KERNEL__
++
++struct siginfo;
++void do_schedule_next_timer(struct siginfo *info);
++
++#ifndef HAVE_ARCH_COPY_SIGINFO
++
++#include <linux/string.h>
++
++static inline void copy_siginfo(struct siginfo *to, struct siginfo *from)
++{
++	if (from->si_code < 0)
++		memcpy(to, from, sizeof(*to));
++	else
++		/* _sigchld is currently the largest know union member */
++		memcpy(to, from, __ARCH_SI_PREAMBLE_SIZE + sizeof(from->_sifields._sigchld));
++}
++
++#endif
++
++extern int copy_siginfo_to_user(struct siginfo __user *to, struct siginfo *from);
++
++#endif /* __KERNEL__ */
++
++#endif
+--- linux-libc-headers-2.6.9.1/include/asm-generic/statfs.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/statfs.h	2004-01-25 14:35:16.000000000 +0100
+@@ -0,0 +1,51 @@
++#ifndef _GENERIC_STATFS_H
++#define _GENERIC_STATFS_H
++
++#ifndef __KERNEL_STRICT_NAMES
++# include <linux/types.h>
++typedef __kernel_fsid_t	fsid_t;
++#endif
++
++struct statfs {
++	__u32 f_type;
++	__u32 f_bsize;
++	__u32 f_blocks;
++	__u32 f_bfree;
++	__u32 f_bavail;
++	__u32 f_files;
++	__u32 f_ffree;
++	__kernel_fsid_t f_fsid;
++	__u32 f_namelen;
++	__u32 f_frsize;
++	__u32 f_spare[5];
++};
++
++struct statfs64 {
++	__u32 f_type;
++	__u32 f_bsize;
++	__u64 f_blocks;
++	__u64 f_bfree;
++	__u64 f_bavail;
++	__u64 f_files;
++	__u64 f_ffree;
++	__kernel_fsid_t f_fsid;
++	__u32 f_namelen;
++	__u32 f_frsize;
++	__u32 f_spare[5];
++};
++
++struct compat_statfs64 {
++	__u32 f_type;
++	__u32 f_bsize;
++	__u64 f_blocks;
++	__u64 f_bfree;
++	__u64 f_bavail;
++	__u64 f_files;
++	__u64 f_ffree;
++	__kernel_fsid_t f_fsid;
++	__u32 f_namelen;
++	__u32 f_frsize;
++	__u32 f_spare[5];
++};
++
++#endif
+--- linux-libc-headers-2.6.9.1/include/asm-generic/tlb.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/tlb.h	2005-05-18 20:35:14.000000000 +0200
+@@ -0,0 +1,152 @@
++/* asm-generic/tlb.h
++ *
++ *	Generic TLB shootdown code
++ *
++ * Copyright 2001 Red Hat, Inc.
++ * Based on code from mm/memory.c Copyright Linus Torvalds and others.
++ *
++ * This program is free software; you can redistribute it and/or
++ * modify it under the terms of the GNU General Public License
++ * as published by the Free Software Foundation; either version
++ * 2 of the License, or (at your option) any later version.
++ */
++#ifndef _ASM_GENERIC__TLB_H
++#define _ASM_GENERIC__TLB_H
++
++// #include <linux/config.h>
++#include <linux/swap.h>
++#include <asm/pgalloc.h>
++#include <asm/tlbflush.h>
++
++/*
++ * For UP we don't need to worry about TLB flush
++ * and page free order so much..
++ */
++#ifdef CONFIG_SMP
++  #define FREE_PTE_NR	506
++  #define tlb_fast_mode(tlb) ((tlb)->nr == ~0U)
++#else
++  #define FREE_PTE_NR	1
++  #define tlb_fast_mode(tlb) 1
++#endif
++
++/* struct mmu_gather is an opaque type used by the mm code for passing around
++ * any data needed by arch specific code for tlb_remove_page.  This structure
++ * can be per-CPU or per-MM as the page table lock is held for the duration of
++ * TLB shootdown.
++ */
++struct mmu_gather {
++	struct mm_struct	*mm;
++	unsigned int		nr;	/* set to ~0U means fast mode */
++	unsigned int		need_flush;/* Really unmapped some ptes? */
++	unsigned int		fullmm; /* non-zero means full mm flush */
++	unsigned long		freed;
++	struct page *		pages[FREE_PTE_NR];
++};
++
++/* Users of the generic TLB shootdown code must declare this storage space. */
++DECLARE_PER_CPU(struct mmu_gather, mmu_gathers);
++
++/* tlb_gather_mmu
++ *	Return a pointer to an initialized struct mmu_gather.
++ */
++static inline struct mmu_gather *
++tlb_gather_mmu(struct mm_struct *mm, unsigned int full_mm_flush)
++{
++	struct mmu_gather *tlb = &per_cpu(mmu_gathers, smp_processor_id());
++
++	tlb->mm = mm;
++
++	/* Use fast mode if only one CPU is online */
++	tlb->nr = num_online_cpus() > 1 ? 0U : ~0U;
++
++	tlb->fullmm = full_mm_flush;
++	tlb->freed = 0;
++
++	return tlb;
++}
++
++static inline void
++tlb_flush_mmu(struct mmu_gather *tlb, unsigned long start, unsigned long end)
++{
++	if (!tlb->need_flush)
++		return;
++	tlb->need_flush = 0;
++	tlb_flush(tlb);
++	if (!tlb_fast_mode(tlb)) {
++		free_pages_and_swap_cache(tlb->pages, tlb->nr);
++		tlb->nr = 0;
++	}
++}
++
++/* tlb_finish_mmu
++ *	Called at the end of the shootdown operation to free up any resources
++ *	that were required.  The page table lock is still held at this point.
++ */
++static inline void
++tlb_finish_mmu(struct mmu_gather *tlb, unsigned long start, unsigned long end)
++{
++	int freed = tlb->freed;
++	struct mm_struct *mm = tlb->mm;
++	int rss = mm->rss;
++
++	if (rss < freed)
++		freed = rss;
++	mm->rss = rss - freed;
++	tlb_flush_mmu(tlb, start, end);
++
++	/* keep the page table cache within bounds */
++	check_pgt_cache();
++}
++
++static inline unsigned int
++tlb_is_full_mm(struct mmu_gather *tlb)
++{
++	return tlb->fullmm;
++}
++
++/* tlb_remove_page
++ *	Must perform the equivalent to __free_pte(pte_get_and_clear(ptep)), while
++ *	handling the additional races in SMP caused by other CPUs caching valid
++ *	mappings in their TLBs.
++ */
++static inline void tlb_remove_page(struct mmu_gather *tlb, struct page *page)
++{
++	tlb->need_flush = 1;
++	if (tlb_fast_mode(tlb)) {
++		free_page_and_swap_cache(page);
++		return;
++	}
++	tlb->pages[tlb->nr++] = page;
++	if (tlb->nr >= FREE_PTE_NR)
++		tlb_flush_mmu(tlb, 0, 0);
++}
++
++/**
++ * tlb_remove_tlb_entry - remember a pte unmapping for later tlb invalidation.
++ *
++ * Record the fact that pte's were really umapped in ->need_flush, so we can
++ * later optimise away the tlb invalidate.   This helps when userspace is
++ * unmapping already-unmapped pages, which happens quite a lot.
++ */
++#define tlb_remove_tlb_entry(tlb, ptep, address)		\
++	do {							\
++		tlb->need_flush = 1;				\
++		__tlb_remove_tlb_entry(tlb, ptep, address);	\
++	} while (0)
++
++#define pte_free_tlb(tlb, ptep)					\
++	do {							\
++		tlb->need_flush = 1;				\
++		__pte_free_tlb(tlb, ptep);			\
++	} while (0)
++
++#define pmd_free_tlb(tlb, pmdp)					\
++	do {							\
++		tlb->need_flush = 1;				\
++		__pmd_free_tlb(tlb, pmdp);			\
++	} while (0)
++
++#define tlb_migrate_finish(mm) do {} while (0)
++
++#endif /* _ASM_GENERIC__TLB_H */
+--- linux-libc-headers-2.6.9.1/include/asm-generic/topology.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/topology.h	2004-05-07 15:36:24.000000000 +0200
+@@ -0,0 +1,53 @@
++/*
++ * linux/include/asm-generic/topology.h
++ *
++ * Written by: Matthew Dobson, IBM Corporation
++ *
++ * Copyright (C) 2002, IBM Corp.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ * Send feedback to <colpatch@us.ibm.com>
++ */
++#ifndef _ASM_GENERIC_TOPOLOGY_H
++#define _ASM_GENERIC_TOPOLOGY_H
++
++/* Other architectures wishing to use this simple topology API should fill
++   in the below functions as appropriate in their own <asm/topology.h> file. */
++#ifndef cpu_to_node
++#define cpu_to_node(cpu)	(0)
++#endif
++#ifndef parent_node
++#define parent_node(node)	(0)
++#endif
++#ifndef node_to_cpumask
++#define node_to_cpumask(node)	(cpu_online_map)
++#endif
++#ifndef node_to_first_cpu
++#define node_to_first_cpu(node)	(0)
++#endif
++#ifndef pcibus_to_cpumask
++#define pcibus_to_cpumask(bus)	(cpu_online_map)
++#endif
++
++/* Cross-node load balancing interval. */
++#ifndef NODE_BALANCE_RATE
++#define NODE_BALANCE_RATE 10
++#endif
++
++#endif /* _ASM_GENERIC_TOPOLOGY_H */
+--- linux-libc-headers-2.6.9.1/include/asm-generic/uaccess.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/uaccess.h	2004-11-27 15:04:26.000000000 +0100
+@@ -0,0 +1,26 @@
++#ifndef _ASM_GENERIC_UACCESS_H_
++#define _ASM_GENERIC_UACCESS_H_
++
++/*
++ * This macro should be used instead of __get_user() when accessing
++ * values at locations that are not known to be aligned.
++ */
++#define __get_user_unaligned(x, ptr)					\
++({									\
++	__typeof__ (*(ptr)) __x;					\
++	__copy_from_user(&__x, (ptr), sizeof(*(ptr))) ? -EFAULT : 0;	\
++	(x) = __x;							\
++})
++
++
++/*
++ * This macro should be used instead of __put_user() when accessing
++ * values at locations that are not known to be aligned.
++ */
++#define __put_user_unaligned(x, ptr)					\
++({									\
++	__typeof__ (*(ptr)) __x = (x);					\
++	__copy_to_user((ptr), &__x, sizeof(*(ptr))) ? -EFAULT : 0;	\
++})
++
++#endif /* _ASM_GENERIC_UACCESS_H */
+--- linux-libc-headers-2.6.9.1/include/asm-generic/unaligned.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/unaligned.h	2004-01-16 16:00:38.000000000 +0100
+@@ -0,0 +1,20 @@
++#ifndef _ASM_GENERIC_UNALIGNED_H_
++#define _ASM_GENERIC_UNALIGNED_H_
++
++/*
++ * For the benefit of those who are trying to port Linux to another
++ * architecture, here are some C-language equivalents. 
++ */
++
++#include <asm/string.h>
++
++
++#define get_unaligned(ptr) \
++  ({ __typeof__(*(ptr)) __tmp; memcpy(&__tmp, (ptr), sizeof(*(ptr))); __tmp; })
++
++#define put_unaligned(val, ptr)				\
++  ({ __typeof__(*(ptr)) __tmp = (val);			\
++     memcpy((ptr), &__tmp, sizeof(*(ptr)));		\
++     (void)0; })
++
++#endif /* _ASM_GENERIC_UNALIGNED_H */
+--- linux-libc-headers-2.6.9.1/include/asm-generic/vmlinux.lds.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/vmlinux.lds.h	2004-12-08 17:39:48.000000000 +0100
+@@ -0,0 +1,84 @@
++#ifndef LOAD_OFFSET
++#define LOAD_OFFSET 0
++#endif
++
++#ifndef VMLINUX_SYMBOL
++#define VMLINUX_SYMBOL(_sym_) _sym_
++#endif
++
++#define RODATA								\
++	.rodata           : AT(ADDR(.rodata) - LOAD_OFFSET) {		\
++		*(.rodata) *(.rodata.*)					\
++		*(__vermagic)		/* Kernel version magic */	\
++	}								\
++									\
++	.rodata1          : AT(ADDR(.rodata1) - LOAD_OFFSET) {		\
++		*(.rodata1)						\
++	}								\
++									\
++	/* PCI quirks */						\
++	.pci_fixup        : AT(ADDR(.pci_fixup) - LOAD_OFFSET) {	\
++		VMLINUX_SYMBOL(__start_pci_fixups_header) = .;		\
++		*(.pci_fixup_header)					\
++		VMLINUX_SYMBOL(__end_pci_fixups_header) = .;		\
++		VMLINUX_SYMBOL(__start_pci_fixups_final) = .;		\
++		*(.pci_fixup_final)					\
++		VMLINUX_SYMBOL(__end_pci_fixups_final) = .;		\
++	}								\
++									\
++	/* Kernel symbol table: Normal symbols */			\
++	__ksymtab         : AT(ADDR(__ksymtab) - LOAD_OFFSET) {		\
++		VMLINUX_SYMBOL(__start___ksymtab) = .;			\
++		*(__ksymtab)						\
++		VMLINUX_SYMBOL(__stop___ksymtab) = .;			\
++	}								\
++									\
++	/* Kernel symbol table: GPL-only symbols */			\
++	__ksymtab_gpl     : AT(ADDR(__ksymtab_gpl) - LOAD_OFFSET) {	\
++		VMLINUX_SYMBOL(__start___ksymtab_gpl) = .;		\
++		*(__ksymtab_gpl)					\
++		VMLINUX_SYMBOL(__stop___ksymtab_gpl) = .;		\
++	}								\
++									\
++	/* Kernel symbol table: Normal symbols */			\
++	__kcrctab         : AT(ADDR(__kcrctab) - LOAD_OFFSET) {		\
++		VMLINUX_SYMBOL(__start___kcrctab) = .;			\
++		*(__kcrctab)						\
++		VMLINUX_SYMBOL(__stop___kcrctab) = .;			\
++	}								\
++									\
++	/* Kernel symbol table: GPL-only symbols */			\
++	__kcrctab_gpl     : AT(ADDR(__kcrctab_gpl) - LOAD_OFFSET) {	\
++		VMLINUX_SYMBOL(__start___kcrctab_gpl) = .;		\
++		*(__kcrctab_gpl)					\
++		VMLINUX_SYMBOL(__stop___kcrctab_gpl) = .;		\
++	}								\
++									\
++	/* Kernel symbol table: strings */				\
++        __ksymtab_strings : AT(ADDR(__ksymtab_strings) - LOAD_OFFSET) {	\
++		*(__ksymtab_strings)					\
++	}								\
++									\
++	/* Built-in module parameters. */				\
++	__param : AT(ADDR(__param) - LOAD_OFFSET) {			\
++		VMLINUX_SYMBOL(__start___param) = .;			\
++		*(__param)						\
++		VMLINUX_SYMBOL(__stop___param) = .;			\
++	}
++
++#define SECURITY_INIT							\
++	.security_initcall.init : {					\
++		VMLINUX_SYMBOL(__security_initcall_start) = .;		\
++		*(.security_initcall.init) 				\
++		VMLINUX_SYMBOL(__security_initcall_end) = .;		\
++	}
++
++#define SCHED_TEXT							\
++		VMLINUX_SYMBOL(__sched_text_start) = .;			\
++		*(.sched.text)						\
++		VMLINUX_SYMBOL(__sched_text_end) = .;
++
++#define LOCK_TEXT							\
++		VMLINUX_SYMBOL(__lock_text_start) = .;			\
++		*(.spinlock.text)					\
++		VMLINUX_SYMBOL(__lock_text_end) = .;
+--- linux-libc-headers-2.6.9.1/include/asm-generic/xor.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-generic/xor.h	2004-01-16 16:00:38.000000000 +0100
+@@ -0,0 +1,718 @@
++/*
++ * include/asm-generic/xor.h
++ *
++ * Generic optimized RAID-5 checksumming functions.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2, or (at your option)
++ * any later version.
++ *
++ * You should have received a copy of the GNU General Public License
++ * (for example /usr/src/linux/COPYING); if not, write to the Free
++ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ */
++
++#include <asm/processor.h>
++
++static void
++xor_8regs_2(unsigned long bytes, unsigned long *p1, unsigned long *p2)
++{
++	long lines = bytes / (sizeof (long)) / 8;
++
++	do {
++		p1[0] ^= p2[0];
++		p1[1] ^= p2[1];
++		p1[2] ^= p2[2];
++		p1[3] ^= p2[3];
++		p1[4] ^= p2[4];
++		p1[5] ^= p2[5];
++		p1[6] ^= p2[6];
++		p1[7] ^= p2[7];
++		p1 += 8;
++		p2 += 8;
++	} while (--lines > 0);
++}
++
++static void
++xor_8regs_3(unsigned long bytes, unsigned long *p1, unsigned long *p2,
++	    unsigned long *p3)
++{
++	long lines = bytes / (sizeof (long)) / 8;
++
++	do {
++		p1[0] ^= p2[0] ^ p3[0];
++		p1[1] ^= p2[1] ^ p3[1];
++		p1[2] ^= p2[2] ^ p3[2];
++		p1[3] ^= p2[3] ^ p3[3];
++		p1[4] ^= p2[4] ^ p3[4];
++		p1[5] ^= p2[5] ^ p3[5];
++		p1[6] ^= p2[6] ^ p3[6];
++		p1[7] ^= p2[7] ^ p3[7];
++		p1 += 8;
++		p2 += 8;
++		p3 += 8;
++	} while (--lines > 0);
++}
++
++static void
++xor_8regs_4(unsigned long bytes, unsigned long *p1, unsigned long *p2,
++	    unsigned long *p3, unsigned long *p4)
++{
++	long lines = bytes / (sizeof (long)) / 8;
++
++	do {
++		p1[0] ^= p2[0] ^ p3[0] ^ p4[0];
++		p1[1] ^= p2[1] ^ p3[1] ^ p4[1];
++		p1[2] ^= p2[2] ^ p3[2] ^ p4[2];
++		p1[3] ^= p2[3] ^ p3[3] ^ p4[3];
++		p1[4] ^= p2[4] ^ p3[4] ^ p4[4];
++		p1[5] ^= p2[5] ^ p3[5] ^ p4[5];
++		p1[6] ^= p2[6] ^ p3[6] ^ p4[6];
++		p1[7] ^= p2[7] ^ p3[7] ^ p4[7];
++		p1 += 8;
++		p2 += 8;
++		p3 += 8;
++		p4 += 8;
++	} while (--lines > 0);
++}
++
++static void
++xor_8regs_5(unsigned long bytes, unsigned long *p1, unsigned long *p2,
++	    unsigned long *p3, unsigned long *p4, unsigned long *p5)
++{
++	long lines = bytes / (sizeof (long)) / 8;
++
++	do {
++		p1[0] ^= p2[0] ^ p3[0] ^ p4[0] ^ p5[0];
++		p1[1] ^= p2[1] ^ p3[1] ^ p4[1] ^ p5[1];
++		p1[2] ^= p2[2] ^ p3[2] ^ p4[2] ^ p5[2];
++		p1[3] ^= p2[3] ^ p3[3] ^ p4[3] ^ p5[3];
++		p1[4] ^= p2[4] ^ p3[4] ^ p4[4] ^ p5[4];
++		p1[5] ^= p2[5] ^ p3[5] ^ p4[5] ^ p5[5];
++		p1[6] ^= p2[6] ^ p3[6] ^ p4[6] ^ p5[6];
++		p1[7] ^= p2[7] ^ p3[7] ^ p4[7] ^ p5[7];
++		p1 += 8;
++		p2 += 8;
++		p3 += 8;
++		p4 += 8;
++		p5 += 8;
++	} while (--lines > 0);
++}
++
++static void
++xor_32regs_2(unsigned long bytes, unsigned long *p1, unsigned long *p2)
++{
++	long lines = bytes / (sizeof (long)) / 8;
++
++	do {
++		register long d0, d1, d2, d3, d4, d5, d6, d7;
++		d0 = p1[0];	/* Pull the stuff into registers	*/
++		d1 = p1[1];	/*  ... in bursts, if possible.		*/
++		d2 = p1[2];
++		d3 = p1[3];
++		d4 = p1[4];
++		d5 = p1[5];
++		d6 = p1[6];
++		d7 = p1[7];
++		d0 ^= p2[0];
++		d1 ^= p2[1];
++		d2 ^= p2[2];
++		d3 ^= p2[3];
++		d4 ^= p2[4];
++		d5 ^= p2[5];
++		d6 ^= p2[6];
++		d7 ^= p2[7];
++		p1[0] = d0;	/* Store the result (in bursts)		*/
++		p1[1] = d1;
++		p1[2] = d2;
++		p1[3] = d3;
++		p1[4] = d4;
++		p1[5] = d5;
++		p1[6] = d6;
++		p1[7] = d7;
++		p1 += 8;
++		p2 += 8;
++	} while (--lines > 0);
++}
++
++static void
++xor_32regs_3(unsigned long bytes, unsigned long *p1, unsigned long *p2,
++	    unsigned long *p3)
++{
++	long lines = bytes / (sizeof (long)) / 8;
++
++	do {
++		register long d0, d1, d2, d3, d4, d5, d6, d7;
++		d0 = p1[0];	/* Pull the stuff into registers	*/
++		d1 = p1[1];	/*  ... in bursts, if possible.		*/
++		d2 = p1[2];
++		d3 = p1[3];
++		d4 = p1[4];
++		d5 = p1[5];
++		d6 = p1[6];
++		d7 = p1[7];
++		d0 ^= p2[0];
++		d1 ^= p2[1];
++		d2 ^= p2[2];
++		d3 ^= p2[3];
++		d4 ^= p2[4];
++		d5 ^= p2[5];
++		d6 ^= p2[6];
++		d7 ^= p2[7];
++		d0 ^= p3[0];
++		d1 ^= p3[1];
++		d2 ^= p3[2];
++		d3 ^= p3[3];
++		d4 ^= p3[4];
++		d5 ^= p3[5];
++		d6 ^= p3[6];
++		d7 ^= p3[7];
++		p1[0] = d0;	/* Store the result (in bursts)		*/
++		p1[1] = d1;
++		p1[2] = d2;
++		p1[3] = d3;
++		p1[4] = d4;
++		p1[5] = d5;
++		p1[6] = d6;
++		p1[7] = d7;
++		p1 += 8;
++		p2 += 8;
++		p3 += 8;
++	} while (--lines > 0);
++}
++
++static void
++xor_32regs_4(unsigned long bytes, unsigned long *p1, unsigned long *p2,
++	    unsigned long *p3, unsigned long *p4)
++{
++	long lines = bytes / (sizeof (long)) / 8;
++
++	do {
++		register long d0, d1, d2, d3, d4, d5, d6, d7;
++		d0 = p1[0];	/* Pull the stuff into registers	*/
++		d1 = p1[1];	/*  ... in bursts, if possible.		*/
++		d2 = p1[2];
++		d3 = p1[3];
++		d4 = p1[4];
++		d5 = p1[5];
++		d6 = p1[6];
++		d7 = p1[7];
++		d0 ^= p2[0];
++		d1 ^= p2[1];
++		d2 ^= p2[2];
++		d3 ^= p2[3];
++		d4 ^= p2[4];
++		d5 ^= p2[5];
++		d6 ^= p2[6];
++		d7 ^= p2[7];
++		d0 ^= p3[0];
++		d1 ^= p3[1];
++		d2 ^= p3[2];
++		d3 ^= p3[3];
++		d4 ^= p3[4];
++		d5 ^= p3[5];
++		d6 ^= p3[6];
++		d7 ^= p3[7];
++		d0 ^= p4[0];
++		d1 ^= p4[1];
++		d2 ^= p4[2];
++		d3 ^= p4[3];
++		d4 ^= p4[4];
++		d5 ^= p4[5];
++		d6 ^= p4[6];
++		d7 ^= p4[7];
++		p1[0] = d0;	/* Store the result (in bursts)		*/
++		p1[1] = d1;
++		p1[2] = d2;
++		p1[3] = d3;
++		p1[4] = d4;
++		p1[5] = d5;
++		p1[6] = d6;
++		p1[7] = d7;
++		p1 += 8;
++		p2 += 8;
++		p3 += 8;
++		p4 += 8;
++	} while (--lines > 0);
++}
++
++static void
++xor_32regs_5(unsigned long bytes, unsigned long *p1, unsigned long *p2,
++	    unsigned long *p3, unsigned long *p4, unsigned long *p5)
++{
++	long lines = bytes / (sizeof (long)) / 8;
++
++	do {
++		register long d0, d1, d2, d3, d4, d5, d6, d7;
++		d0 = p1[0];	/* Pull the stuff into registers	*/
++		d1 = p1[1];	/*  ... in bursts, if possible.		*/
++		d2 = p1[2];
++		d3 = p1[3];
++		d4 = p1[4];
++		d5 = p1[5];
++		d6 = p1[6];
++		d7 = p1[7];
++		d0 ^= p2[0];
++		d1 ^= p2[1];
++		d2 ^= p2[2];
++		d3 ^= p2[3];
++		d4 ^= p2[4];
++		d5 ^= p2[5];
++		d6 ^= p2[6];
++		d7 ^= p2[7];
++		d0 ^= p3[0];
++		d1 ^= p3[1];
++		d2 ^= p3[2];
++		d3 ^= p3[3];
++		d4 ^= p3[4];
++		d5 ^= p3[5];
++		d6 ^= p3[6];
++		d7 ^= p3[7];
++		d0 ^= p4[0];
++		d1 ^= p4[1];
++		d2 ^= p4[2];
++		d3 ^= p4[3];
++		d4 ^= p4[4];
++		d5 ^= p4[5];
++		d6 ^= p4[6];
++		d7 ^= p4[7];
++		d0 ^= p5[0];
++		d1 ^= p5[1];
++		d2 ^= p5[2];
++		d3 ^= p5[3];
++		d4 ^= p5[4];
++		d5 ^= p5[5];
++		d6 ^= p5[6];
++		d7 ^= p5[7];
++		p1[0] = d0;	/* Store the result (in bursts)		*/
++		p1[1] = d1;
++		p1[2] = d2;
++		p1[3] = d3;
++		p1[4] = d4;
++		p1[5] = d5;
++		p1[6] = d6;
++		p1[7] = d7;
++		p1 += 8;
++		p2 += 8;
++		p3 += 8;
++		p4 += 8;
++		p5 += 8;
++	} while (--lines > 0);
++}
++
++static void
++xor_8regs_p_2(unsigned long bytes, unsigned long *p1, unsigned long *p2)
++{
++	long lines = bytes / (sizeof (long)) / 8 - 1;
++	prefetchw(p1);
++	prefetch(p2);
++
++	do {
++		prefetchw(p1+8);
++		prefetch(p2+8);
++ once_more:
++		p1[0] ^= p2[0];
++		p1[1] ^= p2[1];
++		p1[2] ^= p2[2];
++		p1[3] ^= p2[3];
++		p1[4] ^= p2[4];
++		p1[5] ^= p2[5];
++		p1[6] ^= p2[6];
++		p1[7] ^= p2[7];
++		p1 += 8;
++		p2 += 8;
++	} while (--lines > 0);
++	if (lines == 0)
++		goto once_more;
++}
++
++static void
++xor_8regs_p_3(unsigned long bytes, unsigned long *p1, unsigned long *p2,
++	    unsigned long *p3)
++{
++	long lines = bytes / (sizeof (long)) / 8 - 1;
++	prefetchw(p1);
++	prefetch(p2);
++	prefetch(p3);
++
++	do {
++		prefetchw(p1+8);
++		prefetch(p2+8);
++		prefetch(p3+8);
++ once_more:
++		p1[0] ^= p2[0] ^ p3[0];
++		p1[1] ^= p2[1] ^ p3[1];
++		p1[2] ^= p2[2] ^ p3[2];
++		p1[3] ^= p2[3] ^ p3[3];
++		p1[4] ^= p2[4] ^ p3[4];
++		p1[5] ^= p2[5] ^ p3[5];
++		p1[6] ^= p2[6] ^ p3[6];
++		p1[7] ^= p2[7] ^ p3[7];
++		p1 += 8;
++		p2 += 8;
++		p3 += 8;
++	} while (--lines > 0);
++	if (lines == 0)
++		goto once_more;
++}
++
++static void
++xor_8regs_p_4(unsigned long bytes, unsigned long *p1, unsigned long *p2,
++	    unsigned long *p3, unsigned long *p4)
++{
++	long lines = bytes / (sizeof (long)) / 8 - 1;
++
++	prefetchw(p1);
++	prefetch(p2);
++	prefetch(p3);
++	prefetch(p4);
++
++	do {
++		prefetchw(p1+8);
++		prefetch(p2+8);
++		prefetch(p3+8);
++		prefetch(p4+8);
++ once_more:
++		p1[0] ^= p2[0] ^ p3[0] ^ p4[0];
++		p1[1] ^= p2[1] ^ p3[1] ^ p4[1];
++		p1[2] ^= p2[2] ^ p3[2] ^ p4[2];
++		p1[3] ^= p2[3] ^ p3[3] ^ p4[3];
++		p1[4] ^= p2[4] ^ p3[4] ^ p4[4];
++		p1[5] ^= p2[5] ^ p3[5] ^ p4[5];
++		p1[6] ^= p2[6] ^ p3[6] ^ p4[6];
++		p1[7] ^= p2[7] ^ p3[7] ^ p4[7];
++		p1 += 8;
++		p2 += 8;
++		p3 += 8;
++		p4 += 8;
++	} while (--lines > 0);
++	if (lines == 0)
++		goto once_more;
++}
++
++static void
++xor_8regs_p_5(unsigned long bytes, unsigned long *p1, unsigned long *p2,
++	    unsigned long *p3, unsigned long *p4, unsigned long *p5)
++{
++	long lines = bytes / (sizeof (long)) / 8 - 1;
++
++	prefetchw(p1);
++	prefetch(p2);
++	prefetch(p3);
++	prefetch(p4);
++	prefetch(p5);
++
++	do {
++		prefetchw(p1+8);
++		prefetch(p2+8);
++		prefetch(p3+8);
++		prefetch(p4+8);
++		prefetch(p5+8);
++ once_more:
++		p1[0] ^= p2[0] ^ p3[0] ^ p4[0] ^ p5[0];
++		p1[1] ^= p2[1] ^ p3[1] ^ p4[1] ^ p5[1];
++		p1[2] ^= p2[2] ^ p3[2] ^ p4[2] ^ p5[2];
++		p1[3] ^= p2[3] ^ p3[3] ^ p4[3] ^ p5[3];
++		p1[4] ^= p2[4] ^ p3[4] ^ p4[4] ^ p5[4];
++		p1[5] ^= p2[5] ^ p3[5] ^ p4[5] ^ p5[5];
++		p1[6] ^= p2[6] ^ p3[6] ^ p4[6] ^ p5[6];
++		p1[7] ^= p2[7] ^ p3[7] ^ p4[7] ^ p5[7];
++		p1 += 8;
++		p2 += 8;
++		p3 += 8;
++		p4 += 8;
++		p5 += 8;
++	} while (--lines > 0);
++	if (lines == 0)
++		goto once_more;
++}
++
++static void
++xor_32regs_p_2(unsigned long bytes, unsigned long *p1, unsigned long *p2)
++{
++	long lines = bytes / (sizeof (long)) / 8 - 1;
++
++	prefetchw(p1);
++	prefetch(p2);
++
++	do {
++		register long d0, d1, d2, d3, d4, d5, d6, d7;
++
++		prefetchw(p1+8);
++		prefetch(p2+8);
++ once_more:
++		d0 = p1[0];	/* Pull the stuff into registers	*/
++		d1 = p1[1];	/*  ... in bursts, if possible.		*/
++		d2 = p1[2];
++		d3 = p1[3];
++		d4 = p1[4];
++		d5 = p1[5];
++		d6 = p1[6];
++		d7 = p1[7];
++		d0 ^= p2[0];
++		d1 ^= p2[1];
++		d2 ^= p2[2];
++		d3 ^= p2[3];
++		d4 ^= p2[4];
++		d5 ^= p2[5];
++		d6 ^= p2[6];
++		d7 ^= p2[7];
++		p1[0] = d0;	/* Store the result (in bursts)		*/
++		p1[1] = d1;
++		p1[2] = d2;
++		p1[3] = d3;
++		p1[4] = d4;
++		p1[5] = d5;
++		p1[6] = d6;
++		p1[7] = d7;
++		p1 += 8;
++		p2 += 8;
++	} while (--lines > 0);
++	if (lines == 0)
++		goto once_more;
++}
++
++static void
++xor_32regs_p_3(unsigned long bytes, unsigned long *p1, unsigned long *p2,
++	    unsigned long *p3)
++{
++	long lines = bytes / (sizeof (long)) / 8 - 1;
++
++	prefetchw(p1);
++	prefetch(p2);
++	prefetch(p3);
++
++	do {
++		register long d0, d1, d2, d3, d4, d5, d6, d7;
++
++		prefetchw(p1+8);
++		prefetch(p2+8);
++		prefetch(p3+8);
++ once_more:
++		d0 = p1[0];	/* Pull the stuff into registers	*/
++		d1 = p1[1];	/*  ... in bursts, if possible.		*/
++		d2 = p1[2];
++		d3 = p1[3];
++		d4 = p1[4];
++		d5 = p1[5];
++		d6 = p1[6];
++		d7 = p1[7];
++		d0 ^= p2[0];
++		d1 ^= p2[1];
++		d2 ^= p2[2];
++		d3 ^= p2[3];
++		d4 ^= p2[4];
++		d5 ^= p2[5];
++		d6 ^= p2[6];
++		d7 ^= p2[7];
++		d0 ^= p3[0];
++		d1 ^= p3[1];
++		d2 ^= p3[2];
++		d3 ^= p3[3];
++		d4 ^= p3[4];
++		d5 ^= p3[5];
++		d6 ^= p3[6];
++		d7 ^= p3[7];
++		p1[0] = d0;	/* Store the result (in bursts)		*/
++		p1[1] = d1;
++		p1[2] = d2;
++		p1[3] = d3;
++		p1[4] = d4;
++		p1[5] = d5;
++		p1[6] = d6;
++		p1[7] = d7;
++		p1 += 8;
++		p2 += 8;
++		p3 += 8;
++	} while (--lines > 0);
++	if (lines == 0)
++		goto once_more;
++}
++
++static void
++xor_32regs_p_4(unsigned long bytes, unsigned long *p1, unsigned long *p2,
++	    unsigned long *p3, unsigned long *p4)
++{
++	long lines = bytes / (sizeof (long)) / 8 - 1;
++
++	prefetchw(p1);
++	prefetch(p2);
++	prefetch(p3);
++	prefetch(p4);
++
++	do {
++		register long d0, d1, d2, d3, d4, d5, d6, d7;
++
++		prefetchw(p1+8);
++		prefetch(p2+8);
++		prefetch(p3+8);
++		prefetch(p4+8);
++ once_more:
++		d0 = p1[0];	/* Pull the stuff into registers	*/
++		d1 = p1[1];	/*  ... in bursts, if possible.		*/
++		d2 = p1[2];
++		d3 = p1[3];
++		d4 = p1[4];
++		d5 = p1[5];
++		d6 = p1[6];
++		d7 = p1[7];
++		d0 ^= p2[0];
++		d1 ^= p2[1];
++		d2 ^= p2[2];
++		d3 ^= p2[3];
++		d4 ^= p2[4];
++		d5 ^= p2[5];
++		d6 ^= p2[6];
++		d7 ^= p2[7];
++		d0 ^= p3[0];
++		d1 ^= p3[1];
++		d2 ^= p3[2];
++		d3 ^= p3[3];
++		d4 ^= p3[4];
++		d5 ^= p3[5];
++		d6 ^= p3[6];
++		d7 ^= p3[7];
++		d0 ^= p4[0];
++		d1 ^= p4[1];
++		d2 ^= p4[2];
++		d3 ^= p4[3];
++		d4 ^= p4[4];
++		d5 ^= p4[5];
++		d6 ^= p4[6];
++		d7 ^= p4[7];
++		p1[0] = d0;	/* Store the result (in bursts)		*/
++		p1[1] = d1;
++		p1[2] = d2;
++		p1[3] = d3;
++		p1[4] = d4;
++		p1[5] = d5;
++		p1[6] = d6;
++		p1[7] = d7;
++		p1 += 8;
++		p2 += 8;
++		p3 += 8;
++		p4 += 8;
++	} while (--lines > 0);
++	if (lines == 0)
++		goto once_more;
++}
++
++static void
++xor_32regs_p_5(unsigned long bytes, unsigned long *p1, unsigned long *p2,
++	    unsigned long *p3, unsigned long *p4, unsigned long *p5)
++{
++	long lines = bytes / (sizeof (long)) / 8 - 1;
++
++	prefetchw(p1);
++	prefetch(p2);
++	prefetch(p3);
++	prefetch(p4);
++	prefetch(p5);
++
++	do {
++		register long d0, d1, d2, d3, d4, d5, d6, d7;
++
++		prefetchw(p1+8);
++		prefetch(p2+8);
++		prefetch(p3+8);
++		prefetch(p4+8);
++		prefetch(p5+8);
++ once_more:
++		d0 = p1[0];	/* Pull the stuff into registers	*/
++		d1 = p1[1];	/*  ... in bursts, if possible.		*/
++		d2 = p1[2];
++		d3 = p1[3];
++		d4 = p1[4];
++		d5 = p1[5];
++		d6 = p1[6];
++		d7 = p1[7];
++		d0 ^= p2[0];
++		d1 ^= p2[1];
++		d2 ^= p2[2];
++		d3 ^= p2[3];
++		d4 ^= p2[4];
++		d5 ^= p2[5];
++		d6 ^= p2[6];
++		d7 ^= p2[7];
++		d0 ^= p3[0];
++		d1 ^= p3[1];
++		d2 ^= p3[2];
++		d3 ^= p3[3];
++		d4 ^= p3[4];
++		d5 ^= p3[5];
++		d6 ^= p3[6];
++		d7 ^= p3[7];
++		d0 ^= p4[0];
++		d1 ^= p4[1];
++		d2 ^= p4[2];
++		d3 ^= p4[3];
++		d4 ^= p4[4];
++		d5 ^= p4[5];
++		d6 ^= p4[6];
++		d7 ^= p4[7];
++		d0 ^= p5[0];
++		d1 ^= p5[1];
++		d2 ^= p5[2];
++		d3 ^= p5[3];
++		d4 ^= p5[4];
++		d5 ^= p5[5];
++		d6 ^= p5[6];
++		d7 ^= p5[7];
++		p1[0] = d0;	/* Store the result (in bursts)		*/
++		p1[1] = d1;
++		p1[2] = d2;
++		p1[3] = d3;
++		p1[4] = d4;
++		p1[5] = d5;
++		p1[6] = d6;
++		p1[7] = d7;
++		p1 += 8;
++		p2 += 8;
++		p3 += 8;
++		p4 += 8;
++		p5 += 8;
++	} while (--lines > 0);
++	if (lines == 0)
++		goto once_more;
++}
++
++static struct xor_block_template xor_block_8regs = {
++	.name = "8regs",
++	.do_2 = xor_8regs_2,
++	.do_3 = xor_8regs_3,
++	.do_4 = xor_8regs_4,
++	.do_5 = xor_8regs_5,
++};
++
++static struct xor_block_template xor_block_32regs = {
++	.name = "32regs",
++	.do_2 = xor_32regs_2,
++	.do_3 = xor_32regs_3,
++	.do_4 = xor_32regs_4,
++	.do_5 = xor_32regs_5,
++};
++
++static struct xor_block_template xor_block_8regs_p = {
++	.name = "8regs_prefetch",
++	.do_2 = xor_8regs_p_2,
++	.do_3 = xor_8regs_p_3,
++	.do_4 = xor_8regs_p_4,
++	.do_5 = xor_8regs_p_5,
++};
++
++static struct xor_block_template xor_block_32regs_p = {
++	.name = "32regs_prefetch",
++	.do_2 = xor_32regs_p_2,
++	.do_3 = xor_32regs_p_3,
++	.do_4 = xor_32regs_p_4,
++	.do_5 = xor_32regs_p_5,
++};
++
++#define XOR_TRY_TEMPLATES			\
++	do {					\
++		xor_speed(&xor_block_8regs);	\
++		xor_speed(&xor_block_8regs_p);	\
++		xor_speed(&xor_block_32regs);	\
++		xor_speed(&xor_block_32regs_p);	\
++	} while (0)
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/ChangeLog	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/ChangeLog	2004-06-29 11:18:14.000000000 +0200
+@@ -0,0 +1,14 @@
++2004-06-29  Ken Hill  <khill@microtronix.com>
++
++	* bitops.h (find_next_zero_bit): Fix problem with with masking for found_first
++	handling. The masking of the upper bits for size < 32 bits would set all
++	the bits to 1. Removing any zero's there may have been.
++
++2004-06-02  Ken Hill  <khill@microtronix.com>
++
++	* processor.h (TASK_SIZE): Change na_sdram_end to nasys_program_mem_end to remove
++	dependancy on quartus memory component name.
++
++	* page.h (PAGE_OFFSET): Change na_sdram to nasys_program_mem to remove
++	dependancy on quartus memory component name.
++
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/a.out.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/a.out.h	2004-03-30 14:35:04.000000000 +0200
+@@ -0,0 +1,85 @@
++/* $Id: a.out.h,v 1.4 2004/03/30 19:35:04 ken-h Exp $ */
++/*
++ * Copyright (C) 2004 Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++#ifndef __NIOS2NOMMU_A_OUT_H__
++#define __NIOS2NOMMU_A_OUT_H__
++
++#define SPARC_PGSIZE    0x1000        /* Thanks to the sun4 architecture... */
++#define SEGMENT_SIZE    SPARC_PGSIZE  /* whee... */
++
++struct exec {
++	unsigned char a_dynamic:1;      /* A __DYNAMIC is in this image */
++	unsigned char a_toolversion:7;
++	unsigned char a_machtype;
++	unsigned short a_info;
++	unsigned long a_text;		/* length of text, in bytes */
++	unsigned long a_data;		/* length of data, in bytes */
++	unsigned long a_bss;		/* length of bss, in bytes */
++	unsigned long a_syms;		/* length of symbol table, in bytes */
++	unsigned long a_entry;		/* where program begins */
++	unsigned long a_trsize;
++	unsigned long a_drsize;
++};
++
++#define INIT_EXEC {				\
++	.a_dynamic	= 0,			\
++	.a_toolversion	= 0,			\
++	.a_machtype	= 0,			\
++	.a_info		= 0,			\
++	.a_text		= 0,			\
++	.a_data		= 0,			\
++	.a_bss		= 0,			\
++	.a_syms		= 0,			\
++	.a_entry	= 0,			\
++	.a_trsize	= 0,			\
++	.a_drsize	= 0,			\
++}
++
++/* Where in the file does the text information begin? */
++#define N_TXTOFF(x)     (N_MAGIC(x) == ZMAGIC ? 0 : sizeof (struct exec))
++
++/* Where do the Symbols start? */
++#define N_SYMOFF(x)     (N_TXTOFF(x) + (x).a_text +   \
++                         (x).a_data + (x).a_trsize +  \
++                         (x).a_drsize)
++
++/* Where does text segment go in memory after being loaded? */
++#define N_TXTADDR(x)    (((N_MAGIC(x) == ZMAGIC) &&        \
++	                 ((x).a_entry < SPARC_PGSIZE)) ?   \
++                          0 : SPARC_PGSIZE)
++
++/* And same for the data segment.. */
++#define N_DATADDR(x) (N_MAGIC(x)==OMAGIC ?         \
++                      (N_TXTADDR(x) + (x).a_text)  \
++                       : (_N_SEGMENT_ROUND (_N_TXTENDADDR(x))))
++
++#define N_TRSIZE(a)	((a).a_trsize)
++#define N_DRSIZE(a)	((a).a_drsize)
++#define N_SYMSIZE(a)	((a).a_syms)
++
++#ifdef __KERNEL__
++
++#define STACK_TOP	TASK_SIZE
++
++#endif
++
++#endif /* __NIOS2NOMMU_A_OUT_H__ */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/asm-macros.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/asm-macros.h	2004-05-14 13:32:04.000000000 +0200
+@@ -0,0 +1,331 @@
++/*
++ * Macro used to simplify coding multi-line assembler.
++ * Some of the bit test macro can simplify down to one line
++ * depending on the mask value.
++ *
++ * Copyright (C) 2004 Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++/*
++ * ANDs reg2 with mask and places the result in reg1.
++ *
++ * You cannnot use the same register for reg1 & reg2.
++ */
++
++.macro ANDI32	reg1,reg2,mask
++ .if \mask & 0xffff
++  .if \mask & 0xffff0000
++	movhi	\reg1,%hi(\mask)
++	movui	\reg1,%lo(\mask)
++	and	\reg1,\reg1,\reg2
++  .else
++	andi	\reg1,\reg2,%lo(\mask)
++  .endif
++ .else
++	andhi	\reg1,\reg2,%hi(\mask)
++ .endif
++.endm
++
++/*
++ * ORs reg2 with mask and places the result in reg1.
++ *
++ * It is safe to use the same register for reg1 & reg2.
++ */
++
++.macro ORI32	reg1,reg2,mask
++ .if \mask & 0xffff
++  .if \mask & 0xffff0000
++	orhi	\reg1,\reg2,%hi(\mask)
++	ori	\reg1,\reg2,%lo(\mask)
++  .else
++	ori	\reg1,\reg2,%lo(\mask)
++  .endif
++ .else
++	orhi	\reg1,\reg2,%hi(\mask)
++ .endif
++.endm
++
++/*
++ * XORs reg2 with mask and places the result in reg1.
++ *
++ * It is safe to use the same register for reg1 & reg2.
++ */
++
++.macro XORI32	reg1,reg2,mask
++ .if \mask & 0xffff
++  .if \mask & 0xffff0000
++	xorhi	\reg1,\reg2,%hi(\mask)
++	xori	\reg1,\reg1,%lo(\mask)
++  .else
++	xori	\reg1,\reg2,%lo(\mask)
++  .endif
++ .else
++	xorhi	\reg1,\reg2,%hi(\mask)
++ .endif
++.endm
++
++/*
++ * This is a support macro for BTBZ & BTBNZ.  It checks
++ * the bit to make sure it is valid 32 value.
++ *
++ * It is safe to use the same register for reg1 & reg2.
++ */
++
++.macro BT	reg1,reg2,bit
++.if \bit > 31
++ .err 
++.else
++ .if \bit < 16
++	andi	\reg1,\reg2,(1 << \bit)
++ .else
++	andhi	\reg1,\reg2,(1 << (\bit - 16))
++ .endif
++.endif
++.endm
++
++/*
++ * Tests the bit in reg2 and branches to label if the
++ * bit is zero.  The result of the bit test is stored in reg1.
++ *
++ * It is safe to use the same register for reg1 & reg2.
++ */
++
++.macro BTBZ	reg1,reg2,bit,label
++	BT	\reg1,\reg2,\bit
++	beq	\reg1,r0,\label
++.endm
++
++/*
++ * Tests the bit in reg2 and branches to label if the
++ * bit is non-zero.  The result of the bit test is stored in reg1.
++ *
++ * It is safe to use the same register for reg1 & reg2.
++ */
++
++.macro BTBNZ	reg1,reg2,bit,label
++	BT	\reg1,\reg2,\bit
++	bne	\reg1,r0,\label
++.endm
++
++/*
++ * Tests the bit in reg2 and then compliments the bit in reg2.
++ * The result of the bit test is stored in reg1.
++ *
++ * It is NOT safe to use the same register for reg1 & reg2.
++ */
++
++.macro BTC	reg1,reg2,bit
++.if \bit > 31
++ .err 
++.else
++ .if \bit < 16
++	andi	\reg1,\reg2,(1 << \bit)
++	xori	\reg2,\reg2,(1 << \bit)
++ .else
++	andhi	\reg1,\reg2,(1 << (\bit - 16))
++	xorhi	\reg2,\reg2,(1 << (\bit - 16))
++ .endif
++.endif
++.endm
++
++/*
++ * Tests the bit in reg2 and then sets the bit in reg2.
++ * The result of the bit test is stored in reg1.
++ *
++ * It is NOT safe to use the same register for reg1 & reg2.
++ */
++
++.macro BTS	reg1,reg2,bit
++.if \bit > 31
++ .err 
++.else
++ .if \bit < 16
++	andi	\reg1,\reg2,(1 << \bit)
++	ori	\reg2,\reg2,(1 << \bit)
++ .else
++	andhi	\reg1,\reg2,(1 << (\bit - 16))
++	orhi	\reg2,\reg2,(1 << (\bit - 16))
++ .endif
++.endif
++.endm
++
++/*
++ * Tests the bit in reg2 and then resets the bit in reg2.
++ * The result of the bit test is stored in reg1.
++ *
++ * It is NOT safe to use the same register for reg1 & reg2.
++ */
++
++.macro BTR	reg1,reg2,bit
++.if \bit > 31
++ .err 
++.else
++ .if \bit < 16
++	andi	\reg1,\reg2,(1 << \bit)
++	andi	\reg2,\reg2,%lo(~(1 << \bit))
++ .else
++	andhi	\reg1,\reg2,(1 << (\bit - 16))
++	andhi	\reg2,\reg2,%lo(~(1 << (\bit - 16)))
++ .endif
++.endif
++.endm
++
++/*
++ * Tests the bit in reg2 and then compliments the bit in reg2.
++ * The result of the bit test is stored in reg1.  If the 
++ * original bit was zero it branches to label.
++ *
++ * It is NOT safe to use the same register for reg1 & reg2.
++ */
++
++.macro BTCBZ	reg1,reg2,bit,label
++	BTC	\reg1,\reg2,\bit
++	beq	\reg1,r0,\label
++.endm
++
++/*
++ * Tests the bit in reg2 and then compliments the bit in reg2.
++ * The result of the bit test is stored in reg1.  If the 
++ * original bit was non-zero it branches to label.
++ *
++ * It is NOT safe to use the same register for reg1 & reg2.
++ */
++
++.macro BTCBNZ	reg1,reg2,bit,label
++	BTC	\reg1,\reg2,\bit
++	bne	\reg1,r0,\label
++.endm
++
++/*
++ * Tests the bit in reg2 and then sets the bit in reg2.
++ * The result of the bit test is stored in reg1.  If the 
++ * original bit was zero it branches to label.
++ *
++ * It is NOT safe to use the same register for reg1 & reg2.
++ */
++
++.macro BTSBZ	reg1,reg2,bit,label
++	BTS	\reg1,\reg2,\bit
++	beq	\reg1,r0,\label
++.endm
++
++/*
++ * Tests the bit in reg2 and then sets the bit in reg2.
++ * The result of the bit test is stored in reg1.  If the 
++ * original bit was non-zero it branches to label.
++ *
++ * It is NOT safe to use the same register for reg1 & reg2.
++ */
++
++.macro BTSBNZ	reg1,reg2,bit,label
++	BTS	\reg1,\reg2,\bit
++	bne	\reg1,r0,\label
++.endm
++
++/*
++ * Tests the bit in reg2 and then resets the bit in reg2.
++ * The result of the bit test is stored in reg1.  If the 
++ * original bit was zero it branches to label.
++ *
++ * It is NOT safe to use the same register for reg1 & reg2.
++ */
++
++.macro BTRBZ	reg1,reg2,bit,label
++	BTR	\reg1,\reg2,\bit
++	bne	\reg1,r0,\label
++.endm
++
++/*
++ * Tests the bit in reg2 and then resets the bit in reg2.
++ * The result of the bit test is stored in reg1.  If the 
++ * original bit was non-zero it branches to label.
++ *
++ * It is NOT safe to use the same register for reg1 & reg2.
++ */
++
++.macro BTRBNZ	reg1,reg2,bit,label
++	BTR	\reg1,\reg2,\bit
++	bne	\reg1,r0,\label
++.endm
++
++/*
++ * Tests the bits in mask against reg2 stores the result in reg1.
++ * If the all the bits in the mask are zero it branches to label.
++ *
++ * It is safe to use the same register for reg1 & reg2.
++ */
++
++.macro TSTBZ	reg1,reg2,mask,label
++	ANDI32	\reg1,\reg2,\mask
++	beq	\reg1,r0,\label
++.endm
++
++/*
++ * Tests the bits in mask against reg2 stores the result in reg1.
++ * If the any of the bits in the mask are 1 it branches to label.
++ *
++ * It is safe to use the same register for reg1 & reg2.
++ */
++
++.macro TSTBNZ	reg1,reg2,mask,label
++	ANDI32	\reg1,\reg2,\mask
++	bne	\reg1,r0,\label
++.endm
++
++/*
++ * Pushes reg onto the stack.
++ */
++
++.macro PUSH	reg
++	addi	sp,sp,-4
++	stw	\reg,0(sp)
++.endm
++
++/*
++ * Pops the top of the stack into reg.
++ */
++
++.macro POP	reg
++	ldw	\reg,0(sp)
++	addi	sp,sp,4
++.endm
++
++/*
++ * Clears reg
++ */
++
++.macro CLR	reg
++	  mov	\reg,r0
++.endm
++
++/*
++ * The preprocessor macro does not work for
++ * the nios2 compiler. Undefine ENTRY and define
++ * a real assembler macro.
++ */
++#undef ENTRY
++#define ENTRY(name) ASM_ENTRY name
++
++.macro ASM_ENTRY name
++.globl \name
++__ALIGN
++  \name:
++.endm
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/atomic.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/atomic.h	2004-12-08 17:39:48.000000000 +0100
+@@ -0,0 +1,190 @@
++//vic - add 'atomic_add/sub_return', 'atomic_add_negative'
++//vic     from v850 architecture
++
++/* atomic.h: 
++ *
++ * Copyright (C) 2004 Microtronix Datacom Ltd.
++ * Copyright (C) 2001 Vic Phillips (vic@microtronix.com)
++ *
++ * Copyright (C) 1996 David S. Miller (davem@caip.rutgers.edu)
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#ifndef __ARCH_NIOS2NOMMU_ATOMIC__
++#define __ARCH_NIOS2NOMMU_ATOMIC__
++
++#include <asm/system.h>
++
++typedef struct { int counter; } atomic_t;
++#define ATOMIC_INIT(i)	{ (i) }
++
++#define atomic_read(v)		((v)->counter)
++#define atomic_set(v, i)	(((v)->counter) = i)
++
++
++extern __inline__ void atomic_add(int i, atomic_t *v)
++{
++	unsigned long flags;
++
++	local_irq_save(flags);
++	v->counter += i;
++	local_irq_restore(flags);
++}
++
++extern __inline__ int atomic_add_negative(int i, atomic_t *v)
++{
++	unsigned long flags;
++	int result;
++
++	local_irq_save(flags);
++	v->counter += i;
++	result = (v->counter < 0);
++	local_irq_restore(flags);
++	return result;
++}
++
++extern __inline__ void atomic_sub(int i, atomic_t *v)
++{
++	unsigned long flags;
++
++	local_irq_save(flags);
++	v->counter -= i;
++	local_irq_restore(flags);
++}
++
++extern __inline__ int atomic_sub_and_test(int i, atomic_t *v)
++{
++	int result;
++	unsigned long flags;
++
++	local_irq_save(flags);
++	v->counter -= i;
++	result = (v->counter == 0);
++	local_irq_restore(flags);
++	return result;
++}
++
++extern __inline__ void atomic_inc(atomic_t *v)
++{
++	unsigned long flags;
++
++	local_irq_save(flags);
++	v->counter += 1;
++	local_irq_restore(flags);
++}
++
++extern __inline__ int atomic_inc_and_test(atomic_t *v)
++{
++	unsigned long flags;
++	int result;
++
++	local_irq_save(flags);
++	v->counter += 1;
++	result = (v->counter == 0);
++	local_irq_restore(flags);
++	return result;
++}
++
++extern __inline__ void atomic_dec(atomic_t *v)
++{
++	int i = 1;					/* the compiler optimizes better this way */
++	unsigned long flags;
++
++	local_irq_save(flags);
++	v->counter -= i;
++	local_irq_restore(flags);
++}
++
++extern __inline__ int atomic_dec_and_test(atomic_t *v)
++{
++	int result;
++	int i = 1;					/* the compiler optimizes better this way */
++	unsigned long flags;
++
++	local_irq_save(flags);
++	v->counter -= i;
++	result = (v->counter == 0);
++	local_irq_restore(flags);
++	return result;
++}
++
++extern __inline__ int atomic_inc_return(atomic_t *v)
++{
++	int result;
++	unsigned long flags;
++
++	local_irq_save(flags);
++	result = ++v->counter;
++	local_irq_restore(flags);
++	return result;
++}
++
++extern __inline__ int atomic_dec_return(atomic_t *v)
++{
++	int result;
++	int i = 1;					/* the compiler optimizes better this way */
++	unsigned long flags;
++
++	local_irq_save(flags);
++	v->counter -= i;
++	result = v->counter;
++	local_irq_restore(flags);
++	return result;
++}
++
++extern __inline__ int atomic_add_return (int i, volatile atomic_t *v)
++{
++	int res;
++	unsigned long flags;
++
++	local_irq_save(flags);
++	res = v->counter + i;
++	v->counter = res;
++	local_irq_restore(flags);
++
++	return res;
++}
++
++static __inline__ int atomic_sub_return (int i, volatile atomic_t *v)
++{
++	int res;
++	unsigned long flags;
++
++	local_irq_save(flags);
++	res = v->counter - i;
++	v->counter = res;
++	local_irq_restore(flags);
++
++	return res;
++}
++
++#define atomic_dec_return(v) atomic_sub_return(1,(v))
++#define atomic_inc_return(v) atomic_add_return(1,(v))
++
++/* Atomic operations are already serializing */
++#define smp_mb__before_atomic_dec()	barrier()
++#define smp_mb__after_atomic_dec()	barrier()
++#define smp_mb__before_atomic_inc()	barrier()
++#define smp_mb__after_atomic_inc()	barrier()
++
++
++#endif /* !(__ARCH_NIOS2NOMMU_ATOMIC__) */
++
++
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/bitops.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/bitops.h	2004-12-08 17:39:48.000000000 +0100
+@@ -0,0 +1,472 @@
++#ifndef _ASM_NIOS_BITOPS_H_
++#define _ASM_NIOS_BITOPS_H_
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/bitops.h
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++#ifdef __KERNEL__
++#include <linux/config.h>
++#include <linux/compiler.h>
++#include <asm/byteorder.h>	/* swab32 */
++#include <asm/system.h>
++#endif
++
++/*
++ * Adapted to NIOS from generic bitops.h:
++ *
++ * For the benefit of those who are trying to port Linux to another
++ * architecture, here are some C-language equivalents.  You should
++ * recode these in the native assembly language, if at all possible.
++ * To guarantee atomicity, these routines call cli() and sti() to
++ * disable interrupts while they operate.  (You have to provide inline
++ * routines to cli() and sti().)
++ *
++ * Also note, these routines assume that you have 32 bit integers.
++ * You will have to change this if you are trying to port Linux to the
++ * Alpha architecture or to a Cray.  :-)
++ *
++ * C language equivalents written by Theodore Ts'o, 9/26/92
++ */
++
++/*
++ *	Generic ffs().
++ */
++static inline int ffs(int x)
++{
++	int r = 1;
++
++	if (!x)
++		return 0;
++	if (!(x & 0xffff)) {
++		x >>= 16;
++		r += 16;
++	}
++	if (!(x & 0xff)) {
++		x >>= 8;
++		r += 8;
++	}
++	if (!(x & 0xf)) {
++		x >>= 4;
++		r += 4;
++	}
++	if (!(x & 3)) {
++		x >>= 2;
++		r += 2;
++	}
++	if (!(x & 1)) {
++		x >>= 1;
++		r += 1;
++	}
++	return r;
++}
++
++/*
++ *	Generic __ffs().
++ */
++static inline int __ffs(int x)
++{
++	int r = 0;
++
++	if (!x)
++		return 0;
++	if (!(x & 0xffff)) {
++		x >>= 16;
++		r += 16;
++	}
++	if (!(x & 0xff)) {
++		x >>= 8;
++		r += 8;
++	}
++	if (!(x & 0xf)) {
++		x >>= 4;
++		r += 4;
++	}
++	if (!(x & 3)) {
++		x >>= 2;
++		r += 2;
++	}
++	if (!(x & 1)) {
++		x >>= 1;
++		r += 1;
++	}
++	return r;
++}
++
++/*
++ * fls: find last bit set.
++ */
++#define fls(x) generic_fls(x)
++
++
++/*
++ * Every architecture must define this function. It's the fastest
++ * way of searching a 140-bit bitmap where the first 100 bits are
++ * unlikely to be set. It's guaranteed that at least one of the 140
++ * bits is cleared.
++ */
++static inline int sched_find_first_bit(unsigned long *b)
++{
++	if (unlikely(b[0]))
++		return __ffs(b[0]);
++	if (unlikely(b[1]))
++		return __ffs(b[1]) + 32;
++	if (unlikely(b[2]))
++		return __ffs(b[2]) + 64;
++	if (b[3])
++		return __ffs(b[3]) + 96;
++	return __ffs(b[4]) + 128;
++}
++
++/*
++ * ffz = Find First Zero in word. Undefined if no zero exists,
++ * so code should check against ~0UL first..
++ */
++static __inline__ unsigned long ffz(unsigned long word)
++{
++	unsigned long result = 0;
++
++	while(word & 1) {
++		result++;
++		word >>= 1;
++	}
++	return result;
++}
++
++
++static __inline__ void set_bit(int nr, volatile unsigned long * addr)
++{
++	int 	* a = (int *) addr;
++	int	mask;
++	unsigned long flags;
++
++	a += nr >> 5;
++	mask = 1 << (nr & 0x1f);
++	local_irq_save(flags);
++	*a |= mask;
++	local_irq_restore(flags);
++}
++
++static __inline__ void __set_bit(int nr, volatile unsigned long * addr)
++{
++	int 	* a = (int *) addr;
++	int	mask;
++
++	a += nr >> 5;
++	mask = 1 << (nr & 0x1f);
++	*a |= mask;
++}
++
++/*
++ * clear_bit() doesn't provide any barrier for the compiler.
++ */
++#define smp_mb__before_clear_bit()	barrier()
++#define smp_mb__after_clear_bit()	barrier()
++
++static __inline__ void clear_bit(int nr, volatile unsigned long * addr)
++{
++	int 	* a = (int *) addr;
++	int	mask;
++	unsigned long flags;
++
++	a += nr >> 5;
++	mask = 1 << (nr & 0x1f);
++	local_irq_save(flags);
++	*a &= ~mask;
++	local_irq_restore(flags);
++}
++
++static __inline__ void __clear_bit(int nr, volatile unsigned long * addr)
++{
++	int 	* a = (int *) addr;
++	int	mask;
++
++	a += nr >> 5;
++	mask = 1 << (nr & 0x1f);
++	*a &= ~mask;
++}
++
++static __inline__ void change_bit(int nr, volatile unsigned long * addr)
++{
++	int mask, flags;
++	unsigned long *ADDR = (unsigned long *) addr;
++
++	ADDR += nr >> 5;
++	mask = 1 << (nr & 31);
++	local_irq_save(flags);
++	*ADDR ^= mask;
++	local_irq_restore(flags);
++}
++
++static __inline__ void __change_bit(int nr, volatile unsigned long * addr)
++{
++	int mask;
++	unsigned long *ADDR = (unsigned long *) addr;
++
++	ADDR += nr >> 5;
++	mask = 1 << (nr & 31);
++	*ADDR ^= mask;
++}
++
++static __inline__ int test_and_set_bit(int nr, volatile unsigned long * addr)
++{
++	int	mask, retval;
++	volatile unsigned int *a = (volatile unsigned int *) addr;
++	unsigned long flags;
++
++	a += nr >> 5;
++	mask = 1 << (nr & 0x1f);
++	local_irq_save(flags);
++	retval = (mask & *a) != 0;
++	*a |= mask;
++	local_irq_restore(flags);
++
++	return retval;
++}
++
++static __inline__ int __test_and_set_bit(int nr, volatile unsigned long * addr)
++{
++	int	mask, retval;
++	volatile unsigned int *a = (volatile unsigned int *) addr;
++
++	a += nr >> 5;
++	mask = 1 << (nr & 0x1f);
++	retval = (mask & *a) != 0;
++	*a |= mask;
++	return retval;
++}
++
++static __inline__ int test_and_clear_bit(int nr, volatile unsigned long * addr)
++{
++	int	mask, retval;
++	volatile unsigned int *a = (volatile unsigned int *) addr;
++	unsigned long flags;
++
++	a += nr >> 5;
++	mask = 1 << (nr & 0x1f);
++	local_irq_save(flags);
++	retval = (mask & *a) != 0;
++	*a &= ~mask;
++	local_irq_restore(flags);
++
++	return retval;
++}
++
++static __inline__ int __test_and_clear_bit(int nr, volatile unsigned long * addr)
++{
++	int	mask, retval;
++	volatile unsigned int *a = (volatile unsigned int *) addr;
++
++	a += nr >> 5;
++	mask = 1 << (nr & 0x1f);
++	retval = (mask & *a) != 0;
++	*a &= ~mask;
++	return retval;
++}
++
++static __inline__ int test_and_change_bit(int nr, volatile unsigned long * addr)
++{
++	int	mask, retval;
++	volatile unsigned int *a = (volatile unsigned int *) addr;
++	unsigned long flags;
++
++	a += nr >> 5;
++	mask = 1 << (nr & 0x1f);
++	local_irq_save(flags);
++	retval = (mask & *a) != 0;
++	*a ^= mask;
++	local_irq_restore(flags);
++
++	return retval;
++}
++
++static __inline__ int __test_and_change_bit(int nr, volatile unsigned long * addr)
++{
++	int	mask, retval;
++	volatile unsigned int *a = (volatile unsigned int *) addr;
++
++	a += nr >> 5;
++	mask = 1 << (nr & 0x1f);
++	retval = (mask & *a) != 0;
++	*a ^= mask;
++	return retval;
++}
++
++/*
++ * This routine doesn't need to be atomic.
++ */
++static __inline__ int __constant_test_bit(int nr, const volatile unsigned long * addr)
++{
++	return ((1UL << (nr & 31)) & (((const volatile unsigned int *) addr)[nr >> 5])) != 0;
++}
++
++static __inline__ int __test_bit(int nr, const volatile unsigned long * addr)
++{
++	int 	* a = (int *) addr;
++	int	mask;
++
++	a += nr >> 5;
++	mask = 1 << (nr & 0x1f);
++	return ((mask & *a) != 0);
++}
++
++#define test_bit(nr,addr) \
++(__builtin_constant_p(nr) ? \
++ __constant_test_bit((nr),(unsigned long *)(addr)) : \
++ __test_bit((nr),(unsigned long *)(addr)))
++
++
++/* find_next_zero_bit() finds the first zero bit in a bit string of length
++ * 'size' bits, starting the search at bit 'offset'. This is largely based
++ * on Linus's ALPHA routines, which are pretty portable BTW.
++ */
++
++extern __inline__ unsigned long find_next_zero_bit(void *addr, unsigned long size, unsigned long offset)
++{
++	unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
++	unsigned long result = offset & ~31UL;
++	unsigned long tmp;
++
++	if (offset >= size)
++		return size;
++	size -= result;
++	offset &= 31UL;
++	if (offset) {
++		tmp = *(p++);
++		tmp |= ~0UL >> (32-offset);
++		if (size < 32)
++			goto found_first;
++		if (~tmp)
++			goto found_middle;
++		size -= 32;
++		result += 32;
++	}
++	while (size & ~31UL) {
++		if (~(tmp = *(p++)))
++			goto found_middle;
++		result += 32;
++		size -= 32;
++	}
++	if (!size)
++		return result;
++	tmp = *p;
++
++found_first:
++	tmp |= ~0UL << size;
++	if (tmp == ~0UL)
++		return result + size;
++found_middle:
++	return result + ffz(tmp);
++}
++
++/*
++ * Find next one bit in a bitmap reasonably efficiently.
++ */
++extern __inline__ unsigned long find_next_bit(const unsigned long *addr,
++	unsigned long size, unsigned long offset)
++{
++	unsigned int *p = ((unsigned int *) addr) + (offset >> 5);
++	unsigned int result = offset & ~31UL;
++	unsigned int tmp;
++
++	if (offset >= size)
++		return size;
++	size -= result;
++	offset &= 31UL;
++	if (offset) {
++		tmp = *p++;
++		tmp &= ~0UL << offset;
++		if (size < 32)
++			goto found_first;
++		if (tmp)
++			goto found_middle;
++		size -= 32;
++		result += 32;
++	}
++	while (size >= 32) {
++		if ((tmp = *p++) != 0)
++			goto found_middle;
++		result += 32;
++		size -= 32;
++	}
++	if (!size)
++		return result;
++	tmp = *p;
++
++found_first:
++	tmp &= ~0UL >> (32 - size);
++	if (tmp == 0UL)        /* Are any bits set? */
++		return result + size; /* Nope. */
++found_middle:
++	return result + __ffs(tmp);
++}
++
++/*
++ * hweightN: returns the hamming weight (i.e. the number
++ * of bits set) of a N-bit word
++ */
++
++#define hweight32(x) generic_hweight32(x)
++#define hweight16(x) generic_hweight16(x)
++#define hweight8(x) generic_hweight8(x)
++
++/* Linus sez that gcc can optimize the following correctly, we'll see if this
++ * holds on the Sparc as it does for the ALPHA.
++ */
++
++#define find_first_zero_bit(addr, size) \
++        find_next_zero_bit((addr), (size), 0)
++#define find_first_bit(addr, size) \
++        find_next_bit((addr), (size), 0)
++
++/* Now for the ext2 filesystem bit operations and helper routines.
++ *
++ * Both NIOS and ext2 are little endian, so these are the same as above.
++ */
++
++#define ext2_set_bit   test_and_set_bit
++#define ext2_clear_bit test_and_clear_bit
++#define ext2_test_bit  test_bit
++
++#define ext2_set_bit_atomic(lock, nr, addr)		\
++	({						\
++		int ret;				\
++		spin_lock(lock);			\
++		ret = ext2_set_bit((nr),(unsigned long *) (addr));	\
++		spin_unlock(lock);			\
++		ret;					\
++	})
++
++#define ext2_clear_bit_atomic(lock, nr, addr)		\
++	({						\
++		int ret;				\
++		spin_lock(lock);			\
++		ret = ext2_clear_bit((nr),(unsigned long *) (addr));	\
++		spin_unlock(lock);			\
++		ret;					\
++	})
++
++#define ext2_find_first_zero_bit find_first_zero_bit
++#define ext2_find_next_zero_bit  find_next_zero_bit
++
++#endif /* _ASM_NIOS_BITOPS_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/bootinfo.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/bootinfo.h	2004-02-26 15:43:36.000000000 +0100
+@@ -0,0 +1,2 @@
++
++/* Nothing for nios2nommu */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/bug.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/bug.h	2004-02-26 15:43:36.000000000 +0100
+@@ -0,0 +1,48 @@
++#ifndef _NIOS2NOMMU_BUG_H
++#define _NIOS2NOMMU_BUG_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/bug.h
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++#define BUG() do { \
++  printk("%s(%d): kernel BUG!\n", __FILE__, __LINE__); \
++} while (0)
++
++#define BUG_ON(condition) do { \
++	if (unlikely((condition)!=0)) \
++		BUG(); \
++} while(0)
++
++#define PAGE_BUG(page) do { \
++         BUG(); \
++} while (0)
++
++#define WARN_ON(condition) do { \
++	if (unlikely((condition)!=0)) { \
++		printk("Badness in %s at %s:%d\n", __FUNCTION__, __FILE__, __LINE__); \
++		dump_stack(); \
++	} \
++} while (0)
++
++#endif
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/bugs.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/bugs.h	2004-02-26 15:43:36.000000000 +0100
+@@ -0,0 +1,40 @@
++#ifndef __ASM_NIOS_BUGS_H
++#define __ASM_NIOS_BUGS_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/bugs.h
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ *  Copyright (C) 1994  Linus Torvalds
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++/*
++ * This is included by init/main.c to check for architecture-dependent bugs.
++ *
++ * Needs:
++ *	void check_bugs(void);
++ */
++
++static void check_bugs(void)
++{
++}
++
++#endif
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/byteorder.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/byteorder.h	2004-12-08 17:39:48.000000000 +0100
+@@ -0,0 +1,38 @@
++#ifndef __ASM_NIOS_BYTEORDER_H
++#define __ASM_NIOS_BYTEORDER_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/byteorder.h
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++#include <asm/types.h>
++
++#if defined(__GNUC__) && !defined(__STRICT_ANSI__) || defined(__KERNEL__)
++#  define __BYTEORDER_HAS_U64__
++#  define __SWAB_64_THRU_32__
++#endif
++
++#include <linux/byteorder/little_endian.h>
++
++#endif
++
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/cache.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/cache.h	2004-02-26 13:25:08.000000000 +0100
+@@ -0,0 +1,34 @@
++/*
++ * Copyright (C) 2004 Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++#ifndef __ARCH_NIOS2NOMMU_CACHE_H
++#define __ARCH_NIOS2NOMMU_CACHE_H
++
++#include <asm/nios.h>
++
++/* bytes per L1 cache line */
++#define        L1_CACHE_BYTES	nasys_icache_line_size 	/* this need to be at least 1 */
++
++
++#define __cacheline_aligned
++#define ____cacheline_aligned
++
++#endif
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/cachectl.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/cachectl.h	2004-02-12 18:06:40.000000000 +0100
+@@ -0,0 +1,36 @@
++/*
++ * Copyright (C) 2004 Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#ifndef _NIOS2NOMMU_CACHECTL_H
++#define _NIOS2NOMMU_CACHECTL_H
++
++/* Definitions for the cacheflush system call.  */
++
++#define FLUSH_SCOPE_LINE    1	/* Flush a cache line */
++#define FLUSH_SCOPE_PAGE    2	/* Flush a page */
++#define FLUSH_SCOPE_ALL     3	/* Flush the whole cache -- superuser only */
++
++#define FLUSH_CACHE_DATA    1	/* Writeback and flush data cache */
++#define FLUSH_CACHE_INSN    2	/* Flush instruction cache */
++#define FLUSH_CACHE_BOTH    3	/* Flush both caches */
++
++#endif /* _NIOS2NOMMU_CACHECTL_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/cacheflush.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/cacheflush.h	2004-05-14 13:32:04.000000000 +0200
+@@ -0,0 +1,56 @@
++#ifndef _NIOS2NOMMU_CACHEFLUSH_H
++#define _NIOS2NOMMU_CACHEFLUSH_H
++
++/*
++ * Ported from m68knommu.
++ *
++ * (C) Copyright 2003, Microtronix Datacom Ltd.
++ * (C) Copyright 2000-2002, Greg Ungerer <gerg@snapgear.com>
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++#include <linux/mm.h>
++
++extern void cache_push (unsigned long vaddr, int len);
++extern void dcache_push (unsigned long vaddr, int len);
++extern void icache_push (unsigned long vaddr, int len);
++extern void cache_push_all (void);
++
++#define flush_cache_all()			__flush_cache_all()
++#define flush_cache_mm(mm)			do { } while (0)
++#define flush_cache_range(vma, start, end)	do { } while (0)
++#define flush_cache_page(vma, vmaddr)		do { } while (0)
++#define flush_dcache_range(start,end)		dcache_push(start, end - start)
++#define flush_dcache_page(page)			do { } while (0)
++#define flush_icache_range(start,end)		cache_push(start, end - start)
++#define flush_icache_page(vma,pg)		do { } while (0)
++#define flush_icache_user_range(vma,pg,adr,len)	do { } while (0)
++
++#define copy_to_user_page(vma, page, vaddr, dst, src, len) \
++	memcpy(dst, src, len)
++#define copy_from_user_page(vma, page, vaddr, dst, src, len) \
++	memcpy(dst, src, len)
++
++
++extern inline void __flush_cache_all(void)
++{
++	cache_push_all();
++}
++
++#endif /* _NIOS2NOMMU_CACHEFLUSH_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/checksum.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/checksum.h	2005-01-10 13:35:22.000000000 +0100
+@@ -0,0 +1,320 @@
++#ifndef __NIOS2_CHECKSUM_H
++#define __NIOS2_CHECKSUM_H
++
++/*  checksum.h:  IP/UDP/TCP checksum routines on the NIOS.
++ *
++ *  Copyright(C) 1995 Linus Torvalds
++ *  Copyright(C) 1995 Miguel de Icaza
++ *  Copyright(C) 1996 David S. Miller
++ *  Copyright(C) 2001 Ken Hill
++ *  Copyright(C) 2004 Microtronix Datacom Ltd.
++ *
++ * derived from:
++ *	Alpha checksum c-code
++ *      ix86 inline assembly
++ *      Spar nommu
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++
++/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
++
++/*
++ * computes the checksum of the TCP/UDP pseudo-header
++ * returns a 16-bit checksum, already complemented
++ */
++
++extern inline unsigned short csum_tcpudp_magic(unsigned long saddr,
++					       unsigned long daddr,
++					       unsigned short len,
++					       unsigned short proto,
++					       unsigned int sum)
++{
++    barrier();
++	__asm__ __volatile__(
++"		add	%0, %3, %0\n"
++"		bgeu	%0, %3, 1f\n"
++"		addi	%0, %0, 1\n"
++"1:		add	%0, %4, %0\n"
++"		bgeu	%0, %4, 1f\n"
++"		addi	%0, %0, 1\n"
++"1:		add	%0, %5, %0\n"
++"		bgeu	%0, %5, 1f\n"
++"		addi	%0, %0, 1\n"
++"1:\n"
++/*
++		We need the carry from the addition of 16-bit
++		significant addition, so we zap out the low bits
++		in one half, zap out the high bits in another,
++		shift them both up to the top 16-bits of a word
++		and do the carry producing addition, finally
++		shift the result back down to the low 16-bits.
++
++		Actually, we can further optimize away two shifts
++		because we know the low bits of the original
++		value will be added to zero-only bits so cannot
++		affect the addition result nor the final carry
++		bit.
++*/
++"		slli	%1,%0, 16\n"		/* Need a copy to fold with */
++						/* Bring the LOW 16 bits up */
++"		add	%0, %1, %0\n"		/* add and set carry, neat eh? */
++"		cmpltu	r15, %0, %1\n"		/* get remaining carry bit */
++"		srli	%0, %0, 16\n"		/* shift back down the result */
++"		add	%0, %0, r15\n"
++"		nor	%0, %0, %0\n"		/* negate */
++	        : "=&r" (sum), "=&r" (saddr)
++		: "0" (sum), "1" (saddr), "r" (ntohl(len+proto)), "r" (daddr)
++		: "r15");
++		return ((unsigned short) sum); 
++    barrier();
++}
++
++
++/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
++
++
++  extern inline unsigned short from32to16(unsigned long x)
++  {
++    barrier();
++	__asm__ __volatile__(
++		"add	%0, %1, %0\n"
++		"cmpltu	r15, %0, %1\n"
++		"srli	%0, %0, 16\n"
++		"add	%0, %0, r15\n"
++		: "=r" (x)
++		: "r" (x << 16), "0" (x)
++		: "r15");
++	return x;
++    barrier();
++  }
++
++
++/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
++
++
++extern inline unsigned long do_csum(const unsigned char * buff, int len)
++{
++ int odd, count;
++ unsigned long result = 0;
++
++    barrier();
++ if (len <= 0)
++ 	goto out;
++ odd = 1 & (unsigned long) buff;
++ if (odd) {
++////result = *buff;                     // dgt: Big    endian
++ 	result = *buff << 8;                // dgt: Little endian
++
++ 	len--;
++ 	buff++;
++ }
++ count = len >> 1;		/* nr of 16-bit words.. */
++ if (count) {
++ 	if (2 & (unsigned long) buff) {
++ 		result += *(unsigned short *) buff;
++ 		count--;
++ 		len -= 2;
++ 		buff += 2;
++ 	}
++ 	count >>= 1;		/* nr of 32-bit words.. */
++ 	if (count) {
++ 	        unsigned long carry = 0;
++ 		do {
++ 			unsigned long w = *(unsigned long *) buff;
++ 			count--;
++ 			buff += 4;
++ 			result += carry;
++ 			result += w;
++ 			carry = (w > result);
++ 		} while (count);
++ 		result += carry;
++ 		result = (result & 0xffff) + (result >> 16);
++ 	}
++ 	if (len & 2) {
++ 		result += *(unsigned short *) buff;
++ 		buff += 2;
++ 	}
++ }
++ if (len & 1)
++ 	result += *buff;  /* This is little machine, byte is right */
++ result = from32to16(result);
++ if (odd)
++ 	result = ((result >> 8) & 0xff) | ((result & 0xff) << 8);
++out:
++	return result;
++    barrier();
++  }
++
++
++/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
++
++
++/* ihl is always 5 or greater, almost always is 5, iph is always word
++ * aligned but can fail to be dword aligned very often.
++ */
++
++  extern inline unsigned short ip_fast_csum(const unsigned char *iph, unsigned int ihl)
++  {
++	unsigned int sum;
++
++    barrier();
++	__asm__ __volatile__(
++"		andi	r8, %1, 2\n"	/* Remember original alignment */
++"		ldw	%0, (%1)\n"	/* 16 or 32 bit boundary */
++"		beq	r8, r0, 1f\n"	/* Aligned on 32 bit boundary, go */
++"		srli	%0, %0, 16\n"	/* Get correct 16 bits */
++"		addi	%2, %2, -1\n"	/* Take off for 4 bytes, pickup last 2 at end */
++"		addi	%1, %1, 2\n"	/* Adjust pointer to 32 bit boundary */
++"		br	2f\n"
++"1:\n"
++"		addi	%2, %2, -1\n"
++"		addi	%1, %1, 4\n"	/* Bump ptr a long word */
++"2:\n"
++"		ldw     r9, (%1)\n"
++"1:\n"
++"		add     %0, r9, %0\n"
++"		bgeu	%0, r9, 2f\n"
++"		addi	%0, %0, 1\n"
++"2:\n"
++"		addi	%1, %1, 4\n"
++"		addi	%2, %2, -1\n"
++"		ldw     r9, (%1)\n"
++"		bne	%2, r0, 1b\n"
++"		beq	r8, r0, 1f\n"	/* 32 bit boundary time to leave */
++"		srli	r9, r9, 16\n"	/* 16 bit boundary, get correct 16 bits */
++"		add     %0, r9, %0\n"
++"		bgeu	%0, r9, 1f\n"
++"		addi	%0, %0, 1\n"
++"1:\n"
++"		slli	%2, %0, 16\n"
++"		add     %0, %2, %0\n"
++"		cmpltu	r8, %0, %2\n"
++"		srli	%0, %0, 16\n"
++"		add	%0, %0, r8\n"
++"		nor     %0, %0, %0\n"
++		: "=&r" (sum), "=&r" (iph), "=&r" (ihl)
++		: "1" (iph), "2" (ihl)
++		: "r8", "r9");
++	return sum;
++    barrier();
++  }
++
++/*these 2 functions are now in checksum.c */
++unsigned int csum_partial(const unsigned char * buff, int len, unsigned int sum);
++unsigned int csum_partial_copy(const char *src, char *dst, int len, int sum);
++
++/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
++
++/*
++ * the same as csum_partial_copy, but copies from user space.
++ *
++ * here even more important to align src and dst on a 32-bit (or even
++ * better 64-bit) boundary
++ */
++extern inline unsigned int
++csum_partial_copy_from_user(const char *src, char *dst, int len, int sum, int *csum_err)
++{
++    barrier();
++	if (csum_err) *csum_err = 0;
++	memcpy(dst, src, len);
++	return csum_partial(dst, len, sum);
++    barrier();
++}
++
++#define csum_partial_copy_nocheck(src, dst, len, sum)	\
++	csum_partial_copy ((src), (dst), (len), (sum))
++
++
++/*
++ * this routine is used for miscellaneous IP-like checksums, mainly
++ * in icmp.c
++ */
++
++extern inline unsigned short ip_compute_csum(unsigned char * buff, int len)
++{
++    barrier();
++ return ~from32to16(do_csum(buff,len));
++    barrier();
++}
++
++
++/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
++
++
++#define csum_partial_copy_fromuser(s, d, l, w)  \
++                     csum_partial_copy((char *) (s), (d), (l), (w))
++
++
++/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
++
++
++/*
++ *	Fold a partial checksum without adding pseudo headers
++ */
++extern __inline__ unsigned int csum_fold(unsigned int sum)
++{
++    barrier();
++	__asm__ __volatile__(
++		"add	%0, %1, %0\n"
++		"cmpltu	r8, %0, %1\n"
++		"srli	%0, %0, 16\n"
++		"add	%0, %0, r8\n"
++		"nor	%0, %0, %0\n"
++		: "=r" (sum)
++		: "r" (sum << 16), "0" (sum)
++		: "r8"); 
++	return sum;
++    barrier();
++}
++
++
++/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
++
++
++extern __inline__ unsigned long csum_tcpudp_nofold(unsigned long saddr,
++						   unsigned long daddr,
++						   unsigned short len,
++						   unsigned short proto,
++						   unsigned int sum)
++{
++    barrier();
++	__asm__ __volatile__(
++		"add	%0, %1, %0\n"
++		"cmpltu	r8, %0, %1\n"
++		"add	%0, %0, r8\n"	/* add carry */
++		"add	%0, %2, %0\n"
++		"cmpltu	r8, %0, %2\n"
++		"add	%0, %0, r8\n"	/* add carry */
++		"add	%0, %3, %0\n"
++		"cmpltu	r8, %0, %3\n"
++		"add	%0, %0, r8\n"	/* add carry */
++		: "=r" (sum), "=r" (saddr)
++		: "r" (daddr), "r" ( (ntohs(len)<<16) + (proto*256) ),
++		  "0" (sum),
++		  "1" (saddr)
++		: "r8");
++
++	return sum;
++    barrier();
++}
++
++
++#endif /* (__NIOS2_CHECKSUM_H) */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/cprefix.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/cprefix.h	2004-02-12 18:06:40.000000000 +0100
+@@ -0,0 +1,38 @@
++/* cprefix.h:  This file is included by assembly source which needs
++ *             to know what the c-label prefixes are. The newer versions
++ *	       of cpp that come with gcc predefine such things to help
++ *	       us out. The reason this stuff is needed is to make
++ *	       solaris compiles of the kernel work.
++ *
++ * Copyright (C) 2004 Microtronix Datacom Ltd.
++ * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++#ifndef __NIOS2_CPREFIX_H
++#define __NIOS2_CPREFIX_H
++
++#define C_LABEL_PREFIX
++
++#define CONCAT(a, b) CONCAT2(a, b)
++#define CONCAT2(a, b) a##b
++
++#define C_LABEL(name) CONCAT(C_LABEL_PREFIX, name)
++
++#endif /* !(__NIOS2_CPREFIX_H) */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/cpumask.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/cpumask.h	2004-01-25 14:35:16.000000000 +0100
+@@ -0,0 +1,28 @@
++/*
++ * All rights reserved.          
++ *
++ * Copyright (C) 2004, Microtronix Datacom Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#ifndef _ASM_NIOS2NOMMU_CPUMASK_H
++#define _ASM_NIOS2NOMMU_CPUMASK_H
++
++#include <asm-generic/cpumask.h>
++
++#endif /* _ASM_NIOS2NOMMU_CPUMASK_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/current.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/current.h	2004-02-12 18:06:40.000000000 +0100
+@@ -0,0 +1,39 @@
++#ifndef _NIOS2NOMMU_CURRENT_H
++#define _NIOS2NOMMU_CURRENT_H
++/*
++ *	current.h
++ *	(C) Copyright 2000, Lineo, David McCullough <davidm@uclinux.org>
++ *	(C) Copyright 2002, Greg Ungerer (gerg@snapgear.com)
++ *	(C) Copyright 2004, Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#include <linux/thread_info.h>
++
++struct task_struct;
++
++static inline struct task_struct *get_current(void)
++{
++	return(current_thread_info()->task);
++}
++
++#define	current	get_current()
++
++#endif /* _NIOS2NOMMU_CURRENT_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/delay.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/delay.h	2004-05-14 13:32:04.000000000 +0200
+@@ -0,0 +1,96 @@
++#ifndef _NIOS_DELAY_H
++#define _NIOS_DELAY_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/delay.h
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004      dgt     NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++#include <asm/param.h>
++
++extern __inline__ void __delay(unsigned long loops)
++{
++	int dummy;
++
++	__asm__ __volatile__(
++        "1:  \n\t"
++        "    beq    %0,zero,2f\n\t"
++        "    addi   %0, %0, -1\n\t" 
++        "    br     1b\n\t" 
++        "2:  \n\t" 
++
++        :  "=r" (dummy)                     /* Need output for optimizer */
++
++        :  "0" (loops)                      /* %0  Input                */
++        );
++}
++
++/*
++ * Note that 19 * 226 == 4294 ==~ 2^32 / 10^6, so
++ * loops = (4294 * usecs * loops_per_jiffy * HZ) / 2^32.
++ *
++ * The mul instruction gives us loops = (a * b) / 2^32.
++ * We choose a = usecs * 19 * HZ and b = loops_per_jiffy * 226
++ * because this lets us support a wide range of HZ and
++ * loops_per_jiffy values without either a or b overflowing 2^32.
++ * Thus we need usecs * HZ <= (2^32 - 1) / 19 = 226050910 and
++ * loops_per_jiffy <= (2^32 - 1) / 226 = 19004280
++ * (which corresponds to ~3800 bogomips at HZ = 100).
++ *  -- paulus
++ */
++#define __MAX_UDELAY	(226050910UL/HZ)	/* maximum udelay argument */
++#define __MAX_NDELAY	(4294967295UL/HZ)	/* maximum ndelay argument */
++
++extern unsigned long loops_per_jiffy;
++
++extern __inline__ void __udelay(unsigned int x)
++{
++	unsigned int loops;
++
++	__asm__("mulxuu %0,%1,%2" : "=r" (loops) :
++		"r" (x), "r" (loops_per_jiffy * 226));
++	__delay(loops);
++}
++
++extern __inline__ void __ndelay(unsigned int x)
++{
++	unsigned int loops;
++
++	__asm__("mulxuu %0,%1,%2" : "=r" (loops) :
++		"r" (x), "r" (loops_per_jiffy * 5));
++	__delay(loops);
++}
++
++extern void __bad_udelay(void);		/* deliberately undefined */
++extern void __bad_ndelay(void);		/* deliberately undefined */
++
++#define udelay(n) (__builtin_constant_p(n)? \
++	((n) > __MAX_UDELAY? __bad_udelay(): __udelay((n) * (19 * HZ))) : \
++	__udelay((n) * (19 * HZ)))
++
++#define ndelay(n) (__builtin_constant_p(n)? \
++	((n) > __MAX_NDELAY? __bad_ndelay(): __ndelay((n) * HZ)) : \
++	__ndelay((n) * HZ))
++
++#define muldiv(a, b, c)    (((a)*(b))/(c))
++
++#endif /* defined(_NIOS_DELAY_H) */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/div64.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/div64.h	2004-02-26 15:43:36.000000000 +0100
+@@ -0,0 +1,31 @@
++#ifndef __ASMNIOS_DIV64_H
++#define __ASMNIOS_DIV64_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/div64.h
++ *
++ * Derived from m68knommu
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++#include <asm-generic/div64.h>
++
++#endif
++
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/dma-mapping.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/dma-mapping.h	2004-05-07 15:36:26.000000000 +0200
+@@ -0,0 +1,25 @@
++/*
++ *  include/asm-s390/dma-mapping.h
++ *
++ *  S390 version
++ *
++ *  This file exists so that #include <dma-mapping.h> doesn't break anything.
++ */
++
++#ifndef _ASM_DMA_MAPPING_H
++#define _ASM_DMA_MAPPING_H
++
++static inline void *dma_alloc_coherent(struct device *dev, size_t size,
++			 dma_addr_t *dma_handle, int flag)
++{
++	BUG();
++	return 0;
++}
++
++static inline void dma_free_coherent(struct device *dev, size_t size,
++		       void *vaddr, dma_addr_t dma_handle)
++{
++	BUG();
++}
++
++#endif /* _ASM_DMA_MAPPING_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/dma.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/dma.h	2004-03-02 11:05:52.000000000 +0100
+@@ -0,0 +1,40 @@
++/* $Id: dma.h,v 1.5 2004/03/02 16:05:52 ken-h Exp $
++ *
++ * Copyright 1995 (C) David S. Miller (davem@caip.rutgers.edu)
++ * Copyright 2004 (C) Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#ifndef _ASM_NIOS2_DMA_H
++#define _ASM_NIOS2_DMA_H
++
++#include <linux/kernel.h>
++#include <asm/asm-offsets.h>
++
++#define MAX_DMA_CHANNELS 2
++#define MAX_DMA_ADDRESS  (LINUX_SDRAM_START)
++#define DMA_MODE_READ    1
++#define DMA_MODE_WRITE   2
++
++extern int get_dma_list(char *);
++extern int request_dma(unsigned int, const char *);
++extern void free_dma(unsigned int);
++
++#endif /* !(_ASM_NIOS2_DMA_H) */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/elf.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/elf.h	2005-05-18 20:35:42.000000000 +0200
+@@ -0,0 +1,141 @@
++#ifndef __NIOS2_ELF_H
++#define __NIOS2_ELF_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/elf.h
++ *
++ * Nio2 ELF relocation types
++ *
++ * Derived from M68knommu
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * Jan/20/2004		dgt	    NiosII
++ * Mar/18/2004		xwt		NiosII relocation types added
++ *
++ ---------------------------------------------------------------------*/
++
++// #include <linux/config.h>
++#include <asm/ptrace.h>
++#include <asm/user.h>
++
++#define R_NIOS2_NONE			0
++#define R_NIOS2_S16				1
++#define R_NIOS2_U16				2
++#define R_NIOS2_PCREL16			3
++#define R_NIOS2_CALL26			4
++#define R_NIOS2_IMM5			5
++#define R_NIOS2_CACHE_OPX 		6
++#define R_NIOS2_IMM6			7
++#define R_NIOS2_IMM8			8
++#define R_NIOS2_HI16			9
++#define R_NIOS2_LO16			10
++#define R_NIOS2_HIADJ16 		11
++#define R_NIOS2_BFD_RELOC_32	12
++#define R_NIOS2_BFD_RELOC_16	13
++#define R_NIOS2_BFD_RELOC_8 	14
++#define R_NIOS2_GPREL			15
++#define R_NIOS2_GNU_VTINHERIT 	16
++#define R_NIOS2_GNU_VTENTRY  	17
++#define R_NIOS2_UJMP			18
++#define R_NIOS2_CJMP			19
++#define R_NIOS2_CALLR			20
++#define R_NIOS2_ALIGN			21
++/* Keep this the last entry.  */
++#define R_NIOS2_NUM				22
++
++typedef unsigned long elf_greg_t;
++
++#define ELF_NGREG (sizeof (struct user_regs_struct) / sizeof(elf_greg_t))
++typedef elf_greg_t elf_gregset_t[ELF_NGREG];
++
++typedef unsigned long elf_fpregset_t;
++
++/*
++ * This is used to ensure we don't load something for the wrong architecture.
++ */
++#define elf_check_arch(x) \
++	((x)->e_machine == EM_ALTERA_NIOS2)
++
++/*
++ * These are used to set parameters in the core dumps.
++ */
++#define ELF_CLASS	ELFCLASS32
++#define ELF_DATA	ELFDATA2LSB
++#define ELF_ARCH	EM_ALTERA_NIOS2
++
++#define ELF_PLAT_INIT(_r, load_addr)	_r->a1 = 0
++
++#define USE_ELF_CORE_DUMP
++#define ELF_EXEC_PAGESIZE	4096
++
++/* This is the location that an ET_DYN program is loaded if exec'ed.  Typical
++   use of this is to invoke "./ld.so someprog" to test out a new version of
++   the loader.  We need to make sure that it is out of the way of the program
++   that it will "exec", and that there is sufficient room for the brk.  */
++
++#define ELF_ET_DYN_BASE         0xD0000000UL
++
++/* regs is struct pt_regs, pr_reg is elf_gregset_t (which is
++   now struct_user_regs, they are different) */
++
++#define ELF_CORE_COPY_REGS(pr_reg, regs)				\
++	/* Bleech. */							\
++	pr_reg[0] = regs->r1;						\
++	pr_reg[1] = regs->r2;						\
++	pr_reg[2] = regs->r3;						\
++	pr_reg[3] = regs->r4;						\
++	pr_reg[4] = regs->r5;						\
++	pr_reg[5] = regs->r6;						\
++	pr_reg[6] = regs->r7;						\
++	pr_reg[7] = regs->r8;						\
++	pr_reg[8] = regs->r9;						\
++	pr_reg[9] = regs->r10;						\
++	pr_reg[10] = regs->r11;						\
++	pr_reg[11] = regs->r12;						\
++	pr_reg[12] = regs->r13;						\
++	pr_reg[13] = regs->r14;						\
++	pr_reg[14] = regs->r15;						\
++	pr_reg[23] = regs->sp;						\
++	pr_reg[26] = regs->estatus;					\
++	{								\
++	  struct switch_stack *sw = ((struct switch_stack *)regs) - 1;	\
++	  pr_reg[15] = sw->r16;						\
++	  pr_reg[16] = sw->r17;						\
++	  pr_reg[17] = sw->r18;						\
++	  pr_reg[18] = sw->r19;						\
++	  pr_reg[19] = sw->r20;						\
++	  pr_reg[20] = sw->r21;						\
++	  pr_reg[21] = sw->r22;						\
++	  pr_reg[22] = sw->r23;						\
++	  pr_reg[24] = sw->fp;						\
++	  pr_reg[25] = sw->gp;						\
++	}
++
++/* This yields a mask that user programs can use to figure out what
++   instruction set this cpu supports.  */
++
++#define ELF_HWCAP	(0)
++
++/* This yields a string that ld.so will use to load implementation
++   specific libraries for optimization.  This is more specific in
++   intent than poking at uname or /proc/cpuinfo.  */
++
++#define ELF_PLATFORM  (NULL)
++
++#ifdef __KERNEL__
++#define SET_PERSONALITY(ex, ibcs2) set_personality((ibcs2)?PER_SVR4:PER_LINUX)
++#endif
++
++#endif
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/entry.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/entry.h	2005-05-18 20:35:50.000000000 +0200
+@@ -0,0 +1,188 @@
++/*
++ * Hacked from m68knommu port.
++ *
++ *  Copyright(C) 2004 Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#ifndef __NIOS2NOMMU_ENTRY_H
++#define __NIOS2NOMMU_ENTRY_H
++
++#ifdef __ASSEMBLY__
++
++// #include <linux/config.h>
++#include <asm/setup.h>
++#include <asm/page.h>
++#include <asm/asm-offsets.h>
++
++/*
++ * Stack layout in 'ret_from_exception':
++ *
++ * This allows access to the syscall arguments in registers r4-r8
++ *
++ *	 0(sp) - r8
++ *	 4(sp) - r9
++ *	 8(sp) - r10
++ *	 C(sp) - r11
++ *	10(sp) - r12
++ *	14(sp) - r13
++ *	18(sp) - r14
++ *	1C(sp) - r15
++ *	20(sp) - r1
++ *	24(sp) - r2
++ *	28(sp) - r3
++ *	2C(sp) - r4
++ *	30(sp) - r5
++ *	34(sp) - r6
++ *	38(sp) - r7
++ *	3C(sp) - orig_r2
++ *	40(sp) - ra
++ *	44(sp) - fp
++ *	48(sp) - sp
++ *	4C(sp) - gp
++ *	50(sp) - estatus
++ *	54(sp) - status_extension
++ *	58(sp) - ea
++ *
++ */
++
++/* process bits for task_struct.flags */
++PF_TRACESYS_OFF = 3
++PF_TRACESYS_BIT = 5
++PF_PTRACED_OFF = 3
++PF_PTRACED_BIT = 4
++PF_DTRACE_OFF = 1
++PF_DTRACE_BIT = 5
++
++LENOSYS = 38
++
++/*
++ * This defines the normal kernel pt-regs layout.
++ *
++ */
++
++/*
++ * Standard Nios2 interrupt entry and exit macros.
++ * Must be called with interrupts disabled.
++ */
++.macro SAVE_ALL
++	movia	r24,status_extension	// Read status extension
++	ldw	r24,0(r24)
++	andi	r24,r24,PS_S_ASM
++	bne	r24,r0,1f		// In supervisor mode, already on kernel stack
++	movia	r24,_current_thread	// Switch to current kernel stack
++	ldw	r24,0(r24)		//  using the thread_info
++	addi	r24,r24,THREAD_SIZE_ASM-PT_REGS_SIZE
++	stw	sp,PT_SP(r24)		// Save user stack before changing
++	mov	sp,r24
++	br	2f
++
++1:	mov	r24,sp
++	addi	sp,sp,-PT_REGS_SIZE	// Backup the kernel stack pointer
++	stw	r24,PT_SP(sp)
++2:	stw	r1,PT_R1(sp)
++	stw	r2,PT_R2(sp)
++	stw	r3,PT_R3(sp)
++	stw	r4,PT_R4(sp)
++	stw	r5,PT_R5(sp)
++	stw	r6,PT_R6(sp)
++	stw	r7,PT_R7(sp)
++	stw	r8,PT_R8(sp)
++	stw	r9,PT_R9(sp)
++	stw	r10,PT_R10(sp)
++	stw	r11,PT_R11(sp)
++	stw	r12,PT_R12(sp)
++	stw	r13,PT_R13(sp)
++	stw	r14,PT_R14(sp)
++	stw	r15,PT_R15(sp)
++	stw	r2,PT_ORIG_R2(sp)
++	stw	ra,PT_RA(sp)
++	stw	fp,PT_FP(sp)
++	stw	gp,PT_GP(sp)
++	rdctl	r24,estatus
++	stw	r24,PT_ESTATUS(sp)
++	movia	r24,status_extension	// Read status extension
++	ldw	r1,0(r24)
++	stw	r1,PT_STATUS_EXTENSION(sp)	// Store user/supervisor status
++	ORI32	r1,r1,PS_S_ASM			// Set supervisor mode
++	stw	r1,0(r24)
++	stw	ea,PT_EA(sp)
++.endm
++
++.macro RESTORE_ALL
++	ldw	r1,PT_STATUS_EXTENSION(sp)	// Restore user/supervisor status
++	movia	r24,status_extension
++	stw	r1,0(r24)
++	ldw	r1,PT_R1(sp)		// Restore registers
++	ldw	r2,PT_R2(sp)
++	ldw	r3,PT_R3(sp)
++	ldw	r4,PT_R4(sp)
++	ldw	r5,PT_R5(sp)
++	ldw	r6,PT_R6(sp)
++	ldw	r7,PT_R7(sp)
++	ldw	r8,PT_R8(sp)
++	ldw	r9,PT_R9(sp)
++	ldw	r10,PT_R10(sp)
++	ldw	r11,PT_R11(sp)
++	ldw	r12,PT_R12(sp)
++	ldw	r13,PT_R13(sp)
++	ldw	r14,PT_R14(sp)
++	ldw	r15,PT_R15(sp)
++	ldw	ra,PT_RA(sp)
++	ldw	fp,PT_FP(sp)
++	ldw	gp,PT_GP(sp)
++	ldw	r24,PT_ESTATUS(sp)
++	wrctl	estatus,r24
++	ldw	ea,PT_EA(sp)
++	ldw	sp,PT_SP(sp)		// Restore sp last
++.endm
++
++.macro	SAVE_SWITCH_STACK
++	addi	sp,sp,-SWITCH_STACK_SIZE
++	stw	r16,SW_R16(sp)
++	stw	r17,SW_R17(sp)
++	stw	r18,SW_R18(sp)
++	stw	r19,SW_R19(sp)
++	stw	r20,SW_R20(sp)
++	stw	r21,SW_R21(sp)
++	stw	r22,SW_R22(sp)
++	stw	r23,SW_R23(sp)
++	stw	fp,SW_FP(sp)
++	stw	gp,SW_GP(sp)
++	stw	ra,SW_RA(sp)
++.endm
++
++.macro	RESTORE_SWITCH_STACK
++	ldw	r16,SW_R16(sp)
++	ldw	r17,SW_R17(sp)
++	ldw	r18,SW_R18(sp)
++	ldw	r19,SW_R19(sp)
++	ldw	r20,SW_R20(sp)
++	ldw	r21,SW_R21(sp)
++	ldw	r22,SW_R22(sp)
++	ldw	r23,SW_R23(sp)
++	ldw	fp,SW_FP(sp)
++	ldw	gp,SW_GP(sp)
++	ldw	ra,SW_RA(sp)
++	addi	sp,sp,SWITCH_STACK_SIZE
++.endm
++
++#endif /* __ASSEMBLY__ */
++#endif /* __NIOS2NOMMU_ENTRY_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/errno.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/errno.h	2004-02-12 18:06:40.000000000 +0100
+@@ -0,0 +1,6 @@
++#ifndef _NIOS2NOMMU_ERRNO_H
++#define _NIOS2NOMMU_ERRNO_H
++
++#include <asm-generic/errno.h>
++
++#endif /* _NIOS2NOMMU_ERRNO_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/fcntl.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/fcntl.h	2004-12-08 17:39:48.000000000 +0100
+@@ -0,0 +1,110 @@
++/*
++ * This file came from the m68k port.
++ *
++ * Copyright (C) 2004 Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++#ifndef _NIOS2_FCNTL_H
++#define _NIOS2_FCNTL_H
++
++/* open/fcntl - O_SYNC is only implemented on blocks devices and on files
++   located on an ext2 file system */
++#define O_ACCMODE	  0003
++#define O_RDONLY	    00
++#define O_WRONLY	    01
++#define O_RDWR		    02
++#define O_CREAT		  0100	/* not fcntl */
++#define O_EXCL		  0200	/* not fcntl */
++#define O_NOCTTY	  0400	/* not fcntl */
++#define O_TRUNC		 01000	/* not fcntl */
++#define O_APPEND	 02000
++#define O_NONBLOCK	 04000
++#define O_NDELAY	O_NONBLOCK
++#define O_SYNC		010000
++#define FASYNC		020000	/* fcntl, for BSD compatibility */
++#define O_DIRECTORY	040000	/* must be a directory */
++#define O_NOFOLLOW	0100000	/* don't follow links */
++#define O_DIRECT	0200000	/* direct disk access hint - currently ignored */
++#define O_LARGEFILE	0400000
++#define O_NOATIME	01000000
++
++#define F_DUPFD		0	/* dup */
++#define F_GETFD		1	/* get close_on_exec */
++#define F_SETFD		2	/* set/clear close_on_exec */
++#define F_GETFL		3	/* get file->f_flags */
++#define F_SETFL		4	/* set file->f_flags */
++#define F_GETLK		5
++#define F_SETLK		6
++#define F_SETLKW	7
++
++#define F_SETOWN	8	/*  for sockets. */
++#define F_GETOWN	9	/*  for sockets. */
++#define F_SETSIG	10	/*  for sockets. */
++#define F_GETSIG	11	/*  for sockets. */
++
++#define F_GETLK64	12	/*  using 'struct flock64' */
++#define F_SETLK64	13
++#define F_SETLKW64	14
++
++/* for F_[GET|SET]FL */
++#define FD_CLOEXEC	1	/* actually anything with low bit set goes */
++
++/* for posix fcntl() and lockf() */
++#define F_RDLCK		0
++#define F_WRLCK		1
++#define F_UNLCK		2
++
++/* for old implementation of bsd flock () */
++#define F_EXLCK		4	/* or 3 */
++#define F_SHLCK		8	/* or 4 */
++
++/* for leases */
++#define F_INPROGRESS	16
++
++/* operations for bsd flock(), also used by the kernel implementation */
++#define LOCK_SH		1	/* shared lock */
++#define LOCK_EX		2	/* exclusive lock */
++#define LOCK_NB		4	/* or'd with one of the above to prevent
++				   blocking */
++#define LOCK_UN		8	/* remove lock */
++
++#define LOCK_MAND	32	/* This is a mandatory flock */
++#define LOCK_READ	64	/* ... Which allows concurrent read operations */
++#define LOCK_WRITE	128	/* ... Which allows concurrent write operations */
++#define LOCK_RW		192	/* ... Which allows concurrent read & write ops */
++
++struct flock {
++	short l_type;
++	short l_whence;
++	off_t l_start;
++	off_t l_len;
++	pid_t l_pid;
++};
++
++struct flock64 {
++	short  l_type;
++	short  l_whence;
++	loff_t l_start;
++	loff_t l_len;
++	pid_t  l_pid;
++};
++
++#define F_LINUX_SPECIFIC_BASE	1024
++#endif /* _NIOS2_FCNTL_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/flat.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/flat.h	2004-12-08 17:39:48.000000000 +0100
+@@ -0,0 +1,126 @@
++/*
++ * include/asm-nios2nommu/flat.h -- uClinux bFLT relocations
++ *
++ *  Copyright (C) 2004,05  Microtronix Datacom Ltd
++ *
++ * This file is subject to the terms and conditions of the GNU General
++ * Public License.  See the file COPYING in the main directory of this
++ * archive for more details.
++ *
++ * Written by Wentao Xu <wentao@microtronix.com>
++ */
++
++#ifndef __NIOS2_FLAT_H__
++#define __NIOS2_FLAT_H__
++
++#define	flat_reloc_valid(reloc, size)	((reloc) <= (size + 0x8000))
++
++/* The stack is 64-bit aligned for Nios II, so (sp - 1) shall
++ * be 64-bit aligned, where -1 is for argc
++ */
++#define	flat_stack_align(sp)		(sp = (unsigned long *)(((unsigned long)sp - 1) & (-8)))
++
++/* The uClibc port for Nios II expects the argc is followed by argv and envp */
++#define	flat_argvp_envp_on_stack()	1
++
++#define	flat_old_ram_flag(flags)	(flags)
++
++/* We store the type of relocation in the top 4 bits of the `relval.' */
++
++/* Convert a relocation entry into an address.  */
++static inline unsigned long
++flat_get_relocate_addr (unsigned long relval)
++{
++	return relval & 0x0fffffff; /* Mask out top 4-bits */
++}
++
++#define FLAT_NIOS2_RELOC_TYPE(relval) ((relval) >> 28)
++
++#define FLAT_NIOS2_R_32			0 /* Normal 32-bit reloc */
++#define FLAT_NIOS2_R_HI_LO		1 /* High 16-bits + low 16-bits field */
++#define FLAT_NIOS2_R_HIADJ_LO	2 /* High 16-bits adjust + low 16-bits field */
++#define FLAT_NIOS2_R_CALL26		4 /* Call imm26 */
++
++/* Extract the address to be relocated from the symbol reference at rp;
++ * relval is the raw relocation-table entry from which RP is derived.
++ * rp shall always be 32-bit aligned
++ */
++static inline unsigned long flat_get_addr_from_rp (unsigned long *rp,
++						   unsigned long relval,
++						   unsigned long flags)
++{
++	switch (FLAT_NIOS2_RELOC_TYPE(relval))
++	{
++	case FLAT_NIOS2_R_32:
++		/* Simple 32-bit address. The loader expect it in bigger endian */
++		return htonl(*rp);
++
++	case FLAT_NIOS2_R_HI_LO:
++		/* get the two 16-bit immediate value from instructions, then
++		 * construct a 32-bit value. Again the loader expect bigger endian
++		 */
++		return htonl ((((rp[0] >> 6) & 0xFFFF) << 16 ) | 
++					  ((rp[1] >> 6) & 0xFFFF));
++
++	case FLAT_NIOS2_R_HIADJ_LO:
++		{
++		/* get the two 16-bit immediate value from instructions, then
++		 * construct a 32-bit value. Again the loader expect bigger endian
++		 */
++		 unsigned int low, high;
++		 high = (rp[0] >> 6) & 0xFFFF;
++		 low  = (rp[1] >> 6) & 0xFFFF;
++		 
++		 if ((low >> 15) & 1) high--;
++		 
++		 return htonl ((high << 16 ) | low );
++		}
++	case FLAT_NIOS2_R_CALL26:
++		/* the 26-bit immediate value is actually 28-bit */
++		return htonl(((*rp) >> 6) << 2);
++
++	default:
++		return ~0;	/* bogus value */
++	}
++}
++
++/* Insert the address addr into the symbol reference at rp;
++ * relval is the raw relocation-table entry from which rp is derived.
++ * rp shall always be 32-bit aligned
++ */
++static inline void flat_put_addr_at_rp (unsigned long *rp, unsigned long addr,
++					unsigned long relval)
++{
++	unsigned long exist_val;
++	switch (FLAT_NIOS2_RELOC_TYPE (relval)) {
++	case FLAT_NIOS2_R_32:
++		/* Simple 32-bit address.  */
++		*rp = addr;
++		break;
++
++	case FLAT_NIOS2_R_HI_LO:
++		exist_val = rp[0];
++		rp[0] = ((((exist_val >> 22) << 16) | (addr >> 16)) << 6) | (exist_val & 0x3F);
++		exist_val = rp[1];
++		rp[1] = ((((exist_val >> 22) << 16) | (addr & 0xFFFF)) << 6) | (exist_val & 0x3F);
++		break;
++
++	case FLAT_NIOS2_R_HIADJ_LO:
++		{
++		unsigned int high = (addr >> 16);
++		if ((addr >> 15) & 1) 
++			high = (high + 1) & 0xFFFF;
++		exist_val = rp[0];
++		rp[0] = ((((exist_val >> 22) << 16) | high) << 6) | (exist_val & 0x3F);
++		exist_val = rp[1];
++		rp[1] = ((((exist_val >> 22) << 16) | (addr & 0xFFFF)) << 6) | (exist_val & 0x3F);
++		break;
++		}
++	case FLAT_NIOS2_R_CALL26:
++		/* the opcode of CALL is 0, so just store the value */
++		*rp = ((addr >> 2) << 6);
++		break;
++	}
++}
++
++#endif /* __NIOS2_FLAT_H__ */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/hardirq.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/hardirq.h	2005-05-18 20:35:54.000000000 +0200
+@@ -0,0 +1,85 @@
++/*
++ * Ported from m68knommu
++ *
++ * Copyright (C) 2003, Microtronix Datacom Ltd.
++ * Copyright (C) 2004, Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++#ifndef __NIOS2_HARDIRQ_H
++#define __NIOS2_HARDIRQ_H
++
++// #include <linux/config.h>
++#include <linux/cache.h>
++#include <linux/threads.h>
++
++typedef struct {
++	unsigned int __softirq_pending;
++	unsigned int __syscall_count;
++	struct task_struct * __ksoftirqd_task;
++} ____cacheline_aligned irq_cpustat_t;
++
++#include <linux/irq_cpustat.h>	/* Standard mappings for irq_cpustat_t above */
++
++/*
++ * We put the hardirq and softirq counter into the preemption
++ * counter. The bitmask has the following meaning:
++ *
++ * - bits 0-7 are the preemption count (max preemption depth: 256)
++ * - bits 8-15 are the softirq count (max # of softirqs: 256)
++ * - bits 16-23 are the hardirq count (max # of hardirqs: 256)
++ *
++ * - ( bit 26 is the PREEMPT_ACTIVE flag. )
++ *
++ * PREEMPT_MASK: 0x000000ff
++ * HARDIRQ_MASK: 0x0000ff00
++ * SOFTIRQ_MASK: 0x00ff0000
++ */
++
++#define PREEMPT_BITS	8
++#define SOFTIRQ_BITS	8
++#define HARDIRQ_BITS	8
++
++#define PREEMPT_SHIFT	0
++#define SOFTIRQ_SHIFT	(PREEMPT_SHIFT + PREEMPT_BITS)
++#define HARDIRQ_SHIFT	(SOFTIRQ_SHIFT + SOFTIRQ_BITS)
++
++/*
++ * The hardirq mask has to be large enough to have
++ * space for potentially all IRQ sources in the system
++ * nesting on a single CPU:
++ */
++#if (1 << HARDIRQ_BITS) < NR_IRQS
++# error HARDIRQ_BITS is too low!
++#endif
++
++#define irq_enter()		(preempt_count() += HARDIRQ_OFFSET)
++#define irq_exit()							\
++do {									\
++		preempt_count() -= IRQ_EXIT_OFFSET;			\
++		if (!in_interrupt() && softirq_pending(smp_processor_id())) \
++			do_softirq();					\
++		preempt_enable_no_resched();				\
++} while (0)
++
++#ifdef CONFIG_SMP
++# error nios2nommu SMP is not available
++#endif /* CONFIG_SMP */
++
++#endif /* __NIOS2_HARDIRQ_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/hdreg.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/hdreg.h	2004-02-12 18:06:40.000000000 +0100
+@@ -0,0 +1,30 @@
++/*
++ *  Copyright (C) 1994-1996  Linus Torvalds & authors
++ *  Copyright (C) 2002  Wentau Xu (www.microtronix.com)
++ *  copyright (C) 2004  Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#ifndef __NIOS2_HDREG_H
++#define __NIOS2_HDREG_H
++
++typedef unsigned long ide_ioreg_t;
++
++#endif /* __NIOS2_HDREG_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/hw_irq.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/hw_irq.h	2004-09-01 12:54:44.000000000 +0200
+@@ -0,0 +1,16 @@
++#ifndef _ASM_HW_IRQ_H
++#define _ASM_HW_IRQ_H
++
++/*
++ *	linux/include/asm/hw_irq.h
++ *
++ *	(C) 1992, 1993 Linus Torvalds, (C) 1997 Ingo Molnar
++ *
++ *	moved some of the old arch/i386/kernel/irq.h to here. VY
++ *
++ *	IRQ/IPI changes taken from work by Thomas Radke
++ *	<tomsoft@informatik.tu-chemnitz.de>
++ */
++
++
++#endif /* _ASM_HW_IRQ_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/ide.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/ide.h	2004-12-15 12:01:40.000000000 +0100
+@@ -0,0 +1,47 @@
++/*
++ *  linux/include/asm-niosnommu2/ide.h
++ *
++ *  Copyright (C) 1994-1996  Linus Torvalds & authors
++ *  Copyright (C) 2004	     Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#ifndef __ASMNIOS2_IDE_H
++#define __ASMNIOS2_IDE_H
++
++#ifdef __KERNEL__
++#undef MAX_HWIFS		/* we're going to force it */
++
++#ifndef MAX_HWIFS
++#define MAX_HWIFS	1
++#endif
++
++#define IDE_ARCH_OBSOLETE_INIT
++#define IDE_ARCH_OBSOLETE_DEFAULTS
++#define ide_default_io_base(i)		((unsigned long)na_ide_ide)
++#define ide_default_irq(b)			(na_ide_ide_irq)
++#define ide_init_default_irq(base)	ide_default_irq(base)
++#define ide_default_io_ctl(base)	((base) + (0xE*4))
++
++#include <asm-generic/ide_iops.h>
++
++#endif /* __KERNEL__ */
++
++#endif /* __ASMNIOS2_IDE_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/init.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/init.h	2004-02-12 18:06:40.000000000 +0100
+@@ -0,0 +1,22 @@
++/*
++ * Copyright (C) 2004, Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++#error "<asm/init.h> should never be used - use <linux/init.h> instead"
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/io.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/io.h	2004-12-23 15:46:46.000000000 +0100
+@@ -0,0 +1,239 @@
++/*
++ * Copyright (C) 2004, Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#ifndef __NIOS2_IO_H
++#define __NIOS2_IO_H
++
++#ifdef __KERNEL__
++
++#include <linux/kernel.h>
++
++#include <asm/page.h>      /* IO address mapping routines need this */
++#include <asm/system.h>
++#include <asm/unaligned.h>
++
++extern void insw(unsigned long port, void *dst, unsigned long count);
++extern void outsw(unsigned long port, void *src, unsigned long count);
++extern void insl(unsigned long port, void *dst, unsigned long count);
++extern void outsl(unsigned long port, void *src, unsigned long count);
++
++
++/*
++ * readX/writeX() are used to access memory mapped devices. On some
++ * architectures the memory mapped IO stuff needs to be accessed
++ * differently. On the Nios architecture, we just read/write the
++ * memory location directly.
++ */
++
++#define readb(addr) 	\
++({						\
++	unsigned char __res;\
++	__asm__ __volatile__( \
++		"ldbuio %0, 0(%1)" \
++		: "=r"(__res)	\
++		: "r" (addr));	\
++	__res;				\
++})
++
++#define readw(addr) 	\
++({						\
++	unsigned short __res;\
++	__asm__ __volatile__( \
++		"ldhuio %0, 0(%1)" \
++		: "=r"(__res)	\
++		: "r" (addr));	\
++	__res;				\
++})
++
++#define readl(addr) 	\
++({						\
++	unsigned int __res;\
++	__asm__ __volatile__( \
++		"ldwio %0, 0(%1)" \
++		: "=r"(__res)	\
++		: "r" (addr));	\
++	__res;				\
++})
++
++#define writeb(b,addr)	\
++({						\
++	__asm__ __volatile__( \
++		"stbio %0, 0(%1)" \
++		: : "r"(b), "r" (addr));	\
++})
++
++#define writew(b,addr)	\
++({						\
++	__asm__ __volatile__( \
++		"sthio %0, 0(%1)" \
++		: : "r"(b), "r" (addr));	\
++})
++
++#define writel(b,addr)	\
++({						\
++	__asm__ __volatile__( \
++		"stwio %0, 0(%1)" \
++		: : "r"(b), "r" (addr));	\
++})
++
++#define __raw_readb readb
++#define __raw_readw readw
++#define __raw_readl readl
++#define __raw_writeb writeb
++#define __raw_writew writew
++#define __raw_writel writel
++
++
++/*
++ *	make the short names macros so specific devices
++ *	can override them as required
++ */
++
++#define memset_io(addr,c,len)	memset((void *)(((unsigned int)(addr)) | 0x80000000),(c),(len))
++#define memcpy_fromio(to,from,len)	memcpy((to),(void *)(((unsigned int)(from)) | 0x80000000),(len))
++#define memcpy_toio(to,from,len)	memcpy((void *)(((unsigned int)(to)) | 0x80000000),(from),(len))
++
++#define inb(addr)    readb(addr)
++#define inw(addr)    readw(addr)
++#define inl(addr)    readl(addr)
++
++#define outb(x,addr) ((void) writeb(x,addr))
++#define outw(x,addr) ((void) writew(x,addr))
++#define outl(x,addr) ((void) writel(x,addr))
++
++#define inb_p(addr)    inb(addr)
++#define inw_p(addr)    inw(addr)
++#define inl_p(addr)    inl(addr)
++
++#define outb_p(x,addr) outb(x,addr)
++#define outw_p(x,addr) outw(x,addr)
++#define outl_p(x,addr) outl(x,addr)
++
++
++
++extern inline void insb(unsigned long port, void *dst, unsigned long count)
++{
++	unsigned char *p=(unsigned char*)dst;
++	while (count--)
++		*p++ = inb(port);
++}
++
++/* See arch/niosnommu/io.c for optimized version */
++extern inline void _insw(unsigned long port, void *dst, unsigned long count)
++{
++	unsigned short *p=(unsigned short*)dst;
++	while (count--)
++		*p++ = inw(port);
++}
++
++/* See arch/niosnommu/kernel/io.c for unaligned destination pointer */
++extern inline void _insl(unsigned long port, void *dst, unsigned long count)
++{
++	unsigned long *p=(unsigned long*)dst;
++	while (count--)
++		*p++ = inl(port);
++}
++
++extern inline void outsb(unsigned long port, void *src, unsigned long count)
++{
++	unsigned char *p=(unsigned char*)src;
++	while (count--) 
++        outb( *p++, port );
++}
++
++/* See arch/niosnommu/io.c for optimized version */
++extern inline void _outsw(unsigned long port, void *src, unsigned long count)
++{
++	unsigned short *p=(unsigned short*)src;
++	while (count--) 
++        outw( *p++, port );
++}
++
++/* See arch/niosnommu/kernel/io.c for unaligned source pointer */
++extern inline void _outsl(unsigned long port, void *src, unsigned long count)
++{
++	unsigned long *p=(unsigned long*)src;
++	while (count--) 
++        outl( *p++, port );
++}
++
++
++
++extern inline void mapioaddr(unsigned long physaddr, unsigned long virt_addr,
++			     int bus, int rdonly)
++{
++	return;
++}
++
++//vic - copied from m68knommu
++
++/* Values for nocacheflag and cmode */
++#define IOMAP_FULL_CACHING		0
++#define IOMAP_NOCACHE_SER		1
++#define IOMAP_NOCACHE_NONSER		2
++#define IOMAP_WRITETHROUGH		3
++
++extern void *__ioremap(unsigned long physaddr, unsigned long size, int cacheflag);
++extern void __iounmap(void *addr, unsigned long size);
++
++extern inline void *ioremap(unsigned long physaddr, unsigned long size)
++{
++	return __ioremap(physaddr, size, IOMAP_NOCACHE_SER);
++}
++extern inline void *ioremap_nocache(unsigned long physaddr, unsigned long size)
++{
++	return __ioremap(physaddr, size, IOMAP_NOCACHE_SER);
++}
++extern inline void *ioremap_writethrough(unsigned long physaddr, unsigned long size)
++{
++	return __ioremap(physaddr, size, IOMAP_WRITETHROUGH);
++}
++extern inline void *ioremap_fullcache(unsigned long physaddr, unsigned long size)
++{
++	return __ioremap(physaddr, size, IOMAP_FULL_CACHING);
++}
++
++extern void iounmap(void *addr);
++
++
++#define IO_SPACE_LIMIT 0xffffffff
++
++#define dma_cache_inv(_start,_size)		do { } while (0)
++#define dma_cache_wback(_start,_size)		do { } while (0)
++#define dma_cache_wback_inv(_start,_size)	do { } while (0)
++
++/* Pages to physical address... */
++#define page_to_phys(page)      ((page - mem_map) << PAGE_SHIFT)
++#define page_to_bus(page)       ((page - mem_map) << PAGE_SHIFT)
++
++#define mm_ptov(vaddr)		((void *) (vaddr))
++#define mm_vtop(vaddr)		((unsigned long) (vaddr))
++#define phys_to_virt(vaddr)	((void *) (vaddr))
++#define virt_to_phys(vaddr)	((unsigned long) (vaddr))
++
++#define virt_to_bus virt_to_phys
++#define bus_to_virt phys_to_virt
++
++#endif /* __KERNEL__ */
++
++#endif /* !(__NIOS2_IO_H) */
++
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/ioctl.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/ioctl.h	2004-02-12 18:06:40.000000000 +0100
+@@ -0,0 +1,100 @@
++/* $Id: ioctl.h,v 1.3 2004/02/12 23:06:40 ken-h Exp $
++ *
++ * linux/ioctl.h for Linux by H.H. Bergman.
++ *
++ * Copyright (C) 2004,  Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#ifndef _NIOS2_IOCTL_H
++#define _NIOS2_IOCTL_H
++
++/* ioctl command encoding: 32 bits total, command in lower 16 bits,
++ * size of the parameter structure in the lower 14 bits of the
++ * upper 16 bits.
++ * Encoding the size of the parameter structure in the ioctl request
++ * is useful for catching programs compiled with old versions
++ * and to avoid overwriting user space outside the user buffer area.
++ * The highest 2 bits are reserved for indicating the ``access mode''.
++ * NOTE: This limits the max parameter size to 16kB -1 !
++ */
++
++/*
++ * I don't really have any idea about what this should look like, so
++ * for the time being, this is heavily based on the PC definitions.
++ */
++
++/*
++ * The following is for compatibility across the various Linux
++ * platforms.  The i386 ioctl numbering scheme doesn't really enforce
++ * a type field.  De facto, however, the top 8 bits of the lower 16
++ * bits are indeed used as a type field, so we might just as well make
++ * this explicit here.  Please be sure to use the decoding macros
++ * below from now on.
++ */
++#define _IOC_NRBITS	8
++#define _IOC_TYPEBITS	8
++#define _IOC_SIZEBITS	14
++#define _IOC_DIRBITS	2
++
++#define _IOC_NRMASK	((1 << _IOC_NRBITS)-1)
++#define _IOC_TYPEMASK	((1 << _IOC_TYPEBITS)-1)
++#define _IOC_SIZEMASK	((1 << _IOC_SIZEBITS)-1)
++#define _IOC_DIRMASK	((1 << _IOC_DIRBITS)-1)
++
++#define _IOC_NRSHIFT	0
++#define _IOC_TYPESHIFT	(_IOC_NRSHIFT+_IOC_NRBITS)
++#define _IOC_SIZESHIFT	(_IOC_TYPESHIFT+_IOC_TYPEBITS)
++#define _IOC_DIRSHIFT	(_IOC_SIZESHIFT+_IOC_SIZEBITS)
++
++/*
++ * Direction bits.
++ */
++#define _IOC_NONE	0U
++#define _IOC_WRITE	1U
++#define _IOC_READ	2U
++
++#define _IOC(dir,type,nr,size) \
++	(((dir)  << _IOC_DIRSHIFT) | \
++	 ((type) << _IOC_TYPESHIFT) | \
++	 ((nr)   << _IOC_NRSHIFT) | \
++	 ((size) << _IOC_SIZESHIFT))
++
++/* used to create numbers */
++#define _IO(type,nr)		_IOC(_IOC_NONE,(type),(nr),0)
++#define _IOR(type,nr,size)	_IOC(_IOC_READ,(type),(nr),sizeof(size))
++#define _IOW(type,nr,size)	_IOC(_IOC_WRITE,(type),(nr),sizeof(size))
++#define _IOWR(type,nr,size)	_IOC(_IOC_READ|_IOC_WRITE,(type),(nr),sizeof(size))
++
++/* used to decode ioctl numbers.. */
++#define _IOC_DIR(nr)		(((nr) >> _IOC_DIRSHIFT) & _IOC_DIRMASK)
++#define _IOC_TYPE(nr)		(((nr) >> _IOC_TYPESHIFT) & _IOC_TYPEMASK)
++#define _IOC_NR(nr)		(((nr) >> _IOC_NRSHIFT) & _IOC_NRMASK)
++#define _IOC_SIZE(nr)		(((nr) >> _IOC_SIZESHIFT) & _IOC_SIZEMASK)
++
++/* ...and for the drivers/sound files... */
++
++#define IOC_IN		(_IOC_WRITE << _IOC_DIRSHIFT)
++#define IOC_OUT		(_IOC_READ << _IOC_DIRSHIFT)
++#define IOC_INOUT	((_IOC_WRITE|_IOC_READ) << _IOC_DIRSHIFT)
++#define IOCSIZE_MASK	(_IOC_SIZEMASK << _IOC_SIZESHIFT)
++#define IOCSIZE_SHIFT	(_IOC_SIZESHIFT)
++
++#endif /* _NIOS2_IOCTL_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/ioctls.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/ioctls.h	2004-02-12 18:06:40.000000000 +0100
+@@ -0,0 +1,103 @@
++/*
++ * Copyright (C) 2004, Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#ifndef __ARCH_NIOS2_IOCTLS_H__
++#define __ARCH_NIOS2_IOCTLS_H__
++
++#include <asm/ioctl.h>
++
++/* 0x54 is just a magic number to make these relatively unique ('T') */
++
++#define TCGETS		0x5401
++#define TCSETS		0x5402
++#define TCSETSW		0x5403
++#define TCSETSF		0x5404
++#define TCGETA		0x5405
++#define TCSETA		0x5406
++#define TCSETAW		0x5407
++#define TCSETAF		0x5408
++#define TCSBRK		0x5409
++#define TCXONC		0x540A
++#define TCFLSH		0x540B
++#define TIOCEXCL	0x540C
++#define TIOCNXCL	0x540D
++#define TIOCSCTTY	0x540E
++#define TIOCGPGRP	0x540F
++#define TIOCSPGRP	0x5410
++#define TIOCOUTQ	0x5411
++#define TIOCSTI		0x5412
++#define TIOCGWINSZ	0x5413
++#define TIOCSWINSZ	0x5414
++#define TIOCMGET	0x5415
++#define TIOCMBIS	0x5416
++#define TIOCMBIC	0x5417
++#define TIOCMSET	0x5418
++#define TIOCGSOFTCAR	0x5419
++#define TIOCSSOFTCAR	0x541A
++#define FIONREAD	0x541B
++#define TIOCINQ		FIONREAD
++#define TIOCLINUX	0x541C
++#define TIOCCONS	0x541D
++#define TIOCGSERIAL	0x541E
++#define TIOCSSERIAL	0x541F
++#define TIOCPKT		0x5420
++#define FIONBIO		0x5421
++#define TIOCNOTTY	0x5422
++#define TIOCSETD	0x5423
++#define TIOCGETD	0x5424
++#define TCSBRKP		0x5425	/* Needed for POSIX tcsendbreak() */
++#define TIOCTTYGSTRUCT	0x5426  /* For debugging only */
++#define TIOCSBRK	0x5427  /* BSD compatibility */
++#define TIOCCBRK	0x5428  /* BSD compatibility */
++#define TIOCGSID	0x5429  /* Return the session ID of FD */
++#define TIOCGPTN	_IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */
++#define TIOCSPTLCK	_IOW('T',0x31, int)  /* Lock/unlock Pty */
++
++#define FIONCLEX	0x5450  /* these numbers need to be adjusted. */
++#define FIOCLEX		0x5451
++#define FIOASYNC	0x5452
++#define TIOCSERCONFIG	0x5453
++#define TIOCSERGWILD	0x5454
++#define TIOCSERSWILD	0x5455
++#define TIOCGLCKTRMIOS	0x5456
++#define TIOCSLCKTRMIOS	0x5457
++#define TIOCSERGSTRUCT	0x5458 /* For debugging only */
++#define TIOCSERGETLSR   0x5459 /* Get line status register */
++#define TIOCSERGETMULTI 0x545A /* Get multiport config  */
++#define TIOCSERSETMULTI 0x545B /* Set multiport config */
++
++#define TIOCMIWAIT	0x545C	/* wait for a change on serial input line(s) */
++#define TIOCGICOUNT	0x545D	/* read serial port inline interrupt counts */
++#define FIOQSIZE	0x545E
++
++/* Used for packet mode */
++#define TIOCPKT_DATA		 0
++#define TIOCPKT_FLUSHREAD	 1
++#define TIOCPKT_FLUSHWRITE	 2
++#define TIOCPKT_STOP		 4
++#define TIOCPKT_START		 8
++#define TIOCPKT_NOSTOP		16
++#define TIOCPKT_DOSTOP		32
++
++#define TIOCSER_TEMT    0x01	/* Transmitter physically empty */
++
++#endif /* __ARCH_NIOS2_IOCTLS_H__ */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/ipc.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/ipc.h	2004-02-12 18:06:40.000000000 +0100
+@@ -0,0 +1,51 @@
++#ifndef __NIOS2_IPC_H__
++#define __NIOS2_IPC_H__
++
++/* Copied from sparc version
++ * These are used to wrap system calls on the Nios.
++ *
++ * See arch/niosnommu/kernel/sys_nios.c for ugly details..
++ *
++ * Copyright (C) 2004, Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++struct ipc_kludge {
++	struct msgbuf *msgp;
++	long msgtyp;
++};
++
++#define SEMOP		 1
++#define SEMGET		 2
++#define SEMCTL		 3
++#define MSGSND		11
++#define MSGRCV		12
++#define MSGGET		13
++#define MSGCTL		14
++#define SHMAT		21
++#define SHMDT		22
++#define SHMGET		23
++#define SHMCTL		24
++
++/* Used by the DIPC package, try and avoid reusing it */
++#define DIPC            25
++
++#define IPCCALL(version,op)	((version)<<16 | (op))
++
++#endif
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/ipcbuf.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/ipcbuf.h	2004-02-12 18:06:40.000000000 +0100
+@@ -0,0 +1,49 @@
++#ifndef __NIOS2_IPCBUF_H__
++#define __NIOS2_IPCBUF_H__
++
++/* Copied from asm-m68k/ipcbuf.h
++ * The user_ipc_perm structure for Nios architecture.
++ * Note extra padding because this structure is passed back and forth
++ * between kernel and user space.
++ *
++ * Pad space is left for:
++ * - 32-bit mode_t and seq
++ * - 2 miscellaneous 32-bit values
++ * 
++ * Copyright (C) 2004, Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++struct ipc64_perm
++{
++	__kernel_key_t		key;
++	__kernel_uid32_t	uid;
++	__kernel_gid32_t	gid;
++	__kernel_uid32_t	cuid;
++	__kernel_gid32_t	cgid;
++	__kernel_mode_t		mode;
++	unsigned short		__pad1;
++	unsigned short		seq;
++	unsigned short		__pad2;
++	unsigned long		__unused1;
++	unsigned long		__unused2;
++};
++
++#endif /* __NIOS2_IPCBUF_H__ */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/irq.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/irq.h	2005-05-18 20:36:00.000000000 +0200
+@@ -0,0 +1,182 @@
++/*
++ * 21Mar2001    1.1    dgt/microtronix
++ *
++ * Copyright (C) 2004, Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++
++#ifndef _NIOS2NOMMU_IRQ_H_
++#define _NIOS2NOMMU_IRQ_H_
++
++extern void disable_irq(unsigned int);
++extern void enable_irq(unsigned int);
++
++// #include <linux/config.h>
++#include <linux/interrupt.h>
++
++#define	SYS_IRQS	32
++#define	NR_IRQS		SYS_IRQS
++
++/*
++ * Interrupt source definitions
++ * General interrupt sources are the level 1-7.
++ * Adding an interrupt service routine for one of these sources
++ * results in the addition of that routine to a chain of routines.
++ * Each one is called in succession.  Each individual interrupt
++ * service routine should determine if the device associated with
++ * that routine requires service.
++ */
++
++#define IRQ01		(1)	/* level 1  interrupt */
++#define IRQ02		(2)	/* level 2  interrupt */
++#define IRQ03		(3)	/* level 3  interrupt */
++#define IRQ04		(4)	/* level 4  interrupt */
++#define IRQ05		(5)	/* level 5  interrupt */
++#define IRQ06		(6)	/* level 6  interrupt */
++#define IRQ07		(7)	/* level 7  interrupt */
++#define IRQ08		(8)	/* level 8  interrupt */
++#define IRQ09		(9)	/* level 9  interrupt */
++#define IRQ0A		(10)	/* level 10 interrupt */
++#define IRQ0B		(11)	/* level 11 interrupt */
++#define IRQ0C		(12)	/* level 12 interrupt */
++#define IRQ0D		(13)	/* level 13 interrupt */
++#define IRQ0E		(14)	/* level 14 interrupt */
++#define IRQ0F		(15)	/* level 15 interrupt */
++#define IRQ10		(16)	/* level 16 interrupt */
++#define IRQ12		(17)	/* level 17 interrupt */
++#define IRQ13		(18)	/* level 18 interrupt */
++#define IRQ14		(19)	/* level 19 interrupt */
++#define IRQ15		(20)	/* level 20 interrupt */
++#define IRQ16		(21)	/* level 21 interrupt */
++#define IRQ17		(22)	/* level 22 interrupt */
++#define IRQ18		(23)	/* level 23 interrupt */
++#define IRQ19		(24)	/* level 24 interrupt */
++#define IRQ1A		(25)	/* level 25 interrupt */
++#define IRQ1B		(26)	/* level 26 interrupt */
++#define IRQ1C		(27)	/* level 27 interrupt */
++#define IRQ1D		(28)	/* level 28 interrupt */
++#define IRQ1E		(29)	/* level 29 interrupt */
++#define IRQ1F		(30)	/* level 30 interrupt */
++#define IRQ20		(31)	/* level 31 interrupt */
++#define IRQ21		(32)	/* level 32 interrupt */
++
++#define IRQMAX		IRQ21
++
++/*
++ * "Generic" interrupt sources
++ */
++
++/*
++ * Machine specific interrupt sources.
++ *
++ * Adding an interrupt service routine for a source with this bit
++ * set indicates a special machine specific interrupt source.
++ * The machine specific files define these sources.
++ *
++ * Removed, they are not used by any one.
++ */
++
++/*
++ * various flags for request_irq()
++ */
++#define IRQ_FLG_LOCK	(0x0001)	/* handler is not replaceable	*/
++#define IRQ_FLG_REPLACE	(0x0002)	/* replace existing handler	*/
++#define IRQ_FLG_FAST	(0x0004)
++#define IRQ_FLG_SLOW	(0x0008)
++#define IRQ_FLG_STD	(0x8000)	/* internally used		*/
++
++/*
++ * Functions to set and clear the interrupt mask.
++ */
++
++/*
++ * Use a zero to clean the bit.
++ */
++static inline void clrimr(int mask)
++{
++	int flags;
++
++	local_irq_save(flags);
++	__asm__ __volatile__(
++	"rdctl	r8, ienable\n"
++	"and	r8,r8,%0\n"
++	"wrctl	ienable, r8\n"
++	: /* No output */
++	: "r" (mask)
++	: "r8");
++	local_irq_restore(flags);
++}
++
++/*
++ * Use a one to set the bit.
++ */
++static inline void setimr(int mask)
++{
++	int flags;
++
++	local_irq_save(flags);
++	__asm__ __volatile__(
++	"rdctl	r8, ienable\n"
++	"or	r8,r8,%0\n"
++	"wrctl	ienable, r8\n"
++	: /* No output */
++	: "r" (mask)
++	: "r8");
++	local_irq_restore(flags);
++}
++
++/*
++ * This structure is used to chain together the ISRs for a particular
++ * interrupt source (if it supports chaining).
++ */
++typedef struct irq_node {
++	irqreturn_t	(*handler)(int, void *, struct pt_regs *);
++	unsigned long	flags;
++	void		*dev_id;
++	const char	*devname;
++	struct irq_node *next;
++} irq_node_t;
++
++/*
++ * This function returns a new irq_node_t
++ */
++extern irq_node_t *new_irq_node(void);
++
++/*
++ * This structure has only 4 elements for speed reasons
++ */
++typedef struct irq_handler {
++	irqreturn_t	(*handler)(int, void *, struct pt_regs *);
++	unsigned long	flags;
++	void		*dev_id;
++	const char	*devname;
++} irq_handler_t;
++
++/* count of spurious interrupts */
++extern volatile unsigned int num_spurious;
++
++#define disable_irq_nosync(i) disable_irq(i)
++
++#ifndef irq_canonicalize
++#define irq_canonicalize(i)	(i)
++#endif
++
++#endif /* _NIOS2NOMMU_IRQ_H_ */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/kmap_types.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/kmap_types.h	2004-02-12 18:06:40.000000000 +0100
+@@ -0,0 +1,43 @@
++/*
++ * Copyright (C) 2004, Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#ifndef _ASM_KMAP_TYPES_H
++#define _ASM_KMAP_TYPES_H
++
++enum km_type {
++	KM_BOUNCE_READ,
++	KM_SKB_SUNRPC_DATA,
++	KM_SKB_DATA_SOFTIRQ,
++	KM_USER0,
++	KM_USER1,
++	KM_BIO_SRC_IRQ,
++	KM_BIO_DST_IRQ,
++	KM_PTE0,
++	KM_PTE1,
++	KM_IRQ0,
++	KM_IRQ1,
++	KM_SOFTIRQ0,
++	KM_SOFTIRQ1,
++	KM_TYPE_NR
++};
++
++#endif
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/linkage.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/linkage.h	2004-03-12 11:50:10.000000000 +0100
+@@ -0,0 +1,29 @@
++/*
++ * Copyright (C) 2004, Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#ifndef __ASM_LINKAGE_H
++#define __ASM_LINKAGE_H
++
++#define __ALIGN .align 3
++#define __ALIGN_STR ".align 3"
++
++#endif
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/linux_logo.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/linux_logo.h	2004-02-12 18:06:40.000000000 +0100
+@@ -0,0 +1,953 @@
++/* $Id: linux_logo.h,v 1.3 2004/02/12 23:06:40 ken-h Exp $
++ * include/asm-nios/linux_logo.h: This is a linux logo
++ *                                 to be displayed on boot.
++ *
++ * Copyright (C) 1996 Larry Ewing (lewing@isc.tamu.edu)
++ * Copyright (C) 1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
++ * Copyright (C) 2004 Micrtronix Datacom Ltd.
++ *
++ * You can put anything here, but:
++ * LINUX_LOGO_COLORS has to be less than 224
++ * image size has to be 80x80
++ * values have to start from 0x20
++ * (i.e. RGB(linux_logo_red[0],
++ *	     linux_logo_green[0],
++ *	     linux_logo_blue[0]) is color 0x20)
++ * BW image has to be 80x80 as well, with MS bit
++ * on the left
++ * Serial_console ascii image can be any size,
++ * but should contain %s to display the version
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++ 
++#include <linux/init.h>
++#include <linux/version.h>
++
++#define linux_logo_banner "Linux/NIOS2 version " UTS_RELEASE
++
++#define __HAVE_ARCH_LINUX_LOGO
++#define __HAVE_ARCH_LINUX_LOGO16
++
++#define LINUX_LOGO_COLORS	221
++
++#ifdef INCLUDE_LINUX_LOGO_DATA
++
++unsigned char linux_logo_red[] __initdata = {
++    0x00, 0x06, 0x0a, 0x0e, 0x16, 0x1a, 0x1e, 0x22,
++    0x12, 0x00, 0x2a, 0x36, 0x42, 0x4e, 0x4a, 0x56,
++    0x26, 0x46, 0x2e, 0x32, 0x52, 0x3a, 0x02, 0x65,
++    0x5e, 0x3e, 0x74, 0x8a, 0xa2, 0x9a, 0x86, 0xc6,
++    0xc3, 0x65, 0xbb, 0xd2, 0xda, 0xd6, 0xe2, 0xf6,
++    0xfd, 0xae, 0x7b, 0xdd, 0xea, 0x6a, 0xaa, 0xe7,
++    0xbe, 0x5a, 0xee, 0x9e, 0x95, 0x80, 0x76, 0x79,
++    0x62, 0x36, 0x9a, 0xe2, 0xec, 0xe1, 0xb8, 0xd7,
++    0xaf, 0x25, 0xbc, 0xc0, 0xef, 0xea, 0xe8, 0xe8,
++    0xf5, 0xf1, 0xda, 0xd3, 0x79, 0xdb, 0xf4, 0xf6,
++    0xf6, 0xf6, 0xe2, 0x3d, 0xb4, 0xce, 0xe6, 0xee,
++    0xf6, 0x68, 0xd8, 0xec, 0xf5, 0xc6, 0xc8, 0x9c,
++    0x89, 0xd2, 0xee, 0xcb, 0xb9, 0xd2, 0x66, 0x5e,
++    0x8b, 0xbe, 0xa8, 0xd5, 0xca, 0xb6, 0xae, 0x9c,
++    0xc5, 0xbe, 0xbe, 0xca, 0x90, 0xb2, 0x9a, 0xa8,
++    0xb6, 0xf2, 0xce, 0xfa, 0xb2, 0x6e, 0xa6, 0xfe,
++    0xf6, 0xec, 0xfe, 0xd2, 0xea, 0xf5, 0xf2, 0xf2,
++    0xe9, 0xee, 0xf6, 0xf2, 0xee, 0xf6, 0xda, 0xd4,
++    0xfa, 0xca, 0xf2, 0xf6, 0xfe, 0xf2, 0xda, 0xe4,
++    0xf6, 0xdd, 0xf2, 0xee, 0xfa, 0xf0, 0x12, 0x4a,
++    0xd6, 0xf2, 0x8e, 0xf2, 0xf6, 0xf6, 0xb5, 0xf1,
++    0x26, 0x9a, 0xea, 0xf6, 0xe0, 0xd2, 0x16, 0x9a,
++    0x2e, 0xd2, 0x70, 0xd6, 0x46, 0x7c, 0xb4, 0x62,
++    0xda, 0xee, 0xd6, 0xa3, 0x74, 0xa7, 0xa2, 0xe0,
++    0xae, 0xbe, 0xce, 0xe2, 0xa3, 0x8e, 0x6d, 0x8e,
++    0x32, 0xaf, 0x50, 0x9e, 0x5b, 0x8a, 0x98, 0x82,
++    0x7a, 0x82, 0x56, 0x7c, 0x8a, 0x56, 0x5e, 0x86,
++    0x6a, 0x52, 0x59, 0x64, 0x5e,
++};
++
++unsigned char linux_logo_green[] __initdata = {
++    0x00, 0x06, 0x0a, 0x0e, 0x16, 0x1a, 0x1e, 0x22,
++    0x12, 0x00, 0x2a, 0x36, 0x42, 0x4e, 0x4a, 0x56,
++    0x26, 0x46, 0x2e, 0x32, 0x52, 0x3a, 0x02, 0x65,
++    0x5e, 0x3e, 0x74, 0x8a, 0xa2, 0x9a, 0x86, 0xc6,
++    0xc3, 0x62, 0xbb, 0xd2, 0xda, 0xd6, 0xe2, 0xf6,
++    0xfd, 0xae, 0x7b, 0xdd, 0xea, 0x6a, 0xaa, 0xe7,
++    0xbe, 0x5a, 0xee, 0x9e, 0x95, 0x80, 0x62, 0x5c,
++    0x4e, 0x26, 0x72, 0xaa, 0xba, 0xaf, 0x90, 0xae,
++    0x92, 0x1a, 0xa4, 0x85, 0xb6, 0xbe, 0xc3, 0xc8,
++    0xcf, 0xd0, 0xc2, 0xce, 0x57, 0xa2, 0xd6, 0xda,
++    0xda, 0xd7, 0xb8, 0x2a, 0x7b, 0x91, 0xae, 0xca,
++    0xda, 0x45, 0x9e, 0xb2, 0xd7, 0x9b, 0x90, 0x76,
++    0x5c, 0xa2, 0xbe, 0xa6, 0x85, 0x96, 0x4e, 0x46,
++    0x66, 0x92, 0x7a, 0x9a, 0x96, 0x9d, 0x9a, 0x6b,
++    0x8a, 0x8e, 0xb2, 0xca, 0x90, 0xa6, 0x79, 0x7c,
++    0xb6, 0xf2, 0xce, 0xfa, 0xb2, 0x6e, 0xa6, 0xfa,
++    0xea, 0xd7, 0xf6, 0xbc, 0xda, 0xde, 0xda, 0xe6,
++    0xca, 0xd8, 0xea, 0xe0, 0xcc, 0xf2, 0xce, 0xb2,
++    0xee, 0xa2, 0xd6, 0xe6, 0xf6, 0xd7, 0xc5, 0xb8,
++    0xc6, 0xb9, 0xce, 0xde, 0xce, 0xc6, 0x0e, 0x36,
++    0xae, 0xbe, 0x86, 0xba, 0xbe, 0xe6, 0x8e, 0xc4,
++    0x1e, 0x8e, 0xae, 0xba, 0xb2, 0xa6, 0x12, 0x7a,
++    0x20, 0xc6, 0x64, 0xaa, 0x2f, 0x70, 0x85, 0x46,
++    0xce, 0xd6, 0xa6, 0x6e, 0x51, 0x72, 0x92, 0xa6,
++    0x87, 0x96, 0xa2, 0xd6, 0x85, 0x7a, 0x6a, 0x6e,
++    0x22, 0x76, 0x36, 0x76, 0x3c, 0x6e, 0x63, 0x53,
++    0x66, 0x62, 0x42, 0x50, 0x56, 0x42, 0x56, 0x56,
++    0x56, 0x3e, 0x51, 0x52, 0x56,
++};
++
++unsigned char linux_logo_blue[] __initdata = {
++    0x00, 0x06, 0x0a, 0x0e, 0x16, 0x1a, 0x1e, 0x22,
++    0x12, 0x01, 0x2a, 0x36, 0x42, 0x4e, 0x4a, 0x56,
++    0x26, 0x46, 0x2e, 0x32, 0x52, 0x3a, 0x06, 0x65,
++    0x5e, 0x3e, 0x74, 0x8a, 0xa2, 0x9a, 0x86, 0xc6,
++    0xc3, 0x59, 0xbb, 0xd2, 0xda, 0xd6, 0xe2, 0xf6,
++    0xfd, 0xae, 0x7b, 0xdd, 0xea, 0x6a, 0xaa, 0xe7,
++    0xbe, 0x5a, 0xee, 0x9e, 0x95, 0x80, 0x2e, 0x08,
++    0x0a, 0x06, 0x0a, 0x0b, 0x0b, 0x0f, 0x0c, 0x0f,
++    0x3d, 0x09, 0x73, 0x09, 0x0d, 0x0a, 0x10, 0x1e,
++    0x2d, 0x13, 0x86, 0xba, 0x19, 0x0a, 0x36, 0x3c,
++    0x26, 0x14, 0x0d, 0x06, 0x07, 0x0a, 0x0b, 0x0f,
++    0x4a, 0x06, 0x0a, 0x0c, 0x2b, 0x0a, 0x0b, 0x0a,
++    0x06, 0x0a, 0x0a, 0x11, 0x0b, 0x0a, 0x0a, 0x1e,
++    0x0f, 0x0d, 0x0a, 0x0b, 0x22, 0x6a, 0x72, 0x0b,
++    0x0b, 0x22, 0x90, 0xca, 0x90, 0x92, 0x3c, 0x2c,
++    0xb6, 0xf2, 0xce, 0xfa, 0xb2, 0x6e, 0xa6, 0xea,
++    0xb6, 0x7c, 0xda, 0x8e, 0xa6, 0x87, 0x66, 0xb6,
++    0x81, 0x6a, 0xc6, 0x9a, 0x5b, 0xd2, 0xb6, 0x6a,
++    0xca, 0x45, 0x92, 0xb2, 0xca, 0x52, 0x8a, 0x3e,
++    0x2e, 0x66, 0x66, 0xae, 0x3e, 0x47, 0x06, 0x0e,
++    0x52, 0x36, 0x6a, 0x0e, 0x0e, 0xbe, 0x2c, 0x0e,
++    0x0a, 0x5a, 0x0d, 0x0e, 0x3e, 0x0a, 0x06, 0x2e,
++    0x06, 0x9e, 0x4e, 0x36, 0x06, 0x58, 0x24, 0x06,
++    0x9e, 0xae, 0x3a, 0x08, 0x08, 0x07, 0x5e, 0x0a,
++    0x32, 0x2e, 0x2a, 0xb2, 0x43, 0x48, 0x5f, 0x2e,
++    0x06, 0x06, 0x07, 0x24, 0x06, 0x32, 0x06, 0x06,
++    0x46, 0x2e, 0x22, 0x06, 0x06, 0x1e, 0x4c, 0x06,
++    0x3a, 0x22, 0x42, 0x34, 0x42,
++};
++
++unsigned char linux_logo[] __initdata = {
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x21, 0x21, 0x22, 0x22,
++    0x22, 0x21, 0x21, 0x21, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
++    0x26, 0x26, 0x25, 0x28, 0x23, 0x22, 0x21, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x29, 0x29, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x21, 0x23, 0x25, 0x2a, 0x2b, 0x2c, 0x2d, 0x2d,
++    0x2d, 0x2e, 0x2c, 0x2b, 0x2a, 0x25, 0x28, 0x22,
++    0x21, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x29, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x22,
++    0x24, 0x2a, 0x2c, 0x2f, 0x2c, 0x30, 0x30, 0x24,
++    0x25, 0x27, 0x2b, 0x2c, 0x2f, 0x31, 0x32, 0x25,
++    0x23, 0x21, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x29, 0x29, 0x29, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x22, 0x25,
++    0x33, 0x34, 0x35, 0x21, 0x36, 0x36, 0x36, 0x36,
++    0x36, 0x36, 0x36, 0x36, 0x21, 0x2b, 0x2f, 0x2c,
++    0x30, 0x28, 0x21, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x21, 0x24, 0x33,
++    0x2d, 0x27, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
++    0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x21, 0x31,
++    0x2d, 0x32, 0x24, 0x21, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x29, 0x29, 0x29, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x21, 0x28, 0x2a, 0x34,
++    0x25, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
++    0x36, 0x36, 0x36, 0x23, 0x32, 0x27, 0x21, 0x36,
++    0x2a, 0x2d, 0x2a, 0x28, 0x21, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x29, 0x20, 0x29, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x22, 0x26, 0x2c, 0x35,
++    0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
++    0x36, 0x36, 0x36, 0x25, 0x2f, 0x37, 0x32, 0x22,
++    0x36, 0x35, 0x31, 0x27, 0x22, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x29, 0x29, 0x29, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x23, 0x2a, 0x2f, 0x22,
++    0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
++    0x36, 0x36, 0x36, 0x26, 0x38, 0x38, 0x35, 0x25,
++    0x36, 0x21, 0x2d, 0x2b, 0x24, 0x21, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x21, 0x24, 0x39, 0x39, 0x36,
++    0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
++    0x36, 0x36, 0x36, 0x25, 0x2b, 0x30, 0x28, 0x22,
++    0x36, 0x36, 0x27, 0x34, 0x30, 0x23, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x29, 0x29, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x21, 0x26, 0x2d, 0x26, 0x36,
++    0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
++    0x36, 0x36, 0x36, 0x22, 0x22, 0x36, 0x36, 0x36,
++    0x36, 0x36, 0x36, 0x2d, 0x33, 0x28, 0x21, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x29, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x22, 0x30, 0x2f, 0x23, 0x36,
++    0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
++    0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
++    0x36, 0x36, 0x36, 0x2b, 0x2c, 0x25, 0x21, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x29, 0x29, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x23, 0x2a, 0x34, 0x36, 0x36,
++    0x36, 0x21, 0x22, 0x36, 0x36, 0x36, 0x36, 0x36,
++    0x36, 0x36, 0x36, 0x21, 0x23, 0x22, 0x36, 0x36,
++    0x36, 0x36, 0x36, 0x28, 0x34, 0x27, 0x22, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x29, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x23, 0x32, 0x2f, 0x36, 0x36,
++    0x21, 0x21, 0x24, 0x27, 0x21, 0x36, 0x36, 0x36,
++    0x36, 0x36, 0x28, 0x27, 0x22, 0x33, 0x24, 0x36,
++    0x36, 0x36, 0x36, 0x22, 0x2f, 0x2a, 0x23, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x29, 0x29, 0x29, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x23, 0x32, 0x2f, 0x36, 0x36,
++    0x30, 0x3a, 0x38, 0x24, 0x24, 0x36, 0x36, 0x36,
++    0x23, 0x2f, 0x3b, 0x3c, 0x3d, 0x30, 0x25, 0x21,
++    0x36, 0x36, 0x36, 0x36, 0x2f, 0x32, 0x23, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x23, 0x32, 0x2f, 0x36, 0x23,
++    0x3e, 0x3f, 0x40, 0x3a, 0x22, 0x36, 0x36, 0x21,
++    0x41, 0x42, 0x43, 0x44, 0x45, 0x3e, 0x23, 0x21,
++    0x36, 0x36, 0x36, 0x36, 0x2f, 0x33, 0x28, 0x21,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x29, 0x20, 0x29, 0x29, 0x29, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x23, 0x32, 0x2f, 0x36, 0x2b,
++    0x44, 0x40, 0x46, 0x47, 0x35, 0x36, 0x36, 0x26,
++    0x43, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x2e, 0x36,
++    0x36, 0x36, 0x36, 0x36, 0x31, 0x35, 0x24, 0x21,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x23, 0x32, 0x34, 0x36, 0x4d,
++    0x4e, 0x25, 0x2f, 0x46, 0x4a, 0x22, 0x23, 0x32,
++    0x4f, 0x50, 0x21, 0x31, 0x51, 0x52, 0x53, 0x36,
++    0x36, 0x36, 0x36, 0x36, 0x31, 0x35, 0x24, 0x21,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x29, 0x20, 0x29, 0x29, 0x29, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x23, 0x2a, 0x2f, 0x21, 0x3a,
++    0x4d, 0x21, 0x31, 0x54, 0x55, 0x28, 0x30, 0x2b,
++    0x4b, 0x4d, 0x36, 0x23, 0x32, 0x50, 0x3f, 0x36,
++    0x36, 0x36, 0x36, 0x36, 0x2e, 0x39, 0x24, 0x21,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x29, 0x20, 0x29, 0x20, 0x29, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x23, 0x2a, 0x38, 0x23, 0x37,
++    0x55, 0x36, 0x28, 0x3a, 0x56, 0x57, 0x57, 0x58,
++    0x3c, 0x4d, 0x36, 0x36, 0x36, 0x40, 0x40, 0x21,
++    0x36, 0x36, 0x36, 0x36, 0x2e, 0x39, 0x24, 0x21,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x29, 0x29, 0x29, 0x20, 0x29, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x22, 0x30, 0x51, 0x23, 0x35,
++    0x43, 0x25, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e,
++    0x5f, 0x60, 0x61, 0x36, 0x31, 0x47, 0x3b, 0x36,
++    0x36, 0x36, 0x36, 0x36, 0x31, 0x2c, 0x25, 0x21,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x22, 0x30, 0x2f, 0x23, 0x22,
++    0x40, 0x62, 0x63, 0x5d, 0x64, 0x65, 0x66, 0x67,
++    0x68, 0x69, 0x66, 0x5e, 0x6a, 0x6b, 0x2a, 0x36,
++    0x36, 0x36, 0x36, 0x36, 0x33, 0x2e, 0x26, 0x21,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x22, 0x27, 0x2f, 0x23, 0x36,
++    0x6c, 0x63, 0x6d, 0x64, 0x5c, 0x66, 0x69, 0x6e,
++    0x6f, 0x70, 0x71, 0x69, 0x69, 0x72, 0x6c, 0x36,
++    0x36, 0x36, 0x36, 0x36, 0x33, 0x34, 0x27, 0x22,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x22, 0x27, 0x34, 0x26, 0x73,
++    0x74, 0x75, 0x76, 0x64, 0x65, 0x77, 0x69, 0x78,
++    0x70, 0x71, 0x71, 0x71, 0x72, 0x5f, 0x5e, 0x21,
++    0x36, 0x36, 0x36, 0x36, 0x25, 0x38, 0x2a, 0x23,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x22, 0x26, 0x2d, 0x33, 0x79,
++    0x63, 0x7a, 0x7b, 0x5c, 0x66, 0x69, 0x6e, 0x7c,
++    0x71, 0x71, 0x69, 0x7d, 0x7e, 0x7a, 0x7f, 0x36,
++    0x36, 0x36, 0x36, 0x36, 0x21, 0x51, 0x2b, 0x28,
++    0x21, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x22, 0x26, 0x2d, 0x32, 0x24,
++    0x80, 0x81, 0x64, 0x82, 0x77, 0x69, 0x71, 0x71,
++    0x69, 0x83, 0x84, 0x85, 0x7a, 0x85, 0x86, 0x36,
++    0x21, 0x2b, 0x23, 0x36, 0x36, 0x39, 0x2e, 0x26,
++    0x22, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x22, 0x27, 0x2d, 0x33, 0x21,
++    0x87, 0x88, 0x89, 0x72, 0x67, 0x66, 0x5f, 0x89,
++    0x8a, 0x63, 0x85, 0x8b, 0x8c, 0x8d, 0x41, 0x36,
++    0x36, 0x2d, 0x3a, 0x35, 0x36, 0x24, 0x51, 0x32,
++    0x28, 0x21, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x22, 0x30, 0x2f, 0x33, 0x21,
++    0x55, 0x8e, 0x8f, 0x8a, 0x7d, 0x5e, 0x90, 0x7e,
++    0x75, 0x75, 0x90, 0x62, 0x40, 0x3f, 0x49, 0x23,
++    0x36, 0x24, 0x3a, 0x3a, 0x24, 0x36, 0x2e, 0x31,
++    0x26, 0x22, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x21, 0x28, 0x33, 0x37, 0x25, 0x22,
++    0x3b, 0x50, 0x8e, 0x8f, 0x90, 0x7e, 0x90, 0x63,
++    0x74, 0x91, 0x92, 0x42, 0x93, 0x4b, 0x45, 0x2c,
++    0x36, 0x36, 0x33, 0x39, 0x21, 0x36, 0x22, 0x51,
++    0x33, 0x28, 0x21, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x22, 0x27, 0x2e, 0x2e, 0x36, 0x21,
++    0x94, 0x3f, 0x50, 0x95, 0x96, 0x8f, 0x8f, 0x97,
++    0x8e, 0x42, 0x50, 0x43, 0x47, 0x48, 0x48, 0x98,
++    0x21, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x39,
++    0x2e, 0x27, 0x23, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x22, 0x24, 0x2b, 0x38, 0x28, 0x36, 0x32,
++    0x4c, 0x4b, 0x50, 0x50, 0x50, 0x42, 0x42, 0x50,
++    0x50, 0x40, 0x45, 0x99, 0x48, 0x48, 0x48, 0x48,
++    0x34, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x23,
++    0x2f, 0x2b, 0x24, 0x21, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x21, 0x28, 0x32, 0x51, 0x32, 0x28, 0x21, 0x98,
++    0x48, 0x47, 0x9a, 0x50, 0x50, 0x50, 0x50, 0x50,
++    0x9a, 0x4f, 0x9b, 0x48, 0x48, 0x48, 0x48, 0x48,
++    0x93, 0x23, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
++    0x2a, 0x2f, 0x2a, 0x28, 0x21, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x21,
++    0x23, 0x30, 0x2e, 0x2c, 0x36, 0x21, 0x51, 0x9b,
++    0x48, 0x48, 0x52, 0x3f, 0x50, 0x50, 0x40, 0x4b,
++    0x47, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48,
++    0x48, 0x34, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
++    0x36, 0x2d, 0x31, 0x27, 0x23, 0x21, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x23,
++    0x27, 0x2c, 0x2d, 0x21, 0x36, 0x28, 0x44, 0x48,
++    0x48, 0x48, 0x48, 0x47, 0x46, 0x4f, 0x47, 0x48,
++    0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48,
++    0x48, 0x9c, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
++    0x36, 0x28, 0x51, 0x39, 0x26, 0x22, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x22, 0x25,
++    0x35, 0x51, 0x28, 0x36, 0x36, 0x9d, 0x48, 0x48,
++    0x48, 0x48, 0x48, 0x48, 0x9b, 0x48, 0x48, 0x48,
++    0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48,
++    0x48, 0x4f, 0x28, 0x36, 0x36, 0x36, 0x36, 0x36,
++    0x36, 0x36, 0x28, 0x38, 0x2b, 0x25, 0x22, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x21, 0x24, 0x33,
++    0x51, 0x25, 0x36, 0x36, 0x23, 0x40, 0x9b, 0x48,
++    0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48,
++    0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48,
++    0x9b, 0x99, 0x2b, 0x36, 0x36, 0x36, 0x36, 0x36,
++    0x36, 0x36, 0x36, 0x30, 0x2f, 0x33, 0x24, 0x21,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x21, 0x23, 0x30, 0x34,
++    0x27, 0x36, 0x36, 0x36, 0x2a, 0x40, 0x47, 0x48,
++    0x48, 0x48, 0x48, 0x9b, 0x99, 0x99, 0x9b, 0x48,
++    0x48, 0x48, 0x48, 0x48, 0x48, 0x9b, 0x47, 0x52,
++    0x46, 0x4f, 0x37, 0x21, 0x36, 0x36, 0x36, 0x36,
++    0x36, 0x36, 0x36, 0x36, 0x30, 0x34, 0x2a, 0x23,
++    0x21, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x22, 0x25, 0x39, 0x2c,
++    0x36, 0x36, 0x36, 0x21, 0x31, 0x4e, 0x9a, 0x4c,
++    0x47, 0x9b, 0x9b, 0x52, 0x46, 0x4f, 0x52, 0x9b,
++    0x9b, 0x9b, 0x47, 0x4f, 0x45, 0x9a, 0x93, 0x93,
++    0x3f, 0x93, 0x98, 0x28, 0x36, 0x36, 0x36, 0x36,
++    0x36, 0x36, 0x36, 0x36, 0x36, 0x39, 0x2c, 0x26,
++    0x22, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x23, 0x2a, 0x34, 0x28,
++    0x36, 0x36, 0x36, 0x22, 0x38, 0x98, 0x44, 0x99,
++    0x9b, 0x48, 0x48, 0x9b, 0x4c, 0x48, 0x48, 0x48,
++    0x48, 0x48, 0x48, 0x47, 0x52, 0x46, 0x43, 0x93,
++    0x40, 0x40, 0x43, 0x53, 0x21, 0x23, 0x33, 0x23,
++    0x36, 0x36, 0x36, 0x36, 0x36, 0x21, 0x2f, 0x32,
++    0x28, 0x21, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x21, 0x24, 0x2b, 0x31, 0x36,
++    0x36, 0x22, 0x36, 0x24, 0x9e, 0x4f, 0x9b, 0x48,
++    0x48, 0x48, 0x48, 0x9b, 0x99, 0x9f, 0x52, 0x48,
++    0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x47,
++    0x4f, 0x9a, 0x3f, 0x46, 0x38, 0x36, 0x21, 0x30,
++    0x26, 0x36, 0x36, 0x36, 0x36, 0x36, 0x39, 0x2c,
++    0x25, 0x22, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x22, 0x26, 0x2e, 0x33, 0x36,
++    0x25, 0x25, 0x36, 0x4d, 0x52, 0x48, 0x48, 0x48,
++    0x47, 0x9f, 0x48, 0x48, 0x48, 0xa0, 0xa1, 0xa2,
++    0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48,
++    0x48, 0x47, 0x44, 0x93, 0x43, 0x23, 0x36, 0x36,
++    0x26, 0x24, 0x36, 0x36, 0x36, 0x36, 0x28, 0x2f,
++    0x2a, 0x23, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x23, 0x2a, 0x51, 0x24, 0x36,
++    0x2a, 0x36, 0x28, 0x44, 0x48, 0x48, 0x48, 0x48,
++    0xa3, 0xa4, 0x48, 0x48, 0x9f, 0xa5, 0xa6, 0x9f,
++    0x48, 0x48, 0x48, 0xa2, 0xa7, 0x47, 0x48, 0x48,
++    0x48, 0x48, 0x9b, 0x4b, 0x44, 0x37, 0x36, 0x23,
++    0x28, 0x30, 0x22, 0x36, 0x36, 0x36, 0x36, 0x2d,
++    0x35, 0x24, 0x21, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x21, 0x28, 0x2b, 0x34, 0x36, 0x25,
++    0x24, 0x36, 0x4a, 0x48, 0x48, 0x48, 0x48, 0x48,
++    0xa8, 0xa1, 0x48, 0x48, 0x9f, 0xa9, 0xa6, 0x9f,
++    0x48, 0x48, 0xaa, 0xa1, 0xa5, 0x9f, 0x48, 0x48,
++    0x48, 0x48, 0x48, 0x9b, 0x52, 0x3f, 0x21, 0x30,
++    0x35, 0x25, 0x30, 0x36, 0x36, 0x36, 0x36, 0x32,
++    0x2d, 0x26, 0x22, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x22, 0x26, 0x2e, 0x35, 0x36, 0x2a,
++    0x36, 0x24, 0x4f, 0x48, 0x52, 0x52, 0x48, 0x48,
++    0xab, 0xac, 0xa0, 0x48, 0xad, 0xa6, 0xa6, 0x9f,
++    0x48, 0xa2, 0xa9, 0xa6, 0xa2, 0x48, 0x48, 0x48,
++    0x48, 0x48, 0x48, 0x48, 0x48, 0x47, 0x32, 0x30,
++    0x2a, 0x23, 0x30, 0x23, 0x36, 0x36, 0x36, 0x21,
++    0x2f, 0x32, 0x23, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x21, 0x23, 0x2a, 0x51, 0x28, 0x28, 0x25,
++    0x36, 0x3a, 0x48, 0x48, 0xae, 0xaf, 0x48, 0x48,
++    0xad, 0xac, 0xa1, 0x9f, 0xa2, 0xa9, 0xa9, 0xa2,
++    0x48, 0xab, 0x78, 0xa7, 0x48, 0x48, 0x48, 0x48,
++    0x9f, 0x48, 0x48, 0x48, 0x48, 0x48, 0x38, 0x21,
++    0x36, 0x36, 0x22, 0x27, 0x36, 0x36, 0x36, 0x36,
++    0x2e, 0x35, 0x24, 0x21, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x22, 0x25, 0x2c, 0x34, 0x36, 0x30, 0x21,
++    0x23, 0x43, 0x48, 0x48, 0xb0, 0xb1, 0xb2, 0x9f,
++    0x48, 0xb3, 0xa5, 0xb3, 0xab, 0xa9, 0xa9, 0xb3,
++    0xb4, 0xa9, 0xb5, 0xb0, 0x48, 0x48, 0xa0, 0xa5,
++    0xa1, 0xad, 0x48, 0x48, 0x48, 0x48, 0x94, 0x36,
++    0x36, 0x36, 0x36, 0x32, 0x36, 0x36, 0x36, 0x36,
++    0x2a, 0x2e, 0x26, 0x22, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x21, 0x23, 0x2a, 0x51, 0x25, 0x21, 0x2a, 0x36,
++    0x2e, 0x9b, 0x48, 0x48, 0x48, 0xb6, 0xb7, 0xa4,
++    0xa2, 0xa7, 0xb5, 0x78, 0x6f, 0x6f, 0x6e, 0x6f,
++    0xa9, 0xb5, 0xab, 0x48, 0x9f, 0xab, 0xa9, 0xa1,
++    0xaa, 0x48, 0x48, 0x48, 0x48, 0x48, 0x98, 0x36,
++    0x36, 0x36, 0x36, 0x32, 0x36, 0x36, 0x36, 0x36,
++    0x22, 0x2f, 0x30, 0x22, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x22, 0x25, 0x2c, 0x34, 0x36, 0x24, 0x28, 0x36,
++    0x54, 0x48, 0x48, 0x48, 0x48, 0xa2, 0xa8, 0xa1,
++    0xa5, 0xa6, 0x6e, 0x6e, 0x6f, 0x6f, 0x6f, 0x6f,
++    0x6f, 0x78, 0xa5, 0xa0, 0xa0, 0x78, 0xa6, 0xa2,
++    0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x9a, 0x36,
++    0x36, 0x36, 0x36, 0x30, 0x36, 0x36, 0x36, 0x36,
++    0x21, 0x2f, 0x32, 0x23, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x21,
++    0x28, 0x32, 0x2f, 0x28, 0x36, 0x27, 0x22, 0x21,
++    0x43, 0x48, 0x4b, 0xa2, 0x9f, 0x48, 0xa2, 0xa1,
++    0xb8, 0x6e, 0x6e, 0xb5, 0x78, 0x6f, 0x78, 0x78,
++    0x6e, 0x6f, 0x78, 0xb5, 0xa6, 0xa1, 0xa0, 0x48,
++    0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x4b, 0x21,
++    0x36, 0x36, 0x21, 0x26, 0x36, 0x36, 0x36, 0x36,
++    0x36, 0x34, 0x2b, 0x28, 0x21, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x22,
++    0x25, 0x2c, 0x39, 0x36, 0x36, 0x30, 0x22, 0x25,
++    0x52, 0x48, 0xa3, 0xb1, 0xb6, 0xb3, 0xaa, 0xac,
++    0x68, 0x68, 0x6e, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f,
++    0x78, 0x6f, 0x6f, 0xb5, 0xa6, 0xb4, 0x48, 0x9f,
++    0xb4, 0xb4, 0xa2, 0x9f, 0x48, 0x48, 0x4f, 0x21,
++    0x36, 0x36, 0x22, 0x26, 0x36, 0x36, 0x36, 0x36,
++    0x36, 0x2c, 0x35, 0x24, 0x21, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x22,
++    0x30, 0x2d, 0x21, 0x36, 0x36, 0x32, 0x23, 0x2a,
++    0x47, 0x48, 0xa2, 0xb6, 0xaf, 0xb9, 0xba, 0x68,
++    0x6e, 0x6e, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x78,
++    0x6f, 0x6f, 0xa6, 0x6f, 0xb5, 0xa0, 0xaa, 0xa6,
++    0xa6, 0xa9, 0xb2, 0xb3, 0x48, 0x48, 0x4c, 0x22,
++    0x36, 0x36, 0x24, 0x23, 0x36, 0x36, 0x36, 0x36,
++    0x36, 0x2c, 0x39, 0x24, 0x21, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x21, 0x28,
++    0x33, 0x2e, 0x36, 0x36, 0x23, 0x31, 0x27, 0x39,
++    0x9b, 0x48, 0x48, 0x48, 0xb0, 0xb0, 0xba, 0xb8,
++    0x68, 0x68, 0x69, 0x78, 0x6f, 0xb5, 0x6f, 0xb5,
++    0x78, 0x78, 0x78, 0x78, 0x78, 0xa5, 0xbb, 0xa9,
++    0xa5, 0x48, 0x48, 0x48, 0x48, 0x48, 0x4c, 0x23,
++    0x36, 0x36, 0x26, 0x36, 0x36, 0x36, 0x36, 0x36,
++    0x36, 0x2c, 0x39, 0x24, 0x21, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x21, 0x28,
++    0x2b, 0x39, 0x36, 0x36, 0x36, 0x26, 0x32, 0x31,
++    0x9b, 0x48, 0x48, 0x48, 0x48, 0x9f, 0xac, 0x68,
++    0xbc, 0x6e, 0x6e, 0x6e, 0xb5, 0x6f, 0x6e, 0x6f,
++    0x6f, 0x78, 0x78, 0xb5, 0xb5, 0xa5, 0x9f, 0x9f,
++    0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x46, 0x22,
++    0x36, 0x21, 0x26, 0x36, 0x36, 0x36, 0x36, 0x36,
++    0x36, 0x2c, 0x35, 0x24, 0x21, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x21, 0x24,
++    0x35, 0x39, 0x36, 0x36, 0x36, 0x36, 0x26, 0x2d,
++    0x9b, 0x48, 0x48, 0xb0, 0xaa, 0xb3, 0xbd, 0xb8,
++    0xb8, 0x68, 0x6e, 0x6e, 0xb5, 0x6f, 0x78, 0x6e,
++    0x78, 0x6f, 0x78, 0x78, 0xb5, 0xa9, 0xa2, 0x48,
++    0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x9a, 0x36,
++    0x24, 0x27, 0xbe, 0x24, 0x25, 0x28, 0x21, 0x36,
++    0x36, 0x34, 0x2b, 0x28, 0x21, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x21, 0x25,
++    0x39, 0x4d, 0xbf, 0x84, 0x81, 0x57, 0x21, 0x39,
++    0x52, 0x48, 0x48, 0x62, 0xb1, 0xc0, 0xc1, 0xc1,
++    0xb8, 0xb8, 0x68, 0xbc, 0x6e, 0x6e, 0x6e, 0x78,
++    0x78, 0x78, 0x78, 0x6e, 0x78, 0xa9, 0xa0, 0xab,
++    0xb3, 0xa2, 0x48, 0x48, 0x48, 0x48, 0x53, 0x28,
++    0x23, 0x36, 0x36, 0x36, 0x21, 0x28, 0x2c, 0x30,
++    0x21, 0x38, 0x33, 0x28, 0x21, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x21, 0x22, 0x22, 0x28, 0x30,
++    0x2d, 0xc2, 0x7a, 0xc3, 0xc4, 0xc4, 0x7f, 0x22,
++    0x51, 0x52, 0x48, 0x48, 0xb0, 0xaa, 0xa8, 0xbd,
++    0x68, 0xb8, 0xb8, 0x68, 0x68, 0x6e, 0x6e, 0x6f,
++    0x6e, 0x6e, 0xb5, 0x6e, 0x78, 0xab, 0xab, 0xb5,
++    0x78, 0xa6, 0xb3, 0xc5, 0xac, 0xac, 0xc6, 0x61,
++    0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x30, 0x32,
++    0x25, 0x4d, 0x2b, 0x28, 0x21, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x21, 0x23, 0x24, 0x26, 0x30, 0x33, 0x31,
++    0x4d, 0x91, 0x5b, 0xc3, 0xc4, 0xc4, 0xc4, 0x5a,
++    0x21, 0x2e, 0x46, 0x48, 0x48, 0x48, 0xb0, 0x64,
++    0xc1, 0xb8, 0xb8, 0xb8, 0x68, 0x71, 0x6e, 0x6e,
++    0x6f, 0x71, 0x6f, 0x6f, 0xa6, 0xa0, 0x9f, 0xb4,
++    0xb4, 0xa0, 0xa1, 0xb7, 0xc7, 0x69, 0x66, 0xc8,
++    0x36, 0x36, 0x36, 0x36, 0x36, 0x21, 0x26, 0x25,
++    0x83, 0xc9, 0x2c, 0x25, 0x21, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x21, 0x28, 0x30, 0x35, 0x2d, 0x2f, 0x37, 0x4a,
++    0x60, 0x85, 0xca, 0xcb, 0xc4, 0xc4, 0xc4, 0x82,
++    0x86, 0x36, 0x32, 0x3f, 0xa2, 0xa4, 0xa8, 0xa9,
++    0xb8, 0xb8, 0xb8, 0xb8, 0x68, 0x6e, 0x6e, 0x6e,
++    0x6e, 0x71, 0x6f, 0x71, 0xa6, 0xb4, 0x9f, 0x9f,
++    0x48, 0x48, 0x48, 0xcc, 0xc3, 0xc7, 0xcd, 0xce,
++    0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x21, 0x57,
++    0x77, 0x66, 0x34, 0x27, 0x22, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x23, 0x30, 0x31, 0xcf, 0x91, 0x7e, 0x90, 0x90,
++    0x8b, 0x5b, 0xc3, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4,
++    0x5d, 0xd0, 0x36, 0x24, 0xd1, 0xb1, 0xaf, 0xaa,
++    0xba, 0xb8, 0x68, 0x68, 0x68, 0x71, 0x6e, 0x6e,
++    0x6e, 0x6f, 0x6e, 0x78, 0xa1, 0xa9, 0xa1, 0xb0,
++    0x9f, 0x9b, 0x99, 0xcc, 0x64, 0x5c, 0x8b, 0xd0,
++    0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x73, 0x5d,
++    0x82, 0x5c, 0xd2, 0x2a, 0x23, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x21,
++    0x24, 0x2b, 0xcf, 0x8b, 0x5b, 0x76, 0x5b, 0x5b,
++    0x7b, 0xc3, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4,
++    0xc7, 0x5e, 0x22, 0x36, 0x21, 0x3a, 0x99, 0x48,
++    0xa2, 0xa8, 0xb7, 0xc1, 0xb8, 0x68, 0x68, 0xbc,
++    0x68, 0x6e, 0xb5, 0xb4, 0xb4, 0xab, 0xb5, 0xa1,
++    0xb0, 0x4f, 0x3f, 0xd3, 0x7b, 0x7b, 0x85, 0x80,
++    0xbe, 0x36, 0x36, 0x36, 0x21, 0xd4, 0x7e, 0x7b,
++    0x64, 0x64, 0xd5, 0x35, 0x24, 0x21, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x22,
++    0x26, 0x31, 0xd6, 0x5b, 0x64, 0xc3, 0xc3, 0xcb,
++    0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4,
++    0xc4, 0x66, 0xd7, 0x36, 0x36, 0x36, 0x2c, 0x4b,
++    0xd8, 0xd9, 0xb3, 0xa8, 0xbd, 0xbd, 0xbd, 0xbd,
++    0xa9, 0xab, 0xb3, 0xa5, 0xa2, 0x9f, 0xa2, 0xa1,
++    0x6a, 0x9a, 0x3f, 0xda, 0x76, 0x76, 0x7a, 0x63,
++    0xdb, 0xdc, 0x86, 0xdc, 0xdd, 0x90, 0x5b, 0x64,
++    0xc3, 0xc3, 0xde, 0x2d, 0x27, 0x23, 0x21, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x21,
++    0x26, 0x2d, 0x91, 0x5b, 0x64, 0xc4, 0xc4, 0xc4,
++    0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4,
++    0xc4, 0xc7, 0x83, 0xce, 0x36, 0x36, 0x36, 0x30,
++    0xb1, 0xd9, 0x48, 0xa1, 0xb2, 0xb0, 0xb0, 0xb3,
++    0xa2, 0x48, 0xa7, 0xbd, 0xa9, 0xa2, 0x48, 0x9f,
++    0xaa, 0x9a, 0x3f, 0xb1, 0x5b, 0x7b, 0xdf, 0x85,
++    0x7e, 0x90, 0x63, 0x90, 0x85, 0x5b, 0xc3, 0xc4,
++    0xc4, 0xcb, 0x5d, 0xd5, 0x39, 0x26, 0x23, 0x21,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x22,
++    0x26, 0x2d, 0xe0, 0xdf, 0x64, 0xc4, 0xc4, 0xc4,
++    0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4,
++    0xc4, 0xc4, 0xc7, 0x88, 0x36, 0x36, 0x36, 0x36,
++    0x2d, 0x9b, 0x48, 0xb9, 0xaf, 0xa2, 0xa2, 0xb9,
++    0xa8, 0x9f, 0x48, 0xa7, 0xb7, 0xd9, 0x48, 0x48,
++    0x9b, 0x45, 0x3f, 0xe1, 0x6d, 0x7b, 0xca, 0xdf,
++    0x7a, 0x8b, 0x8b, 0x7a, 0x5b, 0x64, 0xc4, 0xc4,
++    0xc4, 0xc4, 0xc3, 0xe2, 0x37, 0x35, 0x26, 0x23,
++    0x21, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x22,
++    0x26, 0x2e, 0xe0, 0x7a, 0x7b, 0xc4, 0xc4, 0xc4,
++    0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4,
++    0xc4, 0xc4, 0xc7, 0x72, 0x73, 0x36, 0x36, 0x36,
++    0x24, 0x52, 0x48, 0xa3, 0xaf, 0x9f, 0x48, 0xb6,
++    0xaf, 0xa2, 0x48, 0x9f, 0xe3, 0xd8, 0x48, 0x48,
++    0x48, 0x46, 0x42, 0xd6, 0x7a, 0x7b, 0x64, 0x7b,
++    0x76, 0x5b, 0x5b, 0x76, 0x7b, 0xc3, 0xc4, 0xc4,
++    0xc4, 0xc4, 0xcb, 0x64, 0xe2, 0x4d, 0x2c, 0x27,
++    0x23, 0x21, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x21,
++    0x25, 0x31, 0xe4, 0x8b, 0x7b, 0xc4, 0xc4, 0xc4,
++    0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4,
++    0xc4, 0xc4, 0xc4, 0xc7, 0x89, 0xbe, 0x36, 0x36,
++    0x32, 0x47, 0x48, 0x4f, 0xa0, 0x48, 0x48, 0xe3,
++    0x92, 0x9f, 0x48, 0x9f, 0x48, 0x48, 0x48, 0x48,
++    0x48, 0x4b, 0x2f, 0x8f, 0x7a, 0x7b, 0xc3, 0xcb,
++    0xc3, 0x64, 0x64, 0xc3, 0xc3, 0xcb, 0xc4, 0xc4,
++    0xc4, 0xc4, 0xc4, 0xc4, 0xc3, 0x5d, 0xe5, 0x2c,
++    0x26, 0x22, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x21,
++    0x25, 0x31, 0xe4, 0x85, 0x7b, 0xc4, 0xc4, 0xc4,
++    0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4,
++    0xc4, 0xc4, 0xc4, 0xc4, 0x66, 0x57, 0x27, 0x4d,
++    0x4b, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48,
++    0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48,
++    0x99, 0x34, 0xbe, 0xdb, 0x7a, 0x7b, 0xc3, 0xc4,
++    0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4,
++    0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc3, 0xe4,
++    0x32, 0x28, 0x21, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x22,
++    0x26, 0x2d, 0xe4, 0x85, 0x7b, 0xcb, 0xc4, 0xc4,
++    0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4,
++    0xc4, 0xc4, 0xc4, 0xc4, 0xc7, 0x5f, 0x92, 0x48,
++    0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48,
++    0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x44,
++    0x35, 0x36, 0xce, 0xdd, 0x7a, 0x7b, 0xcb, 0xc4,
++    0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4,
++    0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xcb, 0xc3, 0xe1,
++    0x2b, 0x24, 0x21, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x23,
++    0x30, 0x2f, 0xd6, 0x8b, 0x7b, 0xcb, 0xc4, 0xc4,
++    0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4,
++    0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0x66, 0x89, 0x45,
++    0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48,
++    0x48, 0x48, 0x48, 0x48, 0x48, 0x9b, 0x4e, 0x25,
++    0x36, 0x36, 0x61, 0xdb, 0x6d, 0x64, 0xcb, 0xc4,
++    0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4,
++    0xc4, 0xc4, 0xc4, 0xc4, 0xcb, 0x7b, 0xdf, 0xe5,
++    0x32, 0x28, 0x21, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x21, 0x28,
++    0x33, 0xe6, 0x63, 0xdf, 0xc3, 0xc4, 0xc4, 0xc4,
++    0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4,
++    0xc4, 0xc4, 0xc4, 0xc4, 0xc3, 0x72, 0x81, 0xe7,
++    0x46, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48,
++    0x48, 0x48, 0x48, 0x48, 0x3f, 0x2c, 0x36, 0x36,
++    0x36, 0x36, 0xe8, 0x8f, 0x6d, 0x64, 0xcb, 0xc4,
++    0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4,
++    0xc4, 0xc4, 0xc4, 0xc3, 0xca, 0x8b, 0xcf, 0x2c,
++    0x26, 0x22, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x21, 0x24,
++    0x35, 0x96, 0x75, 0xca, 0xc3, 0xcb, 0xc4, 0xc4,
++    0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4,
++    0xc4, 0xc4, 0xc4, 0xc4, 0xcb, 0x7b, 0x81, 0xdb,
++    0x73, 0x3b, 0x44, 0x9b, 0x48, 0x48, 0x48, 0x9b,
++    0x99, 0x43, 0x94, 0x2c, 0x21, 0x36, 0x36, 0x36,
++    0x36, 0x36, 0x73, 0xdb, 0x7a, 0x7b, 0xc4, 0xc4,
++    0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4,
++    0xc4, 0x64, 0x76, 0x7a, 0x91, 0xd5, 0x31, 0x30,
++    0x28, 0x21, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x21, 0x24,
++    0x39, 0x97, 0x75, 0xdf, 0x7b, 0x64, 0xc3, 0xc3,
++    0xcb, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4,
++    0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0x7b, 0x7a, 0xe9,
++    0xea, 0x36, 0x21, 0x26, 0x2b, 0x39, 0x33, 0x30,
++    0x23, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
++    0x36, 0x21, 0xea, 0xdd, 0x8b, 0x7b, 0xc4, 0xc4,
++    0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc3, 0x64, 0x64,
++    0x76, 0x85, 0xe0, 0xd5, 0x34, 0x2b, 0x27, 0x28,
++    0x21, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x21, 0x28,
++    0x33, 0xeb, 0x63, 0x7e, 0x7a, 0x6d, 0xdf, 0x5b,
++    0x76, 0x7b, 0x64, 0x64, 0xc3, 0xcb, 0xc4, 0xc4,
++    0xc4, 0xc4, 0xc4, 0xc4, 0xcb, 0x76, 0x85, 0xdb,
++    0x79, 0x22, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
++    0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
++    0x36, 0x21, 0xec, 0xdd, 0x75, 0x76, 0xc3, 0xc4,
++    0xc4, 0xc4, 0xcb, 0xc3, 0x64, 0x76, 0xdf, 0x8b,
++    0xd6, 0xd5, 0x2f, 0x35, 0x30, 0x24, 0x22, 0x21,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x23,
++    0x27, 0x31, 0xed, 0xeb, 0xdd, 0x74, 0x63, 0x90,
++    0x7e, 0x75, 0x8b, 0x6d, 0xdf, 0x76, 0x64, 0xc3,
++    0xcb, 0xcb, 0xcb, 0xcb, 0x64, 0x7a, 0x84, 0xee,
++    0x79, 0xbe, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
++    0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
++    0x36, 0x21, 0xea, 0xee, 0x63, 0x6d, 0x7b, 0x64,
++    0xcb, 0xc3, 0x64, 0x7b, 0xdf, 0x75, 0x63, 0x96,
++    0x38, 0x39, 0x2a, 0x24, 0x23, 0x21, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x21,
++    0x28, 0x27, 0x35, 0x2d, 0x41, 0xd5, 0xe7, 0x8f,
++    0xdb, 0xdd, 0xe9, 0x74, 0x84, 0x90, 0x85, 0x6d,
++    0x5b, 0x7b, 0x7b, 0xca, 0x6d, 0x90, 0xdb, 0xef,
++    0xec, 0x22, 0x36, 0x36, 0x28, 0x30, 0x30, 0x30,
++    0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x25, 0x36,
++    0x36, 0x21, 0xd4, 0x80, 0xe9, 0x7e, 0x6d, 0x76,
++    0xca, 0x76, 0x6d, 0x85, 0x63, 0xdb, 0xd5, 0x34,
++    0x33, 0x26, 0x23, 0x21, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x21, 0x23, 0x24, 0x27, 0x2a, 0x35, 0x2e, 0x2f,
++    0x41, 0xf0, 0xf1, 0x6c, 0x80, 0xee, 0xdb, 0x74,
++    0x84, 0x90, 0x75, 0x7e, 0x74, 0x8f, 0xef, 0x79,
++    0xe8, 0x2b, 0x9d, 0x41, 0x2f, 0x34, 0x2d, 0x2d,
++    0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x34, 0x2f, 0x38,
++    0x4d, 0x37, 0xf2, 0xf3, 0x8f, 0x74, 0x63, 0x7e,
++    0x75, 0x7e, 0x63, 0xe9, 0x88, 0xe6, 0x31, 0x2a,
++    0x24, 0x22, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x21, 0x22, 0x23, 0x24, 0x26, 0x30,
++    0x33, 0x39, 0x2e, 0x51, 0x41, 0xd2, 0x6c, 0xf3,
++    0x80, 0xee, 0xee, 0xee, 0xf4, 0xf3, 0xd7, 0xf5,
++    0x41, 0x34, 0x35, 0x32, 0x30, 0x27, 0x27, 0x27,
++    0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x30, 0x2a,
++    0x2b, 0x34, 0xf6, 0xec, 0xf7, 0x8f, 0xdd, 0xe9,
++    0xe9, 0xdd, 0xee, 0x6c, 0x41, 0x39, 0x27, 0x28,
++    0x21, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x21, 0x21, 0x22,
++    0x28, 0x24, 0x26, 0x2a, 0x33, 0x2c, 0x2f, 0x41,
++    0xf8, 0xd7, 0x79, 0x79, 0x79, 0xec, 0xf9, 0x51,
++    0x39, 0x30, 0x24, 0x23, 0x22, 0x22, 0x22, 0x22,
++    0x22, 0x22, 0x21, 0x22, 0x22, 0x22, 0x22, 0x23,
++    0x24, 0x2a, 0x31, 0xfa, 0xea, 0x79, 0xf3, 0x80,
++    0xf7, 0xdc, 0xfb, 0x2f, 0x35, 0x26, 0x23, 0x21,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x21, 0x22, 0x23, 0x28, 0x25, 0x30, 0x2b,
++    0x31, 0x2f, 0xf6, 0xfa, 0xfa, 0x2f, 0x2e, 0x33,
++    0x26, 0x23, 0x21, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x21, 0x28, 0x27, 0x35, 0x34, 0xfa, 0xfa, 0xfa,
++    0xfc, 0xf6, 0x2e, 0x33, 0x25, 0x23, 0x21, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x21, 0x21, 0x23, 0x28,
++    0x26, 0x30, 0x32, 0x2b, 0x33, 0x2a, 0x26, 0x28,
++    0x22, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x21, 0x23, 0x25, 0x30, 0x33, 0x35, 0x35,
++    0x2b, 0x2a, 0x26, 0x28, 0x22, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x21,
++    0x21, 0x22, 0x23, 0x28, 0x28, 0x23, 0x22, 0x21,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x21, 0x23, 0x28, 0x24, 0x24,
++    0x28, 0x23, 0x22, 0x21, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
++};
++
++unsigned char linux_logo16[1];
++
++#endif /* INCLUDE_LINUX_LOGO_DATA */
++
++#include <linux/linux_logo.h>
++
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/local.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/local.h	2004-02-12 18:06:40.000000000 +0100
+@@ -0,0 +1,28 @@
++/*
++ * Copyright (C) 2004, Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#ifndef __NIOS2NOMMU_LOCAL_H
++#define __NIOS2NOMMU_LOCAL_H
++
++#include <asm-generic/local.h>
++
++#endif /* __NIOS2NOMMU_LOCAL_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/mc146818rtc.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/mc146818rtc.h	2004-02-12 18:06:40.000000000 +0100
+@@ -0,0 +1,29 @@
++/*
++ * Machine dependent access functions for RTC registers.
++ *
++ * Copyright (C) 2004, Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++#ifndef _NIOS2_MC146818RTC_H
++#define _NIOS2_MC146818RTC_H
++
++/* empty include file to satisfy the include in genrtc.c/ide-geometry.c */
++
++#endif /* _NIOS2_MC146818RTC_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/mman.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/mman.h	2004-02-12 18:06:40.000000000 +0100
+@@ -0,0 +1,68 @@
++/*
++ * Copied from the m68k port.
++ *
++ * Copyright (C) 2004, Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#ifndef __NIOS2_MMAN_H__
++#define __NIOS2_MMAN_H__
++
++#define PROT_READ	0x1		/* page can be read */
++#define PROT_WRITE	0x2		/* page can be written */
++#define PROT_EXEC	0x4		/* page can be executed */
++#define PROT_SEM	0x8		/* page may be used for atomic ops */
++#define PROT_NONE	0x0		/* page can not be accessed */
++#define PROT_GROWSDOWN	0x01000000	/* mprotect flag: extend change to start of growsdown vma */
++#define PROT_GROWSUP	0x02000000	/* mprotect flag: extend change to end of growsup vma */
++
++#define MAP_SHARED	0x01		/* Share changes */
++#define MAP_PRIVATE	0x02		/* Changes are private */
++#define MAP_TYPE	0x0f		/* Mask for type of mapping */
++#define MAP_FIXED	0x10		/* Interpret addr exactly */
++#define MAP_ANONYMOUS	0x20		/* don't use a file */
++
++#define MAP_GROWSDOWN	0x0100		/* stack-like segment */
++#define MAP_DENYWRITE	0x0800		/* ETXTBSY */
++#define MAP_EXECUTABLE	0x1000		/* mark it as an executable */
++#define MAP_LOCKED	0x2000		/* pages are locked */
++#define MAP_NORESERVE	0x4000		/* don't check for reservations */
++#define MAP_POPULATE	0x8000		/* populate (prefault) pagetables */
++#define MAP_NONBLOCK	0x10000		/* do not block on IO */
++
++#define MS_ASYNC	1		/* sync memory asynchronously */
++#define MS_INVALIDATE	2		/* invalidate the caches */
++#define MS_SYNC		4		/* synchronous memory sync */
++
++#define MCL_CURRENT	1		/* lock all current mappings */
++#define MCL_FUTURE	2		/* lock all future mappings */
++
++#define MADV_NORMAL	0x0		/* default page-in behavior */
++#define MADV_RANDOM	0x1		/* page-in minimum required */
++#define MADV_SEQUENTIAL	0x2		/* read-ahead aggressively */
++#define MADV_WILLNEED	0x3		/* pre-fault pages */
++#define MADV_DONTNEED	0x4		/* discard these pages */
++
++/* compatibility flags */
++#define MAP_ANON	MAP_ANONYMOUS
++#define MAP_FILE	0
++
++#endif /* __NIOS2_MMAN_H__ */
++
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/mmu.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/mmu.h	2004-02-12 18:06:40.000000000 +0100
+@@ -0,0 +1,47 @@
++/*
++ *
++ * Taken from the m68knommu.
++ * 
++ * Copyright (C) 2004, Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#ifndef __NIOS2NOMMU_MMU_H
++#define __NIOS2NOMMU_MMU_H
++
++/* Copyright (C) 2002, David McCullough <davidm@snapgear.com> */
++
++struct mm_rblock_struct {
++	int	size;
++	int	refcount;
++	void	*kblock;
++};
++
++struct mm_tblock_struct {
++	struct mm_rblock_struct	*rblock;
++	struct mm_tblock_struct	*next;
++};
++
++typedef struct {
++	struct mm_tblock_struct	tblock;
++	unsigned long		end_brk;
++} mm_context_t;
++
++#endif /* __NIOS2NOMMU_MMU_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/mmu_context.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/mmu_context.h	2005-05-18 20:36:04.000000000 +0200
+@@ -0,0 +1,58 @@
++/*
++ *
++ * Taken from the m68knommu.
++ *
++ * Copyright (C) 2004, Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#ifndef __NIOS2NOMMU_MMU_CONTEXT_H
++#define __NIOS2NOMMU_MMU_CONTEXT_H
++
++// #include <linux/config.h>
++#include <asm/setup.h>
++#include <asm/page.h>
++#include <asm/pgalloc.h>
++
++static inline void enter_lazy_tlb(struct mm_struct *mm, struct task_struct *tsk)
++{
++}
++
++extern inline int
++init_new_context(struct task_struct *tsk, struct mm_struct *mm)
++{
++	// mm->context = virt_to_phys(mm->pgd);
++	return(0);
++}
++
++#define destroy_context(mm)		do { } while(0)
++
++static inline void switch_mm(struct mm_struct *prev, struct mm_struct *next, struct task_struct *tsk)
++{
++}
++
++#define deactivate_mm(tsk,mm)	do { } while (0)
++
++extern inline void activate_mm(struct mm_struct *prev_mm,
++			       struct mm_struct *next_mm)
++{
++}
++
++#endif
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/module.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/module.h	2004-03-19 13:57:58.000000000 +0100
+@@ -0,0 +1,36 @@
++#ifndef _NIOS2_MODULE_H
++#define _NIOS2_MODULE_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/module.h
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++struct mod_arch_specific
++{
++};
++
++#define Elf_Shdr Elf32_Shdr
++#define Elf_Sym Elf32_Sym
++#define Elf_Ehdr Elf32_Ehdr
++
++#endif /* _NIOS_MODULE_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/msgbuf.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/msgbuf.h	2004-02-12 18:06:40.000000000 +0100
+@@ -0,0 +1,56 @@
++/*
++ * Taken from the m68k.
++ *
++ * Copyright (C) 2004, Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#ifndef _NIOS2_MSGBUF_H
++#define _NIOS2_MSGBUF_H
++
++/* 
++ * The msqid64_ds structure for nios2 architecture.
++ * Note extra padding because this structure is passed back and forth
++ * between kernel and user space.
++ *
++ * Pad space is left for:
++ * - 64-bit time_t to solve y2038 problem
++ * - 2 miscellaneous 32-bit values
++ */
++
++struct msqid64_ds {
++	struct ipc64_perm msg_perm;
++	__kernel_time_t msg_stime;	/* last msgsnd time */
++	unsigned long	__unused1;
++	__kernel_time_t msg_rtime;	/* last msgrcv time */
++	unsigned long	__unused2;
++	__kernel_time_t msg_ctime;	/* last change time */
++	unsigned long	__unused3;
++	unsigned long  msg_cbytes;	/* current number of bytes on queue */
++	unsigned long  msg_qnum;	/* number of messages in queue */
++	unsigned long  msg_qbytes;	/* max number of bytes on queue */
++	__kernel_pid_t msg_lspid;	/* pid of last msgsnd */
++	__kernel_pid_t msg_lrpid;	/* last receive pid */
++	unsigned long  __unused4;
++	unsigned long  __unused5;
++};
++
++#endif /* _NIOS2_MSGBUF_H */
++
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/namei.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/namei.h	2004-02-12 18:06:40.000000000 +0100
+@@ -0,0 +1,36 @@
++/*
++ * linux/include/asm-nios/namei.h
++ * Moved from m68k version
++ * Included from linux/fs/namei.c
++ *
++ * Copyright (C) 2004, Microtronix Datacom Ltd.
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#ifndef __NIOS2_NAMEI_H
++#define __NIOS2_NAMEI_H
++
++/* This dummy routine maybe changed to something useful
++ * for /usr/gnemul/ emulation stuff.
++ * Look at asm-sparc/namei.h for details.
++ */
++
++#define __emul_prefix() NULL
++
++#endif
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/ndma.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/ndma.h	2004-05-07 15:45:52.000000000 +0200
+@@ -0,0 +1,64 @@
++#ifndef __NDMA_H__
++  #define __NDMA_H__
++
++    #ifndef __ASSEMBLY__
++
++// DMA Registers
++typedef volatile struct
++{
++  int np_dmastatus;        // status register
++  int np_dmareadaddress;   // read address
++  int np_dmawriteaddress;  // write address
++  int np_dmalength;        // length in bytes
++  int np_dmareserved1;     // reserved
++  int np_dmareserved2;     // reserved
++  int np_dmacontrol;       // control register
++  int np_dmareserved3;     // control register alternate
++} np_dma;
++
++// DMA Register Bits
++enum
++{
++  np_dmacontrol_byte_bit  = 0, // Byte transaction
++  np_dmacontrol_hw_bit    = 1, // Half-word transaction
++  np_dmacontrol_word_bit  = 2, // Word transaction
++  np_dmacontrol_go_bit    = 3, // enable execution
++  np_dmacontrol_i_en_bit  = 4, // enable interrupt
++  np_dmacontrol_reen_bit  = 5, // Enable read end-of-packet
++  np_dmacontrol_ween_bit  = 6, // Enable write end-of-packet
++  np_dmacontrol_leen_bit  = 7, // Enable length=0 transaction end
++  np_dmacontrol_rcon_bit  = 8, // Read from a fixed address
++  np_dmacontrol_wcon_bit  = 9, // Write to a fixed address
++  np_dmacontrol_doubleword_bit = 10, // Double-word transaction
++  np_dmacontrol_quadword_bit = 11, // Quad-word transaction
++ 
++  np_dmastatus_done_bit   = 0, // 1 when done.  Status write clears.
++  np_dmastatus_busy_bit   = 1, // 1 when busy.
++  np_dmastatus_reop_bit   = 2, // read-eop received
++  np_dmastatus_weop_bit   = 3, // write-eop received
++  np_dmastatus_len_bit    = 4, // requested length transacted
++ 
++  np_dmacontrol_byte_mask = (1 << 0), // Byte transaction
++  np_dmacontrol_hw_mask   = (1 << 1), // Half-word transaction
++  np_dmacontrol_word_mask = (1 << 2), // Word transaction
++  np_dmacontrol_go_mask   = (1 << 3), // enable execution
++  np_dmacontrol_i_en_mask = (1 << 4), // enable interrupt
++  np_dmacontrol_reen_mask = (1 << 5), // Enable read end-of-packet
++  np_dmacontrol_ween_mask = (1 << 6), // Enable write end-of-packet
++  np_dmacontrol_leen_mask = (1 << 7), // Enable length=0 transaction end
++  np_dmacontrol_rcon_mask = (1 << 8), // Read from a fixed address
++  np_dmacontrol_wcon_mask = (1 << 9), // Write to a fixed address
++  np_dmacontrol_doubleword_mask = (1 << 10), // Double-word transaction
++  np_dmacontrol_quadword_mask = (1 << 11), // Quad-word transaction
++ 
++  np_dmastatus_done_mask  = (1 << 0), // 1 when done.  Status write clears.
++  np_dmastatus_busy_mask  = (1 << 1), // 1 when busy.
++  np_dmastatus_reop_mask  = (1 << 2), // read-eop received
++  np_dmastatus_weop_mask  = (1 << 3), // write-eop received
++  np_dmastatus_len_mask   = (1 << 4), // requested length transacted
++};
++
++    #endif /* __ASSEMBLY__ */
++
++#endif
++/* End of File */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/nios.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/nios.h	2004-04-01 15:12:56.000000000 +0200
+@@ -0,0 +1,7 @@
++#ifndef __NIOS_H__
++#define __NIOS_H__
++
++#include "nios2_system.h"
++
++#endif
++
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/page.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/page.h	2005-05-18 20:36:38.000000000 +0200
+@@ -0,0 +1,135 @@
++/*
++ * Copyright (C) 2004, Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#ifndef _NIOS2_PAGE_H
++#define _NIOS2_PAGE_H
++
++/* copied from m68knommu arch */
++// #include <linux/config.h>
++
++/* PAGE_SHIFT determines the page size */
++
++#define PAGE_SHIFT	(12)
++#define PAGE_SIZE	(1UL << PAGE_SHIFT)
++#define PAGE_MASK	(~(PAGE_SIZE-1))
++
++#ifdef __KERNEL__
++
++#include <asm/setup.h>
++
++#if PAGE_SHIFT < 13
++#define THREAD_SIZE (8192)
++#else
++#define THREAD_SIZE PAGE_SIZE
++#endif
++ 
++#ifndef __ASSEMBLY__
++ 
++#define get_user_page(vaddr)		__get_free_page(GFP_KERNEL)
++#define free_user_page(page, addr)	free_page(addr)
++
++#define clear_page(page)	memset((page), 0, PAGE_SIZE)
++#define copy_page(to,from)	memcpy((to), (from), PAGE_SIZE)
++
++#define clear_user_page(page, vaddr, pg)	clear_page(page)
++#define copy_user_page(to, from, vaddr, pg)	copy_page(to, from)
++
++/*
++ * These are used to make use of C type-checking..
++ */
++typedef struct { unsigned long pte; } pte_t;
++typedef struct { unsigned long pmd[16]; } pmd_t;
++typedef struct { unsigned long pgd; } pgd_t;
++typedef struct { unsigned long pgprot; } pgprot_t;
++
++#define pte_val(x)	((x).pte)
++#define pmd_val(x)	((&x)->pmd[0])
++#define pgd_val(x)	((x).pgd)
++#define pgprot_val(x)	((x).pgprot)
++
++#define __pte(x)	((pte_t) { (x) } )
++#define __pmd(x)	((pmd_t) { (x) } )
++#define __pgd(x)	((pgd_t) { (x) } )
++#define __pgprot(x)	((pgprot_t) { (x) } )
++
++/* to align the pointer to the (next) page boundary */
++#define PAGE_ALIGN(addr)	(((addr)+PAGE_SIZE-1)&PAGE_MASK)
++
++/* Pure 2^n version of get_order */
++extern __inline__ int get_order(unsigned long size)
++{
++	int order;
++
++	size = (size-1) >> (PAGE_SHIFT-1);
++	order = -1;
++	do {
++		size >>= 1;
++		order++;
++	} while (size);
++	return order;
++}
++
++extern unsigned long memory_start;
++extern unsigned long memory_end;
++
++#endif /* !__ASSEMBLY__ */
++#include <asm/nios.h>
++#define PAGE_OFFSET		((int)(nasys_program_mem))
++
++#ifndef __ASSEMBLY__
++
++#define __pa(vaddr)		virt_to_phys((void *)vaddr)
++#define __va(paddr)		phys_to_virt((unsigned long)paddr)
++
++#define MAP_NR(addr)		(((unsigned long)(addr)-PAGE_OFFSET) >> PAGE_SHIFT)
++
++#define virt_to_pfn(kaddr)	(__pa(kaddr) >> PAGE_SHIFT)
++#define pfn_to_virt(pfn)	__va((pfn) << PAGE_SHIFT)
++
++#define virt_to_page(addr)	(mem_map + (((unsigned long)(addr)-PAGE_OFFSET) >> PAGE_SHIFT))
++#define page_to_virt(page)	((((page) - mem_map) << PAGE_SHIFT) + PAGE_OFFSET)
++#define VALID_PAGE(page)	((page - mem_map) < max_mapnr)
++
++#define pfn_to_page(pfn)	virt_to_page(pfn_to_virt(pfn))
++#define page_to_pfn(page)	virt_to_pfn(page_to_virt(page))
++
++#define	virt_addr_valid(kaddr)	(((void *)(kaddr) >= (void *)PAGE_OFFSET) && \
++				((void *)(kaddr) < (void *)memory_end))
++
++#ifdef CONFIG_NO_KERNEL_MSG
++#define	BUG_PRINT()
++#else
++#define	BUG_PRINT() printk("kernel BUG at %s:%d!\n", __FILE__, __LINE__)
++#endif
++
++#ifdef na_cpu_oci_core
++#define BUG_PANIC()	asm volatile ("break") /* drop to debugger */
++#else
++// #define BUG_PANIC()	while(1)
++#define BUG_PANIC()	panic("BUG!")
++#endif
++
++#endif /* __ASSEMBLY__ */
++
++#endif /* __KERNEL__ */
++
++#endif /* _NIOS2_PAGE_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/param.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/param.h	2004-02-26 15:43:36.000000000 +0100
+@@ -0,0 +1,49 @@
++#ifndef _NIOS_PARAM_H
++#define _NIOS_PARAM_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/param.h
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++#ifndef HZ
++#define HZ 100
++#endif
++
++#ifdef __KERNEL__
++#define	USER_HZ		HZ
++#define	CLOCKS_PER_SEC	(USER_HZ)
++#endif
++
++#define EXEC_PAGESIZE	4096
++
++#ifndef NGROUPS
++#define NGROUPS		32
++#endif
++
++#ifndef NOGROUP
++#define NOGROUP		(-1)
++#endif
++
++#define MAXHOSTNAMELEN	64	/* max length of hostname */
++
++#endif
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/pci.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/pci.h	2004-02-26 15:43:36.000000000 +0100
+@@ -0,0 +1,75 @@
++#ifndef _ASM_NIOS2NOMMU_PCI_H
++#define _ASM_NIOS2NOMMU_PCI_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/pci.h
++ *
++ * Derived from asm-m68k/pci_m68k.h
++ *              - m68k specific PCI declarations, by Wout Klaren.
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++#include <asm/scatterlist.h>
++
++struct pci_ops;
++
++/*
++ * Structure with hardware dependent information and functions of the
++ * PCI bus.
++ */
++
++struct pci_bus_info
++{
++	/*
++	 * Resources of the PCI bus.
++	 */
++
++	struct resource mem_space;
++	struct resource io_space;
++
++	/*
++	 * System dependent functions.
++	 */
++
++	struct pci_ops *m68k_pci_ops;
++
++	void (*fixup)(int pci_modify);
++	void (*conf_device)(struct pci_dev *dev);
++};
++
++#define pcibios_assign_all_busses()	0
++
++extern inline void pcibios_set_master(struct pci_dev *dev)
++{
++	/* No special bus mastering setup handling */
++}
++
++extern inline void pcibios_penalize_isa_irq(int irq)
++{
++	/* We don't do dynamic PCI IRQ allocation */
++}
++
++/* The PCI address space does equal the physical memory
++ * address space.  The networking and block device layers use
++ * this boolean for bounce buffer decisions.
++ */
++#define PCI_DMA_BUS_IS_PHYS	(1)
++
++#endif /* _ASM_NIOS2NOMMU_PCI_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/percpu.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/percpu.h	2004-02-26 15:43:36.000000000 +0100
+@@ -0,0 +1,30 @@
++#ifndef __ARCH_NIOS2NOMMU_PERCPU__
++#define __ARCH_NIOS2NOMMU_PERCPU__
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/percpu.h
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++#include <asm-generic/percpu.h>
++
++#endif /* __ARCH_NIOS2NOMMU_PERCPU__ */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/pgalloc.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/pgalloc.h	2004-02-26 15:43:36.000000000 +0100
+@@ -0,0 +1,32 @@
++#ifndef _NIOS2NOMMU_PGALLOC_H
++#define _NIOS2NOMMU_PGALLOC_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/pgalloc.h
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++#include <asm/setup.h>
++
++#define check_pgt_cache()	do { } while (0)
++
++#endif /* _NIOS2NOMMU_PGALLOC_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/pgtable.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/pgtable.h	2005-05-18 20:36:09.000000000 +0200
+@@ -0,0 +1,100 @@
++#ifndef _NIOS_PGTABLE_H
++#define _NIOS_PGTABLE_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/pgtable.h
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++//vic - this bit copied from m68knommu version
++// #include <linux/config.h>
++#include <asm/setup.h>
++#include <asm/io.h>
++
++typedef pte_t *pte_addr_t;
++
++#define pgd_present(pgd)     	(1)       /* pages are always present on NO_MM */
++#define pgd_none(pgd)		(0)
++#define pgd_bad(pgd)		(0)
++#define pgd_clear(pgdp)
++#define kern_addr_valid(addr) 	(1)
++#define	pmd_offset(a, b)	((void *)0)
++
++#define PAGE_NONE		__pgprot(0)    /* these mean nothing to NO_MM */
++#define PAGE_SHARED		__pgprot(0)    /* these mean nothing to NO_MM */
++#define PAGE_COPY		__pgprot(0)    /* these mean nothing to NO_MM */
++#define PAGE_READONLY		__pgprot(0)    /* these mean nothing to NO_MM */
++#define PAGE_KERNEL		__pgprot(0)    /* these mean nothing to NO_MM */
++//vic - this bit copied from m68knommu version
++
++extern void paging_init(void);
++#define swapper_pg_dir ((pgd_t *) 0)
++
++#define __swp_type(x)		(0)
++#define __swp_offset(x)		(0)
++#define __swp_entry(typ,off)	((swp_entry_t) { ((typ) | ((off) << 7)) })
++#define __pte_to_swp_entry(pte)	((swp_entry_t) { pte_val(pte) })
++#define __swp_entry_to_pte(x)	((pte_t) { (x).val })
++
++static inline int pte_file(pte_t pte) { return 0; }
++
++/*
++ * ZERO_PAGE is a global shared page that is always zero: used
++ * for zero-mapped memory areas etc..
++ */
++#define ZERO_PAGE(vaddr)	(virt_to_page(0))
++
++extern unsigned int kobjsize(const void *objp);
++
++/*
++ * No page table caches to initialise
++ */
++#define pgtable_cache_init()   do { } while (0)
++
++extern inline void flush_cache_mm(struct mm_struct *mm)
++{
++}
++
++extern inline void flush_cache_range(struct mm_struct *mm,
++				     unsigned long start,
++				     unsigned long end)
++{
++}
++
++/* Push the page at kernel virtual address and clear the icache */
++extern inline void flush_page_to_ram (unsigned long address)
++{
++}
++
++/* Push n pages at kernel virtual address and clear the icache */
++extern inline void flush_pages_to_ram (unsigned long address, int n)
++{
++}
++
++/*
++ * All 32bit addresses are effectively valid for vmalloc...
++ * Sort of meaningless for non-VM targets.
++ */
++#define	VMALLOC_START	0
++#define	VMALLOC_END	0xffffffff
++
++#endif /* _NIOS_PGTABLE_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/pio_struct.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/pio_struct.h	2004-12-22 15:23:36.000000000 +0100
+@@ -0,0 +1,14 @@
++// PIO Peripheral
++
++// PIO Registers
++typedef volatile struct
++	{
++	int np_piodata;          // read/write, up to 32 bits
++	int np_piodirection;     // write/readable, up to 32 bits, 1->output bit
++	int np_piointerruptmask; // write/readable, up to 32 bits, 1->enable interrupt
++	int np_pioedgecapture;   // read, up to 32 bits, cleared by any write
++	} np_pio;
++
++// PIO Routines
++void nr_pio_showhex(int value); // shows low byte on pio named na_seven_seg_pio
++
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/poll.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/poll.h	2004-03-04 15:03:18.000000000 +0100
+@@ -0,0 +1,46 @@
++#ifndef __NIOS2_POLL_H
++#define __NIOS2_POLL_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/poll.h
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++#define POLLIN		  1
++#define POLLPRI		  2
++#define POLLOUT		  4
++#define POLLERR		  8
++#define POLLHUP		 16
++#define POLLNVAL	 32
++#define POLLRDNORM	 64
++#define POLLWRNORM	POLLOUT
++#define POLLRDBAND	128
++#define POLLWRBAND	256
++#define POLLMSG		0x0400
++
++struct pollfd {
++	int fd;
++	short events;
++	short revents;
++};
++
++#endif
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/posix_types.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/posix_types.h	2004-03-04 11:54:08.000000000 +0100
+@@ -0,0 +1,89 @@
++#ifndef __ARCH_NIOS2_POSIX_TYPES_H
++#define __ARCH_NIOS2_POSIX_TYPES_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/posix_types.h
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++/*
++ * This file is generally used by user-level software, so you need to
++ * be a little careful about namespace pollution etc.  Also, we cannot
++ * assume GCC is being used.
++ */
++
++typedef unsigned long	__kernel_ino_t;
++typedef unsigned short	__kernel_mode_t;
++typedef unsigned short	__kernel_nlink_t;
++typedef long		__kernel_off_t;
++typedef int		__kernel_pid_t;
++typedef unsigned short	__kernel_ipc_pid_t;
++typedef unsigned short	__kernel_uid_t;
++typedef unsigned short	__kernel_gid_t;
++typedef unsigned int	__kernel_size_t;
++typedef int		__kernel_ssize_t;
++typedef int		__kernel_ptrdiff_t;
++typedef long		__kernel_time_t;
++typedef long		__kernel_suseconds_t;
++typedef long		__kernel_clock_t;
++typedef int		__kernel_timer_t;
++typedef int		__kernel_clockid_t;
++typedef int		__kernel_daddr_t;
++typedef char *		__kernel_caddr_t;
++typedef unsigned short	__kernel_uid16_t;
++typedef unsigned short	__kernel_gid16_t;
++typedef unsigned int	__kernel_uid32_t;
++typedef unsigned int	__kernel_gid32_t;
++
++typedef unsigned short	__kernel_old_uid_t;
++typedef unsigned short	__kernel_old_gid_t;
++typedef unsigned short	__kernel_old_dev_t;
++
++#ifdef __GNUC__
++typedef long long	__kernel_loff_t;
++#endif
++
++typedef struct {
++#if defined(__KERNEL__) || defined(__USE_ALL)
++	int	val[2];
++#else /* !defined(__KERNEL__) && !defined(__USE_ALL) */
++	int	__val[2];
++#endif /* !defined(__KERNEL__) && !defined(__USE_ALL) */
++} __kernel_fsid_t;
++
++#if defined(__KERNEL__) || !defined(__GLIBC__) || (__GLIBC__ < 2)
++
++#undef	__FD_SET
++#define	__FD_SET(d, set)	((set)->fds_bits[__FDELT(d)] |= __FDMASK(d))
++
++#undef	__FD_CLR
++#define	__FD_CLR(d, set)	((set)->fds_bits[__FDELT(d)] &= ~__FDMASK(d))
++
++#undef	__FD_ISSET
++#define	__FD_ISSET(d, set)	((set)->fds_bits[__FDELT(d)] & __FDMASK(d))
++
++#undef	__FD_ZERO
++#define __FD_ZERO(fdsetp) (memset (fdsetp, 0, sizeof(*(fd_set *)fdsetp)))
++
++#endif /* defined(__KERNEL__) || !defined(__GLIBC__) || (__GLIBC__ < 2) */
++
++#endif
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/preem_latency.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/preem_latency.h	2004-02-26 15:43:36.000000000 +0100
+@@ -0,0 +1,39 @@
++#ifndef _ASM_PREEM_LATENCY_H
++#define _ASM_PREEM_LATENCY_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/preem_latency.h
++ *
++ * timing support for preempt-stats patch
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++#include <asm/nios.h>
++
++#define readclock(low) \
++do {\
++	*(volatile unsigned long *)na_Counter_64_bit=1;	\
++	low=*(volatile unsigned long *)na_Counter_64_bit; \
++} while (0)
++#define readclock_init()
++
++#endif /* _ASM_PREEM_LATENCY_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/processor.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/processor.h	2004-06-04 15:44:18.000000000 +0200
+@@ -0,0 +1,148 @@
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/processor.h
++ *
++ * Copyright (C) 1994 David S. Miller (davem@caip.rutgers.edu)
++ * Copyright (C) 2001  Ken Hill (khill@microtronix.com)    
++ *                     Vic Phillips (vic@microtronix.com)
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * hacked from:
++ *      include/asm-sparc/processor.h
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ * Nov/02/2003      dgt     Fix task_size
++ *
++ ---------------------------------------------------------------------*/
++
++#ifndef __ASM_NIOS_PROCESSOR_H
++#define __ASM_NIOS_PROCESSOR_H
++
++#define NIOS2_FLAG_KTHREAD	0x00000001	/* task is a kernel thread */
++#define NIOS2_FLAG_COPROC	0x00000002	/* Thread used coprocess */
++#define NIOS2_FLAG_DEBUG	0x00000004	/* task is being debugged */
++
++#define NIOS2_OP_NOP 0x1883a
++#define NIOS2_OP_BREAK	0x3da03a
++
++#ifndef __ASSEMBLY__
++
++/*
++ * Default implementation of macro that returns current
++ * instruction pointer ("program counter").
++ */
++#define current_text_addr() ({ __label__ _l; _l: &&_l;})
++
++#include <linux/a.out.h>
++#include <linux/string.h>
++
++#include <asm/ptrace.h>
++#include <asm/signal.h>
++#include <asm/segment.h>
++#include <asm/current.h>
++#include <asm/system.h> /* for get_hi_limit */
++
++/*
++ * Bus types
++ */
++#define EISA_bus 0
++#define EISA_bus__is_a_macro /* for versions in ksyms.c */
++#define MCA_bus 0
++#define MCA_bus__is_a_macro /* for versions in ksyms.c */
++
++/*
++ * The nios has no problems with write protection
++ */
++#define wp_works_ok 1
++#define wp_works_ok__is_a_macro /* for versions in ksyms.c */
++
++/* Whee, this is STACK_TOP and the lowest kernel address too... */
++#if 0
++#define KERNBASE        0x00000000  /* First address the kernel will eventually be */
++#define TASK_SIZE	(KERNBASE)
++#define MAX_USER_ADDR	TASK_SIZE
++#define MMAP_SEARCH_START (TASK_SIZE/3)
++#endif
++
++#define TASK_SIZE	((unsigned int) nasys_program_mem_end)   //...this is better...
++
++/*
++ * This decides where the kernel will search for a free chunk of vm
++ * space during mmap's. We won't be using it
++ */
++#define TASK_UNMAPPED_BASE	0
++
++/* The Nios processor specific thread struct. */
++struct thread_struct {
++	struct pt_regs *kregs;
++
++	/* For signal handling */
++	unsigned long sig_address;
++	unsigned long sig_desc;
++
++	/* Context switch saved kernel state. */
++	unsigned long ksp;
++	unsigned long kpsr;
++	unsigned long kesr;
++
++	/* Flags are defined below */
++
++	unsigned long flags;
++	int current_ds;
++	struct exec core_exec;     /* just what it says. */
++};
++
++#define INIT_MMAP { &init_mm, (0), (0), \
++		    __pgprot(0x0) , VM_READ | VM_WRITE | VM_EXEC }
++
++#define INIT_THREAD  { \
++	.kregs		= 0,			\
++	.sig_address	= 0,			\
++	.sig_desc	= 0,			\
++	.ksp		= 0,			\
++	.kpsr		= 0,			\
++	.kesr		= PS_S,			\
++	.flags		= NIOS2_FLAG_KTHREAD,	\
++	.current_ds	= __KERNEL_DS,		\
++	.core_exec	= INIT_EXEC		\
++}
++
++/* Free all resources held by a thread. */
++extern void release_thread(struct task_struct *);
++
++extern unsigned long thread_saved_pc(struct task_struct *t);
++
++extern void start_thread(struct pt_regs * regs, unsigned long pc, unsigned long sp);
++
++/* Prepare to copy thread state - unlazy all lazy status */
++#define prepare_to_copy(tsk)	do { } while (0)
++
++extern int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);
++
++unsigned long get_wchan(struct task_struct *p);
++
++#define KSTK_EIP(tsk)  ((tsk)->thread.kregs->ea)
++#define KSTK_ESP(tsk)  ((tsk)->thread.kregs->sp)
++
++#ifdef __KERNEL__
++/* Allocation and freeing of basic task resources. */
++
++//;dgt2;#define alloc_task_struct() ((struct task_struct *) xx..see..linux..fork..xx __get_free_pages(GFP_KERNEL,1))
++//;dgt2;#define get_task_struct(tsk) xx..see..linux..sched.h...atomic_inc(&mem_map[MAP_NR(tsk)].count)
++
++#endif
++
++#define cpu_relax()    do { } while (0)
++#endif /* __ASSEMBLY__ */
++#endif /* __ASM_NIOS_PROCESSOR_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/ptrace.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/ptrace.h	2004-12-08 17:39:48.000000000 +0100
+@@ -0,0 +1,141 @@
++/*
++ * Taken from the m68k port.
++ *
++ * Copyright (C) 2004, Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++#ifndef _NIOS2NOMMU_PTRACE_H
++#define _NIOS2NOMMU_PTRACE_H
++
++#ifndef __ASSEMBLY__
++
++#define PTR_R0		0
++#define PTR_R1		1
++#define PTR_R2		2
++#define PTR_R3		3
++#define PTR_R4		4
++#define PTR_R5		5
++#define PTR_R6		6
++#define PTR_R7		7
++#define PTR_R8		8
++#define PTR_R9		9
++#define PTR_R10		10
++#define PTR_R11		11
++#define PTR_R12		12
++#define PTR_R13		13
++#define PTR_R14		14
++#define PTR_R15		15
++#define PTR_R16		16
++#define PTR_R17		17
++#define PTR_R18		18
++#define PTR_R19		19
++#define PTR_R20		20
++#define PTR_R21		21
++#define PTR_R22		22
++#define PTR_R23		23
++#define PTR_R24		24
++#define PTR_R25		25
++#define PTR_GP		26
++#define PTR_SP		27
++#define PTR_FP		28
++#define PTR_EA		29
++#define PTR_BA		30
++#define PTR_RA		31
++#define PTR_STATUS	32
++#define PTR_ESTATUS	33
++#define PTR_BSTATUS	34
++#define PTR_IENABLE	35
++#define PTR_IPENDING	36
++
++/* this struct defines the way the registers are stored on the
++   stack during a system call. 
++
++   There is a fake_regs in setup.c that has to match pt_regs.*/
++
++struct pt_regs {
++	unsigned long  r8;
++	unsigned long  r9;
++	unsigned long  r10;
++	unsigned long  r11;
++	unsigned long  r12;
++	unsigned long  r13;
++	unsigned long  r14;
++	unsigned long  r15;
++	unsigned long  r1;
++	unsigned long  r2;
++	unsigned long  r3;
++	unsigned long  r4;
++	unsigned long  r5;
++	unsigned long  r6;
++	unsigned long  r7;
++	unsigned long  orig_r2;
++	unsigned long  ra;
++	unsigned long  fp;
++	unsigned long  sp;
++	unsigned long  gp;
++	unsigned long  estatus;
++	unsigned long  status_extension;
++	unsigned long  ea;
++};
++
++
++/*
++ * This is the extended stack used by signal handlers and the context
++ * switcher: it's pushed after the normal "struct pt_regs".
++ */
++struct switch_stack {
++	unsigned long  r16;
++	unsigned long  r17;
++	unsigned long  r18;
++	unsigned long  r19;
++	unsigned long  r20;
++	unsigned long  r21;
++	unsigned long  r22;
++	unsigned long  r23;
++	unsigned long  fp;
++	unsigned long  gp;
++	unsigned long  ra;
++};
++
++/* Arbitrarily choose the same ptrace numbers as used by the Sparc code. */
++#define PTRACE_GETREGS            12
++#define PTRACE_SETREGS            13
++#ifdef CONFIG_FPU
++#define PTRACE_GETFPREGS          14
++#define PTRACE_SETFPREGS          15
++#endif
++
++#ifdef __KERNEL__
++
++#ifndef PS_S
++#define PS_S  (0x00000001)
++#endif
++#ifndef PS_T
++#define PS_T  (0x00000002)
++#endif
++
++#define user_mode(regs) (!((regs)->status_extension & PS_S))
++#define instruction_pointer(regs) ((regs)->ra)
++#define profile_pc(regs) instruction_pointer(regs)
++extern void show_regs(struct pt_regs *);
++
++#endif /* __KERNEL__ */
++#endif /* __ASSEMBLY__ */
++#endif /* _NIOS2NOMMU_PTRACE_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/resource.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/resource.h	2004-12-08 17:39:48.000000000 +0100
+@@ -0,0 +1,73 @@
++#ifndef _NIOS2NOMMU_RESOURCE_H
++#define _NIOS2NOMMU_RESOURCE_H
++
++/*--------------------------------------------------------------------
++ *
++ * Resource limits
++ *
++ * include/asm-nios2nommu/resource.h
++ *
++ * Derived from M68knommu
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++#define RLIMIT_CPU	0		/* CPU time in ms */
++#define RLIMIT_FSIZE	1		/* Maximum filesize */
++#define RLIMIT_DATA	2		/* max data size */
++#define RLIMIT_STACK	3		/* max stack size */
++#define RLIMIT_CORE	4		/* max core file size */
++#define RLIMIT_RSS	5		/* max resident set size */
++#define RLIMIT_NPROC	6		/* max number of processes */
++#define RLIMIT_NOFILE	7		/* max number of open files */
++#define RLIMIT_MEMLOCK	8		/* max locked-in-memory address space */
++#define RLIMIT_AS	9		/* address space limit */
++#define RLIMIT_LOCKS	10		/* maximum file locks held */
++#define RLIMIT_SIGPENDING 11		/* max number of pending signals */
++#define RLIMIT_MSGQUEUE 12		/* maximum bytes in POSIX mqueues */
++
++#define RLIM_NLIMITS	13
++
++/*
++ * SuS says limits have to be unsigned.
++ * Which makes a ton more sense anyway.
++ */
++#define RLIM_INFINITY	(~0UL)
++
++#ifdef __KERNEL__
++
++#define INIT_RLIMITS					\
++{							\
++	{ RLIM_INFINITY, RLIM_INFINITY },		\
++	{ RLIM_INFINITY, RLIM_INFINITY },		\
++	{ RLIM_INFINITY, RLIM_INFINITY },		\
++	{      _STK_LIM, RLIM_INFINITY },		\
++	{             0, RLIM_INFINITY },		\
++	{ RLIM_INFINITY, RLIM_INFINITY },		\
++	{             0,             0 },		\
++	{      INR_OPEN,     INR_OPEN  },		\
++	{   MLOCK_LIMIT,   MLOCK_LIMIT },		\
++	{ RLIM_INFINITY, RLIM_INFINITY },		\
++	{ RLIM_INFINITY, RLIM_INFINITY },		\
++	{ MAX_SIGPENDING, MAX_SIGPENDING },		\
++	{ MQ_BYTES_MAX, MQ_BYTES_MAX },			\
++}
++
++#endif /* __KERNEL__ */
++
++#endif /* _NIOS2NOMMU_RESOURCE_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/rmap.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/rmap.h	2004-01-16 16:00:44.000000000 +0100
+@@ -0,0 +1,2 @@
++/* Do not need anything here */
++
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/scatterlist.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/scatterlist.h	2004-12-15 12:02:14.000000000 +0100
+@@ -0,0 +1,40 @@
++#ifndef _NIOS2NOMMU_SCATTERLIST_H
++#define _NIOS2NOMMU_SCATTERLIST_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/scatterlist.h
++ *
++ * Derived from M68knommu
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++struct scatterlist {
++	struct page	*page;
++	unsigned int	offset;
++	dma_addr_t	dma_address;
++	unsigned int	length;
++};
++
++#define sg_dma_address(sg)	((sg)->dma_address)
++#define sg_dma_len(sg)		((sg)->length)
++
++#define ISA_DMA_THRESHOLD	(0xffffffff)
++
++#endif /* !(_NIOS2NOMMU_SCATTERLIST_H) */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/sections.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/sections.h	2004-02-26 15:43:36.000000000 +0100
+@@ -0,0 +1,30 @@
++#ifndef _NIOS2NOMMU_SECTIONS_H
++#define _NIOS2NOMMU_SECTIONS_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/sections.h
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++#include <asm-generic/sections.h>
++
++#endif /* _NIOS2NOMMU_SECTIONS_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/segment.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/segment.h	2004-02-26 15:43:36.000000000 +0100
+@@ -0,0 +1,75 @@
++#ifndef _NIOS2NOMMU_SEGMENT_H
++#define _NIOS2NOMMU_SEGMENT_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/segment.h
++ *
++ * Derived from M68knommu
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++/* define constants */
++/* Address spaces (FC0-FC2) */
++#define USER_DATA     (1)
++#ifndef __USER_DS
++#define __USER_DS     (USER_DATA)
++#endif
++#define USER_PROGRAM  (2)
++#define SUPER_DATA    (5)
++#ifndef __KERNEL_DS
++#define __KERNEL_DS   (SUPER_DATA)
++#endif
++#define SUPER_PROGRAM (6)
++#define CPU_SPACE     (7)
++
++#ifndef __ASSEMBLY__
++
++typedef struct {
++	unsigned long seg;
++} mm_segment_t;
++
++#define MAKE_MM_SEG(s)	((mm_segment_t) { (s) })
++#define USER_DS		MAKE_MM_SEG(__USER_DS)
++#define KERNEL_DS	MAKE_MM_SEG(__KERNEL_DS)
++
++/*
++ * Get/set the SFC/DFC registers for MOVES instructions
++ */
++
++static inline mm_segment_t get_fs(void)
++{
++    return USER_DS;
++}
++
++static inline mm_segment_t get_ds(void)
++{
++    /* return the supervisor data space code */
++    return KERNEL_DS;
++}
++
++static inline void set_fs(mm_segment_t val)
++{
++}
++
++#define segment_eq(a,b)	((a).seg == (b).seg)
++
++#endif /* __ASSEMBLY__ */
++
++#endif /* _NIOS2NOMMU_SEGMENT_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/semaphore-helper.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/semaphore-helper.h	2005-05-18 20:36:13.000000000 +0200
+@@ -0,0 +1,101 @@
++#ifndef _NIOS2NOMMU_SEMAPHORE_HELPER_H
++#define _NIOS2NOMMU_SEMAPHORE_HELPER_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/semaphore.h
++ *
++ * SMP- and interrupt-safe semaphores helper functions.
++ *
++ * Derived from M68knommu
++ *
++ * (C) Copyright 1996 Linus Torvalds
++ * m68k version by Andreas Schwab
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++// #include <linux/config.h>
++
++/*
++ * These two _must_ execute atomically wrt each other.
++ */
++static inline void wake_one_more(struct semaphore * sem)
++{
++	atomic_inc(&sem->waking);
++}
++
++static inline int waking_non_zero(struct semaphore *sem)
++{
++	int ret;
++	unsigned long flags;
++
++	spin_lock_irqsave(&semaphore_wake_lock, flags);
++	ret = 0;
++	if (atomic_read(&sem->waking) > 0) {
++		atomic_dec(&sem->waking);
++		ret = 1;
++	}
++	spin_unlock_irqrestore(&semaphore_wake_lock, flags);
++	return ret;
++}
++
++/*
++ * waking_non_zero_interruptible:
++ *	1	got the lock
++ *	0	go to sleep
++ *	-EINTR	interrupted
++ */
++static inline int waking_non_zero_interruptible(struct semaphore *sem,
++						struct task_struct *tsk)
++{
++	int ret;
++	unsigned long flags;
++
++	spin_lock_irqsave(&semaphore_wake_lock, flags);
++	ret = 0;
++	if (atomic_read(&sem->waking) > 0) {
++		atomic_dec(&sem->waking);
++		ret = 1;
++	} else if (signal_pending(tsk)) {
++		atomic_inc(&sem->count);
++		ret = -EINTR;
++	}
++	spin_unlock_irqrestore(&semaphore_wake_lock, flags);
++	return ret;
++}
++
++/*
++ * waking_non_zero_trylock:
++ *	1	failed to lock
++ *	0	got the lock
++ */
++static inline int waking_non_zero_trylock(struct semaphore *sem)
++{
++	int ret;
++	unsigned long flags;
++
++	spin_lock_irqsave(&semaphore_wake_lock, flags);
++	ret = 1;
++	if (atomic_read(&sem->waking) > 0) {
++		atomic_dec(&sem->waking);
++		ret = 0;
++	} else
++		atomic_inc(&sem->count);
++	spin_unlock_irqrestore(&semaphore_wake_lock, flags);
++	return ret;
++}
++
++#endif
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/semaphore.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/semaphore.h	2004-12-08 17:39:48.000000000 +0100
+@@ -0,0 +1,155 @@
++#ifndef _NIOS2NOMMU_SEMAPHORE_H
++#define _NIOS2NOMMU_SEMAPHORE_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/semaphore.h
++ *
++ * Interrupt-safe semaphores..
++ *
++ * Derived from M68knommu
++ *
++ * (C) Copyright 1996 Linus Torvalds
++ * m68k version by Andreas Schwab
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++#define RW_LOCK_BIAS		 0x01000000
++
++#ifndef __ASSEMBLY__
++
++#include <linux/linkage.h>
++#include <linux/wait.h>
++#include <linux/spinlock.h>
++#include <linux/rwsem.h>
++
++#include <asm/system.h>
++#include <asm/atomic.h>
++
++struct semaphore {
++	atomic_t count;
++	atomic_t waking;
++	wait_queue_head_t wait;
++};
++
++#define __SEMAPHORE_INITIALIZER(name, n)				\
++{									\
++	.count		= ATOMIC_INIT(n),				\
++	.waking		= ATOMIC_INIT(0),				\
++	.wait		= __WAIT_QUEUE_HEAD_INITIALIZER((name).wait)	\
++}
++
++#define __MUTEX_INITIALIZER(name) \
++	__SEMAPHORE_INITIALIZER(name,1)
++
++#define __DECLARE_SEMAPHORE_GENERIC(name,count) \
++	struct semaphore name = __SEMAPHORE_INITIALIZER(name,count)
++
++#define DECLARE_MUTEX(name) __DECLARE_SEMAPHORE_GENERIC(name,1)
++#define DECLARE_MUTEX_LOCKED(name) __DECLARE_SEMAPHORE_GENERIC(name,0)
++
++extern inline void sema_init (struct semaphore *sem, int val)
++{
++	*sem = (struct semaphore)__SEMAPHORE_INITIALIZER(*sem, val);
++}
++
++static inline void init_MUTEX (struct semaphore *sem)
++{
++	sema_init(sem, 1);
++}
++
++static inline void init_MUTEX_LOCKED (struct semaphore *sem)
++{
++	sema_init(sem, 0);
++}
++
++asmlinkage void __down(struct semaphore * sem);
++asmlinkage int  __down_interruptible(struct semaphore * sem);
++asmlinkage int  __down_trylock(struct semaphore * sem);
++asmlinkage void __up(struct semaphore * sem);
++
++asmlinkage void __down_failed(void /* special register calling convention */);
++asmlinkage int  __down_failed_interruptible(void  /* params in registers */);
++asmlinkage int  __down_failed_trylock(void  /* params in registers */);
++asmlinkage void __up_wakeup(void /* special register calling convention */);
++
++extern spinlock_t semaphore_wake_lock;
++
++/*
++ * This is ugly, but we want the default case to fall through.
++ * "down_failed" is a special asm handler that calls the C
++ * routine that actually waits.
++ */
++extern inline void down(struct semaphore * sem)
++{
++	might_sleep();
++
++  #if 0
++    ...Nios2 has no atomic "decrement memory"....
++  #else
++	if (atomic_dec_return(&sem->count) < 0)
++		__down(sem);
++  #endif
++}
++
++extern inline int down_interruptible(struct semaphore * sem)
++{
++	int ret = 0;
++
++
++	might_sleep();
++
++  #if 0
++    ...Nios2 has no atomic "decrement memory"....
++  #else
++	if(atomic_dec_return(&sem->count) < 0)
++		ret = __down_interruptible(sem);
++	return ret;
++  #endif
++}
++
++extern inline int down_trylock(struct semaphore * sem)
++{
++  #if 0
++    ...Nios2 has no atomic "decrement memory"....
++  #else
++	int ret = 0;
++
++	if (atomic_dec_return (&sem->count) < 0)
++		ret = __down_trylock(sem);
++	return ret;
++  #endif
++}
++
++/*
++ * Note! This is subtle. We jump to wake people up only if
++ * the semaphore was negative (== somebody was waiting on it).
++ * The default case (no contention) will result in NO
++ * jumps for both down() and up().
++ */
++extern inline void up(struct semaphore * sem)
++{
++  #if 0
++    ...Nios2 has no atomic "increment memory"....
++  #else
++	if (atomic_inc_return(&sem->count) <= 0)
++		__up(sem);
++  #endif
++}
++
++#endif /* __ASSEMBLY__ */
++
++#endif
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/sembuf.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/sembuf.h	2004-02-26 15:43:36.000000000 +0100
+@@ -0,0 +1,48 @@
++#ifndef _NIOS_SEMBUF_H
++#define _NIOS_SEMBUF_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/sembuf.h
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++/* 
++ * Note extra padding because this structure is passed back and forth
++ * between kernel and user space.
++ *
++ * Pad space is left for:
++ * - 64-bit time_t to solve y2038 problem
++ * - 2 miscellaneous 32-bit values
++ */
++
++struct semid64_ds {
++	struct ipc64_perm sem_perm;		/* permissions .. see ipc.h */
++	__kernel_time_t	sem_otime;		/* last semop time */
++	unsigned long	__unused1;
++	__kernel_time_t	sem_ctime;		/* last change time */
++	unsigned long	__unused2;
++	unsigned long	sem_nsems;		/* no. of semaphores in array */
++	unsigned long	__unused3;
++	unsigned long	__unused4;
++};
++
++#endif /* _NIOS_SEMBUF_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/setup.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/setup.h	2004-12-08 17:39:48.000000000 +0100
+@@ -0,0 +1,31 @@
++/*	Copied from i386 port.
++ *	Just a place holder. We don't want to have to test x86 before
++ *	we include stuff
++ *
++ * Copyright (C) 2004, Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#ifndef _NIOS2_SETUP_H
++#define _NIOS2_SETUP_H
++
++#define COMMAND_LINE_SIZE 512
++
++#endif /* _NIOS2_SETUP_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/shmbuf.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/shmbuf.h	2004-02-26 15:43:36.000000000 +0100
+@@ -0,0 +1,64 @@
++#ifndef _NIOS_SHMBUF_H
++#define _NIOS_SHMBUF_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/shmbuf.h
++ *
++ * Derived from m68knommu
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++/* Note extra padding because this structure is passed back and forth
++ * between kernel and user space.
++ *
++ * Pad space is left for:
++ * - 64-bit time_t to solve y2038 problem
++ * - 2 miscellaneous 32-bit values
++ */
++
++struct shmid64_ds {
++	struct ipc64_perm	shm_perm;	/* operation perms */
++	size_t			shm_segsz;	/* size of segment (bytes) */
++	__kernel_time_t		shm_atime;	/* last attach time */
++	unsigned long		__unused1;
++	__kernel_time_t		shm_dtime;	/* last detach time */
++	unsigned long		__unused2;
++	__kernel_time_t		shm_ctime;	/* last change time */
++	unsigned long		__unused3;
++	__kernel_pid_t		shm_cpid;	/* pid of creator */
++	__kernel_pid_t		shm_lpid;	/* pid of last operator */
++	unsigned long		shm_nattch;	/* no. of current attaches */
++	unsigned long		__unused4;
++	unsigned long		__unused5;
++};
++
++struct shminfo64 {
++	unsigned long	shmmax;
++	unsigned long	shmmin;
++	unsigned long	shmmni;
++	unsigned long	shmseg;
++	unsigned long	shmall;
++	unsigned long	__unused1;
++	unsigned long	__unused2;
++	unsigned long	__unused3;
++	unsigned long	__unused4;
++};
++
++#endif /* _NIOS_SHMBUF_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/shmparam.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/shmparam.h	2004-02-26 15:43:36.000000000 +0100
+@@ -0,0 +1,30 @@
++#ifndef __NIOS2NOMMU_SHMPARAM_H__
++#define __NIOS2NOMMU_SHMPARAM_H__
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/shmparam.h
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++#define	SHMLBA		PAGE_SIZE	/* attach addr a multiple of this */
++
++#endif /* __NIOS2NOMMU_SHMPARAM_H__ */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/sigcontext.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/sigcontext.h	2004-02-12 18:06:40.000000000 +0100
+@@ -0,0 +1,35 @@
++/*
++ * Taken from the m68knommu.
++ *
++ * Copyright (C) 2004, Microtronix Datacom Ltd.
++ * 
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#ifndef _ASM_NIOS2NOMMU_SIGCONTEXT_H
++#define _ASM_NIOS2NOMMU_SIGCONTEXT_H
++
++#include <asm/ptrace.h>
++
++struct sigcontext {
++	struct pt_regs regs;
++	unsigned long  sc_mask; 	/* old sigmask */
++};
++
++#endif
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/siginfo.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/siginfo.h	2004-02-12 18:06:40.000000000 +0100
+@@ -0,0 +1,28 @@
++/*
++ * Copyright (C) 2004, Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#ifndef _NIOS2NOMMU_SIGINFO_H
++#define _NIOS2NOMMU_SIGINFO_H
++
++#include <asm-generic/siginfo.h>
++
++#endif
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/signal.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/signal.h	2004-02-12 18:06:40.000000000 +0100
+@@ -0,0 +1,207 @@
++/*
++ * Copyright (C) 2004, Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#ifndef _NIOS2_SIGNAL_H
++#define _NIOS2_SIGNAL_H
++
++#include <linux/types.h>
++
++/* Avoid too many header ordering problems.  */
++struct siginfo;
++
++#ifdef __KERNEL__
++/* Most things should be clean enough to redefine this at will, if care
++   is taken to make libc match.  */
++
++#define _NSIG		64
++#define _NSIG_BPW	32
++#define _NSIG_WORDS	(_NSIG / _NSIG_BPW)
++
++typedef unsigned long old_sigset_t;		/* at least 32 bits */
++
++typedef struct {
++	unsigned long sig[_NSIG_WORDS];
++} sigset_t;
++
++#else
++/* Here we must cater to libcs that poke about in kernel headers.  */
++
++#define NSIG		32
++typedef unsigned long sigset_t;
++
++#endif /* __KERNEL__ */
++
++#define SIGHUP		 1
++#define SIGINT		 2
++#define SIGQUIT		 3
++#define SIGILL		 4
++#define SIGTRAP		 5
++#define SIGABRT		 6
++#define SIGIOT		 6
++#define SIGBUS		 7
++#define SIGFPE		 8
++#define SIGKILL		 9
++#define SIGUSR1		10
++#define SIGSEGV		11
++#define SIGUSR2		12
++#define SIGPIPE		13
++#define SIGALRM		14
++#define SIGTERM		15
++#define SIGSTKFLT	16
++#define SIGCHLD		17
++#define SIGCONT		18
++#define SIGSTOP		19
++#define SIGTSTP		20
++#define SIGTTIN		21
++#define SIGTTOU		22
++#define SIGURG		23
++#define SIGXCPU		24
++#define SIGXFSZ		25
++#define SIGVTALRM	26
++#define SIGPROF		27
++#define SIGWINCH	28
++#define SIGIO		29
++#define SIGPOLL		SIGIO
++/*
++#define SIGLOST		29
++*/
++#define SIGPWR		30
++#define SIGSYS		31
++#define	SIGUNUSED	31
++
++/* These should not be considered constants from userland.  */
++#define SIGRTMIN	32
++#define SIGRTMAX	_NSIG-1
++
++/*
++ * SA_FLAGS values:
++ *
++ * SA_ONSTACK indicates that a registered stack_t will be used.
++ * SA_INTERRUPT is a no-op, but left due to historical reasons. Use the
++ * SA_RESTART flag to get restarting signals (which were the default long ago)
++ * SA_NOCLDSTOP flag to turn off SIGCHLD when children stop.
++ * SA_RESETHAND clears the handler when the signal is delivered.
++ * SA_NOCLDWAIT flag on SIGCHLD to inhibit zombies.
++ * SA_NODEFER prevents the current signal from being masked in the handler.
++ *
++ * SA_ONESHOT and SA_NOMASK are the historical Linux names for the Single
++ * Unix names RESETHAND and NODEFER respectively.
++ */
++#define SA_NOCLDSTOP	0x00000001
++#define SA_NOCLDWAIT	0x00000002 /* not supported yet */
++#define SA_SIGINFO	0x00000004
++#define SA_ONSTACK	0x08000000
++#define SA_RESTART	0x10000000
++#define SA_NODEFER	0x40000000
++#define SA_RESETHAND	0x80000000
++
++#define SA_NOMASK	SA_NODEFER
++#define SA_ONESHOT	SA_RESETHAND
++#define SA_INTERRUPT	0x20000000 /* dummy -- ignored */
++
++#define SA_RESTORER	0x04000000
++
++/* 
++ * sigaltstack controls
++ */
++#define SS_ONSTACK	1
++#define SS_DISABLE	2
++
++#define MINSIGSTKSZ	2048
++#define SIGSTKSZ	8192
++
++#ifdef __KERNEL__
++/*
++ * These values of sa_flags are used only by the kernel as part of the
++ * irq handling routines.
++ *
++ * SA_INTERRUPT is also used by the irq handling routines.
++ * SA_SHIRQ is for shared interrupt support on PCI and EISA.
++ */
++#define SA_PROBE		SA_ONESHOT
++#define SA_SAMPLE_RANDOM	SA_RESTART
++#define SA_SHIRQ		0x04000000
++#endif
++
++#define SIG_BLOCK          0	/* for blocking signals */
++#define SIG_UNBLOCK        1	/* for unblocking signals */
++#define SIG_SETMASK        2	/* for setting the signal mask */
++
++/* Type of a signal handler.  */
++typedef void (*__sighandler_t)(int);
++
++#define SIG_DFL	((__sighandler_t)0)	/* default signal handling */
++#define SIG_IGN	((__sighandler_t)1)	/* ignore signal */
++#define SIG_ERR	((__sighandler_t)-1)	/* error return from signal */
++
++#ifdef __KERNEL__
++struct old_sigaction {
++	__sighandler_t sa_handler;
++	old_sigset_t sa_mask;
++	unsigned long sa_flags;
++	void (*sa_restorer)(void);
++};
++
++struct sigaction {
++	__sighandler_t sa_handler;
++	unsigned long sa_flags;
++	void (*sa_restorer)(void);
++	sigset_t sa_mask;		/* mask last for extensibility */
++};
++
++struct k_sigaction {
++	struct sigaction sa;
++};
++#else
++/* Here we must cater to libcs that poke about in kernel headers.  */
++
++struct sigaction {
++	union {
++	  __sighandler_t _sa_handler;
++	  void (*_sa_sigaction)(int, struct siginfo *, void *);
++	} _u;
++	sigset_t sa_mask;
++	unsigned long sa_flags;
++	void (*sa_restorer)(void);
++};
++
++#define sa_handler	_u._sa_handler
++#define sa_sigaction	_u._sa_sigaction
++
++#endif /* __KERNEL__ */
++
++typedef struct sigaltstack {
++	void *ss_sp;
++	int ss_flags;
++	size_t ss_size;
++} stack_t;
++
++#ifdef __KERNEL__
++
++#include <asm/sigcontext.h>
++#undef __HAVE_ARCH_SIG_BITOPS
++
++#define ptrace_signal_deliver(regs, cookie) do { } while (0)
++
++#endif /* __KERNEL__ */
++
++#endif /* _NIOS2_SIGNAL_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/smp.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/smp.h	2005-05-18 20:36:18.000000000 +0200
+@@ -0,0 +1,34 @@
++#ifndef __ASM_SMP_H
++#define __ASM_SMP_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/smp.h
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++// #include <linux/config.h>
++
++#ifdef CONFIG_SMP
++#error SMP not supported
++#endif
++
++#endif
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/socket.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/socket.h	2004-12-08 17:39:48.000000000 +0100
+@@ -0,0 +1,74 @@
++#ifndef _ASM_SOCKET_H
++#define _ASM_SOCKET_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/socket.h
++ *
++ * Derived from m68knommu
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++#include <asm/sockios.h>
++
++/* For setsockopt(2) */
++#define SOL_SOCKET	1
++
++#define SO_DEBUG	1
++#define SO_REUSEADDR	2
++#define SO_TYPE		3
++#define SO_ERROR	4
++#define SO_DONTROUTE	5
++#define SO_BROADCAST	6
++#define SO_SNDBUF	7
++#define SO_RCVBUF	8
++#define SO_KEEPALIVE	9
++#define SO_OOBINLINE	10
++#define SO_NO_CHECK	11
++#define SO_PRIORITY	12
++#define SO_LINGER	13
++#define SO_BSDCOMPAT	14
++/* To add :#define SO_REUSEPORT 15 */
++#define SO_PASSCRED	16
++#define SO_PEERCRED	17
++#define SO_RCVLOWAT	18
++#define SO_SNDLOWAT	19
++#define SO_RCVTIMEO	20
++#define SO_SNDTIMEO	21
++
++/* Security levels - as per NRL IPv6 - don't actually do anything */
++#define SO_SECURITY_AUTHENTICATION		22
++#define SO_SECURITY_ENCRYPTION_TRANSPORT	23
++#define SO_SECURITY_ENCRYPTION_NETWORK		24
++
++#define SO_BINDTODEVICE	25
++
++/* Socket filtering */
++#define SO_ATTACH_FILTER        26
++#define SO_DETACH_FILTER        27
++
++#define SO_PEERNAME             28
++#define SO_TIMESTAMP		29
++#define SCM_TIMESTAMP		SO_TIMESTAMP
++
++#define SO_ACCEPTCONN		30
++
++#define SO_PEERSEC		31      /* ;dgt2;tmp;                   */
++
++#endif /* _ASM_SOCKET_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/sockios.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/sockios.h	2004-02-26 15:43:36.000000000 +0100
+@@ -0,0 +1,38 @@
++#ifndef _ASM_NIOS_SOCKIOS_H
++#define _ASM_NIOS_SOCKIOS_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/sockios.h
++ *
++ * Socket-level I/O control calls.
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++#define FIOSETOWN 	0x8901
++#define SIOCSPGRP	0x8902
++#define FIOGETOWN	0x8903
++#define SIOCGPGRP	0x8904
++#define SIOCATMARK	0x8905
++#define SIOCGSTAMP	0x8906		/* Get stamp */
++
++#endif /* !(_ASM_NIOS_SOCKIOS_H) */
++
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/spi.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/spi.h	2004-02-26 15:43:36.000000000 +0100
+@@ -0,0 +1,92 @@
++#ifndef _ASM_SPI_H_
++#define _ASM_SPI_H_ 1
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/spi.h
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++#include <asm/nios.h>
++
++int  register_NIOS_SPI( void );
++void unregister_NIOS_SPI( void );
++
++#if defined(MODULE)
++void cleanup_module( void );
++int  init_module( void );
++#endif
++
++#if defined(__KERNEL__)
++int  spi_reset  ( void );
++#endif
++
++
++#define clockCS 0x01
++#define temperatureCS 0x02
++
++#define clock_read_base 0x00
++#define clock_write_base 0x80
++#define clock_read_control 0x0F
++#define clock_read_trickle 0x11
++
++#define clock_read_sec 0x00
++#define clock_read_min 0x01
++#define clock_read_hour 0x02
++#define clock_read_day 0x03
++#define clock_read_date 0x04
++#define clock_read_month 0x05
++#define clock_read_year 0x06
++
++#define clock_write_control 0x8F
++#define clock_write_trickle 0x91
++#define clock_write_sec 0x80
++#define clock_write_min 0x81
++#define clock_write_hour 0x82
++#define clock_write_day 0x83
++#define clock_write_date 0x84
++#define clock_write_month 0x85
++#define clock_write_year 0x86
++
++#define clock_write_ram_start 0xA0
++#define clock_write_ram_end 0x100
++#define clock_read_ram_start 0x20
++#define clock_read_ram_end 0x80
++
++
++#define	clock_sec_def 0x11
++#define clock_min_def 0x59
++#define clock_hour_def 0x71
++#define clock_day_def 0x00
++#define clock_date_def 0x20
++#define clock_month_def 0x12
++#define clock_year_def 0x34
++
++#define temp_read_base 0x00
++#define temp_write_base 0x80
++#define temp_read_control 0x00
++#define temp_write_control 0x80
++#define temp_read_msb 0x02
++#define temp_read_lsb 0x01
++
++#define MAX_TEMP_VAR 10
++
++#endif /*_ASM_SPI_H_*/
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/spinlock.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/spinlock.h	2004-02-26 15:43:36.000000000 +0100
+@@ -0,0 +1,30 @@
++#ifndef __NIOS_SPINLOCK_H
++#define __NIOS_SPINLOCK_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/spinlock.h
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++#error "Nios doesn't do SMP yet"
++
++#endif
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/stat.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/stat.h	2004-03-04 12:52:14.000000000 +0100
+@@ -0,0 +1,102 @@
++#ifndef _ASMNIOS2NOMMU_STAT_H
++#define _ASMNIOS2NOMMU_STAT_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/stat.h
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++struct __old_kernel_stat {
++	unsigned short st_dev;
++	unsigned short st_ino;
++	unsigned short st_mode;
++	unsigned short st_nlink;
++	unsigned short st_uid;
++	unsigned short st_gid;
++	unsigned short st_rdev;
++	unsigned long  st_size;
++	unsigned long  st_atime;
++	unsigned long  st_mtime;
++	unsigned long  st_ctime;
++};
++
++struct stat {
++	unsigned short st_dev;
++	unsigned short __pad1;
++	unsigned long st_ino;
++	unsigned short st_mode;
++	unsigned short st_nlink;
++	unsigned short st_uid;
++	unsigned short st_gid;
++	unsigned short st_rdev;
++	unsigned short __pad2;
++	unsigned long  st_size;
++	unsigned long  st_blksize;
++	unsigned long  st_blocks;
++	unsigned long  st_atime;
++	unsigned long  __unused1;
++	unsigned long  st_mtime;
++	unsigned long  __unused2;
++	unsigned long  st_ctime;
++	unsigned long  __unused3;
++	unsigned long  __unused4;
++	unsigned long  __unused5;
++};
++
++/* This matches struct stat64 in glibc2.1, hence the absolutely
++ * insane amounts of padding around dev_t's.
++ */
++struct stat64 {
++	unsigned long long	st_dev;
++	unsigned char	__pad1[4];
++
++#define STAT64_HAS_BROKEN_ST_INO	1
++	unsigned long	__st_ino;
++
++	unsigned int	st_mode;
++	unsigned int	st_nlink;
++
++	unsigned long	st_uid;
++	unsigned long	st_gid;
++
++	unsigned long long	st_rdev;
++	unsigned char	__pad3[4];
++
++	long long	st_size;
++	unsigned long	st_blksize;
++
++	unsigned long	__pad4;		/* future possible st_blocks high bits */
++	unsigned long	st_blocks;	/* Number 512-byte blocks allocated. */
++
++	unsigned long	st_atime;
++	unsigned long	st_atime_nsec;
++
++	unsigned long	st_mtime;
++	unsigned long	st_mtime_nsec;
++
++	unsigned long	st_ctime;
++	unsigned long	st_ctime_nsec;
++
++	unsigned long long	st_ino;
++};
++
++#endif
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/statfs.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/statfs.h	2004-02-26 15:43:36.000000000 +0100
+@@ -0,0 +1,30 @@
++#ifndef _NIOS2NOMMU_STATFS_H
++#define _NIOS2NOMMU_STATFS_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/statfs.h
++ *
++ * Derived from M68knommu
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++#include <asm-generic/statfs.h>
++
++#endif /* _NIOS2NOMMU_STATFS_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/string.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/string.h	2004-02-26 15:43:36.000000000 +0100
+@@ -0,0 +1,45 @@
++#ifndef __NIOS_STRING_H__
++#define __NIOS_STRING_H__
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/string.h
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++#ifdef __KERNEL__ /* only set these up for kernel code */
++
++#define __HAVE_ARCH_MEMMOVE
++void * memmove(void * d, const void * s, size_t count);
++#define __HAVE_ARCH_MEMCPY
++extern void * memcpy(void *d, const void *s, size_t count);
++#define __HAVE_ARCH_MEMSET
++extern void * memset(void * s,int c,size_t count);
++
++#if 0
++#define __HAVE_ARCH_BCOPY
++#define __HAVE_ARCH_STRLEN
++#endif
++
++#endif /* KERNEL */
++
++#endif /* !(__NIOS_STRING_H__) */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/system.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/system.h	2005-05-18 20:36:23.000000000 +0200
+@@ -0,0 +1,172 @@
++/*
++ * Taken from the m68k.
++ *
++ * Copyright (C) 2004, Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#ifndef _NIOS2NOMMU_SYSTEM_H
++#define _NIOS2NOMMU_SYSTEM_H
++
++// #include <linux/config.h> /* get configuration macros */
++#include <linux/linkage.h>
++#include <asm/segment.h>
++#include <asm/entry.h>
++#include <asm/nios.h>
++
++/*
++ * switch_to(n) should switch tasks to task ptr, first checking that
++ * ptr isn't the current task, in which case it does nothing.  This
++ * also clears the TS-flag if the task we switched to has used the
++ * math co-processor latest.
++ */
++
++/*
++ */
++asmlinkage void resume(void);
++#define switch_to(prev,next,last)				\
++{								\
++  void *_last;							\
++  __asm__ __volatile__(						\
++  	"mov	r4, %1\n"					\
++	"mov	r5, %2\n"					\
++	"call	resume\n"					\
++	"mov	%0,r4\n"					\
++       : "=r" (_last)						\
++       : "r" (prev), "r" (next)					\
++       : "r4","r5","r7","r8","ra");	\
++  (last) = _last;						\
++}
++
++#define local_irq_enable() __asm__ __volatile__ (  \
++	"rdctl	r8, status\n"			   \
++	"ori	r8, r8, 1\n"			   \
++	"wrctl	status, r8\n"			   \
++	: : : "r8")	  
++
++#define local_irq_disable() __asm__ __volatile__ ( \
++	"rdctl	r8, status\n"			   \
++	"andi	r8, r8, 0xfffe\n"		   \
++	"wrctl	status, r8\n"			   \
++	: : : "r8")
++
++#define local_save_flags(x) __asm__ __volatile__ (	\
++	"rdctl	r8, status\n"				\
++	"mov	%0, r8\n"				\
++	:"=r" (x) : : "r8", "memory")
++
++#define local_irq_restore(x) __asm__ __volatile__ (	\
++	"mov	r8, %0\n"				\
++	"wrctl	status, r8\n"				\
++	: :"r" (x) : "memory")
++
++/* For spinlocks etc */
++#define local_irq_save(x) do { local_save_flags(x); local_irq_disable(); } while (0)
++
++#define	irqs_disabled()					\
++({							\
++	unsigned long flags;				\
++	local_save_flags(flags);			\
++	((flags & NIOS2_STATUS_PIE_MSK) == 0x0);	\
++})
++
++#define iret() __asm__ __volatile__ ("eret": : :"memory", "ea")
++
++/*
++ * Force strict CPU ordering.
++ * Not really required on m68k...
++ */
++#define nop()  asm volatile ("nop"::)
++#define mb()   asm volatile (""   : : :"memory")
++#define rmb()  asm volatile (""   : : :"memory")
++#define wmb()  asm volatile (""   : : :"memory")
++#define set_rmb(var, value)    do { xchg(&var, value); } while (0)
++#define set_mb(var, value)     set_rmb(var, value)
++#define set_wmb(var, value)    do { var = value; wmb(); } while (0)
++
++#ifdef CONFIG_SMP
++#define smp_mb()	mb()
++#define smp_rmb()	rmb()
++#define smp_wmb()	wmb()
++#define smp_read_barrier_depends()	read_barrier_depends()
++#else
++#define smp_mb()	barrier()
++#define smp_rmb()	barrier()
++#define smp_wmb()	barrier()
++#define smp_read_barrier_depends()	do { } while(0)
++#endif
++
++#define xchg(ptr,x) ((__typeof__(*(ptr)))__xchg((unsigned long)(x),(ptr),sizeof(*(ptr))))
++#define tas(ptr) (xchg((ptr),1))
++
++struct __xchg_dummy { unsigned long a[100]; };
++#define __xg(x) ((volatile struct __xchg_dummy *)(x))
++
++static inline unsigned long __xchg(unsigned long x, volatile void * ptr, int size)
++{
++  unsigned long tmp, flags;
++
++  local_irq_save(flags);
++
++  switch (size) {
++  case 1:
++    __asm__ __volatile__( \
++      "ldb	%0, %2\n" \
++      "stb	%1, %2\n" \
++    : "=&r" (tmp) : "r" (x), "m" (*__xg(ptr)) : "memory");
++    break;
++  case 2:
++    __asm__ __volatile__( \
++      "ldh	%0, %2\n" \
++      "sth	%1, %2\n" \
++    : "=&r" (tmp) : "r" (x), "m" (*__xg(ptr)) : "memory");
++    break;
++  case 4:
++    __asm__ __volatile__( \
++      "ldw	%0, %2\n" \
++      "stw	%1, %2\n" \
++    : "=&r" (tmp) : "r" (x), "m" (*__xg(ptr)) : "memory");
++    break;
++  }
++  local_irq_restore(flags);
++  return tmp;
++}
++
++/*
++ * Atomic compare and exchange.  Compare OLD with MEM, if identical,
++ * store NEW in MEM.  Return the initial value in MEM.  Success is
++ * indicated by comparing RETURN with OLD.
++ */
++#define __HAVE_ARCH_CMPXCHG	1
++
++static __inline__ unsigned long
++cmpxchg(volatile int *p, int old, int new)
++{
++	unsigned long flags;
++	int prev;
++
++	local_irq_save(flags);
++	if ((prev = *p) == old)
++		*p = new;
++	local_irq_restore(flags);
++	return(prev);
++}
++
++#endif /* _NIOS2NOMMU_SYSTEM_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/termbits.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/termbits.h	2004-05-07 15:36:26.000000000 +0200
+@@ -0,0 +1,199 @@
++#ifndef __ARCH_NIOS_TERMBITS_H__
++#define __ARCH_NIOS_TERMBITS_H__
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/termbits.h
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++#include <linux/posix_types.h>
++
++typedef unsigned char	cc_t;
++typedef unsigned int	speed_t;
++typedef unsigned int	tcflag_t;
++
++#define NCCS 19
++struct termios {
++	tcflag_t c_iflag;		/* input mode flags */
++	tcflag_t c_oflag;		/* output mode flags */
++	tcflag_t c_cflag;		/* control mode flags */
++	tcflag_t c_lflag;		/* local mode flags */
++	cc_t c_line;			/* line discipline */
++	cc_t c_cc[NCCS];		/* control characters */
++};
++
++/* c_cc characters */
++#define VINTR 0
++#define VQUIT 1
++#define VERASE 2
++#define VKILL 3
++#define VEOF 4
++#define VTIME 5
++#define VMIN 6
++#define VSWTC 7
++#define VSTART 8
++#define VSTOP 9
++#define VSUSP 10
++#define VEOL 11
++#define VREPRINT 12
++#define VDISCARD 13
++#define VWERASE 14
++#define VLNEXT 15
++#define VEOL2 16
++
++
++/* c_iflag bits */
++#define IGNBRK	0000001
++#define BRKINT	0000002
++#define IGNPAR	0000004
++#define PARMRK	0000010
++#define INPCK	0000020
++#define ISTRIP	0000040
++#define INLCR	0000100
++#define IGNCR	0000200
++#define ICRNL	0000400
++#define IUCLC	0001000
++#define IXON	0002000
++#define IXANY	0004000
++#define IXOFF	0010000
++#define IMAXBEL	0020000
++#define IUTF8	0040000
++
++/* c_oflag bits */
++#define OPOST	0000001
++#define OLCUC	0000002
++#define ONLCR	0000004
++#define OCRNL	0000010
++#define ONOCR	0000020
++#define ONLRET	0000040
++#define OFILL	0000100
++#define OFDEL	0000200
++#define NLDLY	0000400
++#define   NL0	0000000
++#define   NL1	0000400
++#define CRDLY	0003000
++#define   CR0	0000000
++#define   CR1	0001000
++#define   CR2	0002000
++#define   CR3	0003000
++#define TABDLY	0014000
++#define   TAB0	0000000
++#define   TAB1	0004000
++#define   TAB2	0010000
++#define   TAB3	0014000
++#define   XTABS	0014000
++#define BSDLY	0020000
++#define   BS0	0000000
++#define   BS1	0020000
++#define VTDLY	0040000
++#define   VT0	0000000
++#define   VT1	0040000
++#define FFDLY	0100000
++#define   FF0	0000000
++#define   FF1	0100000
++
++/* c_cflag bit meaning */
++#define CBAUD	0010017
++#define  B0	0000000		/* hang up */
++#define  B50	0000001
++#define  B75	0000002
++#define  B110	0000003
++#define  B134	0000004
++#define  B150	0000005
++#define  B200	0000006
++#define  B300	0000007
++#define  B600	0000010
++#define  B1200	0000011
++#define  B1800	0000012
++#define  B2400	0000013
++#define  B4800	0000014
++#define  B9600	0000015
++#define  B19200	0000016
++#define  B38400	0000017
++#define EXTA B19200
++#define EXTB B38400
++#define CSIZE	0000060
++#define   CS5	0000000
++#define   CS6	0000020
++#define   CS7	0000040
++#define   CS8	0000060
++#define CSTOPB	0000100
++#define CREAD	0000200
++#define PARENB	0000400
++#define PARODD	0001000
++#define HUPCL	0002000
++#define CLOCAL	0004000
++#define CBAUDEX 0010000
++#define    B57600 0010001
++#define   B115200 0010002
++#define   B230400 0010003
++#define   B460800 0010004
++#define   B500000 0010005
++#define   B576000 0010006
++#define   B921600 0010007
++#define  B1000000 0010010
++#define  B1152000 0010011
++#define  B1500000 0010012
++#define  B2000000 0010013
++#define  B2500000 0010014
++#define  B3000000 0010015
++#define  B3500000 0010016
++#define  B4000000 0010017
++#define CIBAUD	  002003600000	/* input baud rate (not used) */
++#define CMSPAR	  010000000000		/* mark or space (stick) parity */
++#define CRTSCTS	  020000000000		/* flow control */
++
++/* c_lflag bits */
++#define ISIG	0000001
++#define ICANON	0000002
++#define XCASE	0000004
++#define ECHO	0000010
++#define ECHOE	0000020
++#define ECHOK	0000040
++#define ECHONL	0000100
++#define NOFLSH	0000200
++#define TOSTOP	0000400
++#define ECHOCTL	0001000
++#define ECHOPRT	0002000
++#define ECHOKE	0004000
++#define FLUSHO	0010000
++#define PENDIN	0040000
++#define IEXTEN	0100000
++
++
++/* tcflow() and TCXONC use these */
++#define	TCOOFF		0
++#define	TCOON		1
++#define	TCIOFF		2
++#define	TCION		3
++
++/* tcflush() and TCFLSH use these */
++#define	TCIFLUSH	0
++#define	TCOFLUSH	1
++#define	TCIOFLUSH	2
++
++/* tcsetattr uses these */
++#define	TCSANOW		0
++#define	TCSADRAIN	1
++#define	TCSAFLUSH	2
++
++#endif /* __ARCH_NIOS_TERMBITS_H__ */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/termios.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/termios.h	2004-02-26 15:43:36.000000000 +0100
+@@ -0,0 +1,132 @@
++#ifndef _NIOS_TERMIOS_H
++#define _NIOS_TERMIOS_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/termios.h
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++#include <asm/termbits.h>
++#include <asm/ioctls.h>
++ 
++struct winsize {
++	unsigned short ws_row;
++	unsigned short ws_col;
++	unsigned short ws_xpixel;
++	unsigned short ws_ypixel;
++};
++
++#define NCC 8
++struct termio {
++	unsigned short c_iflag;		/* input mode flags */
++	unsigned short c_oflag;		/* output mode flags */
++	unsigned short c_cflag;		/* control mode flags */
++	unsigned short c_lflag;		/* local mode flags */
++	unsigned char c_line;		/* line discipline */
++	unsigned char c_cc[NCC];	/* control characters */
++};
++
++#ifdef __KERNEL__
++/*	intr=^C		quit=^|		erase=del	kill=^U
++	eof=^D		vtime=\0	vmin=\1		sxtc=\0
++	start=^Q	stop=^S		susp=^Z		eol=\0
++	reprint=^R	discard=^U	werase=^W	lnext=^V
++	eol2=\0
++*/
++#define INIT_C_CC "\003\034\177\025\004\0\1\0\021\023\032\0\022\017\027\026\0"
++#endif
++
++/* modem lines */
++#define TIOCM_LE	0x001
++#define TIOCM_DTR	0x002
++#define TIOCM_RTS	0x004
++#define TIOCM_ST	0x008
++#define TIOCM_SR	0x010
++#define TIOCM_CTS	0x020
++#define TIOCM_CAR	0x040
++#define TIOCM_RNG	0x080
++#define TIOCM_DSR	0x100
++#define TIOCM_CD	TIOCM_CAR
++#define TIOCM_RI	TIOCM_RNG
++#define TIOCM_OUT1	0x2000
++#define TIOCM_OUT2	0x4000
++#define TIOCM_LOOP	0x8000
++
++/* ioctl (fd, TIOCSERGETLSR, &result) where result may be as below */
++
++/* line disciplines */
++#define N_TTY		0
++#define N_SLIP		1
++#define N_MOUSE		2
++#define N_PPP		3
++#define N_STRIP		4
++#define N_AX25		5
++#define N_X25		6	/* X.25 async */
++#define N_6PACK		7
++#define N_MASC		8	/* Reserved for Mobitex module <kaz@cafe.net> */
++#define N_R3964		9	/* Reserved for Simatic R3964 module */
++#define N_PROFIBUS_FDL	10	/* Reserved for Profibus <Dave@mvhi.com> */
++#define N_IRDA		11	/* Linux IrDa - http://irda.sourceforge.net/ */
++#define N_SMSBLOCK	12	/* SMS block mode - for talking to GSM data cards about SMS messages */
++#define N_HDLC		13	/* synchronous HDLC */
++#define N_SYNC_PPP	14
++#define N_HCI		15  /* Bluetooth HCI UART */
++
++#ifdef __KERNEL__
++
++/*
++ * Translate a "termio" structure into a "termios". Ugh.
++ */
++#define user_termio_to_kernel_termios(termios, termio) \
++({ \
++	unsigned short tmp; \
++	get_user(tmp, &(termio)->c_iflag); \
++	(termios)->c_iflag = (0xffff0000 & ((termios)->c_iflag)) | tmp; \
++	get_user(tmp, &(termio)->c_oflag); \
++	(termios)->c_oflag = (0xffff0000 & ((termios)->c_oflag)) | tmp; \
++	get_user(tmp, &(termio)->c_cflag); \
++	(termios)->c_cflag = (0xffff0000 & ((termios)->c_cflag)) | tmp; \
++	get_user(tmp, &(termio)->c_lflag); \
++	(termios)->c_lflag = (0xffff0000 & ((termios)->c_lflag)) | tmp; \
++	get_user((termios)->c_line, &(termio)->c_line); \
++	copy_from_user((termios)->c_cc, (termio)->c_cc, NCC); \
++})
++
++/*
++ * Translate a "termios" structure into a "termio". Ugh.
++ */
++#define kernel_termios_to_user_termio(termio, termios) \
++({ \
++	put_user((termios)->c_iflag, &(termio)->c_iflag); \
++	put_user((termios)->c_oflag, &(termio)->c_oflag); \
++	put_user((termios)->c_cflag, &(termio)->c_cflag); \
++	put_user((termios)->c_lflag, &(termio)->c_lflag); \
++	put_user((termios)->c_line,  &(termio)->c_line); \
++	copy_to_user((termio)->c_cc, (termios)->c_cc, NCC); \
++})
++
++#define user_termios_to_kernel_termios(k, u) copy_from_user(k, u, sizeof(struct termios))
++#define kernel_termios_to_user_termios(u, k) copy_to_user(u, k, sizeof(struct termios))
++
++#endif	/* __KERNEL__ */
++
++#endif /* _NIOS_TERMIOS_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/thread_info.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/thread_info.h	2004-05-14 13:32:04.000000000 +0200
+@@ -0,0 +1,126 @@
++/* thread_info.h: niosnommu low-level thread information
++ * adapted from the m68knommu
++ *
++ * Copyright (C) 2004 Microtronix Datacom Ltd.
++ * Copyright (C) 2002 Microtronix Datacom 
++ *
++ * - Incorporating suggestions made by Linus Torvalds and Dave Miller
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++
++#ifndef _ASM_THREAD_INFO_H
++#define _ASM_THREAD_INFO_H
++
++#include <asm/page.h>
++
++#ifdef __KERNEL__
++
++#ifndef __ASSEMBLY__
++
++/*
++ * low level task data.
++ */
++struct thread_info {
++	struct task_struct *task;		/* main task structure */
++	struct exec_domain *exec_domain;	/* execution domain */
++	unsigned long	   flags;		/* low level flags */
++	int		   cpu;			/* cpu we're on */
++	int		   preempt_count;	/* 0 => preemptable, <0 => BUG*/
++	struct restart_block restart_block;
++};
++
++/*
++ * macros/functions for gaining access to the thread information structure
++ */
++#define INIT_THREAD_INFO(tsk)			\
++{						\
++	.task		= &tsk,			\
++	.exec_domain	= &default_exec_domain,	\
++	.flags		= 0,			\
++	.cpu		= 0,			\
++	.preempt_count	= 1,			\
++	.restart_block	= {			\
++		.fn = do_no_restart_syscall,	\
++	},					\
++}
++
++#define init_thread_info	(init_thread_union.thread_info)
++#define init_stack		(init_thread_union.stack)
++
++
++/* how to get the thread information struct from C
++   usable only in supervisor mode */
++static inline struct thread_info *current_thread_info(void)
++{
++	struct thread_info *ti;
++	__asm__ __volatile__(
++		"mov	%0, sp\n"
++		"and	%0, %0, %1\n"
++		: "=&r"(ti)
++		: "r" (~(THREAD_SIZE-1))
++		);
++	return ti;
++}
++
++/* thread information allocation */
++#define alloc_thread_info(tsk) ((struct thread_info *) \
++				__get_free_pages(GFP_KERNEL, 1))
++#define free_thread_info(ti)	free_pages((unsigned long) (ti), 1)
++#define put_thread_info(ti)	put_task_struct((ti)->task)
++
++#define	PREEMPT_ACTIVE	0x4000000
++
++/*
++ * thread information flag bit numbers
++ */
++#define TIF_SYSCALL_TRACE 	0	/* syscall trace active */
++#define TIF_NOTIFY_RESUME 	1	/* resumption notification requested */
++#define TIF_SIGPENDING	  	2	/* signal pending */
++#define TIF_NEED_RESCHED  	3	/* rescheduling necessary */
++#define TIF_POLLING_NRFLAG	4	/* true if poll_idle() is polling
++					   TIF_NEED_RESCHED */
++
++/* as above, but as bit values */
++#define _TIF_SYSCALL_TRACE	(1<<TIF_SYSCALL_TRACE)
++#define _TIF_NOTIFY_RESUME	(1<<TIF_NOTIFY_RESUME)
++#define _TIF_SIGPENDING		(1<<TIF_SIGPENDING)
++#define _TIF_NEED_RESCHED	(1<<TIF_NEED_RESCHED)
++#define _TIF_POLLING_NRFLAG	(1<<TIF_POLLING_NRFLAG)
++
++#define _TIF_WORK_MASK		0x0000FFFE	/* work to do on interrupt/exception return */
++
++#else /* __ASSEMBLY__ */
++
++/* how to get the thread information struct from ASM 
++   usable only in supervisor mode */
++.macro GET_THREAD_INFO reg 
++.if THREAD_SIZE & 0xffff0000
++	andhi	\reg, sp, %hi(~(THREAD_SIZE-1))
++.else
++	addi	\reg, r0, %lo(~(THREAD_SIZE-1))
++	and	\reg, \reg, sp
++.endif
++.endm
++
++#endif /* __ASSEMBLY__ */
++
++#endif /* __KERNEL__ */
++
++#endif /* _ASM_THREAD_INFO_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/timer_struct.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/timer_struct.h	2004-12-22 15:23:52.000000000 +0100
+@@ -0,0 +1,38 @@
++
++// ----------------------------------------------
++// Timer Peripheral
++
++// Timer Registers
++typedef volatile struct
++	{
++	int np_timerstatus;  // read only, 2 bits (any write to clear TO)
++	int np_timercontrol; // write/readable, 4 bits
++	int np_timerperiodl; // write/readable, 16 bits
++	int np_timerperiodh; // write/readable, 16 bits
++	int np_timersnapl;   // read only, 16 bits
++	int np_timersnaph;   // read only, 16 bits
++	} np_timer;
++
++// Timer Register Bits
++enum
++	{
++	np_timerstatus_run_bit    = 1, // timer is running
++	np_timerstatus_to_bit     = 0, // timer has timed out
++
++	np_timercontrol_stop_bit  = 3, // stop the timer
++	np_timercontrol_start_bit = 2, // start the timer
++	np_timercontrol_cont_bit  = 1, // continous mode
++	np_timercontrol_ito_bit   = 0, // enable time out interrupt
++
++	np_timerstatus_run_mask    = (1<<1), // timer is running
++	np_timerstatus_to_mask     = (1<<0), // timer has timed out
++
++	np_timercontrol_stop_mask  = (1<<3), // stop the timer
++	np_timercontrol_start_mask = (1<<2), // start the timer
++	np_timercontrol_cont_mask  = (1<<1), // continous mode
++	np_timercontrol_ito_mask   = (1<<0)  // enable time out interrupt
++	};
++
++// Timer Routines
++int nr_timer_milliseconds(void);	// Starts on first call, hogs timer1.
++
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/timex.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/timex.h	2004-02-26 15:43:36.000000000 +0100
+@@ -0,0 +1,48 @@
++#ifndef _ASMNIOS2NOMMU_TIMEX_H
++#define _ASMNIOS2NOMMU_TIMEX_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/timex.h
++ *
++ * timex specifications
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++#include <asm/nios.h>
++
++
++#define CLOCK_TICK_RATE	nasys_clock_freq /* Underlying HZ */
++
++#define CLOCK_TICK_FACTOR	20	/* Factor of both 1000000 and CLOCK_TICK_RATE */
++
++#define FINETUNE ((((((long)LATCH * HZ - CLOCK_TICK_RATE) << SHIFT_HZ) * \
++	(1000000/CLOCK_TICK_FACTOR) / (CLOCK_TICK_RATE/CLOCK_TICK_FACTOR)) \
++		<< (SHIFT_SCALE-SHIFT_HZ)) / HZ)
++
++typedef unsigned long cycles_t;
++
++static inline cycles_t get_cycles(void)
++{
++	return 0;
++}
++
++#endif
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/tlb.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/tlb.h	2004-02-26 15:43:36.000000000 +0100
+@@ -0,0 +1,35 @@
++#ifndef __NIOS_TLB_H__
++#define __NIOS_TLB_H__
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/tlb.h
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ *  Copyright (C) 2003  Microtronix Datacom Ltd
++ *  Copyright (C) 2002  NEC Corporation
++ *  Copyright (C) 2002  Miles Bader <miles@gnu.org>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Written by Miles Bader <miles@gnu.org>
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++#define tlb_flush(tlb)	((void)0)
++
++#include <asm-generic/tlb.h>
++
++#endif /* __NIOS_TLB_H__ */
++
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/tlbflush.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/tlbflush.h	2004-02-26 15:43:36.000000000 +0100
+@@ -0,0 +1,86 @@
++#ifndef _NIOS2NOMMU_TLBFLUSH_H
++#define _NIOS2NOMMU_TLBFLUSH_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/tlbflush.h
++ *
++ * Ported from m68knommu.
++ *
++ * Copyright (C) 2003 Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++#include <asm/setup.h>
++
++/*
++ * flush all user-space atc entries.
++ */
++static inline void __flush_tlb(void)
++{
++	BUG();
++}
++
++static inline void __flush_tlb_one(unsigned long addr)
++{
++	BUG();
++}
++
++#define flush_tlb() __flush_tlb()
++
++/*
++ * flush all atc entries (both kernel and user-space entries).
++ */
++static inline void flush_tlb_all(void)
++{
++	BUG();
++}
++
++static inline void flush_tlb_mm(struct mm_struct *mm)
++{
++	BUG();
++}
++
++static inline void flush_tlb_page(struct vm_area_struct *vma, unsigned long addr)
++{
++	BUG();
++}
++
++static inline void flush_tlb_range(struct mm_struct *mm,
++				   unsigned long start, unsigned long end)
++{
++	BUG();
++}
++
++extern inline void flush_tlb_kernel_page(unsigned long addr)
++{
++	BUG();
++}
++
++extern inline void flush_tlb_pgtables(struct mm_struct *mm,
++				      unsigned long start, unsigned long end)
++{
++	BUG();
++}
++
++#endif /* _NIOS2NOMMU_TLBFLUSH_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/topology.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/topology.h	2004-02-26 15:43:36.000000000 +0100
+@@ -0,0 +1,30 @@
++#ifndef _ASM_NIOS2NOMMU_TOPOLOGY_H
++#define _ASM_NIOS2NOMMU_TOPOLOGY_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/topology.h
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++#include <asm-generic/topology.h>
++
++#endif /* _ASM_NIOS2NOMMU_TOPOLOGY_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/traps.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/traps.h	2004-05-26 10:12:18.000000000 +0200
+@@ -0,0 +1,27 @@
++/*
++ * Copyright (C) 2004, Microtronix Datacom Ltd.
++ *
++ * All rights reserved.          
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
++ * NON INFRINGEMENT.  See the GNU General Public License for more
++ * details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ *
++ */
++#ifndef _NIOS2_TRAPS_H
++#define _NIOS2_TRAPS_H
++
++#define TRAP_ID_SYSCALL 0
++#define TRAP_ID_APPDEBUG 1
++#endif /* !(_NIOS2_TRAPS_H) */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/types.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/types.h	2004-12-08 17:39:48.000000000 +0100
+@@ -0,0 +1,93 @@
++#ifndef _NIOS_TYPES_H
++#define _NIOS_TYPES_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/types.h
++ *
++ * Derived from m68knommu
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++/*
++ * This file is never included by application software unless
++ * explicitly requested (e.g., via linux/types.h) in which case the
++ * application is Linux specific so (user-) name space pollution is
++ * not a major issue.  However, for interoperability, libraries still
++ * need to be careful to avoid a name clashes.
++ */
++
++#ifndef __ASSEMBLY__
++
++typedef unsigned short umode_t;
++
++/*
++ * __xx is ok: it doesn't pollute the POSIX namespace. Use these in the
++ * header files exported to user space
++ */
++
++typedef __signed__ char __s8;
++typedef unsigned char __u8;
++
++typedef __signed__ short __s16;
++typedef unsigned short __u16;
++
++typedef __signed__ int __s32;
++typedef unsigned int __u32;
++
++#if defined(__GNUC__) && !defined(__STRICT_ANSI__)
++typedef __signed__ long long __s64;
++typedef unsigned long long __u64;
++#endif
++
++#endif /* __ASSEMBLY__ */
++
++/*
++ * These aren't exported outside the kernel to avoid name space clashes
++ */
++#ifdef __KERNEL__
++
++#define BITS_PER_LONG 32
++
++#ifndef __ASSEMBLY__
++
++typedef signed char s8;
++typedef unsigned char u8;
++
++typedef signed short s16;
++typedef unsigned short u16;
++
++typedef signed int s32;
++typedef unsigned int u32;
++
++typedef signed long long s64;
++typedef unsigned long long u64;
++
++/* DMA addresses are always 32-bits wide */
++
++typedef u32 dma_addr_t;
++typedef u32 dma64_addr_t;
++
++typedef unsigned short kmem_bufctl_t;
++
++#endif /* __ASSEMBLY__ */
++
++#endif /* __KERNEL__ */
++
++#endif /* _NIOS_TYPES_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/uaccess.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/uaccess.h	2004-12-08 17:39:48.000000000 +0100
+@@ -0,0 +1,183 @@
++#ifndef __NIOS2NOMMU_UACCESS_H
++#define __NIOS2NOMMU_UACCESS_H
++
++/*--------------------------------------------------------------------
++ *
++ * asm-nios2nommu/uaccess.h
++ *
++ * User space memory access functions
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Ported from asm-m68knommu/uaccess.h --wentao
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++#include <linux/sched.h>
++#include <linux/mm.h>
++#include <asm/segment.h>
++#include <asm/nios.h>
++
++#define VERIFY_READ	0
++#define VERIFY_WRITE	1
++
++#define access_ok(type,addr,size)	_access_ok((unsigned long)(addr),(size))
++
++static inline int _access_ok(unsigned long addr, unsigned long size)
++{
++	return (((unsigned long)addr < (unsigned long)nasys_program_mem_end) &&
++		(((unsigned long)addr >= (unsigned long)nasys_program_mem)));
++}
++
++extern inline int verify_area(int type, const void * addr, unsigned long size)
++{
++	return access_ok(type,addr,size)?0:-EFAULT;
++}
++
++/*
++ * The exception table consists of pairs of addresses: the first is the
++ * address of an instruction that is allowed to fault, and the second is
++ * the address at which the program should continue.  No registers are
++ * modified, so it is entirely up to the continuation code to figure out
++ * what to do.
++ *
++ * All the routines below use bits of fixup code that are out of line
++ * with the main instruction path.  This means when everything is well,
++ * we don't even have to jump over them.  Further, they do not intrude
++ * on our cache or tlb entries.
++ */
++
++#define ARCH_HAS_SEARCH_EXTABLE
++//;dgt2;tmp;
++
++struct exception_table_entry
++{
++	unsigned long insn, fixup;
++};
++
++/* Returns 0 if exception not found and fixup otherwise.  */
++extern unsigned long search_exception_table(unsigned long);
++
++
++/*
++ * These are the main single-value transfer routines.  They automatically
++ * use the right size if we just have the right pointer type.
++ */
++
++#define put_user(x, ptr)				\
++({							\
++    int __pu_err = 0;					\
++    typeof(*(ptr)) __pu_val = (x);			\
++    switch (sizeof (*(ptr))) {				\
++    case 1:						\
++    case 2:						\
++    case 4:						\
++    case 8:						\
++	memcpy(ptr, &__pu_val, sizeof (*(ptr))); \
++	break;						\
++    default:						\
++	__pu_err = __put_user_bad();			\
++	break;						\
++    }							\
++    __pu_err;						\
++})
++#define __put_user(x, ptr) put_user(x, ptr)
++
++extern int __put_user_bad(void);
++
++/*
++ * Tell gcc we read from memory instead of writing: this is because
++ * we do not write to any memory gcc knows about, so there are no
++ * aliasing issues.
++ */
++
++#define __ptr(x) ((unsigned long *)(x))
++
++#define get_user(x, ptr)					\
++({								\
++    int __gu_err = 0;						\
++    typeof(*(ptr)) __gu_val = 0;				\
++    switch (sizeof(*(ptr))) {					\
++    case 1:						\
++    case 2:						\
++    case 4:						\
++    case 8:						\
++	memcpy(&__gu_val, ptr, sizeof (*(ptr))); \
++	break;							\
++    default:							\
++	__gu_val = 0;						\
++	__gu_err = __get_user_bad();				\
++	break;							\
++    }								\
++    (x) = __gu_val;						\
++    __gu_err;							\
++})
++#define __get_user(x, ptr) get_user(x, ptr)
++
++extern int __get_user_bad(void);
++
++#define copy_from_user(to, from, n)		(memcpy(to, from, n), 0)
++#define copy_to_user(to, from, n)		(memcpy(to, from, n), 0)
++
++#define __copy_from_user(to, from, n) copy_from_user(to, from, n)
++#define __copy_to_user(to, from, n) copy_to_user(to, from, n)
++#define __copy_to_user_inatomic __copy_to_user
++#define __copy_from_user_inatomic __copy_from_user
++
++#define copy_to_user_ret(to,from,n,retval) ({ if (copy_to_user(to,from,n)) return retval; })
++
++#define copy_from_user_ret(to,from,n,retval) ({ if (copy_from_user(to,from,n)) return retval; })
++
++/*
++ * Copy a null terminated string from userspace.
++ */
++
++static inline long
++strncpy_from_user(char *dst, const char *src, long count)
++{
++	char *tmp;
++	strncpy(dst, src, count);
++	for (tmp = dst; *tmp && count > 0; tmp++, count--)
++		;
++	return(tmp - dst); /* DAVIDM should we count a NUL ?  check getname */
++}
++
++/*
++ * Return the size of a string (including the ending 0)
++ *
++ * Return 0 on exception, a value greater than N if too long
++ */
++static inline long strnlen_user(const char *src, long n)
++{
++	return(strlen(src) + 1); /* DAVIDM make safer */
++}
++
++#define strlen_user(str) strnlen_user(str, 32767)
++
++/*
++ * Zero Userspace
++ */
++
++static inline unsigned long
++clear_user(void *to, unsigned long n)
++{
++	memset(to, 0, n);
++    return(0);
++}
++
++#endif /* _NIOS2NOMMU_UACCESS_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/uart_struct.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/uart_struct.h	2004-12-22 15:23:52.000000000 +0100
+@@ -0,0 +1,83 @@
++
++// UART Registers
++typedef volatile struct
++	{
++	int np_uartrxdata;      // Read-only, 8-bit
++	int np_uarttxdata;      // Write-only, 8-bit
++	int np_uartstatus;      // Read-only, 8-bit
++	int np_uartcontrol;     // Read/Write, 9-bit
++	int np_uartdivisor;     // Read/Write, 16-bit, optional
++	int np_uartendofpacket; // Read/Write, end-of-packet character
++	} np_uart;
++
++// UART Status Register Bits
++enum
++	{
++	np_uartstatus_eop_bit  = 12,
++	np_uartstatus_cts_bit  = 11,
++	np_uartstatus_dcts_bit = 10,
++	np_uartstatus_e_bit    = 8,
++	np_uartstatus_rrdy_bit = 7,
++	np_uartstatus_trdy_bit = 6,
++	np_uartstatus_tmt_bit  = 5,
++	np_uartstatus_toe_bit  = 4,
++	np_uartstatus_roe_bit  = 3,
++	np_uartstatus_brk_bit  = 2,
++	np_uartstatus_fe_bit   = 1,
++	np_uartstatus_pe_bit   = 0,
++
++	np_uartstatus_eop_mask  = (1<<12),
++	np_uartstatus_cts_mask  = (1<<11),
++	np_uartstatus_dcts_mask = (1<<10),
++	np_uartstatus_e_mask    = (1<<8),
++	np_uartstatus_rrdy_mask = (1<<7),
++	np_uartstatus_trdy_mask = (1<<6),
++	np_uartstatus_tmt_mask  = (1<<5),
++	np_uartstatus_toe_mask  = (1<<4),
++	np_uartstatus_roe_mask  = (1<<3),
++	np_uartstatus_brk_mask  = (1<<2),
++	np_uartstatus_fe_mask   = (1<<1),
++	np_uartstatus_pe_mask   = (1<<0)
++	};
++
++// UART Control Register Bits
++enum
++	{
++	np_uartcontrol_ieop_bit  = 12,
++	np_uartcontrol_rts_bit   = 11,
++	np_uartcontrol_idcts_bit = 10,
++	np_uartcontrol_tbrk_bit  = 9,
++	np_uartcontrol_ie_bit    = 8,
++	np_uartcontrol_irrdy_bit = 7,
++	np_uartcontrol_itrdy_bit = 6,
++	np_uartcontrol_itmt_bit  = 5,
++	np_uartcontrol_itoe_bit  = 4,
++	np_uartcontrol_iroe_bit  = 3,
++	np_uartcontrol_ibrk_bit  = 2,
++	np_uartcontrol_ife_bit   = 1,
++	np_uartcontrol_ipe_bit   = 0,
++
++	np_uartcontrol_ieop_mask  = (1<<12),
++	np_uartcontrol_rts_mask   = (1<<11),
++	np_uartcontrol_idcts_mask = (1<<10),
++	np_uartcontrol_tbrk_mask  = (1<<9),
++	np_uartcontrol_ie_mask    = (1<<8),
++	np_uartcontrol_irrdy_mask = (1<<7),
++	np_uartcontrol_itrdy_mask = (1<<6),
++	np_uartcontrol_itmt_mask  = (1<<5),
++	np_uartcontrol_itoe_mask  = (1<<4),
++	np_uartcontrol_iroe_mask  = (1<<3),
++	np_uartcontrol_ibrk_mask  = (1<<2),
++	np_uartcontrol_ife_mask   = (1<<1),
++	np_uartcontrol_ipe_mask   = (1<<0)
++	};
++
++// UART Routines
++int nr_uart_rxchar(np_uart *uartBase);        // 0 for default UART
++void nr_uart_txcr(void);
++void nr_uart_txchar(int c,np_uart *uartBase); // 0 for default UART
++void nr_uart_txhex(int x);                     // 16 or 32 bits
++void nr_uart_txhex16(short x);
++void nr_uart_txhex32(long x);
++void nr_uart_txstring(char *s);
++
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/ucontext.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/ucontext.h	2004-11-16 12:20:14.000000000 +0100
+@@ -0,0 +1,63 @@
++#ifndef _NIOSKNOMMU_UCONTEXT_H
++#define _NIOSKNOMMU_UCONTEXT_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/ucontext.h
++ *
++ * Derived from M68knommu
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++typedef int greg_t;
++#define NGREG 32
++typedef greg_t gregset_t[NGREG];
++
++#ifdef CONFIG_FPU
++typedef struct fpregset {
++	int f_pcr;
++	int f_psr;
++	int f_fpiaddr;
++	int f_fpregs[8][3];
++} fpregset_t;
++#endif
++
++struct mcontext {
++	int version;
++	int status_extension;
++	gregset_t gregs;
++#ifdef CONFIG_FPU
++	fpregset_t fpregs;
++#endif
++};
++
++#define MCONTEXT_VERSION 2
++
++struct ucontext {
++	unsigned long	  uc_flags;
++	struct ucontext  *uc_link;
++	stack_t		  uc_stack;
++	struct mcontext	  uc_mcontext;
++#ifdef CONFIG_FPU
++	unsigned long	  uc_filler[80];
++#endif
++	sigset_t	  uc_sigmask;	/* mask last for extensibility */
++};
++
++#endif
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/unaligned.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/unaligned.h	2004-02-26 15:43:36.000000000 +0100
+@@ -0,0 +1,43 @@
++#ifndef __NIOS_UNALIGNED_H
++#define __NIOS_UNALIGNED_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/unaligned.h
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++/*
++ * The nios cannot do unaligned accesses itself. 
++ */ 
++
++#define get_unaligned(ptr) ({			\
++	typeof((*(ptr))) x;			\
++	memcpy(&x, (void*)ptr, sizeof(*(ptr)));	\
++	x;					\
++})
++
++#define put_unaligned(val, ptr) ({		\
++	typeof((*(ptr))) x = val;		\
++	memcpy((void*)ptr, &x, sizeof(*(ptr)));	\
++})
++
++#endif /* __NIOS_UNALIGNED_H */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/unistd.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/unistd.h	2004-12-23 15:46:22.000000000 +0100
+@@ -0,0 +1,686 @@
++#ifndef _ASM_NIOS_UNISTD_H_
++#define _ASM_NIOS_UNISTD_H_
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/unistd.h
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * //vic - kernel_thread moved to process.c
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++#include <asm/traps.h>
++
++/* TRAP isr expects the trap# (syscall=#TRAP_ID_SYSCALL) in r2,
++ *  the syscall # in r3, and arguments in r4, r5, ...
++ * Return argument expected in r2.
++ */
++
++#define __NR_restart_syscall      0
++#define __NR_exit		  1
++#define __NR_fork		  2
++#define __NR_read		  3
++#define __NR_write		  4
++#define __NR_open		  5
++#define __NR_close		  6
++#define __NR_waitpid		  7
++#define __NR_creat		  8
++#define __NR_link		  9
++#define __NR_unlink		 10
++#define __NR_execve		 11
++#define __NR_chdir		 12
++#define __NR_time		 13
++#define __NR_mknod		 14
++#define __NR_chmod		 15
++#define __NR_chown		 16
++#define __NR_break		 17
++#define __NR_oldstat		 18
++#define __NR_lseek		 19
++#define __NR_getpid		 20
++#define __NR_mount		 21
++#define __NR_umount		 22
++#define __NR_setuid		 23
++#define __NR_getuid		 24
++#define __NR_stime		 25
++#define __NR_ptrace		 26
++#define __NR_alarm		 27
++#define __NR_oldfstat		 28
++#define __NR_pause		 29
++#define __NR_utime		 30
++#define __NR_stty		 31
++#define __NR_gtty		 32
++#define __NR_access		 33
++#define __NR_nice		 34
++#define __NR_ftime		 35
++#define __NR_sync		 36
++#define __NR_kill		 37
++#define __NR_rename		 38
++#define __NR_mkdir		 39
++#define __NR_rmdir		 40
++#define __NR_dup		 41
++#define __NR_pipe		 42
++#define __NR_times		 43
++#define __NR_prof		 44
++#define __NR_brk		 45
++#define __NR_setgid		 46
++#define __NR_getgid		 47
++#define __NR_signal		 48
++#define __NR_geteuid		 49
++#define __NR_getegid		 50
++#define __NR_acct		 51
++#define __NR_umount2		 52	//vic #define __NR_phys		 52
++#define __NR_lock		 53
++#define __NR_ioctl		 54
++#define __NR_fcntl		 55
++#define __NR_mpx		 56
++#define __NR_setpgid		 57
++#define __NR_ulimit		 58
++#define __NR_oldolduname	 59
++#define __NR_umask		 60
++#define __NR_chroot		 61
++#define __NR_ustat		 62
++#define __NR_dup2		 63
++#define __NR_getppid		 64
++#define __NR_getpgrp		 65
++#define __NR_setsid		 66
++#define __NR_sigaction		 67
++#define __NR_sgetmask		 68
++#define __NR_ssetmask		 69
++#define __NR_setreuid		 70
++#define __NR_setregid		 71
++#define __NR_sigsuspend		 72
++#define __NR_sigpending		 73
++#define __NR_sethostname	 74
++#define __NR_setrlimit		 75
++#define __NR_getrlimit		 76
++#define __NR_getrusage		 77
++#define __NR_gettimeofday	 78
++#define __NR_settimeofday	 79
++#define __NR_getgroups		 80
++#define __NR_setgroups		 81
++#define __NR_select		 82
++#define __NR_symlink		 83
++#define __NR_oldlstat		 84
++#define __NR_readlink		 85
++#define __NR_uselib		 86
++#define __NR_swapon		 87
++#define __NR_reboot		 88
++#define __NR_readdir		 89
++#define __NR_mmap		 90
++#define __NR_munmap		 91
++#define __NR_truncate		 92
++#define __NR_ftruncate		 93
++#define __NR_fchmod		 94
++#define __NR_fchown		 95
++#define __NR_getpriority	 96
++#define __NR_setpriority	 97
++#define __NR_profil		 98
++#define __NR_statfs		 99
++#define __NR_fstatfs		100
++#define __NR_ioperm		101
++#define __NR_socketcall		102
++#define __NR_syslog		103
++#define __NR_setitimer		104
++#define __NR_getitimer		105
++#define __NR_stat		106
++#define __NR_lstat		107
++#define __NR_fstat		108
++#define __NR_olduname		109
++#define __NR_iopl		/* 110 */ not supported
++#define __NR_vhangup		111
++#define __NR_idle		/* 112 */ Obsolete
++#define __NR_vm86		/* 113 */ not supported
++#define __NR_wait4		114
++#define __NR_swapoff		115
++#define __NR_sysinfo		116
++#define __NR_ipc		117
++#define __NR_fsync		118
++#define __NR_sigreturn		119
++#define __NR_clone		120
++#define __NR_setdomainname	121
++#define __NR_uname		122
++#define __NR_cacheflush		123
++#define __NR_adjtimex		124
++#define __NR_mprotect		125
++#define __NR_sigprocmask	126
++#define __NR_create_module	127
++#define __NR_init_module	128
++#define __NR_delete_module	129
++#define __NR_get_kernel_syms	130
++#define __NR_quotactl		131
++#define __NR_getpgid		132
++#define __NR_fchdir		133
++#define __NR_bdflush		134
++#define __NR_sysfs		135
++#define __NR_personality	136
++#define __NR_afs_syscall	137 /* Syscall for Andrew File System */
++#define __NR_setfsuid		138
++#define __NR_setfsgid		139
++#define __NR__llseek		140
++#define __NR_getdents		141
++#define __NR__newselect		142
++#define __NR_flock		143
++#define __NR_msync		144
++#define __NR_readv		145
++#define __NR_writev		146
++#define __NR_getsid		147
++#define __NR_fdatasync		148
++#define __NR__sysctl		149
++#define __NR_mlock		150
++#define __NR_munlock		151
++#define __NR_mlockall		152
++#define __NR_munlockall		153
++#define __NR_sched_setparam		154
++#define __NR_sched_getparam		155
++#define __NR_sched_setscheduler		156
++#define __NR_sched_getscheduler		157
++#define __NR_sched_yield		158
++#define __NR_sched_get_priority_max	159
++#define __NR_sched_get_priority_min	160
++#define __NR_sched_rr_get_interval	161
++#define __NR_nanosleep		162
++#define __NR_mremap		163
++#define __NR_setresuid		164
++#define __NR_getresuid		165
++#define __NR_getpagesize	166
++#define __NR_query_module	167
++#define __NR_poll		168
++#define __NR_nfsservctl		169
++#define __NR_setresgid		170
++#define __NR_getresgid		171
++#define __NR_prctl		172
++#define __NR_rt_sigreturn	173
++#define __NR_rt_sigaction	174
++#define __NR_rt_sigprocmask	175
++#define __NR_rt_sigpending	176
++#define __NR_rt_sigtimedwait	177
++#define __NR_rt_sigqueueinfo	178
++#define __NR_rt_sigsuspend	179
++#define __NR_pread		180
++#define __NR_pwrite		181
++#define __NR_lchown		182
++#define __NR_getcwd		183
++#define __NR_capget		184
++#define __NR_capset		185
++#define __NR_sigaltstack	186
++#define __NR_sendfile		187
++#define __NR_getpmsg		188	/* some people actually want streams */
++#define __NR_putpmsg		189	/* some people actually want streams */
++#define __NR_vfork		190
++#define __NR_ugetrlimit		191
++#define __NR_mmap2		192
++#define __NR_truncate64		193
++#define __NR_ftruncate64	194
++#define __NR_stat64		195
++#define __NR_lstat64		196
++#define __NR_fstat64		197
++#define __NR_chown32		198
++#define __NR_getuid32		199
++#define __NR_getgid32		200
++#define __NR_geteuid32		201
++#define __NR_getegid32		202
++#define __NR_setreuid32		203
++#define __NR_setregid32		204
++#define __NR_getgroups32	205
++#define __NR_setgroups32	206
++#define __NR_fchown32		207
++#define __NR_setresuid32	208
++#define __NR_getresuid32	209
++#define __NR_setresgid32	210
++#define __NR_getresgid32	211
++#define __NR_lchown32		212
++#define __NR_setuid32		213
++#define __NR_setgid32		214
++#define __NR_setfsuid32		215
++#define __NR_setfsgid32		216
++#define __NR_pivot_root		217
++/* 218 unused */
++/* 219 unused */
++#define __NR_getdents64		220
++#define __NR_gettid		221
++#define __NR_tkill		222
++#define __NR_setxattr		223
++#define __NR_lsetxattr		224
++#define __NR_fsetxattr		225
++#define __NR_getxattr		226
++#define __NR_lgetxattr		227
++#define __NR_fgetxattr		228
++#define __NR_listxattr		229
++#define __NR_llistxattr		230
++#define __NR_flistxattr		231
++#define __NR_removexattr	232
++#define __NR_lremovexattr	233
++#define __NR_fremovexattr	234
++#define __NR_futex		235
++#define __NR_sendfile64		236
++#define __NR_mincore		237
++#define __NR_madvise		238
++#define __NR_fcntl64		239
++#define __NR_readahead		240
++#define __NR_io_setup		241
++#define __NR_io_destroy		242
++#define __NR_io_getevents	243
++#define __NR_io_submit		244
++#define __NR_io_cancel		245
++#define __NR_fadvise64		246
++#define __NR_exit_group		247
++#define __NR_lookup_dcookie	248
++#define __NR_epoll_create	249
++#define __NR_epoll_ctl		250
++#define __NR_epoll_wait		251
++#define __NR_remap_file_pages	252
++#define __NR_set_tid_address	253
++#define __NR_timer_create	254
++#define __NR_timer_settime	255
++#define __NR_timer_gettime	256
++#define __NR_timer_getoverrun	257
++#define __NR_timer_delete	258
++#define __NR_clock_settime	259
++#define __NR_clock_gettime	260
++#define __NR_clock_getres	261
++#define __NR_clock_nanosleep	262
++#define __NR_statfs64		263
++#define __NR_fstatfs64		264
++#define __NR_tgkill		265
++#define __NR_utimes		266
++#define __NR_fadvise64_64	267
++#define __NR_mbind		268
++#define __NR_get_mempolicy	269
++#define __NR_set_mempolicy	270
++#define __NR_mq_open		271
++#define __NR_mq_unlink		272
++#define __NR_mq_timedsend	273
++#define __NR_mq_timedreceive	274
++#define __NR_mq_notify		275
++#define __NR_mq_getsetattr	276
++#define __NR_waitid		277
++#define __NR_sys_setaltroot	278
++#define __NR_add_key		279
++#define __NR_request_key	280
++#define __NR_keyctl		281
++
++#define NR_syscalls		282
++
++/* user-visible error numbers are in the range -1 - -122: see
++   <asm-nios2nommu/errno.h> */
++
++#define __syscall_return(type, res) \
++do { \
++	if ((unsigned long)(res) >= (unsigned long)(-125)) { \
++                                                                        \
++                /* avoid using res which is declared to be in           \
++                    register r2; errno might expand to a function       \
++                    call and clobber it.                          */    \
++                                                                        \
++		int __err = -(res); \
++		errno = __err; \
++		res = -1; \
++	} \
++	return (type) (res); \
++} while (0)
++
++#define _syscall0(type,name) \
++type name(void) \
++{ \
++    long __res;                                             \
++                                                            \
++    __asm__ __volatile__ (                                  \
++                                                            \
++        "    \n\t"                                          \
++                                                            \
++        "    movi    r2,    %2\n\t"   /* TRAP_ID_SYSCALL */ \
++        "    movi    r3,    %1\n\t"   /* __NR_##name     */ \
++                                                            \
++        "    trap\n\t"                                      \
++        "    mov     %0,    r2\n\t"   /* syscall rtn     */ \
++                                                            \
++        "    \n\t"                                          \
++                                                            \
++        :   "=r" (__res)              /* %0              */ \
++                                                            \
++        :   "i" (__NR_##name)         /* %1              */ \
++          , "i" (TRAP_ID_SYSCALL)     /* %2              */ \
++                                                            \
++        :   "r2"                      /* Clobbered       */ \
++          , "r3"                      /* Clobbered       */ \
++        );                                                  \
++                                                            \
++__syscall_return(type,__res); \
++}
++
++//;dgt2;tmp;can we RELY on syscall1 arg a
++//;dgt2;tmp; already being in r4 ?
++#define _syscall1(type,name,atype,a) \
++type name(atype a) \
++{ \
++    long __res;                                             \
++                                                            \
++    __asm__ __volatile__ (                                  \
++                                                            \
++        "    \n\t"                                          \
++                                                            \
++        "    movi    r2,    %2\n\t"   /* TRAP_ID_SYSCALL */ \
++        "    movi    r3,    %1\n\t"   /* __NR_##name     */ \
++        "    mov     r4,    %3\n\t"   /* (long) a        */ \
++                                                            \
++        "    trap\n\t"                                      \
++        "    mov     %0,    r2\n\t"   /* syscall rtn     */ \
++                                                            \
++        "    \n\t"                                          \
++                                                            \
++        :   "=r" (__res)              /* %0              */ \
++                                                            \
++        :   "i" (__NR_##name)         /* %1              */ \
++          , "i" (TRAP_ID_SYSCALL)     /* %2              */ \
++          , "r" ((long) a)            /* %3              */ \
++                                                            \
++        :   "r2"                      /* Clobbered       */ \
++          , "r3"                      /* Clobbered       */ \
++          , "r4"                      /* Clobbered       */ \
++        );                                                  \
++                                                            \
++__syscall_return(type,__res); \
++}
++
++//;dgt2;tmp;can we RELY on syscall2 args a,b
++//;dgt2;tmp; already being in r4,r5 ?
++#define _syscall2(type,name,atype,a,btype,b) \
++type name(atype a,btype b) \
++{ \
++    long __res;                                             \
++                                                            \
++    __asm__ __volatile__ (                                  \
++                                                            \
++        "    \n\t"                                          \
++                                                            \
++        "    movi    r2,    %2\n\t"   /* TRAP_ID_SYSCALL */ \
++        "    movi    r3,    %1\n\t"   /* __NR_##name     */ \
++        "    mov     r4,    %3\n\t"   /* (long) a        */ \
++        "    mov     r5,    %4\n\t"   /* (long) b        */ \
++                                                            \
++        "    trap\n\t"                                      \
++        "    mov     %0,    r2\n\t"   /* syscall rtn     */ \
++                                                            \
++        "    \n\t"                                          \
++                                                            \
++        :   "=r" (__res)              /* %0              */ \
++                                                            \
++        :   "i" (__NR_##name)         /* %1              */ \
++          , "i" (TRAP_ID_SYSCALL)     /* %2              */ \
++          , "r" ((long) a)            /* %3              */ \
++          , "r" ((long) b)            /* %4              */ \
++                                                            \
++        :   "r2"                      /* Clobbered       */ \
++          , "r3"                      /* Clobbered       */ \
++          , "r4"                      /* Clobbered       */ \
++          , "r5"                      /* Clobbered       */ \
++        );                                                  \
++                                                            \
++__syscall_return(type,__res); \
++}
++
++//;dgt2;tmp;can we RELY on syscall3 args a,b,c
++//;dgt2;tmp; already being in r4,r5,r6 ?
++#define _syscall3(type,name,atype,a,btype,b,ctype,c) \
++type name(atype a,btype b,ctype c) \
++{ \
++    long __res;                                             \
++                                                            \
++    __asm__ __volatile__ (                                  \
++                                                            \
++        "    \n\t"                                          \
++                                                            \
++        "    movi    r2,    %2\n\t"   /* TRAP_ID_SYSCALL */ \
++        "    movi    r3,    %1\n\t"   /* __NR_##name     */ \
++        "    mov     r4,    %3\n\t"   /* (long) a        */ \
++        "    mov     r5,    %4\n\t"   /* (long) b        */ \
++        "    mov     r6,    %5\n\t"   /* (long) c        */ \
++                                                            \
++        "    trap\n\t"                                      \
++        "    mov     %0,    r2\n\t"   /* syscall rtn     */ \
++                                                            \
++        "    \n\t"                                          \
++                                                            \
++        :   "=r" (__res)              /* %0              */ \
++                                                            \
++        :   "i" (__NR_##name)         /* %1              */ \
++          , "i" (TRAP_ID_SYSCALL)     /* %2              */ \
++          , "r" ((long) a)            /* %3              */ \
++          , "r" ((long) b)            /* %4              */ \
++          , "r" ((long) c)            /* %5              */ \
++                                                            \
++        :   "r2"                      /* Clobbered       */ \
++          , "r3"                      /* Clobbered       */ \
++          , "r4"                      /* Clobbered       */ \
++          , "r5"                      /* Clobbered       */ \
++          , "r6"                      /* Clobbered       */ \
++        );                                                  \
++                                                            \
++__syscall_return(type,__res); \
++}
++
++//;dgt2;tmp;can we RELY on syscall4 args a,b,c,d
++//;dgt2;tmp; already being in r4,r5,r6,r7 ?
++#define _syscall4(type,name,atype,a,btype,b,ctype,c,dtype,d) \
++type name (atype a, btype b, ctype c, dtype d) \
++{ \
++    long __res;                                             \
++                                                            \
++    __asm__ __volatile__ (                                  \
++                                                            \
++        "    \n\t"                                          \
++                                                            \
++        "    movi    r2,    %2\n\t"   /* TRAP_ID_SYSCALL */ \
++        "    movi    r3,    %1\n\t"   /* __NR_##name     */ \
++        "    mov     r4,    %3\n\t"   /* (long) a        */ \
++        "    mov     r5,    %4\n\t"   /* (long) b        */ \
++        "    mov     r6,    %5\n\t"   /* (long) c        */ \
++        "    mov     r7,    %6\n\t"   /* (long) d        */ \
++                                                            \
++        "    trap\n\t"                                      \
++        "    mov     %0,    r2\n\t"   /* syscall rtn     */ \
++                                                            \
++        "    \n\t"                                          \
++                                                            \
++        :   "=r" (__res)              /* %0              */ \
++                                                            \
++        :   "i" (__NR_##name)         /* %1              */ \
++          , "i" (TRAP_ID_SYSCALL)     /* %2              */ \
++          , "r" ((long) a)            /* %3              */ \
++          , "r" ((long) b)            /* %4              */ \
++          , "r" ((long) c)            /* %5              */ \
++          , "r" ((long) d)            /* %6              */ \
++                                                            \
++        :   "r2"                      /* Clobbered       */ \
++          , "r3"                      /* Clobbered       */ \
++          , "r4"                      /* Clobbered       */ \
++          , "r5"                      /* Clobbered       */ \
++          , "r6"                      /* Clobbered       */ \
++          , "r7"                      /* Clobbered       */ \
++        );                                                  \
++                                                            \
++__syscall_return(type,__res); \
++}
++
++//;dgt2;tmp;can we RELY on syscall5 args a,b,c,d
++//;dgt2;tmp; already being in r4,r5,r6,r7 ?
++#define _syscall5(type,name,atype,a,btype,b,ctype,c,dtype,d,etype,e) \
++type name (atype a,btype b,ctype c,dtype d,etype e) \
++{ \
++    long __res;                                             \
++                                                            \
++    __asm__ __volatile__ (                                  \
++                                                            \
++        "    \n\t"                                          \
++                                                            \
++        "    movi    r2,    %2\n\t"   /* TRAP_ID_SYSCALL */ \
++        "    movi    r3,    %1\n\t"   /* __NR_##name     */ \
++        "    mov     r4,    %3\n\t"   /* (long) a        */ \
++        "    mov     r5,    %4\n\t"   /* (long) b        */ \
++        "    mov     r6,    %5\n\t"   /* (long) c        */ \
++        "    mov     r7,    %6\n\t"   /* (long) c        */ \
++        "    mov     r8,    %7\n\t"   /* (long) e        */ \
++                                                            \
++        "    trap\n\t"                                      \
++        "    mov     %0,    r2\n\t"   /* syscall rtn     */ \
++                                                            \
++        "    \n\t"                                          \
++                                                            \
++        :   "=r" (__res)              /* %0              */ \
++                                                            \
++        :   "i" (__NR_##name)         /* %1              */ \
++          , "i" (TRAP_ID_SYSCALL)     /* %2              */ \
++          , "r" ((long) a)            /* %3              */ \
++          , "r" ((long) b)            /* %4              */ \
++          , "r" ((long) c)            /* %5              */ \
++          , "r" ((long) d)            /* %6              */ \
++          , "r" ((long) e)            /* %7              */ \
++                                                            \
++        :   "r2"                      /* Clobbered       */ \
++          , "r3"                      /* Clobbered       */ \
++          , "r4"                      /* Clobbered       */ \
++          , "r5"                      /* Clobbered       */ \
++          , "r6"                      /* Clobbered       */ \
++          , "r7"                      /* Clobbered       */ \
++          , "r8"                      /* Clobbered       */ \
++        );                                                  \
++                                                            \
++__syscall_return(type,__res); \
++}
++
++//;dgt2;tmp;can we RELY on syscall6 args a,b,c,d
++//;dgt2;tmp; already being in r4,r5,r6,r7 ?
++#define _syscall6(type,name,atype,a,btype,b,ctype,c,dtype,d,etype,e,ftype,f) \
++type name (atype a,btype b,ctype c,dtype d,etype e,ftype f) \
++{ \
++    long __res;                                             \
++                                                            \
++    __asm__ __volatile__ (                                  \
++                                                            \
++        "    \n\t"                                          \
++                                                            \
++        "    movi    r2,    %2\n\t"   /* TRAP_ID_SYSCALL */ \
++        "    movi    r3,    %1\n\t"   /* __NR_##name     */ \
++        "    mov     r4,    %3\n\t"   /* (long) a        */ \
++        "    mov     r5,    %4\n\t"   /* (long) b        */ \
++        "    mov     r6,    %5\n\t"   /* (long) c        */ \
++        "    mov     r7,    %6\n\t"   /* (long) c        */ \
++        "    mov     r8,    %7\n\t"   /* (long) e        */ \
++        "    mov     r9,    %8\n\t"   /* (long) f        */ \
++                                                            \
++        "    trap\n\t"                                      \
++        "    mov     %0,    r2\n\t"   /* syscall rtn     */ \
++                                                            \
++        "    \n\t"                                          \
++                                                            \
++        :   "=r" (__res)              /* %0              */ \
++                                                            \
++        :   "i" (__NR_##name)         /* %1              */ \
++          , "i" (TRAP_ID_SYSCALL)     /* %2              */ \
++          , "r" ((long) a)            /* %3              */ \
++          , "r" ((long) b)            /* %4              */ \
++          , "r" ((long) c)            /* %5              */ \
++          , "r" ((long) d)            /* %6              */ \
++          , "r" ((long) e)            /* %7              */ \
++          , "r" ((long) f)            /* %8              */ \
++                                                            \
++        :   "r2"                      /* Clobbered       */ \
++          , "r3"                      /* Clobbered       */ \
++          , "r4"                      /* Clobbered       */ \
++          , "r5"                      /* Clobbered       */ \
++          , "r6"                      /* Clobbered       */ \
++          , "r7"                      /* Clobbered       */ \
++          , "r8"                      /* Clobbered       */ \
++          , "r9"                      /* Clobbered       */ \
++        );                                                  \
++                                                            \
++__syscall_return(type,__res); \
++}
++
++#ifdef __KERNEL__
++#define __ARCH_WANT_IPC_PARSE_VERSION
++#define __ARCH_WANT_OLD_READDIR
++#define __ARCH_WANT_OLD_STAT
++#define __ARCH_WANT_STAT64
++#define __ARCH_WANT_SYS_ALARM
++#define __ARCH_WANT_SYS_GETHOSTNAME
++#define __ARCH_WANT_SYS_PAUSE
++#define __ARCH_WANT_SYS_SGETMASK
++#define __ARCH_WANT_SYS_SIGNAL
++#define __ARCH_WANT_SYS_TIME
++#define __ARCH_WANT_SYS_UTIME
++#define __ARCH_WANT_SYS_WAITPID
++#define __ARCH_WANT_SYS_SOCKETCALL
++#define __ARCH_WANT_SYS_FADVISE64
++#define __ARCH_WANT_SYS_GETPGRP
++#define __ARCH_WANT_SYS_LLSEEK
++#define __ARCH_WANT_SYS_NICE
++#define __ARCH_WANT_SYS_OLD_GETRLIMIT
++#define __ARCH_WANT_SYS_OLDUMOUNT
++#define __ARCH_WANT_SYS_SIGPENDING
++#define __ARCH_WANT_SYS_SIGPROCMASK
++#define __ARCH_WANT_SYS_RT_SIGACTION
++#endif
++
++#ifdef __KERNEL_SYSCALLS__
++
++/*
++ * we need this inline - forking from kernel space will result
++ * in NO COPY ON WRITE (!!!), until an execve is executed. This
++ * is no problem, but for the stack. This is handled by not letting
++ * main() use the stack at all after fork(). Thus, no function
++ * calls - which means inline code for fork too, as otherwise we
++ * would use the stack upon exit from 'fork()'.
++ *
++ * Actually only pause and fork are needed inline, so that there
++ * won't be any messing with the stack from main(), but we define
++ * some others too.
++ */
++#define __NR__exit __NR_exit
++static inline _syscall0(int,pause)
++static inline _syscall0(int,sync)
++static inline _syscall0(pid_t,setsid)
++static inline _syscall3(int,write,int,fd,const char *,buf,off_t,count)
++static inline _syscall3(int,read,int,fd,char *,buf,off_t,count)
++static inline _syscall3(off_t,lseek,int,fd,off_t,offset,int,count)
++static inline _syscall1(int,dup,int,fd)
++static inline _syscall3(int,execve,const char *,file,char **,argv,char **,envp)
++static inline _syscall3(int,open,const char *,file,int,flag,int,mode)
++static inline _syscall1(int,close,int,fd)
++static inline _syscall1(int,_exit,int,exitcode)
++static inline _syscall3(pid_t,waitpid,pid_t,pid,int *,wait_stat,int,options)
++static inline _syscall1(int,delete_module,const char *,name)
++
++static inline pid_t wait(int * wait_stat)
++{
++	return waitpid(-1,wait_stat,0);
++}
++
++#endif
++
++/*
++ * "Conditional" syscalls
++ *
++ * What we want is __attribute__((weak,alias("sys_ni_syscall"))),
++ * but it doesn't work on all toolchains, so we just do it by hand
++ */
++#define cond_syscall(x) asm(".weak\t" #x "\n\t.set\t" #x ",sys_ni_syscall");
++
++#endif /* _ASM_NIOS_UNISTD_H_ */
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/user.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/user.h	2004-05-11 08:07:50.000000000 +0200
+@@ -0,0 +1,112 @@
++#ifndef _NIOS2NOMMU_USER_H
++#define _NIOS2NOMMU_USER_H
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/user.h
++ *
++ * Derived from M68knommu
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++#include <asm/page.h>
++
++/* Core file format: The core file is written in such a way that gdb
++   can understand it and provide useful information to the user (under
++   linux we use the 'trad-core' bfd).  There are quite a number of
++   obstacles to being able to view the contents of the floating point
++   registers, and until these are solved you will not be able to view the
++   contents of them.  Actually, you can read in the core file and look at
++   the contents of the user struct to find out what the floating point
++   registers contain.
++   The actual file contents are as follows:
++   UPAGE: 1 page consisting of a user struct that tells gdb what is present
++   in the file.  Directly after this is a copy of the task_struct, which
++   is currently not used by gdb, but it may come in useful at some point.
++   All of the registers are stored as part of the upage.  The upage should
++   always be only one page.
++   DATA: The data area is stored.  We use current->end_text to
++   current->brk to pick up all of the user variables, plus any memory
++   that may have been malloced.  No attempt is made to determine if a page
++   is demand-zero or if a page is totally unused, we just cover the entire
++   range.  All of the addresses are rounded in such a way that an integral
++   number of pages is written.
++   STACK: We need the stack information in order to get a meaningful
++   backtrace.  We need to write the data from (esp) to
++   current->start_stack, so we round each of these off in order to be able
++   to write an integer number of pages.
++   The minimum core file size is 3 pages, or 12288 bytes.
++*/
++
++struct user_m68kfp_struct {
++	unsigned long  fpregs[8*3];	/* fp0-fp7 registers */
++	unsigned long  fpcntl[3];	/* fp control regs */
++};
++
++/* This is needs more work, probably should look like gdb useage */
++struct user_regs_struct {
++	long r1,r2,r3,r4,r5,r6,r7,r8;
++	long r9,r10,r11,r12,r13,r14,r15;
++	long r16,r17,r18,r19,r20,r21,r22,r23;
++	long gp;
++	long sp;
++	long ra;
++	long fp;
++	long orig_r2;
++	long estatus;
++	long status_extension;
++	long ea;
++};
++
++	
++/* When the kernel dumps core, it starts by dumping the user struct -
++   this will be used by gdb to figure out where the data and stack segments
++   are within the file, and what virtual addresses to use. */
++struct user{
++/* We start with the registers, to mimic the way that "memory" is returned
++   from the ptrace(3,...) function.  */
++  struct user_regs_struct regs;	/* Where the registers are actually stored */
++/* ptrace does not yet supply these.  Someday.... */
++  int u_fpvalid;		/* True if math co-processor being used. */
++                                /* for this mess. Not yet used. */
++  struct user_m68kfp_struct m68kfp; /* Math Co-processor registers. */
++/* The rest of this junk is to help gdb figure out what goes where */
++  unsigned long int u_tsize;	/* Text segment size (pages). */
++  unsigned long int u_dsize;	/* Data segment size (pages). */
++  unsigned long int u_ssize;	/* Stack segment size (pages). */
++  unsigned long start_code;     /* Starting virtual address of text. */
++  unsigned long start_stack;	/* Starting virtual address of stack area.
++				   This is actually the bottom of the stack,
++				   the top of the stack is always found in the
++				   esp register.  */
++  long int signal;     		/* Signal that caused the core dump. */
++  int reserved;			/* No longer used */
++  struct user_regs_struct *u_ar0;
++				/* Used by gdb to help find the values for */
++				/* the registers. */
++  struct user_m68kfp_struct* u_fpstate;	/* Math Co-processor pointer. */
++  unsigned long magic;		/* To uniquely identify a core file */
++  char u_comm[32];		/* User command that was responsible */
++};
++#define NBPG PAGE_SIZE
++#define UPAGES 1
++#define HOST_TEXT_START_ADDR (u.start_code)
++#define HOST_STACK_END_ADDR (u.start_stack + u.u_ssize * NBPG)
++
++#endif
+--- linux-libc-headers-2.6.9.1/include/asm-nios2nommu/virtconvert.h	1970-01-01 01:00:00.000000000 +0100
++++ linux-libc-headers-2.6.9.1-nios2/include/asm-nios2nommu/virtconvert.h	2005-05-18 20:36:28.000000000 +0200
+@@ -0,0 +1,47 @@
++#ifndef __NIOS_VIRT_CONVERT__
++#define __NIOS_VIRT_CONVERT__
++
++/*--------------------------------------------------------------------
++ *
++ * include/asm-nios2nommu/virtconvert.h
++ *
++ * Derived from various works, Alpha, ix86, M68K, Sparc, ...et al
++ *
++ * Copyright (C) 2004   Microtronix Datacom Ltd
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; either version 2 of the License, or
++ * (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ *
++ * Jan/20/2004		dgt	    NiosII
++ *
++ ---------------------------------------------------------------------*/
++
++
++/*
++ * Macros used for converting between virtual and physical mappings.
++ */
++
++#ifdef __KERNEL__
++
++// #include <linux/config.h>
++#include <asm/setup.h>
++#include <asm/page.h>
++
++#define mm_ptov(vaddr)		((void *) (vaddr))
++#define mm_vtop(vaddr)		((unsigned long) (vaddr))
++#define phys_to_virt(vaddr)	((void *) (vaddr))
++#define virt_to_phys(vaddr)	((unsigned long) (vaddr))
++
++#define virt_to_bus virt_to_phys
++#define bus_to_virt phys_to_virt
++
++#endif /*__KERNEL__ */
++#endif /*__NIOS_VIRT_CONVERT__*/