WebSVN – Kolibri OS – Diff – /drivers/include/linux/bitops.h


#ifndef _LINUX_BITOPS_H
#define _LINUX_BITOPS_H
#include 
 
#ifdef	__KERNEL__
#define BIT(nr)         (1UL << (nr))
#define BIT_MASK(nr)		(1UL << ((nr) % BITS_PER_LONG))
#define BIT_WORD(nr)		((nr) / BITS_PER_LONG)
#define BITS_PER_BYTE		8
#define BITS_TO_LONGS(nr)	DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))
#endif
 
extern unsigned int __sw_hweight8(unsigned int w);
extern unsigned int __sw_hweight16(unsigned int w);
extern unsigned int __sw_hweight32(unsigned int w);
extern unsigned long __sw_hweight64(__u64 w);
 
/*
 * Include this here because some architectures need generic_ffs/fls in
 * scope
 */
#include 
 
#define for_each_set_bit(bit, addr, size) \
	for ((bit) = find_first_bit((addr), (size)); \
	     (bit) < (size); \
	     (bit) = find_next_bit((addr), (size), (bit) + 1))
 
static __inline__ int get_bitmask_order(unsigned int count)
{
	int order;
 
	order = fls(count);
	return order;	/* We could be slightly more clever with -1 here... */
}
 
static __inline__ int get_count_order(unsigned int count)
{
	int order;
 
	order = fls(count) - 1;
	if (count & (count - 1))
		order++;
	return order;
}
 
static inline unsigned long hweight_long(unsigned long w)
{
	return sizeof(w) == 4 ? hweight32(w) : hweight64(w);
}
 
/**
 * rol32 - rotate a 32-bit value left
 * @word: value to rotate
 * @shift: bits to roll
 */
static inline __u32 rol32(__u32 word, unsigned int shift)
{
	return (word << shift) | (word >> (32 - shift));
}
 
/**
 * ror32 - rotate a 32-bit value right
 * @word: value to rotate
 * @shift: bits to roll
 */
static inline __u32 ror32(__u32 word, unsigned int shift)
{
	return (word >> shift) | (word << (32 - shift));
}
 
/**
 * rol16 - rotate a 16-bit value left
 * @word: value to rotate
 * @shift: bits to roll
 */
static inline __u16 rol16(__u16 word, unsigned int shift)
{
	return (word << shift) | (word >> (16 - shift));
}
 
/**
 * ror16 - rotate a 16-bit value right
 * @word: value to rotate
 * @shift: bits to roll
 */
static inline __u16 ror16(__u16 word, unsigned int shift)
{
	return (word >> shift) | (word << (16 - shift));
}
 
/**
 * rol8 - rotate an 8-bit value left
 * @word: value to rotate
 * @shift: bits to roll
 */
static inline __u8 rol8(__u8 word, unsigned int shift)
{
	return (word << shift) | (word >> (8 - shift));
}
 
/**
 * ror8 - rotate an 8-bit value right
 * @word: value to rotate
 * @shift: bits to roll
 */
static inline __u8 ror8(__u8 word, unsigned int shift)
{
	return (word >> shift) | (word << (8 - shift));
}
 
/**
 * sign_extend32 - sign extend a 32-bit value using specified bit as sign-bit
 * @value: value to sign extend
 * @index: 0 based bit index (0<=index<32) to sign bit
 */
static inline __s32 sign_extend32(__u32 value, int index)
{
	__u8 shift = 31 - index;
	return (__s32)(value << shift) >> shift;
}
 
static inline unsigned fls_long(unsigned long l)
{
	if (sizeof(l) == 4)
		return fls(l);
	return fls64(l);
}
 
/**
 * __ffs64 - find first set bit in a 64 bit word
 * @word: The 64 bit word
 *
 * On 64 bit arches this is a synomyn for __ffs
 * The result is not defined if no bits are set, so check that @word
 * is non-zero before calling this.
 */
static inline unsigned long __ffs64(u64 word)
{
#if BITS_PER_LONG == 32
	if (((u32)word) == 0UL)
		return __ffs((u32)(word >> 32)) + 32;
#elif BITS_PER_LONG != 64
#error BITS_PER_LONG not 32 or 64
#endif
	return __ffs((unsigned long)word);
}
 
#ifdef __KERNEL__
 
#ifndef find_last_bit
/**
 * find_last_bit - find the last set bit in a memory region
 * @addr: The address to start the search at
 * @size: The maximum size to search
 *
 * Returns the bit number of the first set bit, or size.
 */
extern unsigned long find_last_bit(const unsigned long *addr,
				   unsigned long size);
#endif
 
#endif /* __KERNEL__ */
#endif

Rev 1964	Rev 1970
1	#ifndef _LINUX_BITOPS_H	1	#ifndef _LINUX_BITOPS_H
2	#define _LINUX_BITOPS_H	2	#define _LINUX_BITOPS_H
3	#include	3	#include
4		4
5	#ifdef __KERNEL__	5	#ifdef __KERNEL__
6	#define BIT(nr) (1UL << (nr))	6	#define BIT(nr) (1UL << (nr))
7	#define BIT_MASK(nr) (1UL << ((nr) % BITS_PER_LONG))	7	#define BIT_MASK(nr) (1UL << ((nr) % BITS_PER_LONG))
8	#define BIT_WORD(nr) ((nr) / BITS_PER_LONG)	8	#define BIT_WORD(nr) ((nr) / BITS_PER_LONG)
9	#define BITS_PER_BYTE 8	9	#define BITS_PER_BYTE 8
10	#define BITS_TO_LONGS(nr) DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))	10	#define BITS_TO_LONGS(nr) DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))
11	#endif	11	#endif
12		12
13	extern unsigned int __sw_hweight8(unsigned int w);	13	extern unsigned int __sw_hweight8(unsigned int w);
14	extern unsigned int __sw_hweight16(unsigned int w);	14	extern unsigned int __sw_hweight16(unsigned int w);
15	extern unsigned int __sw_hweight32(unsigned int w);	15	extern unsigned int __sw_hweight32(unsigned int w);
16	extern unsigned long __sw_hweight64(__u64 w);	16	extern unsigned long __sw_hweight64(__u64 w);
17		17
18	/*	18	/*
19	* Include this here because some architectures need generic_ffs/fls in	19	* Include this here because some architectures need generic_ffs/fls in
20	* scope	20	* scope
21	*/	21	*/
22	#include	22	#include
23		23
24	#define for_each_set_bit(bit, addr, size) \	24	#define for_each_set_bit(bit, addr, size) \
25	for ((bit) = find_first_bit((addr), (size)); \	25	for ((bit) = find_first_bit((addr), (size)); \
26	(bit) < (size); \	26	(bit) < (size); \
27	(bit) = find_next_bit((addr), (size), (bit) + 1))	27	(bit) = find_next_bit((addr), (size), (bit) + 1))
28		28
29	static __inline__ int get_bitmask_order(unsigned int count)	29	static __inline__ int get_bitmask_order(unsigned int count)
30	{	30	{
31	int order;	31	int order;
32		32
33	order = fls(count);	33	order = fls(count);
34	return order; /* We could be slightly more clever with -1 here... */	34	return order; /* We could be slightly more clever with -1 here... */
35	}	35	}
36		36
37	static __inline__ int get_count_order(unsigned int count)	37	static __inline__ int get_count_order(unsigned int count)
38	{	38	{
39	int order;	39	int order;
40		40
41	order = fls(count) - 1;	41	order = fls(count) - 1;
42	if (count & (count - 1))	42	if (count & (count - 1))
43	order++;	43	order++;
44	return order;	44	return order;
45	}	45	}
46		46
47	static inline unsigned long hweight_long(unsigned long w)	47	static inline unsigned long hweight_long(unsigned long w)
48	{	48	{
49	return sizeof(w) == 4 ? hweight32(w) : hweight64(w);	49	return sizeof(w) == 4 ? hweight32(w) : hweight64(w);
50	}	50	}
51		51
52	/**	52	/**
53	* rol32 - rotate a 32-bit value left	53	* rol32 - rotate a 32-bit value left
54	* @word: value to rotate	54	* @word: value to rotate
55	* @shift: bits to roll	55	* @shift: bits to roll
56	*/	56	*/
57	static inline __u32 rol32(__u32 word, unsigned int shift)	57	static inline __u32 rol32(__u32 word, unsigned int shift)
58	{	58	{
59	return (word << shift) \| (word >> (32 - shift));	59	return (word << shift) \| (word >> (32 - shift));
60	}	60	}
61		61
62	/**	62	/**
63	* ror32 - rotate a 32-bit value right	63	* ror32 - rotate a 32-bit value right
64	* @word: value to rotate	64	* @word: value to rotate
65	* @shift: bits to roll	65	* @shift: bits to roll
66	*/	66	*/
67	static inline __u32 ror32(__u32 word, unsigned int shift)	67	static inline __u32 ror32(__u32 word, unsigned int shift)
68	{	68	{
69	return (word >> shift) \| (word << (32 - shift));	69	return (word >> shift) \| (word << (32 - shift));
70	}	70	}
71		71
72	/**	72	/**
73	* rol16 - rotate a 16-bit value left	73	* rol16 - rotate a 16-bit value left
74	* @word: value to rotate	74	* @word: value to rotate
75	* @shift: bits to roll	75	* @shift: bits to roll
76	*/	76	*/
77	static inline __u16 rol16(__u16 word, unsigned int shift)	77	static inline __u16 rol16(__u16 word, unsigned int shift)
78	{	78	{
79	return (word << shift) \| (word >> (16 - shift));	79	return (word << shift) \| (word >> (16 - shift));
80	}	80	}
81		81
82	/**	82	/**
83	* ror16 - rotate a 16-bit value right	83	* ror16 - rotate a 16-bit value right
84	* @word: value to rotate	84	* @word: value to rotate
85	* @shift: bits to roll	85	* @shift: bits to roll
86	*/	86	*/
87	static inline __u16 ror16(__u16 word, unsigned int shift)	87	static inline __u16 ror16(__u16 word, unsigned int shift)
88	{	88	{
89	return (word >> shift) \| (word << (16 - shift));	89	return (word >> shift) \| (word << (16 - shift));
90	}	90	}
91		91
92	/**	92	/**
93	* rol8 - rotate an 8-bit value left	93	* rol8 - rotate an 8-bit value left
94	* @word: value to rotate	94	* @word: value to rotate
95	* @shift: bits to roll	95	* @shift: bits to roll
96	*/	96	*/
97	static inline __u8 rol8(__u8 word, unsigned int shift)	97	static inline __u8 rol8(__u8 word, unsigned int shift)
98	{	98	{
99	return (word << shift) \| (word >> (8 - shift));	99	return (word << shift) \| (word >> (8 - shift));
100	}	100	}
101		101
102	/**	102	/**
103	* ror8 - rotate an 8-bit value right	103	* ror8 - rotate an 8-bit value right
104	* @word: value to rotate	104	* @word: value to rotate
105	* @shift: bits to roll	105	* @shift: bits to roll
106	*/	106	*/
107	static inline __u8 ror8(__u8 word, unsigned int shift)	107	static inline __u8 ror8(__u8 word, unsigned int shift)
108	{	108	{
109	return (word >> shift) \| (word << (8 - shift));	109	return (word >> shift) \| (word << (8 - shift));
110	}	110	}
-		111
-		112	/**
-		113	* sign_extend32 - sign extend a 32-bit value using specified bit as sign-bit
-		114	* @value: value to sign extend
-		115	* @index: 0 based bit index (0<=index<32) to sign bit
-		116	*/
-		117	static inline __s32 sign_extend32(__u32 value, int index)
-		118	{
-		119	__u8 shift = 31 - index;
-		120	return (__s32)(value << shift) >> shift;
-		121	}
111		122
112	static inline unsigned fls_long(unsigned long l)	123	static inline unsigned fls_long(unsigned long l)
113	{	124	{
114	if (sizeof(l) == 4)	125	if (sizeof(l) == 4)
115	return fls(l);	126	return fls(l);
116	return fls64(l);	127	return fls64(l);
117	}	128	}
118		129
119	/**	130	/**
120	* __ffs64 - find first set bit in a 64 bit word	131	* __ffs64 - find first set bit in a 64 bit word
121	* @word: The 64 bit word	132	* @word: The 64 bit word
122	*	133	*
123	* On 64 bit arches this is a synomyn for __ffs	134	* On 64 bit arches this is a synomyn for __ffs
124	* The result is not defined if no bits are set, so check that @word	135	* The result is not defined if no bits are set, so check that @word
125	* is non-zero before calling this.	136	* is non-zero before calling this.
126	*/	137	*/
127	static inline unsigned long __ffs64(u64 word)	138	static inline unsigned long __ffs64(u64 word)
128	{	139	{
129	#if BITS_PER_LONG == 32	140	#if BITS_PER_LONG == 32
130	if (((u32)word) == 0UL)	141	if (((u32)word) == 0UL)
131	return __ffs((u32)(word >> 32)) + 32;	142	return __ffs((u32)(word >> 32)) + 32;
132	#elif BITS_PER_LONG != 64	143	#elif BITS_PER_LONG != 64
133	#error BITS_PER_LONG not 32 or 64	144	#error BITS_PER_LONG not 32 or 64
134	#endif	145	#endif
135	return __ffs((unsigned long)word);	146	return __ffs((unsigned long)word);
136	}	147	}
137		148
138	#ifdef __KERNEL__	149	#ifdef __KERNEL__
139		150
140	#ifdef CONFIG_GENERIC_FIND_LAST_BIT	151	#ifndef find_last_bit
141	/**	152	/**
142	* find_last_bit - find the last set bit in a memory region	153	* find_last_bit - find the last set bit in a memory region
143	* @addr: The address to start the search at	154	* @addr: The address to start the search at
144	* @size: The maximum size to search	155	* @size: The maximum size to search
145	*	156	*
146	* Returns the bit number of the first set bit, or size.	157	* Returns the bit number of the first set bit, or size.
147	*/	158	*/
148	extern unsigned long find_last_bit(const unsigned long *addr,	159	extern unsigned long find_last_bit(const unsigned long *addr,
149	unsigned long size);	160	unsigned long size);
150	#endif /* CONFIG_GENERIC_FIND_LAST_BIT */	161	#endif
151		162
152	#endif /* __KERNEL__ */	163	#endif /* __KERNEL__ */
153	#endif	164	#endif

Subversion Repositories Kolibri OS

(root)/drivers/include/linux/bitops.h – Rev 1964 → 1970