CRIS: use generic atomic.h (e7db8a3c) · Commits · 戴 / test

arch/cris/include/arch-v10/arch/atomic.h

deleted100644 → 0

+0 −7

Original line number	Diff line number	Diff line
		#ifndef __ASM_CRIS_ARCH_ATOMIC__
		#define __ASM_CRIS_ARCH_ATOMIC__

		#define cris_atomic_save(addr, flags) local_irq_save(flags);
		#define cris_atomic_restore(addr, flags) local_irq_restore(flags);

		#endif

arch/cris/include/arch-v32/arch/atomic.h

deleted100644 → 0

+0 −8

Original line number	Diff line number	Diff line
		#ifndef __ASM_CRIS_ARCH_ATOMIC__
		#define __ASM_CRIS_ARCH_ATOMIC__

		#define cris_atomic_save(addr, flags) local_irq_save(flags);
		#define cris_atomic_restore(addr, flags) local_irq_restore(flags);

		#endif

arch/cris/include/asm/Kbuild

+1 −1

Original line number	Diff line number	Diff line

		generic-y += atomic.h
		generic-y += barrier.h
		generic-y += clkdev.h
		generic-y += cputime.h

arch/cris/include/asm/atomic.h

deleted100644 → 0

+0 −149

Original line number	Diff line number	Diff line
		/* $Id: atomic.h,v 1.3 2001/07/25 16:15:19 bjornw Exp $ */

		#ifndef __ASM_CRIS_ATOMIC__
		#define __ASM_CRIS_ATOMIC__

		#include <linux/compiler.h>
		#include <linux/types.h>
		#include <asm/cmpxchg.h>
		#include <arch/atomic.h>
		#include <arch/system.h>
		#include <asm/barrier.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))

		/* These should be written in asm but we do it in C for now. */

		#define ATOMIC_OP(op, c_op) \
		static inline void atomic_##op(int i, volatile atomic_t *v) \
		{ \
		unsigned long flags; \
		cris_atomic_save(v, flags); \
		v->counter c_op i; \
		cris_atomic_restore(v, flags); \
		} \

		#define ATOMIC_OP_RETURN(op, c_op) \
		static inline int atomic_##op##_return(int i, volatile atomic_t *v) \
		{ \
		unsigned long flags; \
		int retval; \
		cris_atomic_save(v, flags); \
		retval = (v->counter c_op i); \
		cris_atomic_restore(v, flags); \
		return retval; \
		}

		#define ATOMIC_OPS(op, c_op) ATOMIC_OP(op, c_op) ATOMIC_OP_RETURN(op, c_op)

		ATOMIC_OPS(add, +=)
		ATOMIC_OPS(sub, -=)

		#undef ATOMIC_OPS
		#undef ATOMIC_OP_RETURN
		#undef ATOMIC_OP

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

		static inline int atomic_sub_and_test(int i, volatile atomic_t *v)
		{
		int retval;
		unsigned long flags;
		cris_atomic_save(v, flags);
		retval = (v->counter -= i) == 0;
		cris_atomic_restore(v, flags);
		return retval;
		}

		static inline void atomic_inc(volatile atomic_t *v)
		{
		unsigned long flags;
		cris_atomic_save(v, flags);
		(v->counter)++;
		cris_atomic_restore(v, flags);
		}

		static inline void atomic_dec(volatile atomic_t *v)
		{
		unsigned long flags;
		cris_atomic_save(v, flags);
		(v->counter)--;
		cris_atomic_restore(v, flags);
		}

		static inline int atomic_inc_return(volatile atomic_t *v)
		{
		unsigned long flags;
		int retval;
		cris_atomic_save(v, flags);
		retval = ++(v->counter);
		cris_atomic_restore(v, flags);
		return retval;
		}

		static inline int atomic_dec_return(volatile atomic_t *v)
		{
		unsigned long flags;
		int retval;
		cris_atomic_save(v, flags);
		retval = --(v->counter);
		cris_atomic_restore(v, flags);
		return retval;
		}
		static inline int atomic_dec_and_test(volatile atomic_t *v)
		{
		int retval;
		unsigned long flags;
		cris_atomic_save(v, flags);
		retval = --(v->counter) == 0;
		cris_atomic_restore(v, flags);
		return retval;
		}

		static inline int atomic_inc_and_test(volatile atomic_t *v)
		{
		int retval;
		unsigned long flags;
		cris_atomic_save(v, flags);
		retval = ++(v->counter) == 0;
		cris_atomic_restore(v, flags);
		return retval;
		}

		static inline int atomic_cmpxchg(atomic_t *v, int old, int new)
		{
		int ret;
		unsigned long flags;

		cris_atomic_save(v, flags);
		ret = v->counter;
		if (likely(ret == old))
		v->counter = new;
		cris_atomic_restore(v, 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;

		cris_atomic_save(v, flags);
		ret = v->counter;
		if (ret != u)
		v->counter += a;
		cris_atomic_restore(v, flags);
		return ret;
		}

		#endif

Admin message