h8300: Assembly headers

generic-y += asm-offsets.h

generic-y += auxvec.h

generic-y += barrier.h

generic-y += bugs.h

generic-y += cacheflush.h

generic-y += checksum.h

generic-y += clkdev.h

generic-y += cputime.h

generic-y += current.h

generic-y += delay.h

generic-y += device.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 += spinlock.h

generic-y += stat.h

generic-y += statfs.h

generic-y += swab.h

generic-y += termbits.h

generic-y += termios.h

generic-y += timex.h

generic-y += tlbflush.h

generic-y += trace_clock.h

generic-y += topology.h

generic-y += types.h

generic-y += uaccess.h

generic-y += ucontext.h

generic-y += unaligned.h

generic-y += vga.h

generic-y += xor.h

#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 __ */

#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 */

#ifndef __ASM_H8300_BITS_PER_LONG

#define __ASM_H8300_BITS_PER_LONG

#include <asm-generic/bitsperlong.h>

#if !defined(__ASSEMBLY__)

/* h8300-unknown-linux required long */

#define __kernel_size_t __kernel_size_t

typedef unsigned long	__kernel_size_t;

typedef long		__kernel_ssize_t;

typedef long		__kernel_ptrdiff_t;

#endif

#endif /* __ASM_H8300_BITS_PER_LONG */

#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