[deliverable/linux.git] / include / asm-blackfin / bitops.h

#ifndef _BLACKFIN_BITOPS_H
#define _BLACKFIN_BITOPS_H

/*
 * Copyright 1992, Linus Torvalds.
 */

#include <linux/compiler.h>
#include <asm/byteorder.h>	/* swab32 */
#include <asm/system.h>		/* save_flags */

#ifdef __KERNEL__

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

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

static __inline__ void set_bit(int nr, volatile unsigned long *addr)
{
	int *a = (int *)addr;
	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 __set_bit(int nr, volatile unsigned long *addr)
{
	int *a = (int *)addr;
	int mask;

	a += nr >> 5;
	mask = 1 << (nr & 0x1f);
	*a |= mask;
}

/*
 * 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 *addr)
{
	int *a = (int *)addr;
	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 __clear_bit(int nr, volatile unsigned long *addr)
{
	int *a = (int *)addr;
	int mask;

	a += nr >> 5;
	mask = 1 << (nr & 0x1f);
	*a &= ~mask;
}

static __inline__ void change_bit(int nr, volatile unsigned long *addr)
{
	int mask, flags;
	unsigned long *ADDR = (unsigned long *)addr;

	ADDR += nr >> 5;
	mask = 1 << (nr & 31);
	local_irq_save(flags);
	*ADDR ^= mask;
	local_irq_restore(flags);
}

static __inline__ void __change_bit(int nr, volatile unsigned long *addr)
{
	int mask;
	unsigned long *ADDR = (unsigned long *)addr;

	ADDR += nr >> 5;
	mask = 1 << (nr & 31);
	*ADDR ^= mask;
}

static __inline__ int test_and_set_bit(int nr, void *addr)
{
	int mask, retval;
	volatile unsigned int *a = (volatile unsigned int *)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_set_bit(int nr, volatile unsigned long *addr)
{
	int mask, retval;
	volatile unsigned int *a = (volatile unsigned int *)addr;

	a += nr >> 5;
	mask = 1 << (nr & 0x1f);
	retval = (mask & *a) != 0;
	*a |= mask;
	return retval;
}

static __inline__ int test_and_clear_bit(int nr, volatile unsigned long *addr)
{
	int mask, retval;
	volatile unsigned int *a = (volatile unsigned int *)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 unsigned long *addr)
{
	int mask, retval;
	volatile unsigned int *a = (volatile unsigned int *)addr;

	a += nr >> 5;
	mask = 1 << (nr & 0x1f);
	retval = (mask & *a) != 0;
	*a &= ~mask;
	return retval;
}

static __inline__ int test_and_change_bit(int nr, volatile unsigned long *addr)
{
	int mask, retval;
	volatile unsigned int *a = (volatile unsigned int *)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 unsigned long *addr)
{
	int mask, retval;
	volatile unsigned int *a = (volatile unsigned int *)addr;

	a += nr >> 5;
	mask = 1 << (nr & 0x1f);
	retval = (mask & *a) != 0;
	*a ^= mask;
	return retval;
}

/*
 * This routine doesn't need to be atomic.
 */
static __inline__ int __constant_test_bit(int nr, const void *addr)
{
	return ((1UL << (nr & 31)) &
		(((const volatile unsigned int *)addr)[nr >> 5])) != 0;
}

static __inline__ int __test_bit(int nr, const void *addr)
{
	int *a = (int *)addr;
	int mask;

	a += nr >> 5;
	mask = 1 << (nr & 0x1f);
	return ((mask & *a) != 0);
}

#define test_bit(nr,addr) \
(__builtin_constant_p(nr) ? \
 __constant_test_bit((nr),(addr)) : \
 __test_bit((nr),(addr)))

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

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

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

#endif				/* __KERNEL__ */

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

#endif				/* _BLACKFIN_BITOPS_H */
Commit	Line	Data
1394f032 BW	1	#ifndef _BLACKFIN_BITOPS_H
	2	#define _BLACKFIN_BITOPS_H
	3
	4	/*
	5	* Copyright 1992, Linus Torvalds.
	6	*/
	7
	8	#include <linux/compiler.h>
	9	#include <asm/byteorder.h> /* swab32 */
	10	#include <asm/system.h> /* save_flags */
	11
	12	#ifdef __KERNEL__
	13
0624517d JS	14	#ifndef _LINUX_BITOPS_H
	15	#error only <linux/bitops.h> can be included directly
	16	#endif
	17
1394f032 BW	18	#include <asm-generic/bitops/ffs.h>
	19	#include <asm-generic/bitops/__ffs.h>
	20	#include <asm-generic/bitops/sched.h>
	21	#include <asm-generic/bitops/ffz.h>
	22
	23	static __inline__ void set_bit(int nr, volatile unsigned long *addr)
	24	{
	25	int a = (int )addr;
	26	int mask;
	27	unsigned long flags;
	28
	29	a += nr >> 5;
	30	mask = 1 << (nr & 0x1f);
	31	local_irq_save(flags);
	32	*a \|= mask;
	33	local_irq_restore(flags);
	34	}
	35
	36	static __inline__ void __set_bit(int nr, volatile unsigned long *addr)
	37	{
	38	int a = (int )addr;
	39	int mask;
	40
	41	a += nr >> 5;
	42	mask = 1 << (nr & 0x1f);
	43	*a \|= mask;
	44	}
	45
	46	/*
	47	* clear_bit() doesn't provide any barrier for the compiler.
	48	*/
	49	#define smp_mb__before_clear_bit() barrier()
	50	#define smp_mb__after_clear_bit() barrier()
	51
	52	static __inline__ void clear_bit(int nr, volatile unsigned long *addr)
	53	{
	54	int a = (int )addr;
	55	int mask;
	56	unsigned long flags;
	57	a += nr >> 5;
	58	mask = 1 << (nr & 0x1f);
	59	local_irq_save(flags);
	60	*a &= ~mask;
	61	local_irq_restore(flags);
	62	}
	63
	64	static __inline__ void __clear_bit(int nr, volatile unsigned long *addr)
	65	{
	66	int a = (int )addr;
	67	int mask;
	68
	69	a += nr >> 5;
	70	mask = 1 << (nr & 0x1f);
	71	*a &= ~mask;
	72	}
	73
	74	static __inline__ void change_bit(int nr, volatile unsigned long *addr)
	75	{
	76	int mask, flags;
	77	unsigned long ADDR = (unsigned long )addr;
	78
	79	ADDR += nr >> 5;
	80	mask = 1 << (nr & 31);
	81	local_irq_save(flags);
82	*ADDR ^= mask;
83	local_irq_restore(flags);
84	}
85
86	static __inline__ void __change_bit(int nr, volatile unsigned long *addr)
87	{
88	int mask;
89	unsigned long ADDR = (unsigned long )addr;
90
91	ADDR += nr >> 5;
92	mask = 1 << (nr & 31);
93	*ADDR ^= mask;
94	}
95
96	static __inline__ int test_and_set_bit(int nr, void *addr)
97	{
98	int mask, retval;
99	volatile unsigned int a = (volatile unsigned int )addr;
100	unsigned long flags;
101
102	a += nr >> 5;
103	mask = 1 << (nr & 0x1f);
104	local_irq_save(flags);
105	retval = (mask & *a) != 0;
106	*a \|= mask;
107	local_irq_restore(flags);
108
109	return retval;
110	}
111
112	static __inline__ int __test_and_set_bit(int nr, volatile unsigned long *addr)
113	{
114	int mask, retval;
115	volatile unsigned int a = (volatile unsigned int )addr;
116
117	a += nr >> 5;
118	mask = 1 << (nr & 0x1f);
119	retval = (mask & *a) != 0;
120	*a \|= mask;
121	return retval;
122	}
123
124	static __inline__ int test_and_clear_bit(int nr, volatile unsigned long *addr)
125	{
126	int mask, retval;
127	volatile unsigned int a = (volatile unsigned int )addr;
128	unsigned long flags;
129
130	a += nr >> 5;
131	mask = 1 << (nr & 0x1f);
132	local_irq_save(flags);
133	retval = (mask & *a) != 0;
134	*a &= ~mask;
135	local_irq_restore(flags);
136
137	return retval;
138	}
139
140	static __inline__ int __test_and_clear_bit(int nr, volatile unsigned long *addr)
141	{
142	int mask, retval;
143	volatile unsigned int a = (volatile unsigned int )addr;
144
145	a += nr >> 5;
146	mask = 1 << (nr & 0x1f);
147	retval = (mask & *a) != 0;
148	*a &= ~mask;
149	return retval;
150	}
151
152	static __inline__ int test_and_change_bit(int nr, volatile unsigned long *addr)
153	{
154	int mask, retval;
155	volatile unsigned int a = (volatile unsigned int )addr;
156	unsigned long flags;
157
158	a += nr >> 5;
159	mask = 1 << (nr & 0x1f);
160	local_irq_save(flags);
161	retval = (mask & *a) != 0;
162	*a ^= mask;
163	local_irq_restore(flags);
164	return retval;
165	}
166
167	static __inline__ int __test_and_change_bit(int nr,
168	volatile unsigned long *addr)
169	{
170	int mask, retval;
171	volatile unsigned int a = (volatile unsigned int )addr;
172
173	a += nr >> 5;
174	mask = 1 << (nr & 0x1f);
175	retval = (mask & *a) != 0;
176	*a ^= mask;
177	return retval;
178	}
179
180	/*
181	* This routine doesn't need to be atomic.
182	*/
183	static __inline__ int __constant_test_bit(int nr, const void *addr)
184	{
185	return ((1UL << (nr & 31)) &
186	(((const volatile unsigned int *)addr)[nr >> 5])) != 0;
187	}
188
189	static __inline__ int __test_bit(int nr, const void *addr)
190	{
191	int a = (int )addr;
192	int mask;
193
194	a += nr >> 5;
195	mask = 1 << (nr & 0x1f);
196	return ((mask & *a) != 0);
197	}
198
199	#define test_bit(nr,addr) \
200	(__builtin_constant_p(nr) ? \
201	__constant_test_bit((nr),(addr)) : \
202	__test_bit((nr),(addr)))
203
204	#include <asm-generic/bitops/find.h>
205	#include <asm-generic/bitops/hweight.h>
26333576	206	#include <asm-generic/bitops/lock.h>
1394f032 BW	207
	208	#include <asm-generic/bitops/ext2-atomic.h>
	209	#include <asm-generic/bitops/ext2-non-atomic.h>
	210
	211	#include <asm-generic/bitops/minix.h>
	212
	213	#endif /* __KERNEL__ */
	214
	215	#include <asm-generic/bitops/fls.h>
	216	#include <asm-generic/bitops/fls64.h>
	217
	218	#endif /* _BLACKFIN_BITOPS_H */