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