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/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 */