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