lkml.org 
[lkml]   [2015]   [Apr]   [20]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
/
Date
SubjectRe: [PATCH v8 01/17] h8300: Assembly headers.
From
dOn Mon, Apr 20, 2015 at 8:13 AM, Yoshinori Sato
<ysato@users.sourceforge.jp> wrote:
> Signed-off-by: Yoshinori Sato <ysato@users.sourceforge.jp>
> ---
> arch/h8300/include/asm/Kbuild | 66 ++++++
> arch/h8300/include/asm/asm-offsets.h | 1 +
> arch/h8300/include/asm/atomic.h | 159 +++++++++++++++
> arch/h8300/include/asm/bitops.h | 185 +++++++++++++++++
> arch/h8300/include/asm/bootparams.h | 17 ++
> arch/h8300/include/asm/bug.h | 12 ++
> arch/h8300/include/asm/cache.h | 11 +
> arch/h8300/include/asm/checksum.h | 102 ++++++++++
> arch/h8300/include/asm/cmpxchg.h | 65 ++++++
> arch/h8300/include/asm/delay.h | 38 ++++
> arch/h8300/include/asm/device.h | 6 +
> arch/h8300/include/asm/dma-mapping.h | 124 ++++++++++++
> arch/h8300/include/asm/elf.h | 101 ++++++++++
> arch/h8300/include/asm/emergency-restart.h | 6 +
> arch/h8300/include/asm/flat.h | 27 +++
> arch/h8300/include/asm/io.h | 314 +++++++++++++++++++++++++++++
> arch/h8300/include/asm/irq.h | 26 +++
> arch/h8300/include/asm/irqflags.h | 96 +++++++++
> arch/h8300/include/asm/mc146818rtc.h | 9 +
> arch/h8300/include/asm/mutex.h | 9 +
> arch/h8300/include/asm/page.h | 18 ++
> arch/h8300/include/asm/page_offset.h | 2 +
> arch/h8300/include/asm/pci.h | 19 ++
> arch/h8300/include/asm/pgtable.h | 49 +++++
> arch/h8300/include/asm/processor.h | 144 +++++++++++++
> arch/h8300/include/asm/ptrace.h | 36 ++++
> arch/h8300/include/asm/segment.h | 49 +++++
> arch/h8300/include/asm/sh_bios.h | 4 +
> arch/h8300/include/asm/signal.h | 22 ++
> arch/h8300/include/asm/smp.h | 1 +
> arch/h8300/include/asm/spinlock.h | 6 +
> arch/h8300/include/asm/string.h | 17 ++
> arch/h8300/include/asm/switch_to.h | 51 +++++
> arch/h8300/include/asm/syscall.h | 56 +++++
> arch/h8300/include/asm/thread_info.h | 119 +++++++++++
> arch/h8300/include/asm/timer.h | 31 +++
> arch/h8300/include/asm/tlb.h | 8 +
> arch/h8300/include/asm/topology.h | 6 +
> arch/h8300/include/asm/traps.h | 41 ++++
> arch/h8300/include/asm/uaccess.h | 136 +++++++++++++
> arch/h8300/include/asm/unaligned.h | 11 +
> arch/h8300/include/asm/user.h | 74 +++++++
> 42 files changed, 2274 insertions(+)
> create mode 100644 arch/h8300/include/asm/Kbuild
> create mode 100644 arch/h8300/include/asm/asm-offsets.h
> create mode 100644 arch/h8300/include/asm/atomic.h
> create mode 100644 arch/h8300/include/asm/bitops.h
> create mode 100644 arch/h8300/include/asm/bootparams.h
> create mode 100644 arch/h8300/include/asm/bug.h
> create mode 100644 arch/h8300/include/asm/cache.h
> create mode 100644 arch/h8300/include/asm/checksum.h
> create mode 100644 arch/h8300/include/asm/cmpxchg.h
> create mode 100644 arch/h8300/include/asm/delay.h
> create mode 100644 arch/h8300/include/asm/device.h
> create mode 100644 arch/h8300/include/asm/dma-mapping.h
> create mode 100644 arch/h8300/include/asm/elf.h
> create mode 100644 arch/h8300/include/asm/emergency-restart.h
> create mode 100644 arch/h8300/include/asm/flat.h
> create mode 100644 arch/h8300/include/asm/io.h
> create mode 100644 arch/h8300/include/asm/irq.h
> create mode 100644 arch/h8300/include/asm/irqflags.h
> create mode 100644 arch/h8300/include/asm/mc146818rtc.h
> create mode 100644 arch/h8300/include/asm/mutex.h
> create mode 100644 arch/h8300/include/asm/page.h
> create mode 100644 arch/h8300/include/asm/page_offset.h
> create mode 100644 arch/h8300/include/asm/pci.h
> create mode 100644 arch/h8300/include/asm/pgtable.h
> create mode 100644 arch/h8300/include/asm/processor.h
> create mode 100644 arch/h8300/include/asm/ptrace.h
> create mode 100644 arch/h8300/include/asm/segment.h
> create mode 100644 arch/h8300/include/asm/sh_bios.h
> create mode 100644 arch/h8300/include/asm/signal.h
> create mode 100644 arch/h8300/include/asm/smp.h
> create mode 100644 arch/h8300/include/asm/spinlock.h
> create mode 100644 arch/h8300/include/asm/string.h
> create mode 100644 arch/h8300/include/asm/switch_to.h
> create mode 100644 arch/h8300/include/asm/syscall.h
> create mode 100644 arch/h8300/include/asm/thread_info.h
> create mode 100644 arch/h8300/include/asm/timer.h
> create mode 100644 arch/h8300/include/asm/tlb.h
> create mode 100644 arch/h8300/include/asm/topology.h
> create mode 100644 arch/h8300/include/asm/traps.h
> create mode 100644 arch/h8300/include/asm/uaccess.h
> create mode 100644 arch/h8300/include/asm/unaligned.h
> create mode 100644 arch/h8300/include/asm/user.h
>
> diff --git a/arch/h8300/include/asm/Kbuild b/arch/h8300/include/asm/Kbuild
> new file mode 100644
> index 0000000..9e9f4f3
> --- /dev/null
> +++ b/arch/h8300/include/asm/Kbuild
> @@ -0,0 +1,66 @@
> +generic-y += barrier.h
> +generic-y += bitsperlong.h
> +generic-y += bugs.h
> +generic-y += cacheflush.h
> +generic-y += clkdev.h
> +generic-y += cputime.h
> +generic-y += current.h
> +generic-y += div64.h
> +generic-y += dma.h
> +generic-y += emergency-restart.h
> +generic-y += errno.h
> +generic-y += exec.h
> +generic-y += fb.h
> +generic-y += fcntl.h
> +generic-y += ftrace.h
> +generic-y += futex.h
> +generic-y += hardirq.h
> +generic-y += hash.h
> +generic-y += hw_irq.h
> +generic-y += ioctl.h
> +generic-y += ioctls.h
> +generic-y += ipcbuf.h
> +generic-y += irq_regs.h
> +generic-y += irq_work.h
> +generic-y += kdebug.h
> +generic-y += kmap_types.h
> +generic-y += kvm_para.h
> +generic-y += linkage.h
> +generic-y += local.h
> +generic-y += local64.h
> +generic-y += mcs_spinlock.h
> +generic-y += mman.h
> +generic-y += mmu.h
> +generic-y += mmu_context.h
> +generic-y += module.h
> +generic-y += msgbuf.h
> +generic-y += param.h
> +generic-y += parport.h
> +generic-y += percpu.h
> +generic-y += pgalloc.h
> +generic-y += poll.h
> +generic-y += posix_types.h
> +generic-y += preempt.h
> +generic-y += resource.h
> +generic-y += scatterlist.h
> +generic-y += sections.h
> +generic-y += sembuf.h
> +generic-y += serial.h
> +generic-y += setup.h
> +generic-y += shmbuf.h
> +generic-y += shmparam.h
> +generic-y += siginfo.h
> +generic-y += sizes.h
> +generic-y += socket.h
> +generic-y += sockios.h
> +generic-y += stat.h
> +generic-y += statfs.h
> +generic-y += termbits.h
> +generic-y += termios.h
> +generic-y += timex.h
> +generic-y += tlbflush.h
> +generic-y += trace_clock.h
> +generic-y += types.h
> +generic-y += ucontext.h
> +generic-y += vga.h
> +generic-y += xor.h
> diff --git a/arch/h8300/include/asm/asm-offsets.h b/arch/h8300/include/asm/asm-offsets.h
> new file mode 100644
> index 0000000..d370ee3
> --- /dev/null
> +++ b/arch/h8300/include/asm/asm-offsets.h
> @@ -0,0 +1 @@
> +#include <generated/asm-offsets.h>
> diff --git a/arch/h8300/include/asm/atomic.h b/arch/h8300/include/asm/atomic.h
> new file mode 100644
> index 0000000..7ca73f8
> --- /dev/null
> +++ b/arch/h8300/include/asm/atomic.h
> @@ -0,0 +1,159 @@
> +#ifndef __ARCH_H8300_ATOMIC__
> +#define __ARCH_H8300_ATOMIC__
> +
> +#include <linux/types.h>
> +#include <asm/cmpxchg.h>
> +
> +/*
> + * Atomic operations that C can't guarantee us. Useful for
> + * resource counting etc..
> + */
> +
> +#define ATOMIC_INIT(i) { (i) }
> +
> +#define atomic_read(v) ACCESS_ONCE((v)->counter)
> +#define atomic_set(v, i) (((v)->counter) = i)
> +
> +#include <linux/kernel.h>
> +
> +static inline int atomic_add_return(int i, atomic_t *v)
> +{
> + h8300flags flags;
> + int ret;
> +
> + flags = arch_local_irq_save();
> + ret = v->counter += i;
> + arch_local_irq_restore(flags);
> + return ret;
> +}
> +
> +#define atomic_add(i, v) atomic_add_return(i, v)
> +#define atomic_add_negative(a, v) (atomic_add_return((a), (v)) < 0)
> +
> +static inline int atomic_sub_return(int i, atomic_t *v)
> +{
> + h8300flags flags;
> + int ret;
> +
> + flags = arch_local_irq_save();
> + ret = v->counter -= i;
> + arch_local_irq_restore(flags);
> + return ret;
> +}
> +
> +#define atomic_sub(i, v) atomic_sub_return(i, v)
> +#define atomic_sub_and_test(i, v) (atomic_sub_return(i, v) == 0)
> +
> +static inline int atomic_inc_return(atomic_t *v)
> +{
> + h8300flags flags;
> + int ret;
> +
> + flags = arch_local_irq_save();
> + v->counter++;
> + ret = v->counter;
> + arch_local_irq_restore(flags);
> + return ret;
> +}
> +
> +#define atomic_inc(v) atomic_inc_return(v)
> +
> +/*
> + * atomic_inc_and_test - increment and test
> + * @v: pointer of type atomic_t
> + *
> + * Atomically increments @v by 1
> + * and returns true if the result is zero, or false for all
> + * other cases.
> + */
> +#define atomic_inc_and_test(v) (atomic_inc_return(v) == 0)
> +
> +static inline int atomic_dec_return(atomic_t *v)
> +{
> + h8300flags flags;
> + int ret;
> +
> + flags = arch_local_irq_save();
> + --v->counter;
> + ret = v->counter;
> + arch_local_irq_restore(flags);
> + return ret;
> +}
> +
> +#define atomic_dec(v) atomic_dec_return(v)
> +
> +static inline int atomic_dec_and_test(atomic_t *v)
> +{
> + h8300flags flags;
> + int ret;
> +
> + flags = arch_local_irq_save();
> + --v->counter;
> + ret = v->counter;
> + arch_local_irq_restore(flags);
> + return ret == 0;
> +}
> +
> +static inline int atomic_cmpxchg(atomic_t *v, int old, int new)
> +{
> + int ret;
> + h8300flags flags;
> +
> + flags = arch_local_irq_save();
> + ret = v->counter;
> + if (likely(ret == old))
> + v->counter = new;
> + arch_local_irq_restore(flags);
> + return ret;
> +}
> +
> +static inline int __atomic_add_unless(atomic_t *v, int a, int u)
> +{
> + int ret;
> + h8300flags flags;
> +
> + flags = arch_local_irq_save();
> + ret = v->counter;
> + if (ret != u)
> + v->counter += a;
> + arch_local_irq_restore(flags);
> + return ret;
> +}
> +
> +static inline void atomic_clear_mask(unsigned long mask, unsigned long *v)
> +{
> + unsigned char ccr;
> + unsigned long tmp;
> +
> + __asm__ __volatile__("stc ccr,%w3\n\t"
> + "orc #0x80,ccr\n\t"
> + "mov.l %0,%1\n\t"
> + "and.l %2,%1\n\t"
> + "mov.l %1,%0\n\t"
> + "ldc %w3,ccr"
> + : "=m"(*v), "=r"(tmp)
> + : "g"(~(mask)), "r"(ccr));
> +}
> +
> +static inline void atomic_set_mask(unsigned long mask, unsigned long *v)
> +{
> + unsigned char ccr;
> + unsigned long tmp;
> +
> + __asm__ __volatile__("stc ccr,%w3\n\t"
> + "orc #0x80,ccr\n\t"
> + "mov.l %0,%1\n\t"
> + "or.l %2,%1\n\t"
> + "mov.l %1,%0\n\t"
> + "ldc %w3,ccr"
> + : "=m"(*v), "=r"(tmp)
> + : "g"(~(mask)), "r"(ccr));
> +}
> +
> +/* 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_H8300_ATOMIC __ */
> diff --git a/arch/h8300/include/asm/bitops.h b/arch/h8300/include/asm/bitops.h
> new file mode 100644
> index 0000000..05999ab
> --- /dev/null
> +++ b/arch/h8300/include/asm/bitops.h
> @@ -0,0 +1,185 @@
> +#ifndef _H8300_BITOPS_H
> +#define _H8300_BITOPS_H
> +
> +/*
> + * Copyright 1992, Linus Torvalds.
> + * Copyright 2002, Yoshinori Sato
> + */
> +
> +#include <linux/compiler.h>
> +
> +#ifdef __KERNEL__
> +
> +#ifndef _LINUX_BITOPS_H
> +#error only <linux/bitops.h> can be included directly
> +#endif
> +
> +/*
> + * Function prototypes to keep gcc -Wall happy
> + */
> +
> +/*
> + * 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;
> +
> + result = -1;
> + __asm__("1:\n\t"
> + "shlr.l %2\n\t"
> + "adds #1,%0\n\t"
> + "bcs 1b"
> + : "=r"(result)
> + : "0"(result), "r"(word));
> + return result;
> +}
> +
> +#define H8300_GEN_BITOP(FNAME, OP) \
> +static inline void FNAME(int nr, volatile unsigned long *addr) \
> +{ \
> + unsigned char *b_addr; \
> + unsigned char bit = nr & 7; \
> + \
> + b_addr = (unsigned char *)addr + ((nr >> 3) ^ 3); \
> + if (__builtin_constant_p(nr)) { \
> + __asm__(OP " %1,%0" : "+WU"(*b_addr) : "i"(nr & 7)); \
> + } else { \
> + __asm__(OP " %s1,%0" : "+WU"(*b_addr) : "r"(bit)); \
> + } \
> +}
> +
> +/*
> + * clear_bit() doesn't provide any barrier for the compiler.
> + */
> +#define smp_mb__before_clear_bit() barrier()
> +#define smp_mb__after_clear_bit() barrier()
> +
> +H8300_GEN_BITOP(set_bit, "bset")
> +H8300_GEN_BITOP(clear_bit, "bclr")
> +H8300_GEN_BITOP(change_bit, "bnot")
> +#define __set_bit(nr, addr) set_bit((nr), (addr))
> +#define __clear_bit(nr, addr) clear_bit((nr), (addr))
> +#define __change_bit(nr, addr) change_bit((nr), (addr))
> +
> +#undef H8300_GEN_BITOP
> +
> +static inline int test_bit(int nr, const unsigned long *addr)
> +{
> + int ret = 0;
> + unsigned char *b_addr;
> + unsigned char bit = nr & 7;
> +
> + b_addr = (unsigned char *)addr + ((nr >> 3) ^ 3);
> + if (__builtin_constant_p(nr)) {
> + __asm__("bld %Z2,%1\n\t"
> + "rotxl %0\n\t"
> + : "=r"(ret)
> + : "WU"(*b_addr), "i"(nr & 7), "0"(ret) : "cc");
> + } else {
> + __asm__("btst %w2,%1\n\t"
> + "beq 1f\n\t"
> + "inc.l #1,%0\n"
> + "1:"
> + : "=r"(ret)
> + : "WU"(*b_addr), "r"(bit), "0"(ret) : "cc");
> + }
> + return ret;
> +}
> +
> +#define __test_bit(nr, addr) test_bit(nr, addr)
> +
> +#define H8300_GEN_TEST_BITOP(FNNAME, OP) \
> +static inline int FNNAME(int nr, void *addr) \
> +{ \
> + int retval = 0; \
> + char ccrsave; \
> + unsigned char *b_addr; \
> + unsigned char bit = nr & 7; \
> + \
> + b_addr = (unsigned char *)addr + ((nr >> 3) ^ 3); \
> + if (__builtin_constant_p(nr)) { \
> + __asm__("stc ccr,%s2\n\t" \
> + "orc #0x80,ccr\n\t" \
> + "bld %4,%1\n\t" \
> + OP " %4,%1\n\t" \
> + "rotxl.l %0\n\t" \
> + "ldc %s2,ccr" \
> + : "=r"(retval), "+WU" (*b_addr), "=&r"(ccrsave) \
> + : "0"(retval), "i"(nr & 7) : "cc"); \
> + } else { \
> + __asm__("stc ccr,%t3\n\t" \
> + "orc #0x80,ccr\n\t" \
> + "btst %s3,%1\n\t" \
> + OP " %s3,%1\n\t" \
> + "beq 1f\n\t" \
> + "inc.l #1,%0\n\t" \
> + "1:\n" \
> + "ldc %t3,ccr" \
> + : "=r"(retval), "+WU" (*b_addr) \
> + : "0" (retval), "r"(bit) : "cc"); \
> + } \
> + return retval; \
> +} \
> + \
> +static inline int __ ## FNNAME(int nr, void *addr) \
> +{ \
> + int retval = 0; \
> + unsigned char *b_addr; \
> + unsigned char bit = nr & 7; \
> + \
> + b_addr = (unsigned char *)addr + ((nr >> 3) ^ 3); \
> + if (__builtin_constant_p(nr)) { \
> + __asm__("bld %3,%1\n\t" \
> + OP " %3,%1\n\t" \
> + "rotxl.l %0\n\t" \
> + : "=r"(retval), "+WU"(*b_addr) \
> + : "0" (retval), "i"(nr & 7)); \
> + } else { \
> + __asm__("btst %s3,%1\n\t" \
> + OP " %s3,%1\n\t" \
> + "beq 1f\n\t" \
> + "inc.l #1,%0\n\t" \
> + "1:" \
> + : "=r"(retval), "+WU"(*b_addr) \
> + : "0" (retval), "r"(bit)); \
> + } \
> + return retval; \
> +}
> +
> +H8300_GEN_TEST_BITOP(test_and_set_bit, "bset")
> +H8300_GEN_TEST_BITOP(test_and_clear_bit, "bclr")
> +H8300_GEN_TEST_BITOP(test_and_change_bit, "bnot")
> +#undef H8300_GEN_TEST_BITOP
> +
> +#include <asm-generic/bitops/ffs.h>
> +
> +static inline unsigned long __ffs(unsigned long word)
> +{
> + unsigned long result;
> +
> + result = -1;
> + __asm__("1:\n\t"
> + "shlr.l %2\n\t"
> + "adds #1,%0\n\t"
> + "bcc 1b"
> + : "=r" (result)
> + : "0"(result), "r"(word));
> + return result;
> +}
> +
> +#include <asm-generic/bitops/find.h>
> +#include <asm-generic/bitops/sched.h>
> +#include <asm-generic/bitops/hweight.h>
> +#include <asm-generic/bitops/lock.h>
> +#include <asm-generic/bitops/le.h>
> +#include <asm-generic/bitops/ext2-atomic.h>
> +
> +#endif /* __KERNEL__ */
> +
> +#include <asm-generic/bitops/fls.h>
> +#include <asm-generic/bitops/__fls.h>
> +#include <asm-generic/bitops/fls64.h>
> +
> +#endif /* _H8300_BITOPS_H */
> diff --git a/arch/h8300/include/asm/bootparams.h b/arch/h8300/include/asm/bootparams.h
> new file mode 100644
> index 0000000..6c0b145
> --- /dev/null
> +++ b/arch/h8300/include/asm/bootparams.h
> @@ -0,0 +1,17 @@
> +/*
> +H8/300 kernel boot parameters
> +*/
> +
> +#ifndef __ASM_H8300_BOOTPARAMS__
> +#define __ASM_H8300_BOOTPARAMS__
> +
> +struct bootparams {
> + short size;
> + unsigned char gpio_ddr[24];
> + unsigned char gpio_use[24];
> + unsigned int clock_freq;
> + unsigned int ram_end;
> + unsigned char *command_line;
> +} __packed __aligned(2);
> +
> +#endif
> diff --git a/arch/h8300/include/asm/bug.h b/arch/h8300/include/asm/bug.h
> new file mode 100644
> index 0000000..1e1be81
> --- /dev/null
> +++ b/arch/h8300/include/asm/bug.h
> @@ -0,0 +1,12 @@
> +#ifndef _H8300_BUG_H
> +#define _H8300_BUG_H
> +
> +/* always true */
> +#define is_valid_bugaddr(addr) (1)
> +
> +#include <asm-generic/bug.h>
> +
> +struct pt_regs;
> +extern void die(const char *str, struct pt_regs *fp, unsigned long err);
> +
> +#endif
> diff --git a/arch/h8300/include/asm/cache.h b/arch/h8300/include/asm/cache.h
> new file mode 100644
> index 0000000..0ef1edc
> --- /dev/null
> +++ b/arch/h8300/include/asm/cache.h
> @@ -0,0 +1,11 @@
> +#ifndef __ARCH_H8300_CACHE_H
> +#define __ARCH_H8300_CACHE_H
> +
> +/* bytes per L1 cache line */
> +#define L1_CACHE_SHIFT 2
> +#define L1_CACHE_BYTES (1 << L1_CACHE_SHIFT)
> +
> +#define __cacheline_aligned
> +#define ____cacheline_aligned
> +
> +#endif
> diff --git a/arch/h8300/include/asm/checksum.h b/arch/h8300/include/asm/checksum.h
> new file mode 100644
> index 0000000..59e2adc9
> --- /dev/null
> +++ b/arch/h8300/include/asm/checksum.h
> @@ -0,0 +1,102 @@
> +#ifndef _H8300_CHECKSUM_H
> +#define _H8300_CHECKSUM_H
> +
> +/*
> + * computes the checksum of a memory block at buff, length len,
> + * and adds in "sum" (32-bit)
> + *
> + * returns a 32-bit number suitable for feeding into itself
> + * or csum_tcpudp_magic
> + *
> + * this function must be called with even lengths, except
> + * for the last fragment, which may be odd
> + *
> + * it's best to have buff aligned on a 32-bit boundary
> + */
> +__wsum csum_partial(const void *buff, int len, __wsum sum);
> +
> +/*
> + * the same as csum_partial, but copies from src while it
> + * checksums
> + *
> + * here even more important to align src and dst on a 32-bit (or even
> + * better 64-bit) boundary
> + */
> +
> +__wsum csum_partial_copy_nocheck(const void *src, void *dst,
> + int len, __wsum 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 __wsum csum_partial_copy_from_user(const void __user *src, void *dst,
> + int len, __wsum sum, int *csum_err);
> +
> +__sum16 ip_fast_csum(const void *iph, unsigned int ihl);
> +
> +
> +/*
> + * Fold a partial checksum
> + */
> +
> +static inline __sum16 csum_fold(__wsum sum)
> +{
> + __asm__("add.w %e0,%f0\n\t"
> + "xor.w %e0,%e0\n\t"
> + "rotxl.w %e0\n\t"
> + "add.w %e0,%f0\n\t"
> + "sub.w %e0,%e0\n\t"
> + : "=r"(sum)
> + : "0"(sum));
> + return (__force __sum16)~sum;
> +}
> +
> +
> +/*
> + * computes the checksum of the TCP/UDP pseudo-header
> + * returns a 16-bit checksum, already complemented
> + */
> +
> +static inline __wsum
> +csum_tcpudp_nofold(__be32 saddr, __be32 daddr, unsigned short len,
> + unsigned short proto, __wsum sum)
> +{
> + int tmp;
> +
> + __asm__ ("sub.l %1,%1\n\t"
> + "add.l %3,%0\n\t"
> + "addx #0,%w1\n\t"
> + "add.l %4,%0\n\t"
> + "addx #0,%w1\n\t"
> + "add.l %5,%0\n\t"
> + "addx #0,%w1\n\t"
> + "add.l %1,%0\n\t"
> + "bcc 1f\n\t"
> + "inc.l #1,%0\n"
> + "1:"
> + : "=&r" (sum), "=&r"(tmp)
> + : "0" (sum), "1" (daddr),
> + "r" (saddr), "r" (len + proto));
> + return sum;
> +}
> +
> +static inline __sum16
> +csum_tcpudp_magic(__be32 saddr, __be32 daddr, unsigned short len,
> + unsigned short proto, __wsum sum)
> +{
> + return csum_fold(csum_tcpudp_nofold(saddr, daddr, len, proto, sum));
> +}
> +
> +/*
> + * this routine is used for miscellaneous IP-like checksums, mainly
> + * in icmp.c
> + */
> +
> +extern __sum16 ip_compute_csum(const void *buff, int len);
> +
> +#endif /* _H8300_CHECKSUM_H */
> diff --git a/arch/h8300/include/asm/cmpxchg.h b/arch/h8300/include/asm/cmpxchg.h
> new file mode 100644
> index 0000000..95fec4c
> --- /dev/null
> +++ b/arch/h8300/include/asm/cmpxchg.h
> @@ -0,0 +1,65 @@
> +#ifndef __ARCH_H8300_CMPXCHG__
> +#define __ARCH_H8300_CMPXCHG__
> +
> +#include <linux/irqflags.h>
> +
> +#define xchg(ptr, x) \
> + ((__typeof__(*(ptr)))__xchg((unsigned long)(x), (ptr), \
> + sizeof(*(ptr))))
> +
> +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__
> + ("mov.b %2,%0\n\t"
> + "mov.b %1,%2"
> + : "=&r" (tmp) : "r" (x), "m" (*__xg(ptr)));
> + break;
> + case 2:
> + __asm__ __volatile__
> + ("mov.w %2,%0\n\t"
> + "mov.w %1,%2"
> + : "=&r" (tmp) : "r" (x), "m" (*__xg(ptr)));
> + break;
> + case 4:
> + __asm__ __volatile__
> + ("mov.l %2,%0\n\t"
> + "mov.l %1,%2"
> + : "=&r" (tmp) : "r" (x), "m" (*__xg(ptr)));
> + break;
> + default:
> + tmp = 0;
> + }
> + local_irq_restore(flags);
> + return tmp;
> +}
> +
> +#include <asm-generic/cmpxchg-local.h>
> +
> +/*
> + * cmpxchg_local and cmpxchg64_local are atomic wrt current CPU. Always make
> + * them available.
> + */
> +#define cmpxchg_local(ptr, o, n) \
> + ((__typeof__(*(ptr)))__cmpxchg_local_generic((ptr), \
> + (unsigned long)(o), \
> + (unsigned long)(n), \
> + sizeof(*(ptr))))
> +#define cmpxchg64_local(ptr, o, n) __cmpxchg64_local_generic((ptr), (o), (n))
> +
> +#ifndef CONFIG_SMP
> +#include <asm-generic/cmpxchg.h>
> +#endif
> +
> +#define atomic_xchg(v, new) (xchg(&((v)->counter), new))
> +
> +#endif /* __ARCH_H8300_CMPXCHG__ */
> diff --git a/arch/h8300/include/asm/delay.h b/arch/h8300/include/asm/delay.h
> new file mode 100644
> index 0000000..2bdde59
> --- /dev/null
> +++ b/arch/h8300/include/asm/delay.h
> @@ -0,0 +1,38 @@
> +#ifndef _H8300_DELAY_H
> +#define _H8300_DELAY_H
> +
> +#include <asm/param.h>
> +
> +/*
> + * Copyright (C) 2002 Yoshinori Sato <ysato@sourceforge.jp>
> + *
> + * Delay routines, using a pre-computed "loops_per_second" value.
> + */
> +
> +static inline void __delay(unsigned long loops)
> +{
> + __asm__ __volatile__ ("1:\n\t"
> + "dec.l #1,%0\n\t"
> + "bne 1b"
> + : "=r" (loops) : "0"(loops));
> +}
> +
> +/*
> + * Use only for very small delays ( < 1 msec). Should probably use a
> + * lookup table, really, as the multiplications take much too long with
> + * short delays. This is a "reasonable" implementation, though (and the
> + * first constant multiplications gets optimized away if the delay is
> + * a constant)
> + */
> +
> +extern unsigned long loops_per_jiffy;
> +
> +static inline void udelay(unsigned long usecs)
> +{
> + usecs *= 4295; /* 2**32 / 1000000 */
> + usecs /= (loops_per_jiffy*HZ);
> + if (usecs)
> + __delay(usecs);
> +}
> +
> +#endif /* _H8300_DELAY_H */
> diff --git a/arch/h8300/include/asm/device.h b/arch/h8300/include/asm/device.h
> new file mode 100644
> index 0000000..06746c5
> --- /dev/null
> +++ b/arch/h8300/include/asm/device.h
> @@ -0,0 +1,6 @@
> +/*
> + * Arch specific extensions to struct device
> + *
> + * This file is released under the GPLv2
> + */
> +#include <asm-generic/device.h>
> diff --git a/arch/h8300/include/asm/dma-mapping.h b/arch/h8300/include/asm/dma-mapping.h
> new file mode 100644
> index 0000000..f6f4716
> --- /dev/null
> +++ b/arch/h8300/include/asm/dma-mapping.h
> @@ -0,0 +1,124 @@
> +#ifndef _H8300_DMA_MAPPING_H
> +#define _H8300_DMA_MAPPING_H
> +
> +struct scatterlist;
> +
> +static inline int dma_supported(struct device *dev, u64 mask)
> +{
> + return 1;
> +}
> +
> +static inline int dma_set_mask(struct device *dev, u64 mask)
> +{
> + return 0;
> +}
> +
> +extern void *dma_alloc_coherent(struct device *, size_t,
> + dma_addr_t *, gfp_t);
> +extern void dma_free_coherent(struct device *, size_t,
> + void *, dma_addr_t);
> +
> +static inline void *dma_alloc_attrs(struct device *dev, size_t size,
> + dma_addr_t *dma_handle, gfp_t flag,
> + struct dma_attrs *attrs)
> +{
> + /* attrs is not supported and ignored */
> + return dma_alloc_coherent(dev, size, dma_handle, flag);
> +}
> +
> +static inline void dma_free_attrs(struct device *dev, size_t size,
> + void *cpu_addr, dma_addr_t dma_handle,
> + struct dma_attrs *attrs)
> +{
> + /* attrs is not supported and ignored */
> + dma_free_coherent(dev, size, cpu_addr, dma_handle);
> +}
> +
> +static inline void *dma_alloc_noncoherent(struct device *dev, size_t size,
> + dma_addr_t *handle, gfp_t flag)
> +{
> + return dma_alloc_coherent(dev, size, handle, flag);
> +}
> +static inline void dma_free_noncoherent(struct device *dev, size_t size,
> + void *addr, dma_addr_t handle)
> +{
> + dma_free_coherent(dev, size, addr, handle);
> +}
> +static inline void dma_cache_sync(struct device *dev, void *vaddr, size_t size,
> + enum dma_data_direction dir)
> +{
> + /* we use coherent allocation, so not much to do here. */
> +}
> +
> +extern dma_addr_t dma_map_single(struct device *, void *, size_t,
> + enum dma_data_direction);
> +static inline void dma_unmap_single(struct device *dev, dma_addr_t addr,
> + size_t size, enum dma_data_direction dir)
> +{
> +}
> +
> +extern dma_addr_t dma_map_page(struct device *, struct page *,
> + unsigned long, size_t size,
> + enum dma_data_direction);
> +static inline void dma_unmap_page(struct device *dev, dma_addr_t address,
> + size_t size, enum dma_data_direction dir)
> +{
> +}
> +
> +extern int dma_map_sg(struct device *, struct scatterlist *, int,
> + enum dma_data_direction);
> +static inline void dma_unmap_sg(struct device *dev, struct scatterlist *sg,
> + int nhwentries, enum dma_data_direction dir)
> +{
> +}
> +
> +extern void dma_sync_single_for_device(struct device *, dma_addr_t, size_t,
> + enum dma_data_direction);
> +extern void dma_sync_sg_for_device(struct device *, struct scatterlist *, int,
> + enum dma_data_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 for now */
> + dma_sync_single_for_device(dev, dma_handle, offset + size, direction);
> +}
> +
> +static inline void dma_sync_single_for_cpu(struct device *dev,
> + dma_addr_t handle,
> + size_t size,
> + enum dma_data_direction dir)
> +{
> +}
> +
> +static inline void dma_sync_sg_for_cpu(struct device *dev,
> + struct scatterlist *sg,
> + int nents, enum dma_data_direction dir)
> +{
> +}
> +
> +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 for now */
> + dma_sync_single_for_cpu(dev, dma_handle, offset + size, direction);
> +}
> +
> +static inline int dma_mapping_error(struct device *dev, dma_addr_t handle)
> +{
> + return 0;
> +}
> +
> +/* drivers/base/dma-mapping.c */
> +extern int dma_common_mmap(struct device *dev, struct vm_area_struct *vma,
> + void *cpu_addr, dma_addr_t dma_addr, size_t size);
> +extern int dma_common_get_sgtable(struct device *dev, struct sg_table *sgt,
> + void *cpu_addr, dma_addr_t dma_addr,
> + size_t size);
> +
> +#define dma_mmap_coherent(d, v, c, h, s) dma_common_mmap(d, v, c, h, s)
> +#define dma_get_sgtable(d, t, v, h, s) dma_common_get_sgtable(d, t, v, h, s)
> +
> +#endif
> diff --git a/arch/h8300/include/asm/elf.h b/arch/h8300/include/asm/elf.h
> new file mode 100644
> index 0000000..09031d0
> --- /dev/null
> +++ b/arch/h8300/include/asm/elf.h
> @@ -0,0 +1,101 @@
> +#ifndef __ASM_H8300_ELF_H
> +#define __ASM_H8300_ELF_H
> +
> +/*
> + * ELF register definitions..
> + */
> +
> +#include <asm/ptrace.h>
> +#include <asm/user.h>
> +
> +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_H8_300)
> +
> +/*
> + * These are used to set parameters in the core dumps.
> + */
> +#define ELF_CLASS ELFCLASS32
> +#define ELF_DATA ELFDATA2MSB
> +#define ELF_ARCH EM_H8_300
> +#if defined(CONFIG_CPU_H8300H)
> +#define ELF_CORE_EFLAGS 0x810000
> +#endif
> +#if defined(CONFIG_CPU_H8S)
> +#define ELF_CORE_EFLAGS 0x820000
> +#endif
> +
> +#define ELF_PLAT_INIT(_r) do { (_r)->er1 = 0; } while (0)
> +
> +#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
> +
> +/* 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)
> +
> +#define R_H8_NONE 0
> +#define R_H8_DIR32 1
> +#define R_H8_DIR32_28 2
> +#define R_H8_DIR32_24 3
> +#define R_H8_DIR32_16 4
> +#define R_H8_DIR32U 6
> +#define R_H8_DIR32U_28 7
> +#define R_H8_DIR32U_24 8
> +#define R_H8_DIR32U_20 9
> +#define R_H8_DIR32U_16 10
> +#define R_H8_DIR24 11
> +#define R_H8_DIR24_20 12
> +#define R_H8_DIR24_16 13
> +#define R_H8_DIR24U 14
> +#define R_H8_DIR24U_20 15
> +#define R_H8_DIR24U_16 16
> +#define R_H8_DIR16 17
> +#define R_H8_DIR16U 18
> +#define R_H8_DIR16S_32 19
> +#define R_H8_DIR16S_28 20
> +#define R_H8_DIR16S_24 21
> +#define R_H8_DIR16S_20 22
> +#define R_H8_DIR16S 23
> +#define R_H8_DIR8 24
> +#define R_H8_DIR8U 25
> +#define R_H8_DIR8Z_32 26
> +#define R_H8_DIR8Z_28 27
> +#define R_H8_DIR8Z_24 28
> +#define R_H8_DIR8Z_20 29
> +#define R_H8_DIR8Z_16 30
> +#define R_H8_PCREL16 31
> +#define R_H8_PCREL8 32
> +#define R_H8_BPOS 33
> +#define R_H8_PCREL32 34
> +#define R_H8_GOT32O 35
> +#define R_H8_GOT16O 36
> +#define R_H8_DIR16A8 59
> +#define R_H8_DIR16R8 60
> +#define R_H8_DIR24A8 61
> +#define R_H8_DIR24R8 62
> +#define R_H8_DIR32A16 63
> +#define R_H8_ABS32 65
> +#define R_H8_ABS32A16 127
> +
> +#endif
> diff --git a/arch/h8300/include/asm/emergency-restart.h b/arch/h8300/include/asm/emergency-restart.h
> new file mode 100644
> index 0000000..108d8c4
> --- /dev/null
> +++ b/arch/h8300/include/asm/emergency-restart.h
> @@ -0,0 +1,6 @@
> +#ifndef _ASM_EMERGENCY_RESTART_H
> +#define _ASM_EMERGENCY_RESTART_H
> +
> +#include <asm-generic/emergency-restart.h>
> +
> +#endif /* _ASM_EMERGENCY_RESTART_H */
> diff --git a/arch/h8300/include/asm/flat.h b/arch/h8300/include/asm/flat.h
> new file mode 100644
> index 0000000..9ff092e
> --- /dev/null
> +++ b/arch/h8300/include/asm/flat.h
> @@ -0,0 +1,27 @@
> +/*
> + * arch/h8300/asm/include/flat.h -- uClinux flat-format executables
> + */
> +
> +#ifndef __H8300_FLAT_H__
> +#define __H8300_FLAT_H__
> +
> +#define flat_argvp_envp_on_stack() 1
> +#define flat_old_ram_flag(flags) 1
> +#define flat_reloc_valid(reloc, size) ((reloc) <= (size))
> +#define flat_set_persistent(relval, p) 0
> +
> +/*
> + * on the H8 a couple of the relocations have an instruction in the
> + * top byte. As there can only be 24bits of address space, we just
> + * always preserve that 8bits at the top, when it isn't an instruction
> + * is is 0 (davidm@snapgear.com)
> + */
> +
> +#define flat_get_relocate_addr(rel) (rel & ~0x00000001)
> +#define flat_get_addr_from_rp(rp, relval, flags, persistent) \
> + (get_unaligned(rp) & (((flags) & FLAT_FLAG_GOTPIC) ? \
> + 0xffffffff : 0x00ffffff))
> +#define flat_put_addr_at_rp(rp, addr, rel) \
> + put_unaligned(((*(char *)(rp)) << 24) | ((addr) & 0x00ffffff), (rp))
> +
> +#endif /* __H8300_FLAT_H__ */
> diff --git a/arch/h8300/include/asm/io.h b/arch/h8300/include/asm/io.h
> new file mode 100644
> index 0000000..51ee096
> --- /dev/null
> +++ b/arch/h8300/include/asm/io.h
> @@ -0,0 +1,314 @@
> +#ifndef _H8300_IO_H
> +#define _H8300_IO_H
> +
> +#ifdef __KERNEL__
> +
> +#include <linux/types.h>
> +
> +#define __raw_readb(addr) ({ u8 __v = *(volatile u8 *)(addr); __v; })
> +
> +#define __raw_readw(addr) ({ u16 __v = *(volatile u16 *)(addr); __v; })
> +
> +#define __raw_readl(addr) ({ u32 __v = *(volatile u32 *)(addr); __v; })
> +
> +#define __raw_writeb(b, addr) (void)((*(volatile u8 *)(addr)) = (b))
> +
> +#define __raw_writew(b, addr) (void)((*(volatile u16 *)(addr)) = (b))
> +
> +#define __raw_writel(b, addr) (void)((*(volatile u32 *)(addr)) = (b))
> +
> +#define readb __raw_readb
> +#define readw __raw_readw
> +#define readl __raw_readl
> +#define writeb __raw_writeb
> +#define writew __raw_writew
> +#define writel __raw_writel
> +
> +#if defined(CONFIG_H83069)
> +#define ABWCR 0xFEE020
> +#elif defined(CONFIG_H8S2678)
> +#define ABWCR 0xFFFEC0
> +#endif
> +
> +#ifdef CONFIG_H8300_BUBSSWAP
> +#define _swapw(x) __builtin_bswap16(x)
> +#define _swapl(x) __builtin_bswap32(x)
> +#else
> +#define _swapw(x) (x)
> +#define _swapl(x) (x)
> +#endif
> +
> +static inline int h8300_buswidth(unsigned int addr)
> +{
> + return (*(volatile u8 *)ABWCR & (1 << ((addr >> 21) & 7))) == 0;
> +}
> +
> +static inline void io_outsb(unsigned int addr, const void *buf, int len)
> +{
> + volatile unsigned char *ap_b = (volatile unsigned char *) addr;
> + volatile unsigned short *ap_w = (volatile unsigned short *) addr;
> + unsigned char *bp = (unsigned char *) buf;
> +
> + if (h8300_buswidth(addr) && (addr & 1)) {
> + while (len--)
> + *ap_w = *bp++;
> + } else {
> + while (len--)
> + *ap_b = *bp++;
> + }
> +}
> +
> +static inline void io_outsw(unsigned int addr, const void *buf, int len)
> +{
> + volatile unsigned short *ap = (volatile unsigned short *) addr;
> + unsigned short *bp = (unsigned short *) buf;
> +
> + while (len--)
> + *ap = _swapw(*bp++);
> +}
> +
> +static inline void io_outsl(unsigned int addr, const void *buf, int len)
> +{
> + volatile unsigned short *ap = (volatile unsigned short *) addr;
> + unsigned short *bp = (unsigned short *) buf;
> +
> + while (len--) {
> + *(ap + 1) = _swapw(*(bp + 0));
> + *(ap + 0) = _swapw(*(bp + 1));
> + bp += 2;
> + }
> +}
> +
> +static inline void io_outsw_noswap(unsigned int addr, const void *buf, int len)
> +{
> + volatile unsigned short *ap = (volatile unsigned short *) addr;
> + unsigned short *bp = (unsigned short *) buf;
> +
> + while (len--)
> + *ap = *bp++;
> +}
> +
> +static inline void io_outsl_noswap(unsigned int addr, const void *buf, int len)
> +{
> + volatile unsigned long *ap = (volatile unsigned long *) addr;
> + unsigned long *bp = (unsigned long *) buf;
> +
> + while (len--)
> + *ap = *bp++;
> +}
> +
> +static inline void io_insb(unsigned int addr, void *buf, int len)
> +{
> + volatile unsigned char *ap_b;
> + volatile unsigned short *ap_w;
> + unsigned char *bp = (unsigned char *) buf;
> +
> + if (h8300_buswidth(addr)) {
> + ap_w = (volatile unsigned short *)(addr & ~1);
> + while (len--)
> + *bp++ = *ap_w & 0xff;
> + } else {
> + ap_b = (volatile unsigned char *)addr;
> + while (len--)
> + *bp++ = *ap_b;
> + }
> +}
> +
> +static inline void io_insw(unsigned int addr, void *buf, int len)
> +{
> + volatile unsigned short *ap = (volatile unsigned short *) addr;
> + unsigned short *bp = (unsigned short *) buf;
> +
> + while (len--)
> + *bp++ = _swapw(*ap);
> +}
> +
> +static inline void io_insl(unsigned int addr, void *buf, int len)
> +{
> + volatile unsigned short *ap = (volatile unsigned short *) addr;
> + unsigned short *bp = (unsigned short *) buf;
> +
> + while (len--) {
> + *(bp + 0) = _swapw(*(ap + 1));
> + *(bp + 1) = _swapw(*(ap + 0));
> + bp += 2;
> + }
> +}
> +
> +static inline void io_insw_noswap(unsigned int addr, void *buf, int len)
> +{
> + volatile unsigned short *ap = (volatile unsigned short *) addr;
> + unsigned short *bp = (unsigned short *) buf;
> +
> + while (len--)
> + *bp++ = *ap;
> +}
> +
> +static inline void io_insl_noswap(unsigned int addr, void *buf, int len)
> +{
> + volatile unsigned long *ap = (volatile unsigned long *) addr;
> + unsigned long *bp = (unsigned long *) buf;
> +
> + while (len--)
> + *bp++ = *ap;
> +}
> +
> +/*
> + * make the short names macros so specific devices
> + * can override them as required
> + */
> +
> +#define memset_io(a, b, c) memset((void *)(a), (b), (c))
> +#define memcpy_fromio(a, b, c) memcpy((a), (void *)(b), (c))
> +#define memcpy_toio(a, b, c) memcpy((void *)(a), (b), (c))
> +
> +#define mmiowb()
> +
> +#define inb(addr) ((h8300_buswidth(addr)) ? \
> + __raw_readw((addr) & ~1) & 0xff:__raw_readb(addr))
> +#define inw(addr) _swapw(__raw_readw(addr))
> +#define inl(addr) (_swapw(__raw_readw(addr) << 16 | \
> + _swapw(__raw_readw(addr + 2))))
> +#define outb(x, addr) ((void)((h8300_buswidth(addr) && ((addr) & 1)) ? \
> + __raw_writeb(x, (addr) & ~1) : \
> + __raw_writeb(x, addr)))
> +#define outw(x, addr) ((void) __raw_writew(_swapw(x), addr))
> +#define outl(x, addr) \
> + ((void) __raw_writel(_swapw(x & 0xffff) | \
> + _swapw(x >> 16) << 16, 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)
> +
> +#define outsb(a, b, l) io_outsb(a, b, l)
> +#define outsw(a, b, l) io_outsw(a, b, l)
> +#define outsl(a, b, l) io_outsl(a, b, l)
> +
> +#define insb(a, b, l) io_insb(a, b, l)
> +#define insw(a, b, l) io_insw(a, b, l)
> +#define insl(a, b, l) io_insl(a, b, l)
> +
> +#define ioread8(a) __raw_readb(a)
> +#define ioread16(a) __raw_readw(a)
> +#define ioread32(a) __raw_readl(a)
> +
> +#define iowrite8(v, a) __raw_writeb((v), (a))
> +#define iowrite16(v, a) __raw_writew((v), (a))
> +#define iowrite32(v, a) __raw_writel((v), (a))
> +
> +#define ioread8_rep(p, d, c) insb(p, d, c)
> +#define ioread16_rep(p, d, c) insw(p, d, c)
> +#define ioread32_rep(p, d, c) insl(p, d, c)
> +#define iowrite8_rep(p, s, c) outsb(p, s, c)
> +#define iowrite16_rep(p, s, c) outsw(p, s, c)
> +#define iowrite32_rep(p, s, c) outsl(p, s, c)
> +
> +#define IO_SPACE_LIMIT 0xffffff
> +
> +/* 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);
> +
> +static inline void *ioremap(unsigned long physaddr, unsigned long size)
> +{
> + return __ioremap(physaddr, size, IOMAP_NOCACHE_SER);
> +}
> +static inline void *ioremap_nocache(unsigned long physaddr,
> + unsigned long size)
> +{
> + return __ioremap(physaddr, size, IOMAP_NOCACHE_SER);
> +}
> +static inline void *ioremap_writethrough(unsigned long physaddr,
> + unsigned long size)
> +{
> + return __ioremap(physaddr, size, IOMAP_WRITETHROUGH);
> +}
> +static inline void *ioremap_fullcache(unsigned long physaddr,
> + unsigned long size)
> +{
> + return __ioremap(physaddr, size, IOMAP_FULL_CACHING);
> +}
> +
> +extern void iounmap(void *addr);
> +
> +#define ioremap_wc ioremap_nocache
> +
> +/* H8/300 internal I/O functions */
> +static inline unsigned char ctrl_inb(unsigned long addr)
> +{
> + return *(volatile unsigned char *)addr;
> +}
> +
> +static inline unsigned short ctrl_inw(unsigned long addr)
> +{
> + return *(volatile unsigned short *)addr;
> +}
> +
> +static inline unsigned long ctrl_inl(unsigned long addr)
> +{
> + return *(volatile unsigned long *)addr;
> +}
> +
> +static inline void ctrl_outb(unsigned char b, unsigned long addr)
> +{
> + *(volatile unsigned char *)addr = b;
> +}
> +
> +static inline void ctrl_outw(unsigned short b, unsigned long addr)
> +{
> + *(volatile unsigned short *)addr = b;
> +}
> +
> +static inline void ctrl_outl(unsigned long b, unsigned long addr)
> +{
> + *(volatile unsigned long *)addr = b;
> +}
> +
> +static inline void ctrl_bclr(int b, unsigned long addr)
> +{
> + if (__builtin_constant_p(b))
> + __asm__("bclr %1,%0" : : "WU"(addr), "i"(b));
> + else
> + __asm__("bclr %w1,%0" : : "WU"(addr), "r"(b));
> +}
> +
> +static inline void ctrl_bset(int b, unsigned long addr)
> +{
> + if (__builtin_constant_p(b))
> + __asm__("bset %1,%0" : : "WU"(addr), "i"(b));
> + else
> + __asm__("bset %w1,%0" : : "WU"(addr), "r"(b));
> +}
> +
> +/*
> + * Macros used for converting between virtual and physical mappings.
> + */
> +#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
> +/*
> + * Convert a physical pointer to a virtual kernel pointer for /dev/mem
> + * access
> + */
> +#define xlate_dev_mem_ptr(p) __va(p)
> +
> +/*
> + * Convert a virtual cached pointer to an uncached pointer
> + */
> +#define xlate_dev_kmem_ptr(p) (p)
> +
> +#endif /* __KERNEL__ */
> +
> +#endif /* _H8300_IO_H */
> diff --git a/arch/h8300/include/asm/irq.h b/arch/h8300/include/asm/irq.h
> new file mode 100644
> index 0000000..69f23f0
> --- /dev/null
> +++ b/arch/h8300/include/asm/irq.h
> @@ -0,0 +1,26 @@
> +#ifndef _H8300_IRQ_H_
> +#define _H8300_IRQ_H_
> +
> +#include <linux/irqchip.h>
> +
> +#if defined(CONFIG_CPU_H8300H)
> +#define NR_IRQS 64
> +#define IRQ_CHIP h8300h_irq_chip
> +#define EXT_IRQ0 12
> +#define EXT_IRQS 6
> +#elif defined(CONFIG_CPU_H8S)
> +#define NR_IRQS 128
> +#define IRQ_CHIP h8s_irq_chip
> +#define EXT_IRQ0 16
> +#define EXT_IRQS 16
> +#endif
> +
> +static inline int irq_canonicalize(int irq)
> +{
> + return irq;
> +}
> +
> +void h8300_init_ipr(void);
> +extern struct irq_chip h8300h_irq_chip;
> +extern struct irq_chip h8s_irq_chip;
> +#endif /* _H8300_IRQ_H_ */
> diff --git a/arch/h8300/include/asm/irqflags.h b/arch/h8300/include/asm/irqflags.h
> new file mode 100644
> index 0000000..5e1e324
> --- /dev/null
> +++ b/arch/h8300/include/asm/irqflags.h
> @@ -0,0 +1,96 @@
> +#ifndef _H8300_IRQFLAGS_H
> +#define _H8300_IRQFLAGS_H
> +
> +#ifdef CONFIG_CPU_H8300H
> +typedef unsigned char h8300flags;
> +
> +static inline h8300flags arch_local_save_flags(void)
> +{
> + h8300flags flags;
> +
> + __asm__ volatile ("stc ccr,%w0" : "=r" (flags));
> + return flags;
> +}
> +
> +static inline void arch_local_irq_disable(void)
> +{
> + __asm__ volatile ("orc #0xc0,ccr");
> +}
> +
> +static inline void arch_local_irq_enable(void)
> +{
> + __asm__ volatile ("andc #0x3f,ccr");
> +}
> +
> +static inline h8300flags arch_local_irq_save(void)
> +{
> + h8300flags flags;
> +
> + __asm__ volatile ("stc ccr,%w0\n\t"
> + "orc #0xc0,ccr" : "=r" (flags));
> + return flags;
> +}
> +
> +static inline void arch_local_irq_restore(h8300flags flags)
> +{
> + __asm__ volatile ("ldc %w0,ccr" : : "r" (flags) : "cc");
> +}
> +
> +static inline int arch_irqs_disabled_flags(unsigned long flags)
> +{
> + return (flags & 0xc0) == 0xc0;
> +}
> +#endif
> +#ifdef CONFIG_CPU_H8S
> +typedef unsigned short h8300flags;
> +
> +static inline h8300flags arch_local_save_flags(void)
> +{
> + h8300flags flags;
> +
> + __asm__ volatile ("stc ccr,%w0\n\tstc exr,%x0" : "=r" (flags));
> + return flags;
> +}
> +
> +static inline void arch_local_irq_disable(void)
> +{
> + __asm__ volatile ("orc #0x80,ccr\n\t");
> +}
> +
> +static inline void arch_local_irq_enable(void)
> +{
> + __asm__ volatile ("andc #0x7f,ccr\n\t"
> + "andc #0xf0,exr\n\t");
> +}
> +
> +static inline h8300flags arch_local_irq_save(void)
> +{
> + h8300flags flags;
> +
> + __asm__ volatile ("stc ccr,%w0\n\t"
> + "stc exr,%x0\n\t"
> + "orc #0x80,ccr\n\t"
> + : "=r" (flags));
> + return flags;
> +}
> +
> +static inline void arch_local_irq_restore(h8300flags flags)
> +{
> + __asm__ volatile ("ldc %w0,ccr\n\t"
> + "ldc %x0,exr"
> + : : "r" (flags) : "cc");
> +}
> +
> +static inline int arch_irqs_disabled_flags(h8300flags flags)
> +{
> + return (flags & 0x0080) == 0x0080;
> +}
> +
> +#endif
> +
> +static inline int arch_irqs_disabled(void)
> +{
> + return arch_irqs_disabled_flags(arch_local_save_flags());
> +}
> +
> +#endif /* _H8300_IRQFLAGS_H */
> diff --git a/arch/h8300/include/asm/mc146818rtc.h b/arch/h8300/include/asm/mc146818rtc.h
> new file mode 100644
> index 0000000..ab9d964
> --- /dev/null
> +++ b/arch/h8300/include/asm/mc146818rtc.h
> @@ -0,0 +1,9 @@
> +/*
> + * Machine dependent access functions for RTC registers.
> + */
> +#ifndef _H8300_MC146818RTC_H
> +#define _H8300_MC146818RTC_H
> +
> +/* empty include file to satisfy the include in genrtc.c/ide-geometry.c */
> +
> +#endif /* _H8300_MC146818RTC_H */
> diff --git a/arch/h8300/include/asm/mutex.h b/arch/h8300/include/asm/mutex.h
> new file mode 100644
> index 0000000..458c1f7
> --- /dev/null
> +++ b/arch/h8300/include/asm/mutex.h
> @@ -0,0 +1,9 @@
> +/*
> + * Pull in the generic implementation for the mutex fastpath.
> + *
> + * TODO: implement optimized primitives instead, or leave the generic
> + * implementation in place, or pick the atomic_xchg() based generic
> + * implementation. (see asm-generic/mutex-xchg.h for details)
> + */
> +
> +#include <asm-generic/mutex-dec.h>
> diff --git a/arch/h8300/include/asm/page.h b/arch/h8300/include/asm/page.h
> new file mode 100644
> index 0000000..3a987a5
> --- /dev/null
> +++ b/arch/h8300/include/asm/page.h
> @@ -0,0 +1,18 @@
> +#ifndef _H8300_PAGE_H
> +#define _H8300_PAGE_H
> +
> +#include <asm-generic/page.h>
> +#include <linux/types.h>
> +
> +#define MAP_NR(addr) (((uintptr_t)(addr)-PAGE_OFFSET) >> PAGE_SHIFT)
> +#define VM_DATA_DEFAULT_FLAGS (VM_READ | VM_WRITE | VM_EXEC | \
> + VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC)
> +
> +#ifndef __ASSEMBLY__
> +extern unsigned long rom_length;
> +extern unsigned long memory_start;
> +extern unsigned long memory_end;
> +extern unsigned long _ramend;
> +#endif
> +
> +#endif
> diff --git a/arch/h8300/include/asm/page_offset.h b/arch/h8300/include/asm/page_offset.h
> new file mode 100644
> index 0000000..888576d
> --- /dev/null
> +++ b/arch/h8300/include/asm/page_offset.h
> @@ -0,0 +1,2 @@
> +
> +#define PAGE_OFFSET_RAW 0x00000000
> diff --git a/arch/h8300/include/asm/pci.h b/arch/h8300/include/asm/pci.h
> new file mode 100644
> index 0000000..0b2acaa
> --- /dev/null
> +++ b/arch/h8300/include/asm/pci.h
> @@ -0,0 +1,19 @@
> +#ifndef _ASM_H8300_PCI_H
> +#define _ASM_H8300_PCI_H
> +
> +/*
> + * asm-h8300/pci.h - H8/300 specific PCI declarations.
> + *
> + * Yoshinori Sato <ysato@users.sourceforge.jp>
> + */
> +
> +#define pcibios_assign_all_busses() 0
> +
> +static inline void pcibios_penalize_isa_irq(int irq, int active)
> +{
> + /* We don't do dynamic PCI IRQ allocation */
> +}
> +
> +#define PCI_DMA_BUS_IS_PHYS (1)
> +
> +#endif /* _ASM_H8300_PCI_H */
> diff --git a/arch/h8300/include/asm/pgtable.h b/arch/h8300/include/asm/pgtable.h
> new file mode 100644
> index 0000000..8341db6
> --- /dev/null
> +++ b/arch/h8300/include/asm/pgtable.h
> @@ -0,0 +1,49 @@
> +#ifndef _H8300_PGTABLE_H
> +#define _H8300_PGTABLE_H
> +#include <asm-generic/pgtable-nopud.h>
> +#include <asm-generic/pgtable.h>
> +#define pgtable_cache_init() do { } while (0)
> +extern void paging_init(void);
> +#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 */
> +#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 })
> +#define kern_addr_valid(addr) (1)
> +#define pgprot_writecombine(prot) (prot)
> +#define pgprot_noncached pgprot_writecombine
> +
> +static inline int pte_file(pte_t pte) { return 0; }
> +#define swapper_pg_dir ((pgd_t *) 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))
> +
> +/*
> + * These would be in other places but having them here reduces the diffs.
> + */
> +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)
> +
> +/*
> + * All 32bit addresses are effectively valid for vmalloc...
> + * Sort of meaningless for non-VM targets.
> + */
> +#define VMALLOC_START 0
> +#define VMALLOC_END 0xffffffff
> +
> +#define arch_enter_lazy_cpu_mode() do {} while (0)
> +
> +#endif /* _H8300_PGTABLE_H */
> diff --git a/arch/h8300/include/asm/processor.h b/arch/h8300/include/asm/processor.h
> new file mode 100644
> index 0000000..54e3fd8
> --- /dev/null
> +++ b/arch/h8300/include/asm/processor.h
> @@ -0,0 +1,144 @@
> +/*
> + * include/asm-h8300/processor.h
> + *
> + * Copyright (C) 2002 Yoshinori Sato
> + *
> + * Based on: linux/asm-m68nommu/processor.h
> + *
> + * Copyright (C) 1995 Hamish Macdonald
> + */
> +
> +#ifndef __ASM_H8300_PROCESSOR_H
> +#define __ASM_H8300_PROCESSOR_H
> +
> +/*
> + * Default implementation of macro that returns current
> + * instruction pointer ("program counter").
> + */
> +#define current_text_addr() ({ __label__ _l; _l: &&_l; })
> +
> +#include <linux/compiler.h>
> +#include <asm/segment.h>
> +#include <asm/ptrace.h>
> +#include <asm/current.h>
> +
> +static inline unsigned long rdusp(void)
> +{
> + extern unsigned int _sw_usp;
> +
> + return _sw_usp;
> +}
> +
> +static inline void wrusp(unsigned long usp)
> +{
> + extern unsigned int _sw_usp;
> +
> + _sw_usp = usp;
> +}
> +
> +/*
> + * User space process size: 3.75GB. This is hardcoded into a few places,
> + * so don't change it unless you know what you are doing.
> + */
> +#define TASK_SIZE (0xFFFFFFFFUL)
> +
> +#ifdef __KERNEL__
> +#define STACK_TOP TASK_SIZE
> +#define STACK_TOP_MAX STACK_TOP
> +#endif
> +
> +/*
> + * 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
> +
> +struct thread_struct {
> + unsigned long ksp; /* kernel stack pointer */
> + unsigned long usp; /* user stack pointer */
> + unsigned long ccr; /* saved status register */
> + unsigned long esp0; /* points to SR of stack frame */
> + struct {
> + unsigned short *addr;
> + unsigned short inst;
> + } breakinfo;
> +};
> +
> +#define INIT_THREAD { \
> + .ksp = sizeof(init_stack) + (unsigned long)init_stack, \
> + .usp = 0, \
> + .ccr = PS_S, \
> + .esp0 = 0, \
> + .breakinfo = { \
> + .addr = (unsigned short *)-1, \
> + .inst = 0 \
> + } \
> +}
> +
> +/*
> + * Do necessary setup to start up a newly executed thread.
> + *
> + * pass the data segment into user programs if it exists,
> + * it can't hurt anything as far as I can tell
> + */
> +#if defined(CONFIG_CPU_H8300H)
> +#define start_thread(_regs, _pc, _usp) \
> +do { \
> + (_regs)->pc = (_pc); \
> + (_regs)->ccr = 0x00; /* clear all flags */ \
> + (_regs)->er5 = current->mm->start_data; /* GOT base */ \
> + (_regs)->sp = ((unsigned long)(_usp)) - sizeof(unsigned long) * 3; \
> +} while (0)
> +#endif
> +#if defined(CONFIG_CPU_H8S)
> +#define start_thread(_regs, _pc, _usp) \
> +do { \
> + (_regs)->pc = (_pc); \
> + (_regs)->ccr = 0x00; /* clear kernel flag */ \
> + (_regs)->exr = 0x78; /* enable all interrupts */ \
> + (_regs)->er5 = current->mm->start_data; /* GOT base */ \
> + /* 14 = space for retaddr(4), vector(4), er0(4) and exr(2) on stack */ \
> + (_regs)->sp = ((unsigned long)(_usp)) - 14; \
> +} while (0)
> +#endif
> +
> +/* Forward declaration, a strange C thing */
> +struct task_struct;
> +
> +/* Free all resources held by a thread. */
> +static inline void release_thread(struct task_struct *dead_task)
> +{
> +}
> +
> +/*
> + * Free current thread data structures etc..
> + */
> +static inline void exit_thread(void)
> +{
> +}
> +
> +/*
> + * Return saved PC of a blocked thread.
> + */
> +unsigned long thread_saved_pc(struct task_struct *tsk);
> +unsigned long get_wchan(struct task_struct *p);
> +
> +#define KSTK_EIP(tsk) \
> + ({ \
> + unsigned long eip = 0; \
> + if ((tsk)->thread.esp0 > PAGE_SIZE && \
> + MAP_NR((tsk)->thread.esp0) < max_mapnr) \
> + eip = ((struct pt_regs *) (tsk)->thread.esp0)->pc; \
> + eip; })
> +
> +#define KSTK_ESP(tsk) ((tsk) == current ? rdusp() : (tsk)->thread.usp)
> +
> +#define cpu_relax() barrier()
> +#define cpu_relax_lowlatency() cpu_relax()
> +
> +#define HARD_RESET_NOW() ({ \
> + local_irq_disable(); \
> + asm("jmp @@0"); \
> +})
> +
> +#endif
> diff --git a/arch/h8300/include/asm/ptrace.h b/arch/h8300/include/asm/ptrace.h
> new file mode 100644
> index 0000000..e693fb4
> --- /dev/null
> +++ b/arch/h8300/include/asm/ptrace.h
> @@ -0,0 +1,36 @@
> +#ifndef _H8300_PTRACE_H
> +#define _H8300_PTRACE_H
> +
> +#include <uapi/asm/ptrace.h>
> +
> +#ifndef __ASSEMBLY__
> +#ifndef PS_S
> +#define PS_S (0x10)
> +#endif
> +
> +#if defined(CONFIG_CPU_H8300H)
> +#define H8300_REGS_NO 11
> +#endif
> +#if defined(CONFIG_CPU_H8S)
> +#define H8300_REGS_NO 12
> +#endif
> +
> +#define arch_has_single_step() (1)
> +
> +#define user_mode(regs) (!((regs)->ccr & PS_S))
> +#define instruction_pointer(regs) ((regs)->pc)
> +#define profile_pc(regs) instruction_pointer(regs)
> +#define user_stack_pointer(regs) ((regs)->sp)
> +#define current_pt_regs() ((struct pt_regs *) \
> + (THREAD_SIZE + (unsigned long)current_thread_info()) - 1)
> +#define signal_pt_regs() ((struct pt_regs *)current->thread.esp0)
> +#define current_user_stack_pointer() rdusp()
> +#define task_pt_regs(task) \
> + ((struct pt_regs *) (task_stack_page(task) + THREAD_SIZE) - 1)
> +
> +extern long h8300_get_reg(struct task_struct *task, int regno);
> +extern int h8300_put_reg(struct task_struct *task, int regno,
> + unsigned long data);
> +
> +#endif /* __ASSEMBLY__ */
> +#endif /* _H8300_PTRACE_H */
> diff --git a/arch/h8300/include/asm/segment.h b/arch/h8300/include/asm/segment.h
> new file mode 100644
> index 0000000..c8bc68e
> --- /dev/null
> +++ b/arch/h8300/include/asm/segment.h
> @@ -0,0 +1,49 @@
> +#ifndef _H8300_SEGMENT_H
> +#define _H8300_SEGMENT_H
> +
> +/* define constants */
> +#define USER_DATA (1)
> +#ifndef __USER_DS
> +#define __USER_DS (USER_DATA)
> +#endif
> +#define USER_PROGRAM (2)
> +#define SUPER_DATA (3)
> +#ifndef __KERNEL_DS
> +#define __KERNEL_DS (SUPER_DATA)
> +#endif
> +#define SUPER_PROGRAM (4)
> +
> +#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 /* _H8300_SEGMENT_H */
> diff --git a/arch/h8300/include/asm/sh_bios.h b/arch/h8300/include/asm/sh_bios.h
> new file mode 100644
> index 0000000..9ce513c
> --- /dev/null
> +++ b/arch/h8300/include/asm/sh_bios.h
> @@ -0,0 +1,4 @@
> +#ifndef SH_BIOS_H
> +#define SH_BIOS_H
> +
> +#endif
> diff --git a/arch/h8300/include/asm/signal.h b/arch/h8300/include/asm/signal.h
> new file mode 100644
> index 0000000..5870835
> --- /dev/null
> +++ b/arch/h8300/include/asm/signal.h
> @@ -0,0 +1,22 @@
> +#ifndef _H8300_SIGNAL_H
> +#define _H8300_SIGNAL_H
> +
> +#include <uapi/asm/signal.h>
> +
> +/* 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;
> +
> +#define __ARCH_HAS_SA_RESTORER
> +#include <asm/sigcontext.h>
> +
> +#endif /* _H8300_SIGNAL_H */
> diff --git a/arch/h8300/include/asm/smp.h b/arch/h8300/include/asm/smp.h
> new file mode 100644
> index 0000000..9e9bd7e
> --- /dev/null
> +++ b/arch/h8300/include/asm/smp.h
> @@ -0,0 +1 @@
> +/* nothing required here yet */
> diff --git a/arch/h8300/include/asm/spinlock.h b/arch/h8300/include/asm/spinlock.h
> new file mode 100644
> index 0000000..d5407fa
> --- /dev/null
> +++ b/arch/h8300/include/asm/spinlock.h
> @@ -0,0 +1,6 @@
> +#ifndef __H8300_SPINLOCK_H
> +#define __H8300_SPINLOCK_H
> +
> +#error "H8/300 doesn't do SMP yet"
> +
> +#endif
> diff --git a/arch/h8300/include/asm/string.h b/arch/h8300/include/asm/string.h
> new file mode 100644
> index 0000000..5dc5a8a
> --- /dev/null
> +++ b/arch/h8300/include/asm/string.h
> @@ -0,0 +1,17 @@
> +#ifndef _H8300_STRING_H_
> +#define _H8300_STRING_H_
> +
> +#ifdef __KERNEL__ /* only set these up for kernel code */
> +
> +#include <asm/setup.h>
> +#include <asm/page.h>
> +
> +#define __HAVE_ARCH_MEMSET
> +extern void *memset(void *s, int c, size_t count);
> +
> +#define __HAVE_ARCH_MEMCPY
> +extern void *memcpy(void *d, const void *s, size_t count);
> +
> +#endif /* KERNEL */
> +
> +#endif
> diff --git a/arch/h8300/include/asm/switch_to.h b/arch/h8300/include/asm/switch_to.h
> new file mode 100644
> index 0000000..7ad1bf9
> --- /dev/null
> +++ b/arch/h8300/include/asm/switch_to.h
> @@ -0,0 +1,51 @@
> +#ifndef _H8300_SWITCH_TO_H
> +#define _H8300_SWITCH_TO_H
> +
> +/*
> + * switch_to(n) should switch tasks to task ptr, first checking that
> + * ptr isn't the current task, in which case it does nothing. This
> + * also clears the TS-flag if the task we switched to has used the
> + * math co-processor latest.
> + */
> +/*
> + * switch_to() saves the extra registers, that are not saved
> + * automatically by SAVE_SWITCH_STACK in resume(), ie. d0-d5 and
> + * a0-a1. Some of these are used by schedule() and its predecessors
> + * and so we might get see unexpected behaviors when a task returns
> + * with unexpected register values.
> + *
> + * syscall stores these registers itself and none of them are used
> + * by syscall after the function in the syscall has been called.
> + *
> + * Beware that resume now expects *next to be in d1 and the offset of
> + * tss to be in a1. This saves a few instructions as we no longer have
> + * to push them onto the stack and read them back right after.
> + *
> + * 02/17/96 - Jes Sorensen (jds@kom.auc.dk)
> + *
> + * Changed 96/09/19 by Andreas Schwab
> + * pass prev in a0, next in a1, offset of tss in d1, and whether
> + * the mm structures are shared in d2 (to avoid atc flushing).
> + *
> + * H8/300 Porting 2002/09/04 Yoshinori Sato
> + */
> +
> +asmlinkage void resume(void);
> +#define switch_to(prev, next, last) \
> +do { \
> + void *_last; \
> + __asm__ __volatile__( \
> + "mov.l %1, er0\n\t" \
> + "mov.l %2, er1\n\t" \
> + "mov.l %3, er2\n\t" \
> + "jsr @_resume\n\t" \
> + "mov.l er2,%0\n\t" \
> + : "=r" (_last) \
> + : "r" (&(prev->thread)), \
> + "r" (&(next->thread)), \
> + "g" (prev) \
> + : "cc", "er0", "er1", "er2", "er3"); \
> + (last) = _last; \
> +} while (0)
> +
> +#endif /* _H8300_SWITCH_TO_H */
> diff --git a/arch/h8300/include/asm/syscall.h b/arch/h8300/include/asm/syscall.h
> new file mode 100644
> index 0000000..b41f688
> --- /dev/null
> +++ b/arch/h8300/include/asm/syscall.h
> @@ -0,0 +1,56 @@
> +#ifndef __ASM_H8300_SYSCALLS_32_H
> +#define __ASM_H8300_SYSCALLS_32_H
> +
> +#ifdef __KERNEL__
> +
> +#include <linux/compiler.h>
> +#include <linux/linkage.h>
> +#include <linux/types.h>
> +#include <linux/ptrace.h>
> +
> +static inline int
> +syscall_get_nr(struct task_struct *task, struct pt_regs *regs)
> +{
> + return regs->orig_er0;
> +}
> +
> +static inline void
> +syscall_get_arguments(struct task_struct *task, struct pt_regs *regs,
> + unsigned int i, unsigned int n, unsigned long *args)
> +{
> + BUG_ON(i + n > 6);
> +
> + while (n > 0) {
> + switch (i) {
> + case 0:
> + *args++ = regs->er1;
> + break;
> + case 1:
> + *args++ = regs->er2;
> + break;
> + case 2:
> + *args++ = regs->er3;
> + break;
> + case 3:
> + *args++ = regs->er4;
> + break;
> + case 4:
> + *args++ = regs->er5;
> + break;
> + case 5:
> + *args++ = regs->er6;
> + break;
> + }
> + i++;
> + n--;
> + }
> +}
> +
> +
> +
> +/* Misc syscall related bits */
> +asmlinkage long do_syscall_trace_enter(struct pt_regs *regs);
> +asmlinkage void do_syscall_trace_leave(struct pt_regs *regs);
> +
> +#endif /* __KERNEL__ */
> +#endif /* __ASM_H8300_SYSCALLS_32_H */
> diff --git a/arch/h8300/include/asm/thread_info.h b/arch/h8300/include/asm/thread_info.h
> new file mode 100644
> index 0000000..eded1ee
> --- /dev/null
> +++ b/arch/h8300/include/asm/thread_info.h
> @@ -0,0 +1,119 @@
> +/* thread_info.h: h8300 low-level thread information
> + * adapted from the i386 and PPC versions by Yoshinori Sato <ysato@users.sourceforge.jp>
> + *
> + * Copyright (C) 2002 David Howells (dhowells@redhat.com)
> + * - Incorporating suggestions made by Linus Torvalds and Dave Miller
> + */
> +
> +#ifndef _ASM_THREAD_INFO_H
> +#define _ASM_THREAD_INFO_H
> +
> +#include <asm/page.h>
> +
> +#ifdef __KERNEL__
> +
> +#ifndef __ASSEMBLY__
> +
> +/*
> + * low level task data.
> + * If you change this, change the TI_* offsets below to match.
> + */
> +struct thread_info {
> + struct task_struct *task; /* main task structure */
> + struct exec_domain *exec_domain; /* execution domain */

Same here, remove exec_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 = INIT_PREEMPT_COUNT, \
> + .restart_block = { \
> + .fn = do_no_restart_syscall, \
> + }, \
> +}
> +
> +#define init_thread_info (init_thread_union.thread_info)
> +#define init_stack (init_thread_union.stack)
> +
> +
> +/*
> + * Size of kernel stack for each process. This must be a power of 2...
> + */
> +#define THREAD_SIZE_ORDER 1
> +#define THREAD_SIZE 8192 /* 2 pages */
> +
> +
> +/* how to get the thread information struct from C */
> +static inline struct thread_info *current_thread_info(void)
> +{
> + struct thread_info *ti;
> +
> + __asm__("mov.l sp, %0\n\t"
> + "and.w %1, %T0"
> + : "=&r"(ti)
> + : "i" (~(THREAD_SIZE-1) & 0xffff));
> + return ti;
> +}
> +
> +#endif /* __ASSEMBLY__ */
> +
> +/*
> + * Offsets in thread_info structure, used in assembly code
> + */
> +#define TI_TASK 0
> +#define TI_EXECDOMAIN 4
> +#define TI_FLAGS 8
> +#define TI_CPU 12
> +#define TI_PRE_COUNT 16
>

You can kill TI_EXECDOMAIN, execution domain support is gone.
It would be also nice if the TI_* constants would be created using
asm-offsets.c.
See git.kernel.org/linus/37f078ff4c97ad143a6dc2adae31e20a3f780ca7 as an example.

> +/*
> + * thread information flag bit numbers
> + */
> +#define TIF_SYSCALL_TRACE 0 /* syscall trace active */
> +#define TIF_SIGPENDING 1 /* signal pending */
> +#define TIF_NEED_RESCHED 2 /* rescheduling necessary */
> +#define TIF_SINGLESTEP 3 /* singlestepping active */
> +#define TIF_MEMDIE 4 /* is terminating due to OOM killer */
> +#define TIF_RESTORE_SIGMASK 5 /* restore signal mask in do_signal() */
> +#define TIF_NOTIFY_RESUME 6 /* callback before returning to user */
> +#define TIF_SYSCALL_AUDIT 7 /* syscall auditing active */
> +#define TIF_SYSCALL_TRACEPOINT 8 /* for ftrace syscall instrumentation */
> +#define TIF_POLLING_NRFLAG 9 /* true if poll_idle() is polling TIF_NEED_RESCHED */
> +
> +/* as above, but as bit values */
> +#define _TIF_SYSCALL_TRACE (1 << TIF_SYSCALL_TRACE)
> +#define _TIF_SIGPENDING (1 << TIF_SIGPENDING)
> +#define _TIF_NEED_RESCHED (1 << TIF_NEED_RESCHED)
> +#define _TIF_NOTIFY_RESUME (1 << TIF_NOTIFY_RESUME)
> +#define _TIF_SINGLESTEP (1 << TIF_SINGLESTEP)
> +#define _TIF_SYSCALL_AUDIT (1 << TIF_SYSCALL_AUDIT)
> +#define _TIF_SYSCALL_TRACEPOINT (1 << TIF_SYSCALL_TRACEPOINT)
> +#define _TIF_POLLING_NRFLAG (1 << TIF_POLLING_NRFLAG)
> +
> +/* work to do in syscall trace */
> +#define _TIF_WORK_SYSCALL_MASK (_TIF_SYSCALL_TRACE | _TIF_SINGLESTEP | \
> + _TIF_SYSCALL_AUDIT | _TIF_SYSCALL_TRACEPOINT)
> +
> +/* work to do on any return to u-space */
> +#define _TIF_ALLWORK_MASK (_TIF_SYSCALL_TRACE | _TIF_SIGPENDING | \
> + _TIF_NEED_RESCHED | _TIF_SYSCALL_AUDIT | \
> + _TIF_SINGLESTEP | _TIF_NOTIFY_RESUME | \
> + _TIF_SYSCALL_TRACEPOINT)
> +
> +/* work to do on interrupt/exception return */
> +#define _TIF_WORK_MASK (_TIF_ALLWORK_MASK & ~(_TIF_SYSCALL_TRACE | \
> + _TIF_SYSCALL_AUDIT | _TIF_SINGLESTEP))
> +
> +#endif /* __KERNEL__ */
> +
> +#endif /* _ASM_THREAD_INFO_H */
> diff --git a/arch/h8300/include/asm/timer.h b/arch/h8300/include/asm/timer.h
> new file mode 100644
> index 0000000..c905f4e
> --- /dev/null
> +++ b/arch/h8300/include/asm/timer.h
> @@ -0,0 +1,31 @@
> +#ifndef __H8300_TIMER_H
> +#define __H8300_TIMER_H
> +
> +unsigned long get_cpu_clock(void);
> +
> +#define H8300_TIMER_FREQ get_cpu_clock() /* Timer input freq. */
> +
> +#define H8300_TMR8_CLKSRC 0
> +#define H8300_TMR8_CLKEVTDEV 1
> +
> +#define H8300_TMR8_DIV_8 0
> +#define H8300_TMR8_DIV_64 1
> +#define H8300_TMR8_DIV_8192 2
> +
> +struct h8300_timer8_config {
> + int mode;
> + int div;
> + int rating;
> +};
> +
> +struct h8300_timer16_config {
> + int rating;
> + __u8 enb;
> + __u8 imfa;
> + __u8 imiea;
> +};
> +
> +struct h8300_tpu_config {
> + int rating;
> +};
> +#endif
> diff --git a/arch/h8300/include/asm/tlb.h b/arch/h8300/include/asm/tlb.h
> new file mode 100644
> index 0000000..2c6fa4ee
> --- /dev/null
> +++ b/arch/h8300/include/asm/tlb.h
> @@ -0,0 +1,8 @@
> +#ifndef __H8300_TLB_H__
> +#define __H8300_TLB_H__
> +
> +#define tlb_flush(tlb) do { } while (0)
> +
> +#include <asm-generic/tlb.h>
> +
> +#endif
> diff --git a/arch/h8300/include/asm/topology.h b/arch/h8300/include/asm/topology.h
> new file mode 100644
> index 0000000..fdc1219
> --- /dev/null
> +++ b/arch/h8300/include/asm/topology.h
> @@ -0,0 +1,6 @@
> +#ifndef _ASM_H8300_TOPOLOGY_H
> +#define _ASM_H8300_TOPOLOGY_H
> +
> +#include <asm-generic/topology.h>
> +
> +#endif /* _ASM_H8300_TOPOLOGY_H */
> diff --git a/arch/h8300/include/asm/traps.h b/arch/h8300/include/asm/traps.h
> new file mode 100644
> index 0000000..aa34e75
> --- /dev/null
> +++ b/arch/h8300/include/asm/traps.h
> @@ -0,0 +1,41 @@
> +/*
> + * linux/include/asm-h8300/traps.h
> + *
> + * Copyright (C) 2003 Yoshinori Sato <ysato@users.sourceforge.jp>
> + *
> + * 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.
> + */
> +
> +#ifndef _H8300_TRAPS_H
> +#define _H8300_TRAPS_H
> +
> +extern void _system_call(void);
> +extern void _interrupt_entry(void);
> +extern void _trace_break(void);
> +extern void _nmi(void);
> +extern void _interrupt_entry(void);
> +
> +extern unsigned long *_interrupt_redirect_table;
> +
> +#define JMP_OP 0x5a000000
> +#define JSR_OP 0x5e000000
> +#define VECTOR(address) ((JMP_OP)|((unsigned long)address))
> +#define REDIRECT(address) ((JSR_OP)|((unsigned long)address))
> +#define CPU_VECTOR ((unsigned long *)0x000000)
> +#define ADDR_MASK (0xffffff)
> +
> +#define TRACE_VEC 5
> +
> +#define TRAP0_VEC 8
> +#define TRAP1_VEC 9
> +#define TRAP2_VEC 10
> +#define TRAP3_VEC 11
> +
> +extern char _start, _etext;
> +#define check_kernel_text(addr) \
> + ((addr >= (unsigned long)(&_start)) && \
> + (addr < (unsigned long)(&_etext)))
> +
> +#endif /* _H8300_TRAPS_H */
> diff --git a/arch/h8300/include/asm/uaccess.h b/arch/h8300/include/asm/uaccess.h
> new file mode 100644
> index 0000000..a3b6b18
> --- /dev/null
> +++ b/arch/h8300/include/asm/uaccess.h
> @@ -0,0 +1,136 @@
> +#ifndef __H8300_UACCESS_H
> +#define __H8300_UACCESS_H
> +
> +/*
> + * User space memory access functions
> + */
> +#include <linux/sched.h>
> +#include <linux/mm.h>
> +#include <linux/string.h>
> +
> +#include <asm/segment.h>
> +
> +#define VERIFY_READ 0
> +#define VERIFY_WRITE 1
> +
> +/* We let the MMU do all checking */
> +#define access_ok(type, addr, size) __access_ok((unsigned long)addr, size)
> +static inline int __access_ok(unsigned long addr, unsigned long size)
> +{
> +#define RANGE_CHECK_OK(addr, size, lower, upper) \
> + (((addr) >= (lower)) && (((addr) + (size)) < (upper)))
> +
> + extern unsigned long memory_end;
> +
> + return RANGE_CHECK_OK(addr, size, 0L, memory_end);
> +}
> +
> +/*
> + * 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.
> + */
> +
> +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: \
> + /* falll through */ \
> + case 2: \
> + /* fall through */ \
> + case 4: \
> + *(ptr) = x; \
> + break; \
> + 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))
> +
> +/*
> + * 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 get_user(x, ptr) \
> +({ \
> + typeof(*(ptr)) __gu_val; \
> + int __gu_err = 0; \
> + switch (sizeof(*(ptr))) { \
> + case 1: \
> + *(u8 *)&__gu_val = *((u8 *)(ptr)); \
> + break; \
> + case 2: \
> + *(u16 *)&__gu_val = *((u16 *)ptr); \
> + break; \
> + case 4: \
> + *(u32 *)&__gu_val = *((u32 *)ptr); \
> + break; \
> + case 8: \
> + memcpy((void *)&__gu_val, ptr, sizeof(*(ptr))); \
> + break; \
> + default: \
> + __gu_err = __get_user_bad(); \
> + break; \
> + } \
> + (x) = (typeof(*(ptr)))__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
> +
> +unsigned long clear_user(void __user *addr, unsigned long size);
> +#define strnlen_user(s, n) (strnlen(s, n) + 1)
> +long strncpy_from_user(char *d, const char *s, long n);
> +
> +#define __clear_user clear_user
> +
> +#endif /* _H8300_UACCESS_H */
> diff --git a/arch/h8300/include/asm/unaligned.h b/arch/h8300/include/asm/unaligned.h
> new file mode 100644
> index 0000000..b8d06c7
> --- /dev/null
> +++ b/arch/h8300/include/asm/unaligned.h
> @@ -0,0 +1,11 @@
> +#ifndef _ASM_H8300_UNALIGNED_H
> +#define _ASM_H8300_UNALIGNED_H
> +
> +#include <linux/unaligned/be_memmove.h>
> +#include <linux/unaligned/le_byteshift.h>
> +#include <linux/unaligned/generic.h>
> +
> +#define get_unaligned __get_unaligned_be
> +#define put_unaligned __put_unaligned_be
> +
> +#endif /* _ASM_H8300_UNALIGNED_H */
> diff --git a/arch/h8300/include/asm/user.h b/arch/h8300/include/asm/user.h
> new file mode 100644
> index 0000000..2e3555f
> --- /dev/null
> +++ b/arch/h8300/include/asm/user.h
> @@ -0,0 +1,74 @@
> +#ifndef _H8300_USER_H
> +#define _H8300_USER_H
> +
> +#include <asm/page.h>
> +
> +/* Core file format: The core file is written in such a way that gdb
> + can understand it and provide useful information to the user (under
> + linux we use the 'trad-core' bfd). There are quite a number of
> + obstacles to being able to view the contents of the floating point
> + registers, and until these are solved you will not be able to view the
> + contents of them. Actually, you can read in the core file and look at
> + the contents of the user struct to find out what the floating point
> + registers contain.
> + The actual file contents are as follows:
> + UPAGE: 1 page consisting of a user struct that tells gdb what is present
> + in the file. Directly after this is a copy of the task_struct, which
> + is currently not used by gdb, but it may come in useful at some point.
> + All of the registers are stored as part of the upage. The upage should
> + always be only one page.
> + DATA: The data area is stored. We use current->end_text to
> + current->brk to pick up all of the user variables, plus any memory
> + that may have been malloced. No attempt is made to determine if a page
> + is demand-zero or if a page is totally unused, we just cover the entire
> + range. All of the addresses are rounded in such a way that an integral
> + number of pages is written.
> + STACK: We need the stack information in order to get a meaningful
> + backtrace. We need to write the data from (esp) to
> + current->start_stack, so we round each of these off in order to be able
> + to write an integer number of pages.
> + The minimum core file size is 3 pages, or 12288 bytes.
> +*/
> +
> +/* This is the old layout of "struct pt_regs" as of Linux 1.x, and
> + is still the layout used by user (the new pt_regs doesn't have
> + all registers). */
> +struct user_regs_struct {
> + long er1, er2, er3, er4, er5, er6;
> + long er0;
> + long usp;
> + long orig_er0;
> + long ccr;
> + long pc;
> +};
> +
> +/* 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.... */
> +/* 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 */
> + unsigned long u_ar0; /* Used by gdb to help find the values for */
> + /* the registers. */
> + 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
> --
> 2.1.4
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-arch" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html



--
Thanks,
//richard


\
 
 \ /
  Last update: 2015-04-20 10:01    [W:0.304 / U:5.736 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site