[net-next-2.6.git] / include / asm-generic / system.h

/* Generic system definitions, based on MN10300 definitions.
 *
 * It should be possible to use these on really simple architectures,
 * but it serves more as a starting point for new ports.
 *
 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public Licence
 * as published by the Free Software Foundation; either version
 * 2 of the Licence, or (at your option) any later version.
 */
#ifndef __ASM_GENERIC_SYSTEM_H
#define __ASM_GENERIC_SYSTEM_H

#ifdef __KERNEL__
#ifndef __ASSEMBLY__

#include <linux/types.h>
#include <linux/irqflags.h>

#include <asm/cmpxchg-local.h>

struct task_struct;

/* context switching is now performed out-of-line in switch_to.S */
extern struct task_struct *__switch_to(struct task_struct *,
		struct task_struct *);
#define switch_to(prev, next, last)					\
	do {								\
		((last) = __switch_to((prev), (next)));			\
	} while (0)

#define arch_align_stack(x) (x)

#define nop() asm volatile ("nop")

#endif /* !__ASSEMBLY__ */

/*
 * Force strict CPU ordering.
 * And yes, this is required on UP too when we're talking
 * to devices.
 *
 * This implementation only contains a compiler barrier.
 */

#define mb()	asm volatile ("": : :"memory")
#define rmb()	mb()
#define wmb()	asm volatile ("": : :"memory")

#ifdef CONFIG_SMP
#define smp_mb()	mb()
#define smp_rmb()	rmb()
#define smp_wmb()	wmb()
#else
#define smp_mb()	barrier()
#define smp_rmb()	barrier()
#define smp_wmb()	barrier()
#endif

#define set_mb(var, value)  do { var = value;  mb(); } while (0)
#define set_wmb(var, value) do { var = value; wmb(); } while (0)

#define read_barrier_depends()		do {} while (0)
#define smp_read_barrier_depends()	do {} while (0)

/*
 * we make sure local_irq_enable() doesn't cause priority inversion
 */
#ifndef __ASSEMBLY__

/* This function doesn't exist, so you'll get a linker error
 *    if something tries to do an invalid xchg().  */
extern void __xchg_called_with_bad_pointer(void);

static inline
unsigned long __xchg(unsigned long x, volatile void *ptr, int size)
{
	unsigned long ret, flags;

	switch (size) {
	case 1:
#ifdef __xchg_u8
		return __xchg_u8(x, ptr);
#else
		local_irq_save(flags);
		ret = *(volatile u8 *)ptr;
		*(volatile u8 *)ptr = x;
		local_irq_restore(flags);
		return ret;
#endif /* __xchg_u8 */

	case 2:
#ifdef __xchg_u16
		return __xchg_u16(x, ptr);
#else
		local_irq_save(flags);
		ret = *(volatile u16 *)ptr;
		*(volatile u16 *)ptr = x;
		local_irq_restore(flags);
		return ret;
#endif /* __xchg_u16 */

	case 4:
#ifdef __xchg_u32
		return __xchg_u32(x, ptr);
#else
		local_irq_save(flags);
		ret = *(volatile u32 *)ptr;
		*(volatile u32 *)ptr = x;
		local_irq_restore(flags);
		return ret;
#endif /* __xchg_u32 */

#ifdef CONFIG_64BIT
	case 8:
#ifdef __xchg_u64
		return __xchg_u64(x, ptr);
#else
		local_irq_save(flags);
		ret = *(volatile u64 *)ptr;
		*(volatile u64 *)ptr = x;
		local_irq_restore(flags);
		return ret;
#endif /* __xchg_u64 */
#endif /* CONFIG_64BIT */

	default:
		__xchg_called_with_bad_pointer();
		return x;
	}
}

#define xchg(ptr, x) \
	((__typeof__(*(ptr))) __xchg((unsigned long)(x), (ptr), sizeof(*(ptr))))

static inline unsigned long __cmpxchg(volatile unsigned long *m,
				      unsigned long old, unsigned long new)
{
	unsigned long retval;
	unsigned long flags;

	local_irq_save(flags);
	retval = *m;
	if (retval == old)
		*m = new;
	local_irq_restore(flags);
	return retval;
}

#define cmpxchg(ptr, o, n)					\
	((__typeof__(*(ptr))) __cmpxchg((unsigned long *)(ptr), \
					(unsigned long)(o),	\
					(unsigned long)(n)))

#endif /* !__ASSEMBLY__ */

#endif /* __KERNEL__ */
#endif /* __ASM_GENERIC_SYSTEM_H */
Commit	Line	Data
aafe4dbe AB	1	/* Generic system definitions, based on MN10300 definitions.
	2	*
	3	* It should be possible to use these on really simple architectures,
	4	* but it serves more as a starting point for new ports.
	5	*
	6	* Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
	7	* Written by David Howells (dhowells@redhat.com)
	8	*
	9	* This program is free software; you can redistribute it and/or
	10	* modify it under the terms of the GNU General Public Licence
	11	* as published by the Free Software Foundation; either version
	12	* 2 of the Licence, or (at your option) any later version.
	13	*/
	14	#ifndef __ASM_GENERIC_SYSTEM_H
	15	#define __ASM_GENERIC_SYSTEM_H
	16
	17	#ifdef __KERNEL__
	18	#ifndef __ASSEMBLY__
	19
	20	#include <linux/types.h>
	21	#include <linux/irqflags.h>
	22
	23	#include <asm/cmpxchg-local.h>
	24
	25	struct task_struct;
	26
	27	/* context switching is now performed out-of-line in switch_to.S */
	28	extern struct task_struct __switch_to(struct task_struct ,
	29	struct task_struct *);
	30	#define switch_to(prev, next, last) \
	31	do { \
	32	((last) = __switch_to((prev), (next))); \
	33	} while (0)
	34
	35	#define arch_align_stack(x) (x)
	36
	37	#define nop() asm volatile ("nop")
	38
	39	#endif /* !__ASSEMBLY__ */
	40
	41	/*
	42	* Force strict CPU ordering.
	43	* And yes, this is required on UP too when we're talking
	44	* to devices.
	45	*
	46	* This implementation only contains a compiler barrier.
	47	*/
	48
	49	#define mb() asm volatile ("": : :"memory")
	50	#define rmb() mb()
	51	#define wmb() asm volatile ("": : :"memory")
	52
	53	#ifdef CONFIG_SMP
	54	#define smp_mb() mb()
	55	#define smp_rmb() rmb()
	56	#define smp_wmb() wmb()
	57	#else
	58	#define smp_mb() barrier()
	59	#define smp_rmb() barrier()
	60	#define smp_wmb() barrier()
	61	#endif
	62
	63	#define set_mb(var, value) do { var = value; mb(); } while (0)
	64	#define set_wmb(var, value) do { var = value; wmb(); } while (0)
65
66	#define read_barrier_depends() do {} while (0)
67	#define smp_read_barrier_depends() do {} while (0)
68
69	/*
70	* we make sure local_irq_enable() doesn't cause priority inversion
71	*/
72	#ifndef __ASSEMBLY__
73
74	/* This function doesn't exist, so you'll get a linker error
75	* if something tries to do an invalid xchg(). */
76	extern void __xchg_called_with_bad_pointer(void);
77
78	static inline
79	unsigned long __xchg(unsigned long x, volatile void *ptr, int size)
80	{
81	unsigned long ret, flags;
82
83	switch (size) {
84	case 1:
85	#ifdef __xchg_u8
86	return __xchg_u8(x, ptr);
87	#else
88	local_irq_save(flags);
89	ret = (volatile u8 )ptr;
90	(volatile u8 )ptr = x;
91	local_irq_restore(flags);
92	return ret;
93	#endif /* __xchg_u8 */
94
95	case 2:
96	#ifdef __xchg_u16
97	return __xchg_u16(x, ptr);
98	#else
99	local_irq_save(flags);
100	ret = (volatile u16 )ptr;
101	(volatile u16 )ptr = x;
102	local_irq_restore(flags);
103	return ret;
104	#endif /* __xchg_u16 */
105
106	case 4:
107	#ifdef __xchg_u32
108	return __xchg_u32(x, ptr);
109	#else
110	local_irq_save(flags);
111	ret = (volatile u32 )ptr;
112	(volatile u32 )ptr = x;
113	local_irq_restore(flags);
114	return ret;
115	#endif /* __xchg_u32 */
116
117	#ifdef CONFIG_64BIT
118	case 8:
119	#ifdef __xchg_u64
120	return __xchg_u64(x, ptr);
121	#else
122	local_irq_save(flags);
123	ret = (volatile u64 )ptr;
124	(volatile u64 )ptr = x;
125	local_irq_restore(flags);
126	return ret;
127	#endif /* __xchg_u64 */
128	#endif /* CONFIG_64BIT */
129
130	default:
131	__xchg_called_with_bad_pointer();
132	return x;
133	}
134	}
135
136	#define xchg(ptr, x) \
137	((__typeof__((ptr))) __xchg((unsigned long)(x), (ptr), sizeof((ptr))))
138
139	static inline unsigned long __cmpxchg(volatile unsigned long *m,
140	unsigned long old, unsigned long new)
141	{
142	unsigned long retval;
143	unsigned long flags;
144
145	local_irq_save(flags);
146	retval = *m;
147	if (retval == old)
148	*m = new;
149	local_irq_restore(flags);
150	return retval;
151	}
152
153	#define cmpxchg(ptr, o, n) \
154	((__typeof__((ptr))) __cmpxchg((unsigned long )(ptr), \
155	(unsigned long)(o), \
156	(unsigned long)(n)))
157
158	#endif /* !__ASSEMBLY__ */
159
160	#endif /* __KERNEL__ */
161	#endif /* __ASM_GENERIC_SYSTEM_H */