From 5ebb4e6ba553bfc7ca66349a45d6ad187280dcbd Mon Sep 17 00:00:00 2001 From: Mike Frysinger Date: Tue, 10 Jan 2006 02:16:11 +0000 Subject: [PATCH] Thomas Chou says in bug 618: clean up nios2 headers and add support for 2.6.11 --- toolchain/kernel-headers/Config.in | 1 - ...eaders-2.6.11-nios2nommu.patch.conditional | 13527 ++++++++++++++++ ...headers-2.6.9-nios2nommu.patch.conditional | 532 +- 3 files changed, 13793 insertions(+), 267 deletions(-) create mode 100644 toolchain/kernel-headers/linux-libc-headers-2.6.11-nios2nommu.patch.conditional diff --git a/toolchain/kernel-headers/Config.in b/toolchain/kernel-headers/Config.in index e0303836db..5bf02bab06 100644 --- a/toolchain/kernel-headers/Config.in +++ b/toolchain/kernel-headers/Config.in @@ -32,7 +32,6 @@ choice 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 diff --git a/toolchain/kernel-headers/linux-libc-headers-2.6.11-nios2nommu.patch.conditional b/toolchain/kernel-headers/linux-libc-headers-2.6.11-nios2nommu.patch.conditional new file mode 100644 index 0000000000..b8c3fff8f0 --- /dev/null +++ b/toolchain/kernel-headers/linux-libc-headers-2.6.11-nios2nommu.patch.conditional @@ -0,0 +1,13527 @@ +--- linux/include/asm-generic/4level-fixup.h ++++ linux/include/asm-generic/4level-fixup.h +@@ -0,0 +1,34 @@ ++#ifndef _4LEVEL_FIXUP_H ++#define _4LEVEL_FIXUP_H ++ ++#define __ARCH_HAS_4LEVEL_HACK ++ ++#define PUD_SIZE PGDIR_SIZE ++#define PUD_MASK PGDIR_MASK ++#define PTRS_PER_PUD 1 ++ ++#define pud_t pgd_t ++ ++#define pmd_alloc(mm, pud, address) \ ++({ pmd_t *ret; \ ++ if (pgd_none(*pud)) \ ++ ret = __pmd_alloc(mm, pud, address); \ ++ else \ ++ ret = pmd_offset(pud, address); \ ++ ret; \ ++}) ++ ++#define pud_alloc(mm, pgd, address) (pgd) ++#define pud_offset(pgd, start) (pgd) ++#define pud_none(pud) 0 ++#define pud_bad(pud) 0 ++#define pud_present(pud) 1 ++#define pud_ERROR(pud) do { } while (0) ++#define pud_clear(pud) pgd_clear(pud) ++ ++#undef pud_free_tlb ++#define pud_free_tlb(tlb, x) do { } while (0) ++#define pud_free(x) do { } while (0) ++#define __pud_free_tlb(tlb, x) do { } while (0) ++ ++#endif +--- linux/include/asm-generic/bitops.h ++++ linux/include/asm-generic/bitops.h +@@ -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/include/asm-generic/bug.h ++++ linux/include/asm-generic/bug.h +@@ -0,0 +1,34 @@ ++#ifndef _ASM_GENERIC_BUG_H ++#define _ASM_GENERIC_BUG_H ++ ++#include ++// #include ++ ++#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/include/asm-generic/cpumask_arith.h ++++ linux/include/asm-generic/cpumask_arith.h +@@ -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/include/asm-generic/cpumask_array.h ++++ linux/include/asm-generic/cpumask_array.h +@@ -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/include/asm-generic/cpumask_const_reference.h ++++ linux/include/asm-generic/cpumask_const_reference.h +@@ -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/include/asm-generic/cpumask_const_value.h ++++ linux/include/asm-generic/cpumask_const_value.h +@@ -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/include/asm-generic/cpumask.h ++++ linux/include/asm-generic/cpumask.h +@@ -0,0 +1,40 @@ ++#ifndef __ASM_GENERIC_CPUMASK_H ++#define __ASM_GENERIC_CPUMASK_H ++ ++// #include ++#include ++#include ++#include ++#include ++ ++#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 ++#else ++#include ++#endif ++#else ++#include ++#endif ++ ++#if NR_CPUS <= 4*BITS_PER_LONG ++#include ++#else ++#include ++#endif ++ ++#endif /* __ASM_GENERIC_CPUMASK_H */ +--- linux/include/asm-generic/cpumask_up.h ++++ linux/include/asm-generic/cpumask_up.h +@@ -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/include/asm-generic/cputime.h ++++ linux/include/asm-generic/cputime.h +@@ -0,0 +1,64 @@ ++#ifndef _ASM_GENERIC_CPUTIME_H ++#define _ASM_GENERIC_CPUTIME_H ++ ++#include ++#include ++ ++typedef unsigned long cputime_t; ++ ++#define cputime_zero (0UL) ++#define cputime_max ((~0UL >> 1) - 1) ++#define cputime_add(__a, __b) ((__a) + (__b)) ++#define cputime_sub(__a, __b) ((__a) - (__b)) ++#define cputime_eq(__a, __b) ((__a) == (__b)) ++#define cputime_gt(__a, __b) ((__a) > (__b)) ++#define cputime_ge(__a, __b) ((__a) >= (__b)) ++#define cputime_lt(__a, __b) ((__a) < (__b)) ++#define cputime_le(__a, __b) ((__a) <= (__b)) ++#define cputime_to_jiffies(__ct) (__ct) ++#define jiffies_to_cputime(__hz) (__hz) ++ ++typedef u64 cputime64_t; ++ ++#define cputime64_zero (0ULL) ++#define cputime64_add(__a, __b) ((__a) + (__b)) ++#define cputime64_to_jiffies64(__ct) (__ct) ++#define cputime_to_cputime64(__ct) ((u64) __ct) ++ ++ ++/* ++ * Convert cputime to milliseconds and back. ++ */ ++#define cputime_to_msecs(__ct) jiffies_to_msecs(__ct) ++#define msecs_to_cputime(__msecs) msecs_to_jiffies(__msecs) ++ ++/* ++ * Convert cputime to seconds and back. ++ */ ++#define cputime_to_secs(jif) ((jif) / HZ) ++#define secs_to_cputime(sec) ((sec) * HZ) ++ ++/* ++ * Convert cputime to timespec and back. ++ */ ++#define timespec_to_cputime(__val) timespec_to_jiffies(__val) ++#define cputime_to_timespec(__ct,__val) jiffies_to_timespec(__ct,__val) ++ ++/* ++ * Convert cputime to timeval and back. ++ */ ++#define timeval_to_cputime(__val) timeval_to_jiffies(__val) ++#define cputime_to_timeval(__ct,__val) jiffies_to_timeval(__ct,__val) ++ ++/* ++ * Convert cputime to clock and back. ++ */ ++#define cputime_to_clock_t(__ct) jiffies_to_clock_t(__ct) ++#define clock_t_to_cputime(__x) clock_t_to_jiffies(__x) ++ ++/* ++ * Convert cputime64 to clock. ++ */ ++#define cputime64_to_clock_t(__ct) jiffies_64_to_clock_t(__ct) ++ ++#endif +--- linux/include/asm-generic/div64.h ++++ linux/include/asm-generic/div64.h +@@ -0,0 +1,58 @@ ++#ifndef _ASM_GENERIC_DIV64_H ++#define _ASM_GENERIC_DIV64_H ++/* ++ * Copyright (C) 2003 Bernardo Innocenti ++ * 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 ++#include ++ ++#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/include/asm-generic/dma-mapping-broken.h ++++ linux/include/asm-generic/dma-mapping-broken.h +@@ -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 NULL; ++} ++ ++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/include/asm-generic/dma-mapping.h ++++ linux/include/asm-generic/dma-mapping.h +@@ -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 ++ ++#ifdef CONFIG_PCI ++ ++/* we implement the API below in terms of the existing PCI one, ++ * so include it */ ++#include ++/* need struct page definitions */ ++#include ++ ++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/include/asm-generic/errno-base.h ++++ linux/include/asm-generic/errno-base.h +@@ -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/include/asm-generic/errno.h ++++ linux/include/asm-generic/errno.h +@@ -0,0 +1,105 @@ ++#ifndef _ASM_GENERIC_ERRNO_H ++#define _ASM_GENERIC_ERRNO_H ++ ++#include ++ ++#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 */ ++#define ECANCELED 125 /* Operation Canceled */ ++#define ENOKEY 126 /* Required key not available */ ++#define EKEYEXPIRED 127 /* Key has expired */ ++#define EKEYREVOKED 128 /* Key has been revoked */ ++#define EKEYREJECTED 129 /* Key was rejected by service */ ++ ++#endif +--- linux/include/asm-generic/hdreg.h ++++ linux/include/asm-generic/hdreg.h +@@ -0,0 +1,8 @@ ++#warning 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/include/asm-generic/ide_iops.h ++++ linux/include/asm-generic/ide_iops.h +@@ -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/include/asm-generic/iomap.h ++++ linux/include/asm-generic/iomap.h +@@ -0,0 +1,63 @@ ++#ifndef __GENERIC_IO_H ++#define __GENERIC_IO_H ++ ++#include ++ ++/* ++ * 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 . ++ */ ++ ++/* ++ * 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/include/asm-generic/local.h ++++ linux/include/asm-generic/local.h +@@ -0,0 +1,118 @@ ++#ifndef _ASM_GENERIC_LOCAL_H ++#define _ASM_GENERIC_LOCAL_H ++ ++// #include ++#include ++#include ++#include ++ ++/* 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/include/asm-generic/pci-dma-compat.h ++++ linux/include/asm-generic/pci-dma-compat.h +@@ -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 ++ ++/* 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/include/asm-generic/pci.h ++++ linux/include/asm-generic/pci.h +@@ -0,0 +1,34 @@ ++/* ++ * 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 ++ ++#ifndef HAVE_ARCH_PCI_GET_LEGACY_IDE_IRQ ++static inline int pci_get_legacy_ide_irq(struct pci_dev *dev, int channel) ++{ ++ return channel ? 15 : 14; ++} ++#endif /* HAVE_ARCH_PCI_GET_LEGACY_IDE_IRQ */ ++ ++#endif +--- linux/include/asm-generic/percpu.h ++++ linux/include/asm-generic/percpu.h +@@ -0,0 +1,42 @@ ++#ifndef _ASM_GENERIC_PERCPU_H_ ++#define _ASM_GENERIC_PERCPU_H_ ++#include ++ ++#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/include/asm-generic/pgtable.h ++++ linux/include/asm-generic/pgtable.h +@@ -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/include/asm-generic/pgtable-nopmd.h ++++ linux/include/asm-generic/pgtable-nopmd.h +@@ -0,0 +1,60 @@ ++#ifndef _PGTABLE_NOPMD_H ++#define _PGTABLE_NOPMD_H ++ ++#ifndef __ASSEMBLY__ ++ ++#include ++ ++/* ++ * Having the pmd type consist of a pud gets the size right, and allows ++ * us to conceptually access the pud entry that this pmd is folded into ++ * without casting. ++ */ ++typedef struct { pud_t pud; } pmd_t; ++ ++#define PMD_SHIFT PUD_SHIFT ++#define PTRS_PER_PMD 1 ++#define PMD_SIZE (1UL << PMD_SHIFT) ++#define PMD_MASK (~(PMD_SIZE-1)) ++ ++/* ++ * The "pud_xxx()" functions here are trivial for a folded two-level ++ * setup: the pmd is never bad, and a pmd always exists (as it's folded ++ * into the pud entry) ++ */ ++static inline int pud_none(pud_t pud) { return 0; } ++static inline int pud_bad(pud_t pud) { return 0; } ++static inline int pud_present(pud_t pud) { return 1; } ++static inline void pud_clear(pud_t *pud) { } ++#define pmd_ERROR(pmd) (pud_ERROR((pmd).pud)) ++ ++#define pud_populate(mm, pmd, pte) do { } while (0) ++ ++/* ++ * (pmds are folded into puds so this doesn't get actually called, ++ * but the define is needed for a generic inline function.) ++ */ ++#define set_pud(pudptr, pudval) set_pmd((pmd_t *)(pudptr), (pmd_t) { pudval }) ++ ++static inline pmd_t * pmd_offset(pud_t * pud, unsigned long address) ++{ ++ return (pmd_t *)pud; ++} ++ ++#define pmd_val(x) (pud_val((x).pud)) ++#define __pmd(x) ((pmd_t) { __pud(x) } ) ++ ++#define pud_page(pud) (pmd_page((pmd_t){ pud })) ++#define pud_page_kernel(pud) (pmd_page_kernel((pmd_t){ pud })) ++ ++/* ++ * allocating and freeing a pmd is trivial: the 1-entry pmd is ++ * inside the pud, so has no extra memory associated with it. ++ */ ++#define pmd_alloc_one(mm, address) NULL ++#define pmd_free(x) do { } while (0) ++#define __pmd_free_tlb(tlb, x) do { } while (0) ++ ++#endif /* __ASSEMBLY__ */ ++ ++#endif /* _PGTABLE_NOPMD_H */ +--- linux/include/asm-generic/pgtable-nopud.h ++++ linux/include/asm-generic/pgtable-nopud.h +@@ -0,0 +1,56 @@ ++#ifndef _PGTABLE_NOPUD_H ++#define _PGTABLE_NOPUD_H ++ ++#ifndef __ASSEMBLY__ ++ ++/* ++ * Having the pud type consist of a pgd gets the size right, and allows ++ * us to conceptually access the pgd entry that this pud is folded into ++ * without casting. ++ */ ++typedef struct { pgd_t pgd; } pud_t; ++ ++#define PUD_SHIFT PGDIR_SHIFT ++#define PTRS_PER_PUD 1 ++#define PUD_SIZE (1UL << PUD_SHIFT) ++#define PUD_MASK (~(PUD_SIZE-1)) ++ ++/* ++ * The "pgd_xxx()" functions here are trivial for a folded two-level ++ * setup: the pud is never bad, and a pud always exists (as it's folded ++ * into the pgd entry) ++ */ ++static inline int pgd_none(pgd_t pgd) { return 0; } ++static inline int pgd_bad(pgd_t pgd) { return 0; } ++static inline int pgd_present(pgd_t pgd) { return 1; } ++static inline void pgd_clear(pgd_t *pgd) { } ++#define pud_ERROR(pud) (pgd_ERROR((pud).pgd)) ++ ++#define pgd_populate(mm, pgd, pud) do { } while (0) ++/* ++ * (puds are folded into pgds so this doesn't get actually called, ++ * but the define is needed for a generic inline function.) ++ */ ++#define set_pgd(pgdptr, pgdval) set_pud((pud_t *)(pgdptr), (pud_t) { pgdval }) ++ ++static inline pud_t * pud_offset(pgd_t * pgd, unsigned long address) ++{ ++ return (pud_t *)pgd; ++} ++ ++#define pud_val(x) (pgd_val((x).pgd)) ++#define __pud(x) ((pud_t) { __pgd(x) } ) ++ ++#define pgd_page(pgd) (pud_page((pud_t){ pgd })) ++#define pgd_page_kernel(pgd) (pud_page_kernel((pud_t){ pgd })) ++ ++/* ++ * allocating and freeing a pud is trivial: the 1-entry pud is ++ * inside the pgd, so has no extra memory associated with it. ++ */ ++#define pud_alloc_one(mm, address) NULL ++#define pud_free(x) do { } while (0) ++#define __pud_free_tlb(tlb, x) do { } while (0) ++ ++#endif /* __ASSEMBLY__ */ ++#endif /* _PGTABLE_NOPUD_H */ +--- linux/include/asm-generic/resource.h ++++ linux/include/asm-generic/resource.h +@@ -0,0 +1,60 @@ ++#ifndef _ASM_GENERIC_RESOURCE_H ++#define _ASM_GENERIC_RESOURCE_H ++ ++/* ++ * Resource limits ++ */ ++ ++/* Allow arch to control resource order */ ++#ifndef __ARCH_RLIMIT_ORDER ++#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 ++#endif ++ ++/* ++ * SuS says limits have to be unsigned. ++ * Which makes a ton more sense anyway. ++ */ ++#ifndef RLIM_INFINITY ++#define RLIM_INFINITY (~0UL) ++#endif ++ ++#ifndef _STK_LIM_MAX ++#define _STK_LIM_MAX RLIM_INFINITY ++#endif ++ ++#ifdef __KERNEL__ ++ ++#define INIT_RLIMITS \ ++{ \ ++ [RLIMIT_CPU] = { RLIM_INFINITY, RLIM_INFINITY }, \ ++ [RLIMIT_FSIZE] = { RLIM_INFINITY, RLIM_INFINITY }, \ ++ [RLIMIT_DATA] = { RLIM_INFINITY, RLIM_INFINITY }, \ ++ [RLIMIT_STACK] = { _STK_LIM, _STK_LIM_MAX }, \ ++ [RLIMIT_CORE] = { 0, RLIM_INFINITY }, \ ++ [RLIMIT_RSS] = { RLIM_INFINITY, RLIM_INFINITY }, \ ++ [RLIMIT_NPROC] = { 0, 0 }, \ ++ [RLIMIT_NOFILE] = { INR_OPEN, INR_OPEN }, \ ++ [RLIMIT_MEMLOCK] = { MLOCK_LIMIT, MLOCK_LIMIT }, \ ++ [RLIMIT_AS] = { RLIM_INFINITY, RLIM_INFINITY }, \ ++ [RLIMIT_LOCKS] = { RLIM_INFINITY, RLIM_INFINITY }, \ ++ [RLIMIT_SIGPENDING] = { MAX_SIGPENDING, MAX_SIGPENDING }, \ ++ [RLIMIT_MSGQUEUE] = { MQ_BYTES_MAX, MQ_BYTES_MAX }, \ ++} ++ ++#endif /* __KERNEL__ */ ++ ++#endif +--- linux/include/asm-generic/rmap.h ++++ linux/include/asm-generic/rmap.h +@@ -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 ++ ++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/include/asm-generic/rtc.h ++++ linux/include/asm-generic/rtc.h +@@ -0,0 +1,213 @@ ++/* ++ * inclue/asm-generic/rtc.h ++ * ++ * Author: Tom Rini ++ * ++ * 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 ++#include ++#include ++ ++#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/include/asm-generic/sections.h ++++ linux/include/asm-generic/sections.h +@@ -0,0 +1,13 @@ ++#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[]; ++extern char _end[]; ++ ++#endif /* _ASM_GENERIC_SECTIONS_H_ */ +--- linux/include/asm-generic/siginfo.h ++++ linux/include/asm-generic/siginfo.h +@@ -0,0 +1,288 @@ ++#ifndef _ASM_GENERIC_SIGINFO_H ++#define _ASM_GENERIC_SIGINFO_H ++ ++#include ++#include ++#include ++ ++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) ++ ++/* ++ * 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 ++ ++/* ++ * 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 ++ ++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; ++ ++#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 ++ ++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/include/asm-generic/statfs.h ++++ linux/include/asm-generic/statfs.h +@@ -0,0 +1,51 @@ ++#ifndef _GENERIC_STATFS_H ++#define _GENERIC_STATFS_H ++ ++#ifndef __KERNEL_STRICT_NAMES ++# include ++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/include/asm-generic/termios.h ++++ linux/include/asm-generic/termios.h +@@ -0,0 +1,69 @@ ++/* termios.h: generic termios/termio user copying/translation ++ */ ++ ++#ifndef _ASM_GENERIC_TERMIOS_H ++#define _ASM_GENERIC_TERMIOS_H ++ ++#include ++ ++#ifndef __ARCH_TERMIO_GETPUT ++ ++/* ++ * Translate a "termio" structure into a "termios". Ugh. ++ */ ++static inline int user_termio_to_kernel_termios(struct termios *termios, ++ struct termio __user *termio) ++{ ++ unsigned short tmp; ++ ++ if (get_user(tmp, &termio->c_iflag) < 0) ++ goto fault; ++ termios->c_iflag = (0xffff0000 & termios->c_iflag) | tmp; ++ ++ if (get_user(tmp, &termio->c_oflag) < 0) ++ goto fault; ++ termios->c_oflag = (0xffff0000 & termios->c_oflag) | tmp; ++ ++ if (get_user(tmp, &termio->c_cflag) < 0) ++ goto fault; ++ termios->c_cflag = (0xffff0000 & termios->c_cflag) | tmp; ++ ++ if (get_user(tmp, &termio->c_lflag) < 0) ++ goto fault; ++ termios->c_lflag = (0xffff0000 & termios->c_lflag) | tmp; ++ ++ if (get_user(termios->c_line, &termio->c_line) < 0) ++ goto fault; ++ ++ if (copy_from_user(termios->c_cc, termio->c_cc, NCC) != 0) ++ goto fault; ++ ++ return 0; ++ ++ fault: ++ return -EFAULT; ++} ++ ++/* ++ * Translate a "termios" structure into a "termio". Ugh. ++ */ ++static inline int kernel_termios_to_user_termio(struct termio __user *termio, ++ struct termios *termios) ++{ ++ if (put_user(termios->c_iflag, &termio->c_iflag) < 0 || ++ put_user(termios->c_oflag, &termio->c_oflag) < 0 || ++ put_user(termios->c_cflag, &termio->c_cflag) < 0 || ++ put_user(termios->c_lflag, &termio->c_lflag) < 0 || ++ put_user(termios->c_line, &termio->c_line) < 0 || ++ copy_to_user(termio->c_cc, termios->c_cc, NCC) != 0) ++ return -EFAULT; ++ ++ return 0; ++} ++ ++#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 /* __ARCH_TERMIO_GETPUT */ ++ ++#endif /* _ASM_GENERIC_TERMIOS_H */ +--- linux/include/asm-generic/tlb.h ++++ linux/include/asm-generic/tlb.h +@@ -0,0 +1,160 @@ ++/* 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 ++#include ++#include ++#include ++ ++/* ++ * 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) ++ ++#ifndef __ARCH_HAS_4LEVEL_HACK ++#define pud_free_tlb(tlb, pudp) \ ++ do { \ ++ tlb->need_flush = 1; \ ++ __pud_free_tlb(tlb, pudp); \ ++ } while (0) ++#endif ++ ++#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/include/asm-generic/topology.h ++++ linux/include/asm-generic/topology.h +@@ -0,0 +1,48 @@ ++/* ++ * 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 ++ */ ++#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 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 ++ ++#endif /* _ASM_GENERIC_TOPOLOGY_H */ +--- linux/include/asm-generic/uaccess.h ++++ linux/include/asm-generic/uaccess.h +@@ -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/include/asm-generic/unaligned.h ++++ linux/include/asm-generic/unaligned.h +@@ -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 ++ ++ ++#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/include/asm-generic/vmlinux.lds.h ++++ linux/include/asm-generic/vmlinux.lds.h +@@ -0,0 +1,90 @@ ++#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_early) = .; \ ++ *(.pci_fixup_early) \ ++ VMLINUX_SYMBOL(__end_pci_fixups_early) = .; \ ++ 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) = .; \ ++ VMLINUX_SYMBOL(__start_pci_fixups_enable) = .; \ ++ *(.pci_fixup_enable) \ ++ VMLINUX_SYMBOL(__end_pci_fixups_enable) = .; \ ++ } \ ++ \ ++ /* 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/include/asm-generic/xor.h ++++ linux/include/asm-generic/xor.h +@@ -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 ++ ++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/include/asm-nios2nommu/altera_juart.h ++++ linux/include/asm-nios2nommu/altera_juart.h +@@ -0,0 +1,36 @@ ++/*------------------------------------------------------------------------ ++ * ++ * linux/drivers/serial/altera_juart.h ++ * ++ * Driver for Altera JTAG UART core with Avalon interface ++ * ++ * 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. ++ * ++ * ++ * History: ++ * Jun/20/2005 DGT Microtronix Datacom NiosII ++ * ++ -----------------------------------------------------------------------*/ ++ ++#ifndef _ALTERA_JUART_H_ ++ #define _ALTERA_JUART_H_ ++ ++ /* jtag uart details needed outside of the driver itself: */ ++ /* by: arch/kernel/start.c - boot time error message(s) */ ++ ++ void jtaguart_console_write ++ ( struct console *co, ++ const char *s, ++ unsigned int count); ++ ++#endif /* _ALTERA_JUART_H_ */ +--- linux/include/asm-nios2nommu/a.out.h ++++ linux/include/asm-nios2nommu/a.out.h +@@ -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/include/asm-nios2nommu/asm-macros.h ++++ linux/include/asm-nios2nommu/asm-macros.h +@@ -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/include/asm-nios2nommu/atomic.h ++++ linux/include/asm-nios2nommu/atomic.h +@@ -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 ++ ++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/include/asm-nios2nommu/bitops.h ++++ linux/include/asm-nios2nommu/bitops.h +@@ -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 ++#include ++#include /* swab32 */ ++#include ++#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/include/asm-nios2nommu/bootinfo.h ++++ linux/include/asm-nios2nommu/bootinfo.h +@@ -0,0 +1,2 @@ ++ ++/* Nothing for nios2nommu */ +--- linux/include/asm-nios2nommu/bug.h ++++ linux/include/asm-nios2nommu/bug.h +@@ -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/include/asm-nios2nommu/bugs.h ++++ linux/include/asm-nios2nommu/bugs.h +@@ -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/include/asm-nios2nommu/byteorder.h ++++ linux/include/asm-nios2nommu/byteorder.h +@@ -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 ++ ++#if defined(__GNUC__) && !defined(__STRICT_ANSI__) || defined(__KERNEL__) ++# define __BYTEORDER_HAS_U64__ ++# define __SWAB_64_THRU_32__ ++#endif ++ ++#include ++ ++#endif ++ +--- linux/include/asm-nios2nommu/cachectl.h ++++ linux/include/asm-nios2nommu/cachectl.h +@@ -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/include/asm-nios2nommu/cacheflush.h ++++ linux/include/asm-nios2nommu/cacheflush.h +@@ -0,0 +1,59 @@ ++#ifndef _NIOS2NOMMU_CACHEFLUSH_H ++#define _NIOS2NOMMU_CACHEFLUSH_H ++ ++/* ++ * Ported from m68knommu. ++ * ++ * (C) Copyright 2003, Microtronix Datacom Ltd. ++ * (C) Copyright 2000-2002, Greg Ungerer ++ * ++ * 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 ++ ++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); ++extern void cache_clear (unsigned long paddr, int len); ++ ++#define flush_cache_all() __flush_cache_all() ++#define flush_cache_mm(mm) do { } while (0) ++#define flush_cache_range(vma, start, end) cache_push(start, end - start) ++#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_dcache_mmap_lock(mapping) do { } while (0) ++#define flush_dcache_mmap_unlock(mapping) 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/include/asm-nios2nommu/cache.h ++++ linux/include/asm-nios2nommu/cache.h +@@ -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 ++ ++/* 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/include/asm-nios2nommu/ChangeLog ++++ linux/include/asm-nios2nommu/ChangeLog +@@ -0,0 +1,14 @@ ++2004-06-29 Ken Hill ++ ++ * 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 ++ ++ * 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/include/asm-nios2nommu/checksum.h ++++ linux/include/asm-nios2nommu/checksum.h +@@ -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/include/asm-nios2nommu/cprefix.h ++++ linux/include/asm-nios2nommu/cprefix.h +@@ -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/include/asm-nios2nommu/cpumask.h ++++ linux/include/asm-nios2nommu/cpumask.h +@@ -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 ++ ++#endif /* _ASM_NIOS2NOMMU_CPUMASK_H */ +--- linux/include/asm-nios2nommu/cputime.h ++++ linux/include/asm-nios2nommu/cputime.h +@@ -0,0 +1,31 @@ ++/* ++ * cputime.h ++ * (C) Copyright 2004, Microtronix Datacom Ltd. ++ * ++ * Taken from m68knommu ++ * ++ * 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_CPUTIME_H ++#define __NIOS2NOMMU_CPUTIME_H ++ ++#include ++ ++#endif /* __NIOS@NOMMU_CPUTIME_H */ +--- linux/include/asm-nios2nommu/current.h ++++ linux/include/asm-nios2nommu/current.h +@@ -0,0 +1,39 @@ ++#ifndef _NIOS2NOMMU_CURRENT_H ++#define _NIOS2NOMMU_CURRENT_H ++/* ++ * current.h ++ * (C) Copyright 2000, Lineo, David McCullough ++ * (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 ++ ++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/include/asm-nios2nommu/delay.h ++++ linux/include/asm-nios2nommu/delay.h +@@ -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 ++ ++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/include/asm-nios2nommu/div64.h ++++ linux/include/asm-nios2nommu/div64.h +@@ -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 ++ ++#endif ++ +--- linux/include/asm-nios2nommu/dma.h ++++ linux/include/asm-nios2nommu/dma.h +@@ -0,0 +1,57 @@ ++/* $Id: dma.h,v 1.6 2005/04/07 21:00:26 wentao Exp $ ++ * ++ * 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 ++#include ++ ++#define MAX_DMA_ADDRESS (LINUX_SDRAM_END) ++ ++int request_dma(unsigned int, const char *); ++void free_dma(unsigned int); ++void enable_dma(unsigned int dmanr); ++void disable_dma(unsigned int dmanr); ++void set_dma_count(unsigned int dmanr, unsigned int count); ++int get_dma_residue(unsigned int dmanr); ++void nios2_set_dma_data_width(unsigned int dmanr, unsigned int width); ++ ++void nios2_set_dma_handler(unsigned int dmanr, int (*handler)(void*, int), void* user); ++int nios2_request_dma(const char *); ++ ++void nios2_set_dma_mode(unsigned int dmanr, unsigned int mode); ++void nios2_set_dma_rcon(unsigned int dmanr, unsigned int set); ++void nios2_set_dma_wcon(unsigned int dmanr, unsigned int set); ++void nios2_set_dma_raddr(unsigned int dmanr, unsigned int a); ++void nios2_set_dma_waddr(unsigned int dmanr, unsigned int a); ++ ++static inline unsigned long claim_dma_lock(void) ++{ ++} ++ ++static inline void release_dma_lock(unsigned long flags) ++{ ++} ++ ++#endif /* !(_ASM_NIOS2_DMA_H) */ +--- linux/include/asm-nios2nommu/dma-mapping.h ++++ linux/include/asm-nios2nommu/dma-mapping.h +@@ -0,0 +1,133 @@ ++/* ++ * include/asm-nios2nommu/dma-mapping.h ++ * ++ * This file exists so that #include doesn't break anything. ++ */ ++ ++#ifndef _ASM_DMA_MAPPING_H ++#define _ASM_DMA_MAPPING_H ++ ++#include ++#include ++#include ++#include ++ ++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(); ++} ++ ++/** ++ * dma_map_single - map a single buffer for streaming DMA ++ * @dev: valid struct device pointer, or NULL for ISA and EISA-like devices ++ * @cpu_addr: CPU direct mapped address of buffer ++ * @size: size of buffer to map ++ * @dir: DMA transfer direction ++ * ++ * Ensure that any data held in the cache is appropriately discarded ++ * or written back. ++ * ++ * The device owns this memory once this call has completed. The CPU ++ * can regain ownership by calling dma_unmap_single() or ++ * dma_sync_single_for_cpu(). ++ */ ++static inline dma_addr_t ++dma_map_single(struct device *dev, void *cpu_addr, size_t size, ++ enum dma_data_direction dir) ++{ ++ cache_push ((unsigned long)cpu_addr, size); ++ return virt_to_bus((unsigned long)cpu_addr); ++} ++ ++/** ++ * dma_unmap_single - unmap a single buffer previously mapped ++ * @dev: valid struct device pointer, or NULL for ISA and EISA-like devices ++ * @handle: DMA address of buffer ++ * @size: size of buffer to map ++ * @dir: DMA transfer direction ++ * ++ * Unmap a single streaming mode DMA translation. The handle and size ++ * must match what was provided in the previous dma_map_single() call. ++ * All other usages are undefined. ++ * ++ * After this call, reads by the CPU to the buffer are guaranteed to see ++ * whatever the device wrote there. ++ */ ++static inline void ++dma_unmap_single(struct device *dev, dma_addr_t handle, size_t size, ++ enum dma_data_direction dir) ++{ ++ cache_clear((unsigned long)bus_to_virt(handle), size); ++} ++ ++/** ++ * dma_map_sg - map a set of SG buffers for streaming mode DMA ++ * @dev: valid struct device pointer, or NULL for ISA and EISA-like devices ++ * @sg: list of buffers ++ * @nents: number of buffers to map ++ * @dir: DMA transfer direction ++ * ++ * Map a set of buffers described by scatterlist in streaming ++ * mode for DMA. This is the scatter-gather version of the ++ * above dma_map_single interface. Here the scatter gather list ++ * elements are each tagged with the appropriate dma address ++ * and length. They are obtained via sg_dma_{address,length}(SG). ++ * ++ * NOTE: An implementation may be able to use a smaller number of ++ * DMA address/length pairs than there are SG table elements. ++ * (for example via virtual mapping capabilities) ++ * The routine returns the number of addr/length pairs actually ++ * used, at most nents. ++ * ++ * Device ownership issues as mentioned above for dma_map_single are ++ * the same here. ++ */ ++static inline int ++dma_map_sg(struct device *dev, struct scatterlist *sg, int nents, ++ enum dma_data_direction dir) ++{ ++ int i; ++ ++ for (i = 0; i < nents; i++, sg++) { ++ char *virt; ++ ++ sg->dma_address = page_to_bus(sg->page) + sg->offset; ++ virt = page_address(sg->page) + sg->offset; ++ cache_push ((unsigned long)virt, sg->length); ++ } ++ ++ return nents; ++} ++ ++/** ++ * dma_unmap_sg - unmap a set of SG buffers mapped by dma_map_sg ++ * @dev: valid struct device pointer, or NULL for ISA and EISA-like devices ++ * @sg: list of buffers ++ * @nents: number of buffers to map ++ * @dir: DMA transfer direction ++ * ++ * Unmap a set of streaming mode DMA translations. ++ * Again, CPU read rules concerning calls here are the same as for ++ * dma_unmap_single() above. ++ */ ++static inline void ++dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nents, ++ enum dma_data_direction dir) ++{ ++ int i; ++ ++ for (i = 0; i < nents; i++, sg++) { ++ char *virt; ++ virt = page_address(sg->page) + sg->offset; ++ cache_clear ((unsigned long)virt, sg->length); ++ } ++} ++#endif /* _ASM_DMA_MAPPING_H */ +--- linux/include/asm-nios2nommu/elf.h ++++ linux/include/asm-nios2nommu/elf.h +@@ -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 ++#include ++#include ++ ++#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/include/asm-nios2nommu/entry.h ++++ linux/include/asm-nios2nommu/entry.h +@@ -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 ++#include ++#include ++#include ++ ++/* ++ * 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/include/asm-nios2nommu/errno.h ++++ linux/include/asm-nios2nommu/errno.h +@@ -0,0 +1,6 @@ ++#ifndef _NIOS2NOMMU_ERRNO_H ++#define _NIOS2NOMMU_ERRNO_H ++ ++#include ++ ++#endif /* _NIOS2NOMMU_ERRNO_H */ +--- linux/include/asm-nios2nommu/fcntl.h ++++ linux/include/asm-nios2nommu/fcntl.h +@@ -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/include/asm-nios2nommu/flat.h ++++ linux/include/asm-nios2nommu/flat.h +@@ -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 ++ */ ++ ++#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/include/asm-nios2nommu/hardirq.h ++++ linux/include/asm-nios2nommu/hardirq.h +@@ -0,0 +1,53 @@ ++/* ++ * 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 ++#include ++#include ++ ++typedef struct { ++ unsigned int __softirq_pending; ++} ____cacheline_aligned irq_cpustat_t; ++ ++#include /* Standard mappings for irq_cpustat_t above */ ++ ++#define HARDIRQ_BITS 8 ++ ++/* ++ * 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 ++ ++#ifdef CONFIG_SMP ++# error nios2nommu SMP is not available ++#endif /* CONFIG_SMP */ ++ ++#endif /* __NIOS2_HARDIRQ_H */ +--- linux/include/asm-nios2nommu/hdreg.h ++++ linux/include/asm-nios2nommu/hdreg.h +@@ -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/include/asm-nios2nommu/hw_irq.h ++++ linux/include/asm-nios2nommu/hw_irq.h +@@ -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 ++ * ++ */ ++ ++ ++#endif /* _ASM_HW_IRQ_H */ +--- linux/include/asm-nios2nommu/ide.h ++++ linux/include/asm-nios2nommu/ide.h +@@ -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 ++ ++#endif /* __KERNEL__ */ ++ ++#endif /* __ASMNIOS2_IDE_H */ +--- linux/include/asm-nios2nommu/init.h ++++ linux/include/asm-nios2nommu/init.h +@@ -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 " should never be used - use instead" +--- linux/include/asm-nios2nommu/ioctl.h ++++ linux/include/asm-nios2nommu/ioctl.h +@@ -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/include/asm-nios2nommu/ioctls.h ++++ linux/include/asm-nios2nommu/ioctls.h +@@ -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 ++ ++/* 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/include/asm-nios2nommu/io.h ++++ linux/include/asm-nios2nommu/io.h +@@ -0,0 +1,240 @@ ++/* ++ * 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 ++ ++#include /* IO address mapping routines need this */ ++#include ++#include ++ ++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 ++ ++#define mmiowb() ++ ++/* ++ * 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/include/asm-nios2nommu/ipcbuf.h ++++ linux/include/asm-nios2nommu/ipcbuf.h +@@ -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/include/asm-nios2nommu/ipc.h ++++ linux/include/asm-nios2nommu/ipc.h +@@ -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/include/asm-nios2nommu/irq.h ++++ linux/include/asm-nios2nommu/irq.h +@@ -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 ++#include ++ ++#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/include/asm-nios2nommu/kmap_types.h ++++ linux/include/asm-nios2nommu/kmap_types.h +@@ -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/include/asm-nios2nommu/linkage.h ++++ linux/include/asm-nios2nommu/linkage.h +@@ -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/include/asm-nios2nommu/linux_logo.h ++++ linux/include/asm-nios2nommu/linux_logo.h +@@ -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 ++#include ++ ++#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/include/asm-nios2nommu/local.h ++++ linux/include/asm-nios2nommu/local.h +@@ -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 ++ ++#endif /* __NIOS2NOMMU_LOCAL_H */ +--- linux/include/asm-nios2nommu/mc146818rtc.h ++++ linux/include/asm-nios2nommu/mc146818rtc.h +@@ -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/include/asm-nios2nommu/mman.h ++++ linux/include/asm-nios2nommu/mman.h +@@ -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/include/asm-nios2nommu/mmu_context.h ++++ linux/include/asm-nios2nommu/mmu_context.h +@@ -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 ++#include ++#include ++#include ++ ++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/include/asm-nios2nommu/mmu.h ++++ linux/include/asm-nios2nommu/mmu.h +@@ -0,0 +1,36 @@ ++/* ++ * ++ * 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 */ ++ ++typedef struct { ++ struct vm_list_struct *vmlist; ++ unsigned long end_brk; ++} mm_context_t; ++ ++#endif /* __NIOS2NOMMU_MMU_H */ +--- linux/include/asm-nios2nommu/module.h ++++ linux/include/asm-nios2nommu/module.h +@@ -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/include/asm-nios2nommu/msgbuf.h ++++ linux/include/asm-nios2nommu/msgbuf.h +@@ -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/include/asm-nios2nommu/namei.h ++++ linux/include/asm-nios2nommu/namei.h +@@ -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/include/asm-nios2nommu/ndma.h ++++ linux/include/asm-nios2nommu/ndma.h +@@ -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/include/asm-nios2nommu/nios.h ++++ linux/include/asm-nios2nommu/nios.h +@@ -0,0 +1,7 @@ ++#ifndef __NIOS_H__ ++#define __NIOS_H__ ++ ++#include "nios2_system.h" ++ ++#endif ++ +--- linux/include/asm-nios2nommu/page.h ++++ linux/include/asm-nios2nommu/page.h +@@ -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 ++ ++/* 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 ++ ++#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 ++#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/include/asm-nios2nommu/param.h ++++ linux/include/asm-nios2nommu/param.h +@@ -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/include/asm-nios2nommu/pci.h ++++ linux/include/asm-nios2nommu/pci.h +@@ -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 ++ ++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/include/asm-nios2nommu/percpu.h ++++ linux/include/asm-nios2nommu/percpu.h +@@ -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 ++ ++#endif /* __ARCH_NIOS2NOMMU_PERCPU__ */ +--- linux/include/asm-nios2nommu/pgalloc.h ++++ linux/include/asm-nios2nommu/pgalloc.h +@@ -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 ++ ++#define check_pgt_cache() do { } while (0) ++ ++#endif /* _NIOS2NOMMU_PGALLOC_H */ +--- linux/include/asm-nios2nommu/pgtable.h ++++ linux/include/asm-nios2nommu/pgtable.h +@@ -0,0 +1,104 @@ ++#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 ++ * ++ ---------------------------------------------------------------------*/ ++ ++#include ++ ++//vic - this bit copied from m68knommu version ++// #include ++#include ++#include ++ ++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); ++extern int is_in_rom(unsigned long); ++ ++/* ++ * No page table caches to initialise ++ */ ++#define pgtable_cache_init() do { } while (0) ++#define io_remap_page_range(vma, vaddr, paddr, size, prot) \ ++ remap_pfn_range(vma, vaddr, (paddr) >> PAGE_SHIFT, size, prot) ++ ++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/include/asm-nios2nommu/pio_struct.h ++++ linux/include/asm-nios2nommu/pio_struct.h +@@ -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/include/asm-nios2nommu/poll.h ++++ linux/include/asm-nios2nommu/poll.h +@@ -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/include/asm-nios2nommu/posix_types.h ++++ linux/include/asm-nios2nommu/posix_types.h +@@ -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/include/asm-nios2nommu/preem_latency.h ++++ linux/include/asm-nios2nommu/preem_latency.h +@@ -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 ++ ++#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/include/asm-nios2nommu/processor.h ++++ linux/include/asm-nios2nommu/processor.h +@@ -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 ++#include ++ ++#include ++#include ++#include ++#include ++#include /* 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/include/asm-nios2nommu/ptrace.h ++++ linux/include/asm-nios2nommu/ptrace.h +@@ -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/include/asm-nios2nommu/resource.h ++++ linux/include/asm-nios2nommu/resource.h +@@ -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/include/asm-nios2nommu/rmap.h ++++ linux/include/asm-nios2nommu/rmap.h +@@ -0,0 +1,2 @@ ++/* Do not need anything here */ ++ +--- linux/include/asm-nios2nommu/scatterlist.h ++++ linux/include/asm-nios2nommu/scatterlist.h +@@ -0,0 +1,42 @@ ++#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 ++ * ++ ---------------------------------------------------------------------*/ ++ ++#include ++ ++struct scatterlist { ++ struct page *page; ++ unsigned int offset; ++ dma_addr_t dma_address; ++ unsigned int length; ++}; ++ ++#define sg_address(sg) (page_address((sg)->page) + (sg)->offset ++#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/include/asm-nios2nommu/sections.h ++++ linux/include/asm-nios2nommu/sections.h +@@ -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 ++ ++#endif /* _NIOS2NOMMU_SECTIONS_H */ +--- linux/include/asm-nios2nommu/segment.h ++++ linux/include/asm-nios2nommu/segment.h +@@ -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/include/asm-nios2nommu/semaphore.h ++++ linux/include/asm-nios2nommu/semaphore.h +@@ -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 ++#include ++#include ++#include ++ ++#include ++#include ++ ++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/include/asm-nios2nommu/semaphore-helper.h ++++ linux/include/asm-nios2nommu/semaphore-helper.h +@@ -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 ++ ++/* ++ * 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/include/asm-nios2nommu/sembuf.h ++++ linux/include/asm-nios2nommu/sembuf.h +@@ -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/include/asm-nios2nommu/setup.h ++++ linux/include/asm-nios2nommu/setup.h +@@ -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/include/asm-nios2nommu/shmbuf.h ++++ linux/include/asm-nios2nommu/shmbuf.h +@@ -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/include/asm-nios2nommu/shmparam.h ++++ linux/include/asm-nios2nommu/shmparam.h +@@ -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/include/asm-nios2nommu/sigcontext.h ++++ linux/include/asm-nios2nommu/sigcontext.h +@@ -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 ++ ++struct sigcontext { ++ struct pt_regs regs; ++ unsigned long sc_mask; /* old sigmask */ ++}; ++ ++#endif +--- linux/include/asm-nios2nommu/siginfo.h ++++ linux/include/asm-nios2nommu/siginfo.h +@@ -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 ++ ++#endif +--- linux/include/asm-nios2nommu/signal.h ++++ linux/include/asm-nios2nommu/signal.h +@@ -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 ++ ++/* 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 ++#undef __HAVE_ARCH_SIG_BITOPS ++ ++#define ptrace_signal_deliver(regs, cookie) do { } while (0) ++ ++#endif /* __KERNEL__ */ ++ ++#endif /* _NIOS2_SIGNAL_H */ +--- linux/include/asm-nios2nommu/smp.h ++++ linux/include/asm-nios2nommu/smp.h +@@ -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 ++ ++#ifdef CONFIG_SMP ++#error SMP not supported ++#endif ++ ++#endif +--- linux/include/asm-nios2nommu/socket.h ++++ linux/include/asm-nios2nommu/socket.h +@@ -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 ++ ++/* 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/include/asm-nios2nommu/sockios.h ++++ linux/include/asm-nios2nommu/sockios.h +@@ -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/include/asm-nios2nommu/spi.h ++++ linux/include/asm-nios2nommu/spi.h +@@ -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 ++ ++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/include/asm-nios2nommu/spinlock.h ++++ linux/include/asm-nios2nommu/spinlock.h +@@ -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/include/asm-nios2nommu/spi_struct.h ++++ linux/include/asm-nios2nommu/spi_struct.h +@@ -0,0 +1,57 @@ ++// SPI Registers ++typedef volatile struct ++ { ++ int np_spirxdata; // Read-only, 1-16 bit ++ int np_spitxdata; // Write-only, same width as rxdata ++ int np_spistatus; // Read-only, 9-bit ++ int np_spicontrol; // Read/Write, 9-bit ++ int np_spireserved; // reserved ++ int np_spislaveselect; // Read/Write, 1-16 bit, master only ++ int np_spiendofpacket; // Read/write, same width as txdata, rxdata. ++ } np_spi; ++ ++// SPI Status Register Bits ++enum ++ { ++ np_spistatus_eop_bit = 9, ++ np_spistatus_e_bit = 8, ++ np_spistatus_rrdy_bit = 7, ++ np_spistatus_trdy_bit = 6, ++ np_spistatus_tmt_bit = 5, ++ np_spistatus_toe_bit = 4, ++ np_spistatus_roe_bit = 3, ++ ++ np_spistatus_eop_mask = (1 << 9), ++ np_spistatus_e_mask = (1 << 8), ++ np_spistatus_rrdy_mask = (1 << 7), ++ np_spistatus_trdy_mask = (1 << 6), ++ np_spistatus_tmt_mask = (1 << 5), ++ np_spistatus_toe_mask = (1 << 4), ++ np_spistatus_roe_mask = (1 << 3), ++ }; ++ ++// SPI Control Register Bits ++enum ++ { ++ np_spicontrol_sso_bit = 10, ++ np_spicontrol_ieop_bit = 9, ++ np_spicontrol_ie_bit = 8, ++ np_spicontrol_irrdy_bit = 7, ++ np_spicontrol_itrdy_bit = 6, ++ np_spicontrol_itoe_bit = 4, ++ np_spicontrol_iroe_bit = 3, ++ ++ np_spicontrol_sso_mask = (1 << 10), ++ np_spicontrol_ieop_mask = (1 << 9), ++ np_spicontrol_ie_mask = (1 << 8), ++ np_spicontrol_irrdy_mask = (1 << 7), ++ np_spicontrol_itrdy_mask = (1 << 6), ++ np_spicontrol_itoe_mask = (1 << 4), ++ np_spicontrol_iroe_mask = (1 << 3), ++ }; ++ ++// SPI Routines. ++int nr_spi_rxchar(np_spi *spiBase); ++int nr_spi_txchar(int i, np_spi *spiBase); ++ ++ +--- linux/include/asm-nios2nommu/statfs.h ++++ linux/include/asm-nios2nommu/statfs.h +@@ -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 ++ ++#endif /* _NIOS2NOMMU_STATFS_H */ +--- linux/include/asm-nios2nommu/stat.h ++++ linux/include/asm-nios2nommu/stat.h +@@ -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/include/asm-nios2nommu/string.h ++++ linux/include/asm-nios2nommu/string.h +@@ -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/include/asm-nios2nommu/system.h ++++ linux/include/asm-nios2nommu/system.h +@@ -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 /* get configuration macros */ ++#include ++#include ++#include ++#include ++ ++/* ++ * 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/include/asm-nios2nommu/termbits.h ++++ linux/include/asm-nios2nommu/termbits.h +@@ -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 ++ ++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/include/asm-nios2nommu/termios.h ++++ linux/include/asm-nios2nommu/termios.h +@@ -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 ++#include ++ ++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 */ ++#define N_R3964 9 /* Reserved for Simatic R3964 module */ ++#define N_PROFIBUS_FDL 10 /* Reserved for Profibus */ ++#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/include/asm-nios2nommu/thread_info.h ++++ linux/include/asm-nios2nommu/thread_info.h +@@ -0,0 +1,127 @@ ++/* 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 ++ ++#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 */ ++#define TIF_MEMDIE 5 ++ ++/* as above, but as bit values */ ++#define _TIF_SYSCALL_TRACE (1< ++ ++ ++#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/include/asm-nios2nommu/tlbflush.h ++++ linux/include/asm-nios2nommu/tlbflush.h +@@ -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 ++ ++/* ++ * 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/include/asm-nios2nommu/tlb.h ++++ linux/include/asm-nios2nommu/tlb.h +@@ -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 ++ * ++ * 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 ++ * Jan/20/2004 dgt NiosII ++ * ++ ---------------------------------------------------------------------*/ ++ ++#define tlb_flush(tlb) ((void)0) ++ ++#include ++ ++#endif /* __NIOS_TLB_H__ */ ++ +--- linux/include/asm-nios2nommu/topology.h ++++ linux/include/asm-nios2nommu/topology.h +@@ -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 ++ ++#endif /* _ASM_NIOS2NOMMU_TOPOLOGY_H */ +--- linux/include/asm-nios2nommu/traps.h ++++ linux/include/asm-nios2nommu/traps.h +@@ -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/include/asm-nios2nommu/types.h ++++ linux/include/asm-nios2nommu/types.h +@@ -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/include/asm-nios2nommu/uaccess.h ++++ linux/include/asm-nios2nommu/uaccess.h +@@ -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 ++#include ++#include ++#include ++ ++#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/include/asm-nios2nommu/uart_struct.h ++++ linux/include/asm-nios2nommu/uart_struct.h +@@ -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/include/asm-nios2nommu/ucontext.h ++++ linux/include/asm-nios2nommu/ucontext.h +@@ -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/include/asm-nios2nommu/unaligned.h ++++ linux/include/asm-nios2nommu/unaligned.h +@@ -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/include/asm-nios2nommu/unistd.h ++++ linux/include/asm-nios2nommu/unistd.h +@@ -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 ++ ++/* 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 ++ */ ++ ++#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/include/asm-nios2nommu/user.h ++++ linux/include/asm-nios2nommu/user.h +@@ -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 ++ ++/* 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/include/asm-nios2nommu/virtconvert.h ++++ linux/include/asm-nios2nommu/virtconvert.h +@@ -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 ++#include ++#include ++ ++#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__*/ 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 index 820868ffb7..b828b3bb3f 100644 --- 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 @@ -1,5 +1,5 @@ ---- 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 +--- linux/include/asm-generic/bitops.h ++++ linux/include/asm-generic/bitops.h @@ -0,0 +1,81 @@ +#ifndef _ASM_GENERIC_BITOPS_H_ +#define _ASM_GENERIC_BITOPS_H_ @@ -82,8 +82,8 @@ +#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 +--- linux/include/asm-generic/bug.h ++++ linux/include/asm-generic/bug.h @@ -0,0 +1,34 @@ +#ifndef _ASM_GENERIC_BUG_H +#define _ASM_GENERIC_BUG_H @@ -119,8 +119,8 @@ +#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 +--- linux/include/asm-generic/cpumask.h ++++ linux/include/asm-generic/cpumask.h @@ -0,0 +1,40 @@ +#ifndef __ASM_GENERIC_CPUMASK_H +#define __ASM_GENERIC_CPUMASK_H @@ -162,8 +162,8 @@ +#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 +--- linux/include/asm-generic/cpumask_arith.h ++++ linux/include/asm-generic/cpumask_arith.h @@ -0,0 +1,49 @@ +#ifndef __ASM_GENERIC_CPUMASK_ARITH_H +#define __ASM_GENERIC_CPUMASK_ARITH_H @@ -214,8 +214,8 @@ +#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 +--- linux/include/asm-generic/cpumask_array.h ++++ linux/include/asm-generic/cpumask_array.h @@ -0,0 +1,54 @@ +#ifndef __ASM_GENERIC_CPUMASK_ARRAY_H +#define __ASM_GENERIC_CPUMASK_ARRAY_H @@ -271,8 +271,8 @@ +#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 +--- linux/include/asm-generic/cpumask_const_reference.h ++++ linux/include/asm-generic/cpumask_const_reference.h @@ -0,0 +1,29 @@ +#ifndef __ASM_GENERIC_CPUMASK_CONST_REFERENCE_H +#define __ASM_GENERIC_CPUMASK_CONST_REFERENCE_H @@ -303,8 +303,8 @@ +#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 +--- linux/include/asm-generic/cpumask_const_value.h ++++ linux/include/asm-generic/cpumask_const_value.h @@ -0,0 +1,21 @@ +#ifndef __ASM_GENERIC_CPUMASK_CONST_VALUE_H +#define __ASM_GENERIC_CPUMASK_CONST_VALUE_H @@ -327,8 +327,8 @@ +#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 +--- linux/include/asm-generic/cpumask_up.h ++++ linux/include/asm-generic/cpumask_up.h @@ -0,0 +1,59 @@ +#ifndef __ASM_GENERIC_CPUMASK_UP_H +#define __ASM_GENERIC_CPUMASK_UP_H @@ -389,8 +389,8 @@ +#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 +--- linux/include/asm-generic/div64.h ++++ linux/include/asm-generic/div64.h @@ -0,0 +1,58 @@ +#ifndef _ASM_GENERIC_DIV64_H +#define _ASM_GENERIC_DIV64_H @@ -450,8 +450,8 @@ +#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 +--- linux/include/asm-generic/dma-mapping-broken.h ++++ linux/include/asm-generic/dma-mapping-broken.h @@ -0,0 +1,22 @@ +#ifndef _ASM_GENERIC_DMA_MAPPING_H +#define _ASM_GENERIC_DMA_MAPPING_H @@ -475,8 +475,8 @@ +} + +#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 +--- linux/include/asm-generic/dma-mapping.h ++++ linux/include/asm-generic/dma-mapping.h @@ -0,0 +1,309 @@ +/* Copyright (C) 2002 by James.Bottomley@HansenPartnership.com + * @@ -787,8 +787,8 @@ + +#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 +--- linux/include/asm-generic/errno-base.h ++++ linux/include/asm-generic/errno-base.h @@ -0,0 +1,39 @@ +#ifndef _ASM_GENERIC_ERRNO_BASE_H +#define _ASM_GENERIC_ERRNO_BASE_H @@ -829,8 +829,8 @@ +#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 +--- linux/include/asm-generic/errno.h ++++ linux/include/asm-generic/errno.h @@ -0,0 +1,100 @@ +#ifndef _ASM_GENERIC_ERRNO_H +#define _ASM_GENERIC_ERRNO_H @@ -932,8 +932,8 @@ +#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 +--- linux/include/asm-generic/hdreg.h ++++ linux/include/asm-generic/hdreg.h @@ -0,0 +1,8 @@ +#warning is obsolete, please do not use it + @@ -943,8 +943,8 @@ +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 +--- linux/include/asm-generic/ide_iops.h ++++ linux/include/asm-generic/ide_iops.h @@ -0,0 +1,38 @@ +/* Generic I/O and MEMIO string operations. */ + @@ -984,8 +984,8 @@ + 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 +--- linux/include/asm-generic/iomap.h ++++ linux/include/asm-generic/iomap.h @@ -0,0 +1,63 @@ +#ifndef __GENERIC_IO_H +#define __GENERIC_IO_H @@ -1050,8 +1050,8 @@ +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 +--- linux/include/asm-generic/local.h ++++ linux/include/asm-generic/local.h @@ -0,0 +1,118 @@ +#ifndef _ASM_GENERIC_LOCAL_H +#define _ASM_GENERIC_LOCAL_H @@ -1171,8 +1171,8 @@ +#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 +--- linux/include/asm-generic/pci-dma-compat.h ++++ linux/include/asm-generic/pci-dma-compat.h @@ -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 */ @@ -1281,8 +1281,8 @@ +} + +#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 +--- linux/include/asm-generic/pci.h ++++ linux/include/asm-generic/pci.h @@ -0,0 +1,27 @@ +/* + * linux/include/asm-generic/pci.h @@ -1311,8 +1311,8 @@ +#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 +--- linux/include/asm-generic/percpu.h ++++ linux/include/asm-generic/percpu.h @@ -0,0 +1,42 @@ +#ifndef _ASM_GENERIC_PERCPU_H_ +#define _ASM_GENERIC_PERCPU_H_ @@ -1356,8 +1356,8 @@ +#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 +--- linux/include/asm-generic/pgtable.h ++++ linux/include/asm-generic/pgtable.h @@ -0,0 +1,137 @@ +#ifndef _ASM_GENERIC_PGTABLE_H +#define _ASM_GENERIC_PGTABLE_H @@ -1496,8 +1496,8 @@ +#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 +--- linux/include/asm-generic/rmap.h ++++ linux/include/asm-generic/rmap.h @@ -0,0 +1,90 @@ +#ifndef _GENERIC_RMAP_H +#define _GENERIC_RMAP_H @@ -1589,8 +1589,8 @@ +#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 +--- linux/include/asm-generic/rtc.h ++++ linux/include/asm-generic/rtc.h @@ -0,0 +1,213 @@ +/* + * inclue/asm-generic/rtc.h @@ -1805,8 +1805,8 @@ + +#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 +--- linux/include/asm-generic/sections.h ++++ linux/include/asm-generic/sections.h @@ -0,0 +1,12 @@ +#ifndef _ASM_GENERIC_SECTIONS_H_ +#define _ASM_GENERIC_SECTIONS_H_ @@ -1820,8 +1820,8 @@ +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 +--- linux/include/asm-generic/siginfo.h ++++ linux/include/asm-generic/siginfo.h @@ -0,0 +1,295 @@ +#ifndef _ASM_GENERIC_SIGINFO_H +#define _ASM_GENERIC_SIGINFO_H @@ -2118,8 +2118,8 @@ +#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 +--- linux/include/asm-generic/statfs.h ++++ linux/include/asm-generic/statfs.h @@ -0,0 +1,51 @@ +#ifndef _GENERIC_STATFS_H +#define _GENERIC_STATFS_H @@ -2172,8 +2172,8 @@ +}; + +#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 +--- linux/include/asm-generic/tlb.h ++++ linux/include/asm-generic/tlb.h @@ -0,0 +1,152 @@ +/* asm-generic/tlb.h + * @@ -2327,8 +2327,8 @@ +#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 +--- linux/include/asm-generic/topology.h ++++ linux/include/asm-generic/topology.h @@ -0,0 +1,53 @@ +/* + * linux/include/asm-generic/topology.h @@ -2383,8 +2383,8 @@ +#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 +--- linux/include/asm-generic/uaccess.h ++++ linux/include/asm-generic/uaccess.h @@ -0,0 +1,26 @@ +#ifndef _ASM_GENERIC_UACCESS_H_ +#define _ASM_GENERIC_UACCESS_H_ @@ -2412,8 +2412,8 @@ +}) + +#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 +--- linux/include/asm-generic/unaligned.h ++++ linux/include/asm-generic/unaligned.h @@ -0,0 +1,20 @@ +#ifndef _ASM_GENERIC_UNALIGNED_H_ +#define _ASM_GENERIC_UNALIGNED_H_ @@ -2435,8 +2435,8 @@ + (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 +--- linux/include/asm-generic/vmlinux.lds.h ++++ linux/include/asm-generic/vmlinux.lds.h @@ -0,0 +1,84 @@ +#ifndef LOAD_OFFSET +#define LOAD_OFFSET 0 @@ -2522,8 +2522,8 @@ + 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 +--- linux/include/asm-generic/xor.h ++++ linux/include/asm-generic/xor.h @@ -0,0 +1,718 @@ +/* + * include/asm-generic/xor.h @@ -3243,8 +3243,8 @@ + 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 +--- linux/include/asm-nios2nommu/ChangeLog ++++ linux/include/asm-nios2nommu/ChangeLog @@ -0,0 +1,14 @@ +2004-06-29 Ken Hill + @@ -3260,8 +3260,8 @@ + * 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 +--- linux/include/asm-nios2nommu/a.out.h ++++ linux/include/asm-nios2nommu/a.out.h @@ -0,0 +1,85 @@ +/* $Id: a.out.h,v 1.4 2004/03/30 19:35:04 ken-h Exp $ */ +/* @@ -3348,8 +3348,8 @@ +#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 +--- linux/include/asm-nios2nommu/asm-macros.h ++++ linux/include/asm-nios2nommu/asm-macros.h @@ -0,0 +1,331 @@ +/* + * Macro used to simplify coding multi-line assembler. @@ -3682,8 +3682,8 @@ +__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 +--- linux/include/asm-nios2nommu/atomic.h ++++ linux/include/asm-nios2nommu/atomic.h @@ -0,0 +1,190 @@ +//vic - add 'atomic_add/sub_return', 'atomic_add_negative' +//vic from v850 architecture @@ -3875,8 +3875,8 @@ +#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 +--- linux/include/asm-nios2nommu/bitops.h ++++ linux/include/asm-nios2nommu/bitops.h @@ -0,0 +1,472 @@ +#ifndef _ASM_NIOS_BITOPS_H_ +#define _ASM_NIOS_BITOPS_H_ @@ -4350,13 +4350,13 @@ +#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 +--- linux/include/asm-nios2nommu/bootinfo.h ++++ linux/include/asm-nios2nommu/bootinfo.h @@ -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 +--- linux/include/asm-nios2nommu/bug.h ++++ linux/include/asm-nios2nommu/bug.h @@ -0,0 +1,48 @@ +#ifndef _NIOS2NOMMU_BUG_H +#define _NIOS2NOMMU_BUG_H @@ -4406,8 +4406,8 @@ +} 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 +--- linux/include/asm-nios2nommu/bugs.h ++++ linux/include/asm-nios2nommu/bugs.h @@ -0,0 +1,40 @@ +#ifndef __ASM_NIOS_BUGS_H +#define __ASM_NIOS_BUGS_H @@ -4449,8 +4449,8 @@ +} + +#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 +--- linux/include/asm-nios2nommu/byteorder.h ++++ linux/include/asm-nios2nommu/byteorder.h @@ -0,0 +1,38 @@ +#ifndef __ASM_NIOS_BYTEORDER_H +#define __ASM_NIOS_BYTEORDER_H @@ -4490,8 +4490,8 @@ + +#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 +--- linux/include/asm-nios2nommu/cache.h ++++ linux/include/asm-nios2nommu/cache.h @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2004 Microtronix Datacom Ltd. @@ -4527,8 +4527,8 @@ +#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 +--- linux/include/asm-nios2nommu/cachectl.h ++++ linux/include/asm-nios2nommu/cachectl.h @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2004 Microtronix Datacom Ltd. @@ -4566,8 +4566,8 @@ +#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 +--- linux/include/asm-nios2nommu/cacheflush.h ++++ linux/include/asm-nios2nommu/cacheflush.h @@ -0,0 +1,56 @@ +#ifndef _NIOS2NOMMU_CACHEFLUSH_H +#define _NIOS2NOMMU_CACHEFLUSH_H @@ -4625,8 +4625,8 @@ +} + +#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 +--- linux/include/asm-nios2nommu/checksum.h ++++ linux/include/asm-nios2nommu/checksum.h @@ -0,0 +1,320 @@ +#ifndef __NIOS2_CHECKSUM_H +#define __NIOS2_CHECKSUM_H @@ -4948,8 +4948,8 @@ + + +#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 +--- linux/include/asm-nios2nommu/cprefix.h ++++ linux/include/asm-nios2nommu/cprefix.h @@ -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 @@ -4989,8 +4989,8 @@ +#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 +--- linux/include/asm-nios2nommu/cpumask.h ++++ linux/include/asm-nios2nommu/cpumask.h @@ -0,0 +1,28 @@ +/* + * All rights reserved. @@ -5020,8 +5020,8 @@ +#include + +#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 +--- linux/include/asm-nios2nommu/current.h ++++ linux/include/asm-nios2nommu/current.h @@ -0,0 +1,39 @@ +#ifndef _NIOS2NOMMU_CURRENT_H +#define _NIOS2NOMMU_CURRENT_H @@ -5062,8 +5062,8 @@ +#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 +--- linux/include/asm-nios2nommu/delay.h ++++ linux/include/asm-nios2nommu/delay.h @@ -0,0 +1,96 @@ +#ifndef _NIOS_DELAY_H +#define _NIOS_DELAY_H @@ -5161,8 +5161,8 @@ +#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 +--- linux/include/asm-nios2nommu/div64.h ++++ linux/include/asm-nios2nommu/div64.h @@ -0,0 +1,31 @@ +#ifndef __ASMNIOS_DIV64_H +#define __ASMNIOS_DIV64_H @@ -5195,8 +5195,8 @@ + +#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 +--- linux/include/asm-nios2nommu/dma-mapping.h ++++ linux/include/asm-nios2nommu/dma-mapping.h @@ -0,0 +1,25 @@ +/* + * include/asm-s390/dma-mapping.h @@ -5223,8 +5223,8 @@ +} + +#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 +--- linux/include/asm-nios2nommu/dma.h ++++ linux/include/asm-nios2nommu/dma.h @@ -0,0 +1,40 @@ +/* $Id: dma.h,v 1.5 2004/03/02 16:05:52 ken-h Exp $ + * @@ -5266,8 +5266,8 @@ +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 +--- linux/include/asm-nios2nommu/elf.h ++++ linux/include/asm-nios2nommu/elf.h @@ -0,0 +1,141 @@ +#ifndef __NIOS2_ELF_H +#define __NIOS2_ELF_H @@ -5410,8 +5410,8 @@ +#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 +--- linux/include/asm-nios2nommu/entry.h ++++ linux/include/asm-nios2nommu/entry.h @@ -0,0 +1,188 @@ +/* + * Hacked from m68knommu port. @@ -5601,8 +5601,8 @@ + +#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 +--- linux/include/asm-nios2nommu/errno.h ++++ linux/include/asm-nios2nommu/errno.h @@ -0,0 +1,6 @@ +#ifndef _NIOS2NOMMU_ERRNO_H +#define _NIOS2NOMMU_ERRNO_H @@ -5610,8 +5610,8 @@ +#include + +#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 +--- linux/include/asm-nios2nommu/fcntl.h ++++ linux/include/asm-nios2nommu/fcntl.h @@ -0,0 +1,110 @@ +/* + * This file came from the m68k port. @@ -5723,8 +5723,8 @@ + +#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 +--- linux/include/asm-nios2nommu/flat.h ++++ linux/include/asm-nios2nommu/flat.h @@ -0,0 +1,126 @@ +/* + * include/asm-nios2nommu/flat.h -- uClinux bFLT relocations @@ -5852,8 +5852,8 @@ +} + +#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 +--- linux/include/asm-nios2nommu/hardirq.h ++++ linux/include/asm-nios2nommu/hardirq.h @@ -0,0 +1,85 @@ +/* + * Ported from m68knommu @@ -5940,8 +5940,8 @@ +#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 +--- linux/include/asm-nios2nommu/hdreg.h ++++ linux/include/asm-nios2nommu/hdreg.h @@ -0,0 +1,30 @@ +/* + * Copyright (C) 1994-1996 Linus Torvalds & authors @@ -5973,8 +5973,8 @@ +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 +--- linux/include/asm-nios2nommu/hw_irq.h ++++ linux/include/asm-nios2nommu/hw_irq.h @@ -0,0 +1,16 @@ +#ifndef _ASM_HW_IRQ_H +#define _ASM_HW_IRQ_H @@ -5992,8 +5992,8 @@ + + +#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 +--- linux/include/asm-nios2nommu/ide.h ++++ linux/include/asm-nios2nommu/ide.h @@ -0,0 +1,47 @@ +/* + * linux/include/asm-niosnommu2/ide.h @@ -6042,8 +6042,8 @@ +#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 +--- linux/include/asm-nios2nommu/init.h ++++ linux/include/asm-nios2nommu/init.h @@ -0,0 +1,22 @@ +/* + * Copyright (C) 2004, Microtronix Datacom Ltd. @@ -6067,8 +6067,8 @@ + * + */ +#error " should never be used - use 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 +--- linux/include/asm-nios2nommu/io.h ++++ linux/include/asm-nios2nommu/io.h @@ -0,0 +1,239 @@ +/* + * Copyright (C) 2004, Microtronix Datacom Ltd. @@ -6309,8 +6309,8 @@ + +#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 +--- linux/include/asm-nios2nommu/ioctl.h ++++ linux/include/asm-nios2nommu/ioctl.h @@ -0,0 +1,100 @@ +/* $Id: ioctl.h,v 1.3 2004/02/12 23:06:40 ken-h Exp $ + * @@ -6412,8 +6412,8 @@ +#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 +--- linux/include/asm-nios2nommu/ioctls.h ++++ linux/include/asm-nios2nommu/ioctls.h @@ -0,0 +1,103 @@ +/* + * Copyright (C) 2004, Microtronix Datacom Ltd. @@ -6518,8 +6518,8 @@ +#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 +--- linux/include/asm-nios2nommu/ipc.h ++++ linux/include/asm-nios2nommu/ipc.h @@ -0,0 +1,51 @@ +#ifndef __NIOS2_IPC_H__ +#define __NIOS2_IPC_H__ @@ -6572,8 +6572,8 @@ +#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 +--- linux/include/asm-nios2nommu/ipcbuf.h ++++ linux/include/asm-nios2nommu/ipcbuf.h @@ -0,0 +1,49 @@ +#ifndef __NIOS2_IPCBUF_H__ +#define __NIOS2_IPCBUF_H__ @@ -6624,8 +6624,8 @@ +}; + +#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 +--- linux/include/asm-nios2nommu/irq.h ++++ linux/include/asm-nios2nommu/irq.h @@ -0,0 +1,182 @@ +/* + * 21Mar2001 1.1 dgt/microtronix @@ -6809,8 +6809,8 @@ +#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 +--- linux/include/asm-nios2nommu/kmap_types.h ++++ linux/include/asm-nios2nommu/kmap_types.h @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2004, Microtronix Datacom Ltd. @@ -6855,8 +6855,8 @@ +}; + +#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 +--- linux/include/asm-nios2nommu/linkage.h ++++ linux/include/asm-nios2nommu/linkage.h @@ -0,0 +1,29 @@ +/* + * Copyright (C) 2004, Microtronix Datacom Ltd. @@ -6887,8 +6887,8 @@ +#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 +--- linux/include/asm-nios2nommu/linux_logo.h ++++ linux/include/asm-nios2nommu/linux_logo.h @@ -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 @@ -7843,8 +7843,8 @@ + +#include + ---- 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 +--- linux/include/asm-nios2nommu/local.h ++++ linux/include/asm-nios2nommu/local.h @@ -0,0 +1,28 @@ +/* + * Copyright (C) 2004, Microtronix Datacom Ltd. @@ -7874,8 +7874,8 @@ +#include + +#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 +--- linux/include/asm-nios2nommu/mc146818rtc.h ++++ linux/include/asm-nios2nommu/mc146818rtc.h @@ -0,0 +1,29 @@ +/* + * Machine dependent access functions for RTC registers. @@ -7906,8 +7906,8 @@ +/* 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 +--- linux/include/asm-nios2nommu/mman.h ++++ linux/include/asm-nios2nommu/mman.h @@ -0,0 +1,68 @@ +/* + * Copied from the m68k port. @@ -7977,8 +7977,8 @@ + +#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 +--- linux/include/asm-nios2nommu/mmu.h ++++ linux/include/asm-nios2nommu/mmu.h @@ -0,0 +1,47 @@ +/* + * @@ -8027,8 +8027,8 @@ +} 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 +--- linux/include/asm-nios2nommu/mmu_context.h ++++ linux/include/asm-nios2nommu/mmu_context.h @@ -0,0 +1,58 @@ +/* + * @@ -8088,8 +8088,8 @@ +} + +#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 +--- linux/include/asm-nios2nommu/module.h ++++ linux/include/asm-nios2nommu/module.h @@ -0,0 +1,36 @@ +#ifndef _NIOS2_MODULE_H +#define _NIOS2_MODULE_H @@ -8127,8 +8127,8 @@ +#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 +--- linux/include/asm-nios2nommu/msgbuf.h ++++ linux/include/asm-nios2nommu/msgbuf.h @@ -0,0 +1,56 @@ +/* + * Taken from the m68k. @@ -8186,8 +8186,8 @@ + +#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 +--- linux/include/asm-nios2nommu/namei.h ++++ linux/include/asm-nios2nommu/namei.h @@ -0,0 +1,36 @@ +/* + * linux/include/asm-nios/namei.h @@ -8225,8 +8225,8 @@ +#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 +--- linux/include/asm-nios2nommu/ndma.h ++++ linux/include/asm-nios2nommu/ndma.h @@ -0,0 +1,64 @@ +#ifndef __NDMA_H__ + #define __NDMA_H__ @@ -8292,8 +8292,8 @@ + +#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 +--- linux/include/asm-nios2nommu/nios.h ++++ linux/include/asm-nios2nommu/nios.h @@ -0,0 +1,7 @@ +#ifndef __NIOS_H__ +#define __NIOS_H__ @@ -8302,8 +8302,8 @@ + +#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 +--- linux/include/asm-nios2nommu/page.h ++++ linux/include/asm-nios2nommu/page.h @@ -0,0 +1,135 @@ +/* + * Copyright (C) 2004, Microtronix Datacom Ltd. @@ -8440,8 +8440,8 @@ +#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 +--- linux/include/asm-nios2nommu/param.h ++++ linux/include/asm-nios2nommu/param.h @@ -0,0 +1,49 @@ +#ifndef _NIOS_PARAM_H +#define _NIOS_PARAM_H @@ -8492,8 +8492,8 @@ +#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 +--- linux/include/asm-nios2nommu/pci.h ++++ linux/include/asm-nios2nommu/pci.h @@ -0,0 +1,75 @@ +#ifndef _ASM_NIOS2NOMMU_PCI_H +#define _ASM_NIOS2NOMMU_PCI_H @@ -8570,8 +8570,8 @@ +#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 +--- linux/include/asm-nios2nommu/percpu.h ++++ linux/include/asm-nios2nommu/percpu.h @@ -0,0 +1,30 @@ +#ifndef __ARCH_NIOS2NOMMU_PERCPU__ +#define __ARCH_NIOS2NOMMU_PERCPU__ @@ -8603,8 +8603,8 @@ +#include + +#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 +--- linux/include/asm-nios2nommu/pgalloc.h ++++ linux/include/asm-nios2nommu/pgalloc.h @@ -0,0 +1,32 @@ +#ifndef _NIOS2NOMMU_PGALLOC_H +#define _NIOS2NOMMU_PGALLOC_H @@ -8638,8 +8638,8 @@ +#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 +--- linux/include/asm-nios2nommu/pgtable.h ++++ linux/include/asm-nios2nommu/pgtable.h @@ -0,0 +1,100 @@ +#ifndef _NIOS_PGTABLE_H +#define _NIOS_PGTABLE_H @@ -8741,8 +8741,8 @@ +#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 +--- linux/include/asm-nios2nommu/pio_struct.h ++++ linux/include/asm-nios2nommu/pio_struct.h @@ -0,0 +1,14 @@ +// PIO Peripheral + @@ -8758,8 +8758,8 @@ +// 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 +--- linux/include/asm-nios2nommu/poll.h ++++ linux/include/asm-nios2nommu/poll.h @@ -0,0 +1,46 @@ +#ifndef __NIOS2_POLL_H +#define __NIOS2_POLL_H @@ -8807,8 +8807,8 @@ +}; + +#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 +--- linux/include/asm-nios2nommu/posix_types.h ++++ linux/include/asm-nios2nommu/posix_types.h @@ -0,0 +1,89 @@ +#ifndef __ARCH_NIOS2_POSIX_TYPES_H +#define __ARCH_NIOS2_POSIX_TYPES_H @@ -8899,8 +8899,8 @@ +#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 +--- linux/include/asm-nios2nommu/preem_latency.h ++++ linux/include/asm-nios2nommu/preem_latency.h @@ -0,0 +1,39 @@ +#ifndef _ASM_PREEM_LATENCY_H +#define _ASM_PREEM_LATENCY_H @@ -8941,8 +8941,8 @@ +#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 +--- linux/include/asm-nios2nommu/processor.h ++++ linux/include/asm-nios2nommu/processor.h @@ -0,0 +1,148 @@ +/*-------------------------------------------------------------------- + * @@ -9092,8 +9092,8 @@ +#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 +--- linux/include/asm-nios2nommu/ptrace.h ++++ linux/include/asm-nios2nommu/ptrace.h @@ -0,0 +1,141 @@ +/* + * Taken from the m68k port. @@ -9236,8 +9236,8 @@ +#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 +--- linux/include/asm-nios2nommu/resource.h ++++ linux/include/asm-nios2nommu/resource.h @@ -0,0 +1,73 @@ +#ifndef _NIOS2NOMMU_RESOURCE_H +#define _NIOS2NOMMU_RESOURCE_H @@ -9312,13 +9312,13 @@ +#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 +--- linux/include/asm-nios2nommu/rmap.h ++++ linux/include/asm-nios2nommu/rmap.h @@ -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 +--- linux/include/asm-nios2nommu/scatterlist.h ++++ linux/include/asm-nios2nommu/scatterlist.h @@ -0,0 +1,40 @@ +#ifndef _NIOS2NOMMU_SCATTERLIST_H +#define _NIOS2NOMMU_SCATTERLIST_H @@ -9360,8 +9360,8 @@ +#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 +--- linux/include/asm-nios2nommu/sections.h ++++ linux/include/asm-nios2nommu/sections.h @@ -0,0 +1,30 @@ +#ifndef _NIOS2NOMMU_SECTIONS_H +#define _NIOS2NOMMU_SECTIONS_H @@ -9393,8 +9393,8 @@ +#include + +#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 +--- linux/include/asm-nios2nommu/segment.h ++++ linux/include/asm-nios2nommu/segment.h @@ -0,0 +1,75 @@ +#ifndef _NIOS2NOMMU_SEGMENT_H +#define _NIOS2NOMMU_SEGMENT_H @@ -9471,8 +9471,8 @@ +#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 +--- linux/include/asm-nios2nommu/semaphore-helper.h ++++ linux/include/asm-nios2nommu/semaphore-helper.h @@ -0,0 +1,101 @@ +#ifndef _NIOS2NOMMU_SEMAPHORE_HELPER_H +#define _NIOS2NOMMU_SEMAPHORE_HELPER_H @@ -9575,8 +9575,8 @@ +} + +#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 +--- linux/include/asm-nios2nommu/semaphore.h ++++ linux/include/asm-nios2nommu/semaphore.h @@ -0,0 +1,155 @@ +#ifndef _NIOS2NOMMU_SEMAPHORE_H +#define _NIOS2NOMMU_SEMAPHORE_H @@ -9733,8 +9733,8 @@ +#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 +--- linux/include/asm-nios2nommu/sembuf.h ++++ linux/include/asm-nios2nommu/sembuf.h @@ -0,0 +1,48 @@ +#ifndef _NIOS_SEMBUF_H +#define _NIOS_SEMBUF_H @@ -9784,8 +9784,8 @@ +}; + +#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 +--- linux/include/asm-nios2nommu/setup.h ++++ linux/include/asm-nios2nommu/setup.h @@ -0,0 +1,31 @@ +/* Copied from i386 port. + * Just a place holder. We don't want to have to test x86 before @@ -9818,8 +9818,8 @@ +#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 +--- linux/include/asm-nios2nommu/shmbuf.h ++++ linux/include/asm-nios2nommu/shmbuf.h @@ -0,0 +1,64 @@ +#ifndef _NIOS_SHMBUF_H +#define _NIOS_SHMBUF_H @@ -9885,8 +9885,8 @@ +}; + +#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 +--- linux/include/asm-nios2nommu/shmparam.h ++++ linux/include/asm-nios2nommu/shmparam.h @@ -0,0 +1,30 @@ +#ifndef __NIOS2NOMMU_SHMPARAM_H__ +#define __NIOS2NOMMU_SHMPARAM_H__ @@ -9918,8 +9918,8 @@ +#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 +--- linux/include/asm-nios2nommu/sigcontext.h ++++ linux/include/asm-nios2nommu/sigcontext.h @@ -0,0 +1,35 @@ +/* + * Taken from the m68knommu. @@ -9956,8 +9956,8 @@ +}; + +#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 +--- linux/include/asm-nios2nommu/siginfo.h ++++ linux/include/asm-nios2nommu/siginfo.h @@ -0,0 +1,28 @@ +/* + * Copyright (C) 2004, Microtronix Datacom Ltd. @@ -9987,8 +9987,8 @@ +#include + +#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 +--- linux/include/asm-nios2nommu/signal.h ++++ linux/include/asm-nios2nommu/signal.h @@ -0,0 +1,207 @@ +/* + * Copyright (C) 2004, Microtronix Datacom Ltd. @@ -10197,8 +10197,8 @@ +#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 +--- linux/include/asm-nios2nommu/smp.h ++++ linux/include/asm-nios2nommu/smp.h @@ -0,0 +1,34 @@ +#ifndef __ASM_SMP_H +#define __ASM_SMP_H @@ -10234,8 +10234,8 @@ +#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 +--- linux/include/asm-nios2nommu/socket.h ++++ linux/include/asm-nios2nommu/socket.h @@ -0,0 +1,74 @@ +#ifndef _ASM_SOCKET_H +#define _ASM_SOCKET_H @@ -10311,8 +10311,8 @@ +#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 +--- linux/include/asm-nios2nommu/sockios.h ++++ linux/include/asm-nios2nommu/sockios.h @@ -0,0 +1,38 @@ +#ifndef _ASM_NIOS_SOCKIOS_H +#define _ASM_NIOS_SOCKIOS_H @@ -10352,8 +10352,8 @@ + +#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 +--- linux/include/asm-nios2nommu/spi.h ++++ linux/include/asm-nios2nommu/spi.h @@ -0,0 +1,92 @@ +#ifndef _ASM_SPI_H_ +#define _ASM_SPI_H_ 1 @@ -10447,8 +10447,8 @@ +#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 +--- linux/include/asm-nios2nommu/spinlock.h ++++ linux/include/asm-nios2nommu/spinlock.h @@ -0,0 +1,30 @@ +#ifndef __NIOS_SPINLOCK_H +#define __NIOS_SPINLOCK_H @@ -10480,8 +10480,8 @@ +#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 +--- linux/include/asm-nios2nommu/stat.h ++++ linux/include/asm-nios2nommu/stat.h @@ -0,0 +1,102 @@ +#ifndef _ASMNIOS2NOMMU_STAT_H +#define _ASMNIOS2NOMMU_STAT_H @@ -10585,8 +10585,8 @@ +}; + +#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 +--- linux/include/asm-nios2nommu/statfs.h ++++ linux/include/asm-nios2nommu/statfs.h @@ -0,0 +1,30 @@ +#ifndef _NIOS2NOMMU_STATFS_H +#define _NIOS2NOMMU_STATFS_H @@ -10618,8 +10618,8 @@ +#include + +#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 +--- linux/include/asm-nios2nommu/string.h ++++ linux/include/asm-nios2nommu/string.h @@ -0,0 +1,45 @@ +#ifndef __NIOS_STRING_H__ +#define __NIOS_STRING_H__ @@ -10666,8 +10666,8 @@ +#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 +--- linux/include/asm-nios2nommu/system.h ++++ linux/include/asm-nios2nommu/system.h @@ -0,0 +1,172 @@ +/* + * Taken from the m68k. @@ -10841,8 +10841,8 @@ +} + +#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 +--- linux/include/asm-nios2nommu/termbits.h ++++ linux/include/asm-nios2nommu/termbits.h @@ -0,0 +1,199 @@ +#ifndef __ARCH_NIOS_TERMBITS_H__ +#define __ARCH_NIOS_TERMBITS_H__ @@ -11043,8 +11043,8 @@ +#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 +--- linux/include/asm-nios2nommu/termios.h ++++ linux/include/asm-nios2nommu/termios.h @@ -0,0 +1,132 @@ +#ifndef _NIOS_TERMIOS_H +#define _NIOS_TERMIOS_H @@ -11178,8 +11178,8 @@ +#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 +--- linux/include/asm-nios2nommu/thread_info.h ++++ linux/include/asm-nios2nommu/thread_info.h @@ -0,0 +1,126 @@ +/* thread_info.h: niosnommu low-level thread information + * adapted from the m68knommu @@ -11307,8 +11307,8 @@ +#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 +--- linux/include/asm-nios2nommu/timer_struct.h ++++ linux/include/asm-nios2nommu/timer_struct.h @@ -0,0 +1,38 @@ + +// ---------------------------------------------- @@ -11348,8 +11348,8 @@ +// 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 +--- linux/include/asm-nios2nommu/timex.h ++++ linux/include/asm-nios2nommu/timex.h @@ -0,0 +1,48 @@ +#ifndef _ASMNIOS2NOMMU_TIMEX_H +#define _ASMNIOS2NOMMU_TIMEX_H @@ -11399,8 +11399,8 @@ +} + +#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 +--- linux/include/asm-nios2nommu/tlb.h ++++ linux/include/asm-nios2nommu/tlb.h @@ -0,0 +1,35 @@ +#ifndef __NIOS_TLB_H__ +#define __NIOS_TLB_H__ @@ -11437,8 +11437,8 @@ + +#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 +--- linux/include/asm-nios2nommu/tlbflush.h ++++ linux/include/asm-nios2nommu/tlbflush.h @@ -0,0 +1,86 @@ +#ifndef _NIOS2NOMMU_TLBFLUSH_H +#define _NIOS2NOMMU_TLBFLUSH_H @@ -11526,8 +11526,8 @@ +} + +#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 +--- linux/include/asm-nios2nommu/topology.h ++++ linux/include/asm-nios2nommu/topology.h @@ -0,0 +1,30 @@ +#ifndef _ASM_NIOS2NOMMU_TOPOLOGY_H +#define _ASM_NIOS2NOMMU_TOPOLOGY_H @@ -11559,8 +11559,8 @@ +#include + +#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 +--- linux/include/asm-nios2nommu/traps.h ++++ linux/include/asm-nios2nommu/traps.h @@ -0,0 +1,27 @@ +/* + * Copyright (C) 2004, Microtronix Datacom Ltd. @@ -11589,8 +11589,8 @@ +#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 +--- linux/include/asm-nios2nommu/types.h ++++ linux/include/asm-nios2nommu/types.h @@ -0,0 +1,93 @@ +#ifndef _NIOS_TYPES_H +#define _NIOS_TYPES_H @@ -11685,8 +11685,8 @@ +#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 +--- linux/include/asm-nios2nommu/uaccess.h ++++ linux/include/asm-nios2nommu/uaccess.h @@ -0,0 +1,183 @@ +#ifndef __NIOS2NOMMU_UACCESS_H +#define __NIOS2NOMMU_UACCESS_H @@ -11871,8 +11871,8 @@ +} + +#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 +--- linux/include/asm-nios2nommu/uart_struct.h ++++ linux/include/asm-nios2nommu/uart_struct.h @@ -0,0 +1,83 @@ + +// UART Registers @@ -11957,8 +11957,8 @@ +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 +--- linux/include/asm-nios2nommu/ucontext.h ++++ linux/include/asm-nios2nommu/ucontext.h @@ -0,0 +1,63 @@ +#ifndef _NIOSKNOMMU_UCONTEXT_H +#define _NIOSKNOMMU_UCONTEXT_H @@ -12023,8 +12023,8 @@ +}; + +#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 +--- linux/include/asm-nios2nommu/unaligned.h ++++ linux/include/asm-nios2nommu/unaligned.h @@ -0,0 +1,43 @@ +#ifndef __NIOS_UNALIGNED_H +#define __NIOS_UNALIGNED_H @@ -12069,8 +12069,8 @@ +}) + +#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 +--- linux/include/asm-nios2nommu/unistd.h ++++ linux/include/asm-nios2nommu/unistd.h @@ -0,0 +1,686 @@ +#ifndef _ASM_NIOS_UNISTD_H_ +#define _ASM_NIOS_UNISTD_H_ @@ -12758,8 +12758,8 @@ +#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 +--- linux/include/asm-nios2nommu/user.h ++++ linux/include/asm-nios2nommu/user.h @@ -0,0 +1,112 @@ +#ifndef _NIOS2NOMMU_USER_H +#define _NIOS2NOMMU_USER_H @@ -12873,8 +12873,8 @@ +#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 +--- linux/include/asm-nios2nommu/virtconvert.h ++++ linux/include/asm-nios2nommu/virtconvert.h @@ -0,0 +1,47 @@ +#ifndef __NIOS_VIRT_CONVERT__ +#define __NIOS_VIRT_CONVERT__ -- 2.30.2