Enable 2.6.33 compatibility
[~emulex/for-vlad/old/compat.git] / include / linux / compat-2.6.26.h
1 #ifndef LINUX_26_26_COMPAT_H
2 #define LINUX_26_26_COMPAT_H
3
4 #include <linux/version.h>
5
6 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26))
7
8 #include <linux/device.h>
9 #include <linux/list.h>
10 #include <linux/kernel.h>
11 #include <linux/jiffies.h>
12 #include <net/sock.h>
13 #include <linux/fs.h>
14 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24))
15 #include <net/net_namespace.h>
16 #endif
17 #include <linux/fs.h>
18 #include <linux/types.h>
19
20 #if 0
21 /* This cannot be backported :( */
22 #if defined(CONFIG_DEBUG_FS)
23 void debugfs_remove_recursive(struct dentry *dentry);
24 #else
25 static inline void debugfs_remove_recursive(struct dentry *dentry)
26 { }
27 #endif
28 #endif
29
30 /* These jiffie helpers added as of 2.6.26 */
31
32 /*
33  * These four macros compare jiffies and 'a' for convenience.
34  */
35
36 /* time_is_before_jiffies(a) return true if a is before jiffies */
37 #define time_is_before_jiffies(a) time_after(jiffies, a)
38
39 /* time_is_after_jiffies(a) return true if a is after jiffies */
40 #define time_is_after_jiffies(a) time_before(jiffies, a)
41
42 /* time_is_before_eq_jiffies(a) return true if a is before or equal to jiffies*/
43 #define time_is_before_eq_jiffies(a) time_after_eq(jiffies, a)
44
45 /* time_is_after_eq_jiffies(a) return true if a is after or equal to jiffies*/
46 #define time_is_after_eq_jiffies(a) time_before_eq(jiffies, a)
47
48 /* This comes from include/linux/input.h */
49 #define SW_RFKILL_ALL           0x03  /* rfkill master switch, type "any"
50                                          set = radio enabled */
51
52 /* From kernel.h */
53 #define USHORT_MAX      ((u16)(~0U))
54 #define SHORT_MAX       ((s16)(USHORT_MAX>>1))
55 #define SHORT_MIN       (-SHORT_MAX - 1)
56
57 extern int dev_set_name(struct device *dev, const char *name, ...)
58                         __attribute__((format(printf, 2, 3)));
59
60 /**
61  * clamp_t - return a value clamped to a given range using a given type
62  * @type: the type of variable to use
63  * @val: current value
64  * @min: minimum allowable value
65  * @max: maximum allowable value
66  *
67  * This macro does no typechecking and uses temporary variables of type
68  * 'type' to make all the comparisons.
69  */
70 #define clamp_t(type, val, min, max) ({         \
71         type __val = (val);                     \
72         type __min = (min);                     \
73         type __max = (max);                     \
74         __val = __val < __min ? __min: __val;   \
75         __val > __max ? __max: __val; })
76
77
78 /* from include/linux/device.h */
79 /* device_create_drvdata() is new */
80 extern struct device *device_create_drvdata(struct class *cls,
81         struct device *parent,
82         dev_t devt,
83         void *drvdata,
84         const char *fmt, ...)
85 __attribute__((format(printf, 5, 6)));
86
87 /* This is from include/linux/list.h */
88
89 /**
90  * list_is_singular - tests whether a list has just one entry.
91  * @head: the list to test.
92  */
93 static inline int list_is_singular(const struct list_head *head)
94 {
95         return !list_empty(head) && (head->next == head->prev);
96 }
97
98 /* This is from include/linux/device.h, which was added as of 2.6.26 */
99 static inline const char *dev_name(struct device *dev)
100 {
101         /* will be changed into kobject_name(&dev->kobj) in the near future */
102         return dev->bus_id;
103 }
104
105 /* This is from include/linux/kernel.h, which was added as of 2.6.26 */
106
107 /**
108  * clamp_val - return a value clamped to a given range using val's type
109  * @val: current value
110  * @min: minimum allowable value
111  * @max: maximum allowable value
112  *
113  * This macro does no typechecking and uses temporary variables of whatever
114  * type the input argument 'val' is.  This is useful when val is an unsigned
115  * type and min and max are literals that will otherwise be assigned a signed
116  * integer type.
117  */
118
119 #define clamp_val(val, min, max) ({             \
120         typeof(val) __val = (val);              \
121         typeof(val) __min = (min);              \
122         typeof(val) __max = (max);              \
123         __val = __val < __min ? __min: __val;   \
124         __val > __max ? __max: __val; })
125
126 /* This comes from include/net/net_namespace.h */
127
128 #ifdef CONFIG_NET_NS
129 static inline
130 int net_eq(const struct net *net1, const struct net *net2)
131 {
132         return net1 == net2;
133 }
134 #else
135 static inline
136 int net_eq(const struct net *net1, const struct net *net2)
137 {
138         return 1;
139 }
140 #endif
141
142 static inline
143 void dev_net_set(struct net_device *dev, struct net *net)
144 {
145 #ifdef CONFIG_NET_NS
146         release_net(dev->nd_net);
147         dev->nd_net = hold_net(net);
148 #endif
149 }
150
151 static inline
152 struct net *sock_net(const struct sock *sk)
153 {
154 #ifdef CONFIG_NET_NS
155         return sk->sk_net;
156 #else
157         return &init_net;
158 #endif
159 }
160
161 /* This comes from include/linux/netdevice.h */
162
163 /*
164  * Net namespace inlines
165  */
166 static inline
167 struct net *dev_net(const struct net_device *dev)
168 {
169 #ifdef CONFIG_NET_NS
170         /*
171          * compat-wirelss backport note:
172          * For older kernels we may just need to always return init_net,
173          * not sure when we added dev->nd_net.
174          */
175         return dev->nd_net;
176 #else
177         return &init_net;
178 #endif
179 }
180
181
182 /*
183  * 2.6.26 added its own unaligned API which the
184  * new drivers can use. Lets port it here by including it in older
185  * kernels and also deal with the architecture handling here.
186  */
187
188 #ifdef CONFIG_ALPHA
189
190 #include <linux/unaligned/be_struct.h>
191 #include <linux/unaligned/le_byteshift.h>
192 #include <linux/unaligned/generic.h>
193
194 #endif /* alpha */
195 #ifdef CONFIG_ARM
196
197 /* arm */
198 #include <linux/unaligned/le_byteshift.h>
199 #include <linux/unaligned/be_byteshift.h>
200 #include <linux/unaligned/generic.h>
201
202 #endif /* arm */
203 #ifdef CONFIG_AVR32
204
205 /*
206  * AVR32 can handle some unaligned accesses, depending on the
207  * implementation.  The AVR32 AP implementation can handle unaligned
208  * words, but halfwords must be halfword-aligned, and doublewords must
209  * be word-aligned.
210  *
211  * However, swapped word loads must be word-aligned so we can't
212  * optimize word loads in general.
213  */
214
215 #include <linux/unaligned/be_struct.h>
216 #include <linux/unaligned/le_byteshift.h>
217 #include <linux/unaligned/generic.h>
218
219 #endif
220 #ifdef CONFIG_BLACKFIN
221
222 #include <linux/unaligned/le_struct.h>
223 #include <linux/unaligned/be_byteshift.h>
224 #include <linux/unaligned/generic.h>
225
226 #endif /* blackfin */
227 #ifdef CONFIG_CRIS
228
229 /*
230  * CRIS can do unaligned accesses itself.
231  */
232 #include <linux/unaligned/access_ok.h>
233 #include <linux/unaligned/generic.h>
234
235 #endif /* cris */
236 #ifdef CONFIG_FRV
237
238 #include <linux/unaligned/le_byteshift.h>
239 #include <linux/unaligned/be_byteshift.h>
240 #include <linux/unaligned/generic.h>
241
242 #endif /* frv */
243 #ifdef CONFIG_H8300
244
245 #include <linux/unaligned/be_memmove.h>
246 #include <linux/unaligned/le_byteshift.h>
247 #include <linux/unaligned/generic.h>
248
249 #endif /* h8300 */
250 #ifdef  CONFIG_IA64
251
252 #include <linux/unaligned/le_struct.h>
253 #include <linux/unaligned/be_byteshift.h>
254 #include <linux/unaligned/generic.h>
255
256 #endif /* ia64 */
257 #ifdef CONFIG_M32R
258
259 #if defined(__LITTLE_ENDIAN__)
260 # include <linux/unaligned/le_memmove.h>
261 # include <linux/unaligned/be_byteshift.h>
262 # include <linux/unaligned/generic.h>
263 #else
264 # include <linux/unaligned/be_memmove.h>
265 # include <linux/unaligned/le_byteshift.h>
266 # include <linux/unaligned/generic.h>
267 #endif
268
269 #endif /* m32r */
270 #ifdef CONFIG_M68K /* this handles both m68k and m68knommu */
271
272 #ifdef CONFIG_COLDFIRE
273 #include <linux/unaligned/be_struct.h>
274 #include <linux/unaligned/le_byteshift.h>
275 #include <linux/unaligned/generic.h>
276 #else
277
278 /*
279  * The m68k can do unaligned accesses itself.
280  */
281 #include <linux/unaligned/access_ok.h>
282 #include <linux/unaligned/generic.h>
283 #endif
284
285 #endif /* m68k and m68knommu */
286 #ifdef CONFIG_MIPS
287
288 #if defined(__MIPSEB__)
289 # include <linux/unaligned/be_struct.h>
290 # include <linux/unaligned/le_byteshift.h>
291 # include <linux/unaligned/generic.h>
292 # define get_unaligned  __get_unaligned_be
293 # define put_unaligned  __put_unaligned_be
294 #elif defined(__MIPSEL__)
295 # include <linux/unaligned/le_struct.h>
296 # include <linux/unaligned/be_byteshift.h>
297 # include <linux/unaligned/generic.h>
298 #endif
299
300 #endif /* mips */
301 #ifdef CONFIG_MN10300
302
303 #include <linux/unaligned/access_ok.h>
304 #include <linux/unaligned/generic.h>
305
306 #endif /* mn10300 */
307 #ifdef CONFIG_PARISC
308
309 #include <linux/unaligned/be_struct.h>
310 #include <linux/unaligned/le_byteshift.h>
311 #include <linux/unaligned/generic.h>
312
313 #endif /* parisc */
314 #ifdef CONFIG_PPC
315 /*
316  * The PowerPC can do unaligned accesses itself in big endian mode.
317  */
318 #include <linux/unaligned/access_ok.h>
319 #include <linux/unaligned/generic.h>
320
321 #endif /* ppc */
322 #ifdef CONFIG_S390
323
324 /*
325  * The S390 can do unaligned accesses itself.
326  */
327 #include <linux/unaligned/access_ok.h>
328 #include <linux/unaligned/generic.h>
329
330 #endif /* s390 */
331 #ifdef CONFIG_SUPERH
332
333 /* SH can't handle unaligned accesses. */
334 #ifdef __LITTLE_ENDIAN__
335 # include <linux/unaligned/le_struct.h>
336 # include <linux/unaligned/be_byteshift.h>
337 # include <linux/unaligned/generic.h>
338 #else
339 # include <linux/unaligned/be_struct.h>
340 # include <linux/unaligned/le_byteshift.h>
341 # include <linux/unaligned/generic.h>
342 #endif
343
344 #endif /* sh - SUPERH */
345 #ifdef CONFIG_SPARC
346
347 /* sparc and sparc64 */
348 #include <linux/unaligned/be_struct.h>
349 #include <linux/unaligned/le_byteshift.h>
350 #include <linux/unaligned/generic.h>
351
352 #endif  /* sparc */
353 #ifdef CONFIG_UML
354
355 #include "asm/arch/unaligned.h"
356
357 #endif /* um - uml */
358 #ifdef CONFIG_V850
359
360 #include <linux/unaligned/be_byteshift.h>
361 #include <linux/unaligned/le_byteshift.h>
362 #include <linux/unaligned/generic.h>
363
364 #endif /* v850 */
365 #ifdef CONFIG_X86
366 /*
367  * The x86 can do unaligned accesses itself.
368  */
369 #include <linux/unaligned/access_ok.h>
370 #include <linux/unaligned/generic.h>
371
372 #endif /* x86 */
373 #ifdef CONFIG_XTENSA
374
375 #ifdef __XTENSA_EL__
376 # include <linux/unaligned/le_memmove.h>
377 # include <linux/unaligned/be_byteshift.h>
378 # include <linux/unaligned/generic.h>
379 #elif defined(__XTENSA_EB__)
380 # include <linux/unaligned/be_memmove.h>
381 # include <linux/unaligned/le_byteshift.h>
382 # include <linux/unaligned/generic.h>
383 #else
384 # error processor byte order undefined!
385 #endif
386
387 #endif /* xtensa */
388
389 #endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26)) */
390
391 #endif /* LINUX_26_26_COMPAT_H */