sh: Purge dead sh64 headers.

include include/asm-generic/Kbuild.asm

#ifndef __ASM_SH64_A_OUT_H

#define __ASM_SH64_A_OUT_H

/*

 * 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.

 *

 * include/asm-sh64/a.out.h

 *

 * Copyright (C) 2000, 2001  Paolo Alberelli

 *

 */

struct exec

{

  unsigned long a_info;		/* Use macros N_MAGIC, etc for access */

  unsigned a_text;		/* length of text, in bytes */

  unsigned a_data;		/* length of data, in bytes */

  unsigned a_bss;		/* length of uninitialized data area for file, in bytes */

  unsigned a_syms;		/* length of symbol table data in file, in bytes */

  unsigned a_entry;		/* start address */

  unsigned a_trsize;		/* length of relocation info for text, in bytes */

  unsigned a_drsize;		/* length of relocation info for data, in bytes */

};

#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

#define STACK_TOP_MAX	STACK_TOP

#endif

#endif /* __ASM_SH64_A_OUT_H */

#ifndef __ASM_SH64_ATOMIC_H

#define __ASM_SH64_ATOMIC_H

/*

 * 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.

 *

 * include/asm-sh64/atomic.h

 *

 * Copyright (C) 2000, 2001  Paolo Alberelli

 * Copyright (C) 2003  Paul Mundt

 *

 */

/*

 * Atomic operations that C can't guarantee us.  Useful for

 * resource counting etc..

 *

 */

typedef struct { volatile int counter; } atomic_t;

#define ATOMIC_INIT(i)	( (atomic_t) { (i) } )

#define atomic_read(v)		((v)->counter)

#define atomic_set(v,i)		((v)->counter = (i))

#include <asm/system.h>

/*

 * To get proper branch prediction for the main line, we must branch

 * forward to code at the end of this object's .text section, then

 * branch back to restart the operation.

 */

static __inline__ void atomic_add(int i, atomic_t * v)

{

	unsigned long flags;

	local_irq_save(flags);

	*(long *)v += i;

	local_irq_restore(flags);

}

static __inline__ void atomic_sub(int i, atomic_t *v)

{

	unsigned long flags;

	local_irq_save(flags);

	*(long *)v -= i;

	local_irq_restore(flags);

}

static __inline__ int atomic_add_return(int i, atomic_t * v)

{

	unsigned long temp, flags;

	local_irq_save(flags);

	temp = *(long *)v;

	temp += i;

	*(long *)v = temp;

	local_irq_restore(flags);

	return temp;

}

#define atomic_add_negative(a, v)	(atomic_add_return((a), (v)) < 0)

static __inline__ int atomic_sub_return(int i, atomic_t * v)

{

	unsigned long temp, flags;

	local_irq_save(flags);

	temp = *(long *)v;

	temp -= i;

	*(long *)v = temp;

	local_irq_restore(flags);

	return temp;

}

#define atomic_dec_return(v) atomic_sub_return(1,(v))

#define atomic_inc_return(v) atomic_add_return(1,(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)

#define atomic_sub_and_test(i,v) (atomic_sub_return((i), (v)) == 0)

#define atomic_dec_and_test(v) (atomic_sub_return(1, (v)) == 0)

#define atomic_inc(v) atomic_add(1,(v))

#define atomic_dec(v) atomic_sub(1,(v))

static inline int atomic_cmpxchg(atomic_t *v, int old, int new)

{

	int ret;

	unsigned long flags;

	local_irq_save(flags);

	ret = v->counter;

	if (likely(ret == old))

		v->counter = new;

	local_irq_restore(flags);

	return ret;

}

#define atomic_xchg(v, new) (xchg(&((v)->counter), new))

static inline int atomic_add_unless(atomic_t *v, int a, int u)

{

	int ret;

	unsigned long flags;

	local_irq_save(flags);

	ret = v->counter;

	if (ret != u)

		v->counter += a;

	local_irq_restore(flags);

	return ret != u;

}

#define atomic_inc_not_zero(v) atomic_add_unless((v), 1, 0)

static __inline__ void atomic_clear_mask(unsigned int mask, atomic_t *v)

{

	unsigned long flags;

	local_irq_save(flags);

	*(long *)v &= ~mask;

	local_irq_restore(flags);

}

static __inline__ void atomic_set_mask(unsigned int mask, atomic_t *v)

{

	unsigned long flags;

	local_irq_save(flags);

	*(long *)v |= mask;

	local_irq_restore(flags);

}

/* Atomic operations are already serializing on SH */

#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()

#include <asm-generic/atomic.h>

#endif /* __ASM_SH64_ATOMIC_H */

#ifndef __ASM_SH64_AUXVEC_H

#define __ASM_SH64_AUXVEC_H

#endif /* __ASM_SH64_AUXVEC_H */

#ifndef __ASM_SH64_BITOPS_H

#define __ASM_SH64_BITOPS_H

/*

 * 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.

 *

 * include/asm-sh64/bitops.h

 *

 * Copyright (C) 2000, 2001  Paolo Alberelli

 * Copyright (C) 2003  Paul Mundt

 */

#ifdef __KERNEL__

#ifndef _LINUX_BITOPS_H

#error only <linux/bitops.h> can be included directly

#endif

#include <linux/compiler.h>

#include <asm/system.h>

/* For __swab32 */

#include <asm/byteorder.h>

static __inline__ void set_bit(int nr, volatile void * addr)

{

	int	mask;

	volatile unsigned int *a = addr;

	unsigned long flags;

	a += nr >> 5;

	mask = 1 << (nr & 0x1f);

	local_irq_save(flags);

	*a |= mask;

	local_irq_restore(flags);

}

/*

 * 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 *a)

{

	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 change_bit(int nr, volatile void * addr)

{

	int	mask;

	volatile unsigned int *a = addr;

	unsigned long flags;

	a += nr >> 5;

	mask = 1 << (nr & 0x1f);

	local_irq_save(flags);

	*a ^= mask;

	local_irq_restore(flags);

}

static __inline__ int test_and_set_bit(int nr, volatile void * addr)

{

	int	mask, retval;

	volatile unsigned int *a = 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 void * addr)

{

	int	mask, retval;

	volatile unsigned int *a = 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 void * addr)

{

	int	mask, retval;

	volatile unsigned int *a = 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;

}

#include <asm-generic/bitops/non-atomic.h>

static __inline__ unsigned long ffz(unsigned long word)

{

	unsigned long result, __d2, __d3;

        __asm__("gettr  tr0, %2\n\t"

                "pta    $+32, tr0\n\t"

                "andi   %1, 1, %3\n\t"

                "beq    %3, r63, tr0\n\t"

                "pta    $+4, tr0\n"

                "0:\n\t"

                "shlri.l        %1, 1, %1\n\t"

                "addi   %0, 1, %0\n\t"

                "andi   %1, 1, %3\n\t"

                "beqi   %3, 1, tr0\n"

                "1:\n\t"

                "ptabs  %2, tr0\n\t"

                : "=r" (result), "=r" (word), "=r" (__d2), "=r" (__d3)

                : "0" (0L), "1" (word));

	return result;

}

#include <asm-generic/bitops/__ffs.h>

#include <asm-generic/bitops/find.h>

#include <asm-generic/bitops/hweight.h>

#include <asm-generic/bitops/lock.h>

#include <asm-generic/bitops/sched.h>

#include <asm-generic/bitops/ffs.h>

#include <asm-generic/bitops/ext2-non-atomic.h>

#include <asm-generic/bitops/ext2-atomic.h>

#include <asm-generic/bitops/minix.h>

#include <asm-generic/bitops/fls.h>

#include <asm-generic/bitops/fls64.h>

#endif /* __KERNEL__ */

#endif /* __ASM_SH64_BITOPS_H */