From: Johannes Berg Date: Thu, 11 Apr 2013 14:55:22 +0000 (+0200) Subject: backports: move header files X-Git-Url: http://git.lede-project.org./?a=commitdiff_plain;h=a09a3f4cd32915a438f92be173c91bd17d88f89f;p=openwrt%2Fstaging%2Fblogic.git backports: move header files This first step in reorganising the header files moves all the header files into a new backport-include/ directory that gets priority over the regular include/ where we copy the files we want to backport from the kernel. This will help split all the header files into logical units. While at it, move and rename compat_2.6.h and compat_autoconf.h to backport/backport.h and backport/autoconf.h respectively. Signed-off-by: Johannes Berg --- diff --git a/backport/.gitignore b/backport/.gitignore index b3c3260bccb1..c906800dc3f5 100644 --- a/backport/.gitignore +++ b/backport/.gitignore @@ -12,7 +12,7 @@ Kconfig.versions *.tmp *.ver modules.order -include/linux/compat_autoconf.h +backport-include/backport/autoconf.h modules kconfig/mconf kconfig/conf diff --git a/backport/Makefile.kernel b/backport/Makefile.kernel index e2e2f4446a22..2f80cc8e6fc7 100644 --- a/backport/Makefile.kernel +++ b/backport/Makefile.kernel @@ -4,10 +4,11 @@ backport-cc-disable-warning = $(call try-run,\ $(CC) $(KBUILD_CPPFLAGS) $(KBUILD_CFLAGS) -W$(strip $(1)) -c -x c /dev/null -o "$$TMP",-Wno-$(strip $(1))) NOSTDINC_FLAGS := \ + -I$(M)/backport-include/ \ -I$(M)/include/ \ -I$(M)/include/uapi \ -I$(M)/include/drm \ - -include $(M)/include/linux/compat-2.6.h \ + -include $(M)/backport-include/backport/backport.h \ $(call backport-cc-disable-warning, unused-but-set-variable) \ -DBACKPORTS_VERSION=\"$(BACKPORTS_VERSION)\" \ -DBACKPORTED_KERNEL_VERSION=\"$(BACKPORTED_KERNEL_VERSION)\" \ diff --git a/backport/Makefile.real b/backport/Makefile.real index 0040ec7ccb03..81164da31701 100644 --- a/backport/Makefile.real +++ b/backport/Makefile.real @@ -52,9 +52,9 @@ defconfig-%:: echo "\--" ;\ false ) -include/linux/compat_autoconf.h: .config +backport-include/backport/autoconf.h: .config @$(MAKE) oldconfig - @echo -n "Building include/linux/compat_autoconf.h ..." + @echo -n "Building backport-include/backport/autoconf.h ..." @grep -f .local-symbols .config | ( \ echo "#ifndef COMPAT_AUTOCONF_INCLUDED" ;\ echo "#define COMPAT_AUTOCONF_INCLUDED" ;\ @@ -75,11 +75,11 @@ include/linux/compat_autoconf.h: .config esac ;\ done ;\ echo "#endif /* COMPAT_AUTOCONF_INCLUDED */" ;\ - ) > include/linux/compat_autoconf.h + ) > backport-include/backport/autoconf.h @echo " done." .PHONY: modules -modules: include/linux/compat_autoconf.h +modules: backport-include/backport/autoconf.h @$(MAKE) -f Makefile.build modules .PHONY: install diff --git a/backport/backport-include/backport/backport.h b/backport/backport-include/backport/backport.h new file mode 100644 index 000000000000..6bbf4a79dbc7 --- /dev/null +++ b/backport/backport-include/backport/backport.h @@ -0,0 +1,91 @@ +#ifndef LINUX_BACKPORT_H +#define LINUX_BACKPORT_H + +#ifndef __ASSEMBLY__ + +#define LINUX_BACKPORT(__sym) backport_ ##__sym +#include + +#include +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0)) +#include +#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33)) +#include +#else +#include +#endif +#include +#include +#include +#include + +/* + * The define overwriting module_init is based on the original module_init + * which looks like this: + * #define module_init(initfn) \ + * static inline initcall_t __inittest(void) \ + * { return initfn; } \ + * int init_module(void) __attribute__((alias(#initfn))); + * + * To the call to the initfn we added the symbol dependency on compat + * to make sure that compat.ko gets loaded for any compat modules. + */ +void backport_dependency_symbol(void); + +#ifdef BACKPORTS_GIT_TRACKED +#define BACKPORT_MOD_VERSIONS MODULE_VERSION(BACKPORTS_GIT_TRACKED); +#else +#define BACKPORT_MOD_VERSIONS \ + MODULE_VERSION("backported from " BACKPORTED_KERNEL_NAME \ + " (" BACKPORTED_KERNEL_VERSION ")" \ + " using backports " BACKPORTS_VERSION); +#endif + +#undef module_init +#define module_init(initfn) \ + static int __init __init_backport(void) \ + { \ + backport_dependency_symbol(); \ + return initfn(); \ + } \ + int init_module(void) __attribute__((alias("__init_backport")));\ + BACKPORT_MOD_VERSIONS + +/* + * Each compat file represents compatibility code for new kernel + * code introduced for *that* kernel revision. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#endif /* __ASSEMBLY__ */ + +#endif /* LINUX_BACKPORT_H */ diff --git a/backport/backport-include/backport/checks.h b/backport/backport-include/backport/checks.h new file mode 100644 index 000000000000..6244559a5cef --- /dev/null +++ b/backport/backport-include/backport/checks.h @@ -0,0 +1,16 @@ +#ifndef __BACKPORT_CHECKS +#define __BACKPORT_CHECKS + +#if defined(CPTCFG_BACKPORT_KERNEL_2_6_28) && defined(CONFIG_DYNAMIC_FTRACE) +#error "You can't build on a 2.6.27 or older kernel with dynamic ftrace, it's broken" +#endif + +#if defined(CONFIG_MAC80211) && defined(CPTCFG_MAC80211) +#error "You must not have mac80211 built into your kernel if you want to enable it" +#endif + +#if defined(CONFIG_CFG80211) && defined(CPTCFG_CFG80211) +#error "You must not have cfg80211 built into your kernel if you want to enable it" +#endif + +#endif /* __BACKPORT_CHECKS */ diff --git a/backport/backport-include/crypto/aes.h b/backport/backport-include/crypto/aes.h new file mode 100644 index 000000000000..8031a54d4a45 --- /dev/null +++ b/backport/backport-include/crypto/aes.h @@ -0,0 +1,21 @@ +#ifndef _COMPAT_CRYPTO_AES_H +#define _COMPAT_CRYPTO_AES_H + +#include + +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,24)) +#include_next +#else + +#define AES_MIN_KEY_SIZE 16 +#define AES_MAX_KEY_SIZE 32 +#define AES_KEYSIZE_128 16 +#define AES_KEYSIZE_192 24 +#define AES_KEYSIZE_256 32 +#define AES_BLOCK_SIZE 16 +#define AES_MAX_KEYLENGTH (15 * 16) +#define AES_MAX_KEYLENGTH_U32 (AES_MAX_KEYLENGTH / sizeof(u32)) + +#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,24)) */ + +#endif diff --git a/backport/backport-include/linux/atomic.h b/backport/backport-include/linux/atomic.h new file mode 100644 index 000000000000..378b748fb207 --- /dev/null +++ b/backport/backport-include/linux/atomic.h @@ -0,0 +1,46 @@ +#ifndef _COMPAT_LINUX_ATOMIC_H +#define _COMPAT_LINUX_ATOMIC_H 1 + +#include + +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,36)) +#include_next +#else + +#include + +/** + * atomic_inc_not_zero_hint - increment if not null + * @v: pointer of type atomic_t + * @hint: probable value of the atomic before the increment + * + * This version of atomic_inc_not_zero() gives a hint of probable + * value of the atomic. This helps processor to not read the memory + * before doing the atomic read/modify/write cycle, lowering + * number of bus transactions on some arches. + * + * Returns: 0 if increment was not done, 1 otherwise. + */ +#ifndef atomic_inc_not_zero_hint +static inline int atomic_inc_not_zero_hint(atomic_t *v, int hint) +{ + int val, c = hint; + + /* sanity test, should be removed by compiler if hint is a constant */ + if (!hint) + return atomic_inc_not_zero(v); + + do { + val = atomic_cmpxchg(v, c, c + 1); + if (val == c) + return 1; + c = val; + } while (c); + + return 0; +} +#endif + +#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,36)) */ + +#endif /* _COMPAT_LINUX_ATOMIC_H */ diff --git a/backport/backport-include/linux/average.h b/backport/backport-include/linux/average.h new file mode 100644 index 000000000000..2d6210e53105 --- /dev/null +++ b/backport/backport-include/linux/average.h @@ -0,0 +1,34 @@ +#include + +#ifndef CPTCFG_BACKPORT_BUILD_AVERAGE +#include_next +#else +/* Exponentially weighted moving average (EWMA) */ + +/* For more documentation see lib/average.c */ + +struct ewma { + unsigned long internal; + unsigned long factor; + unsigned long weight; +}; + +#define ewma_init LINUX_BACKPORT(ewma_init) +extern void ewma_init(struct ewma *avg, unsigned long factor, + unsigned long weight); + +#define ewma_add LINUX_BACKPORT(ewma_add) +extern struct ewma *ewma_add(struct ewma *avg, unsigned long val); + +#define ewma_read LINUX_BACKPORT(ewma_read) +/** + * ewma_read() - Get average value + * @avg: Average structure + * + * Returns the average value held in @avg. + */ +static inline unsigned long ewma_read(const struct ewma *avg) +{ + return avg->internal >> avg->factor; +} +#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,37)) */ diff --git a/backport/backport-include/linux/bitops.h b/backport/backport-include/linux/bitops.h new file mode 100644 index 000000000000..aa76af184344 --- /dev/null +++ b/backport/backport-include/linux/bitops.h @@ -0,0 +1,211 @@ +#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 +#ifndef BITS_TO_LONGS /* Older kernels define this already */ +#define BITS_TO_LONGS(nr) DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long)) +#endif +#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__ +#ifdef CONFIG_GENERIC_FIND_FIRST_BIT + +/** + * find_first_bit - find the first 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. + */ +extern unsigned long find_first_bit(const unsigned long *addr, + unsigned long size); + +/** + * find_first_zero_bit - find the first cleared 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 cleared bit. + */ +extern unsigned long find_first_zero_bit(const unsigned long *addr, + unsigned long size); +#endif /* CONFIG_GENERIC_FIND_FIRST_BIT */ + +#ifdef CONFIG_GENERIC_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 /* CONFIG_GENERIC_FIND_LAST_BIT */ + +#ifdef CONFIG_GENERIC_FIND_NEXT_BIT + +/** + * find_next_bit - find the next set bit in a memory region + * @addr: The address to base the search on + * @offset: The bitnumber to start searching at + * @size: The bitmap size in bits + */ +extern unsigned long find_next_bit(const unsigned long *addr, + unsigned long size, unsigned long offset); + +/** + * find_next_zero_bit - find the next cleared bit in a memory region + * @addr: The address to base the search on + * @offset: The bitnumber to start searching at + * @size: The bitmap size in bits + */ + +extern unsigned long find_next_zero_bit(const unsigned long *addr, + unsigned long size, + unsigned long offset); + +#endif /* CONFIG_GENERIC_FIND_NEXT_BIT */ +#endif /* __KERNEL__ */ +#endif diff --git a/backport/backport-include/linux/compat-2.6.14.h b/backport/backport-include/linux/compat-2.6.14.h new file mode 100644 index 000000000000..1f19f7fee562 --- /dev/null +++ b/backport/backport-include/linux/compat-2.6.14.h @@ -0,0 +1,13 @@ +#ifndef LINUX_26_14_COMPAT_H +#define LINUX_26_14_COMPAT_H + +#include + +/* Compat work for 2.6.14 */ +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14)) + +typedef unsigned int gfp_t; + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14)) */ + +#endif /* LINUX_26_14_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-2.6.18.h b/backport/backport-include/linux/compat-2.6.18.h new file mode 100644 index 000000000000..5e0182b18a16 --- /dev/null +++ b/backport/backport-include/linux/compat-2.6.18.h @@ -0,0 +1,13 @@ +#ifndef LINUX_26_18_COMPAT_H +#define LINUX_26_18_COMPAT_H + +#include + +/* Compat work for 2.6.18 */ +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)) + +#define roundup(x, y) ((((x) + ((y) - 1)) / (y)) * (y)) + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)) */ + +#endif /* LINUX_26_18_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-2.6.19.h b/backport/backport-include/linux/compat-2.6.19.h new file mode 100644 index 000000000000..1e648c0aeba6 --- /dev/null +++ b/backport/backport-include/linux/compat-2.6.19.h @@ -0,0 +1,24 @@ +#ifndef LINUX_26_19_COMPAT_H +#define LINUX_26_19_COMPAT_H + +#include + +/* Compat work for 2.6.19 */ +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19)) + +#include + +static inline int +compat_kmem_cache_destroy(struct kmem_cache *cachep) +{ +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)) + return kmem_cache_destroy(cachep); +#else + kmem_cache_destroy(cachep); + return 0; +#endif +} + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)) */ + +#endif /* LINUX_26_19_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-2.6.20.h b/backport/backport-include/linux/compat-2.6.20.h new file mode 100644 index 000000000000..14579e29cf8e --- /dev/null +++ b/backport/backport-include/linux/compat-2.6.20.h @@ -0,0 +1,21 @@ +#ifndef LINUX_26_20_COMPAT_H +#define LINUX_26_20_COMPAT_H + +#include + +/* Compat work for 2.6.20 */ +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)) + +#include + +typedef void (*work_func_t)(struct work_struct *work); +typedef void (*compat_work_func_t)(void *work); +static inline void (INIT_WORK)(struct work_struct *work, work_func_t func) +{ + INIT_WORK(work, (compat_work_func_t)func, work); +} +#undef INIT_WORK + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)) */ + +#endif /* LINUX_26_20_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-2.6.21.h b/backport/backport-include/linux/compat-2.6.21.h new file mode 100644 index 000000000000..89ed6d9a4358 --- /dev/null +++ b/backport/backport-include/linux/compat-2.6.21.h @@ -0,0 +1,18 @@ +#ifndef LINUX_26_21_COMPAT_H +#define LINUX_26_21_COMPAT_H + +#include + +/* Compat work for 2.6.21 */ +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)) + +#include + +#define register_sysctl_table(table) \ + ({ \ + register_sysctl_table((table), 0); \ + }) + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)) */ + +#endif /* LINUX_26_21_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-2.6.22.h b/backport/backport-include/linux/compat-2.6.22.h new file mode 100644 index 000000000000..7ca1b18ea0f3 --- /dev/null +++ b/backport/backport-include/linux/compat-2.6.22.h @@ -0,0 +1,104 @@ +#ifndef LINUX_26_22_COMPAT_H +#define LINUX_26_22_COMPAT_H + +#include + +/* Compat work for 2.6.21 */ +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)) + +#include +#include + +/* reuse ax25_ptr */ +#define ieee80211_ptr ax25_ptr + +#ifdef CONFIG_AX25 +#error Compat reuses the AX.25 pointer so that may not be enabled! +#endif + +static inline unsigned char *skb_mac_header(const struct sk_buff *skb) +{ + return skb->mac.raw; +} + +static inline void skb_set_mac_header(struct sk_buff *skb, int offset) +{ + skb->mac.raw = skb->data + offset; +} + +static inline void skb_reset_mac_header(struct sk_buff *skb) +{ + skb->mac.raw = skb->data; +} + +static inline void skb_reset_network_header(struct sk_buff *skb) +{ + skb->nh.raw = skb->data; +} + +static inline void skb_set_network_header(struct sk_buff *skb, int offset) +{ + skb->nh.raw = skb->data + offset; +} + +static inline void skb_set_transport_header(struct sk_buff *skb, int offset) +{ + skb->h.raw = skb->data + offset; +} + +static inline unsigned char *skb_transport_header(struct sk_buff *skb) +{ + return skb->h.raw; +} + +static inline unsigned char *skb_network_header(const struct sk_buff *skb) +{ + return skb->nh.raw; +} + +static inline unsigned char *skb_tail_pointer(const struct sk_buff *skb) +{ + return skb->tail; +} + +static inline struct iphdr *ip_hdr(const struct sk_buff *skb) +{ + return (struct iphdr *)skb_network_header(skb); +} + +static inline void skb_copy_from_linear_data(const struct sk_buff *skb, + void *to, + const unsigned int len) +{ + memcpy(to, skb->data, len); +} + +static inline void skb_copy_from_linear_data_offset(const struct sk_buff *skb, + const int offset, void *to, + const unsigned int len) +{ + memcpy(to, skb->data + offset, len); +} + +#define __maybe_unused __attribute__((unused)) + +#define uninitialized_var(x) x = x + +/* This will lead to very weird behaviour... */ +#define NLA_BINARY NLA_STRING + +static inline int pci_set_mwi(struct pci_dev *dev) +{ + return -ENOSYS; +} + +static inline void pci_clear_mwi(struct pci_dev *dev) +{ +} + +#define list_first_entry(ptr, type, member) \ + list_entry((ptr)->next, type, member) + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)) */ + +#endif /* LINUX_26_22_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-2.6.23.h b/backport/backport-include/linux/compat-2.6.23.h new file mode 100644 index 000000000000..37cbc22a6670 --- /dev/null +++ b/backport/backport-include/linux/compat-2.6.23.h @@ -0,0 +1,139 @@ +#ifndef LINUX_26_23_COMPAT_H +#define LINUX_26_23_COMPAT_H + +#include + +/* Compat work for < 2.6.23 */ +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)) + +#include +#include +#include +#include +#include + +/* + * Tell gcc if a function is cold. The compiler will assume any path + * directly leading to the call is unlikely. + */ + +#if !(__GNUC__ == 4 && __GNUC_MINOR__ < 3) +/* Mark functions as cold. gcc will assume any path leading to a call + * to them will be unlikely. This means a lot of manual unlikely()s + * are unnecessary now for any paths leading to the usual suspects + * like BUG(), printk(), panic() etc. [but let's keep them for now for + * older compilers] + * + * Early snapshots of gcc 4.3 don't support this and we can't detect this + * in the preprocessor, but we can live with this because they're unreleased. + * Maketime probing would be overkill here. + * + * gcc also has a __attribute__((__hot__)) to move hot functions into + * a special section, but I don't see any sense in this right now in + * the kernel context */ +#define __cold __attribute__((__cold__)) +#endif /* gcc 4.3 check */ + +#ifndef __cold +#define __cold +#endif + +/* Added as of 2.6.23 in include/linux/netdevice.h */ +#define alloc_netdev_mq(sizeof_priv, name, setup, queue) \ + alloc_netdev(sizeof_priv, name, setup) +#define NETIF_F_MULTI_QUEUE 16384 + +/* Added as of 2.6.23 on include/linux/netdevice.h */ +static inline int netif_is_multiqueue(const struct net_device *dev) +{ + return (!!(NETIF_F_MULTI_QUEUE & dev->features)); +} + +/* 2.6.23 fixed a bug in tcf_destroy_chain and the parameter changed */ +static inline void tcf_destroy_chain_compat(struct tcf_proto **fl) +{ + struct tcf_proto *tp; + + while ((tp = *fl) != NULL) { + *fl = tp->next; + tp->ops->destroy(tp); + module_put(tp->ops->owner); + kfree(tp); + } +} + +/* dev_mc_list was replaced with dev_addr_list as of 2.6.23, + * only new member added is da_synced. */ +#define dev_addr_list dev_mc_list +#define da_addr dmi_addr +#define da_addrlen dmi_addrlen +#define da_users dmi_users +#define da_gusers dmi_gusers + +/* dev_set_promiscuity() was moved to __dev_set_promiscuity() on 2.6.23 and + * dev_set_promiscuity() became a wrapper. */ +#define __dev_set_promiscuity dev_set_promiscuity + +/* Our own 2.6.22 port on compat.c */ +#define dev_mc_unsync LINUX_BACKPORT(dev_mc_unsync) +#define dev_mc_sync LINUX_BACKPORT(dev_mc_sync) +extern void dev_mc_unsync(struct net_device *to, struct net_device *from); +extern int dev_mc_sync(struct net_device *to, struct net_device *from); + +/* Our own 2.6.22 port on compat.c */ +extern void __dev_set_rx_mode(struct net_device *dev); + +/* Simple to add this */ +extern int cancel_delayed_work_sync(struct delayed_work *work); + +#define cancel_delayed_work_sync cancel_rearming_delayed_work + +#define debugfs_rename(a, b, c, d) 1 + +/* nl80211 requires multicast group support which is new and added on + * 2.6.23. We can't add support for it for older kernels to support it + * genl_family structure was changed. Lets just let through the + * genl_register_mc_group call. This means no multicast group suppport */ + +#define genl_register_mc_group(a, b) 0 + +/** + * struct genl_multicast_group - generic netlink multicast group + * @name: name of the multicast group, names are per-family + * @id: multicast group ID, assigned by the core, to use with + * genlmsg_multicast(). + * @list: list entry for linking + * @family: pointer to family, need not be set before registering + */ +struct genl_multicast_group +{ + struct genl_family *family; /* private */ + struct list_head list; /* private */ + char name[GENL_NAMSIZ]; + u32 id; +}; + + +/* Added as of 2.6.23 */ +#define pci_try_set_mwi LINUX_BACKPORT(pci_try_set_mwi) +int pci_try_set_mwi(struct pci_dev *dev); + +/* Added as of 2.6.23 */ +#ifdef CONFIG_PM_SLEEP +/* + * Tell the freezer that the current task should be frozen by it + */ +static inline void set_freezable(void) +{ + current->flags &= ~PF_NOFREEZE; +} + +#else +static inline void set_freezable(void) {} +#endif /* CONFIG_PM_SLEEP */ + +#else +#define tcf_destroy_chain_compat tcf_destroy_chain +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)) */ + +#endif /* LINUX_26_23_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-2.6.24.h b/backport/backport-include/linux/compat-2.6.24.h new file mode 100644 index 000000000000..5448604cdbb2 --- /dev/null +++ b/backport/backport-include/linux/compat-2.6.24.h @@ -0,0 +1,252 @@ +#ifndef LINUX_26_24_COMPAT_H +#define LINUX_26_24_COMPAT_H + +#include + +/* Compat work for 2.6.21, 2.6.22 and 2.6.23 */ +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)) + +#include +#include +#include +#include +#include +#include +#include + +#define KEY_BLUETOOTH 237 +#define KEY_WLAN 238 +#define KEY_UWB 239 + +#define DMA_BIT_MASK(n) (((n) == 64) ? ~0ULL : ((1ULL<<(n))-1)) + +struct proc_dir_entry; +struct net_device; +struct net { + atomic_t count; /* To decided when the network + * namespace should be freed. + */ + atomic_t use_count; /* To track references we + * destroy on demand + */ + struct list_head list; /* list of network namespaces */ + struct work_struct work; /* work struct for freeing */ + + struct proc_dir_entry *proc_net; + struct proc_dir_entry *proc_net_stat; + struct proc_dir_entry *proc_net_root; + + struct net_device *loopback_dev; /* The loopback */ + + struct list_head dev_base_head; + struct hlist_head *dev_name_head; + struct hlist_head *dev_index_head; +}; + +#ifdef CONFIG_NET +/* Init's network namespace */ +#define init_net LINUX_BACKPORT(init_net) +extern struct net init_net; +#define INIT_NET_NS(net_ns) .net_ns = &init_net, +#else +#define INIT_NET_NS(net_ns) +#endif + +/* Added on 2.6.24 in include/linux/types.h by Al viro on commit 142956af */ +typedef unsigned long uintptr_t; + +/* From include/linux/net.h */ +enum sock_shutdown_cmd { + SHUT_RD = 0, + SHUT_WR = 1, + SHUT_RDWR = 2, +}; + +#if (LINUX_VERSION_CODE == KERNEL_VERSION(2,6,23)) /* Local check */ +/* Added as of 2.6.24 in include/linux/skbuff.h. + * + * Although 2.6.23 does support for CONFIG_NETDEVICES_MULTIQUEUE + * this helper was not added until 2.6.24. This implementation + * is exactly as it is on newer kernels. + * + * For older kernels we use the an internal mac80211 hack. + * For details see changes to include/net/mac80211.h through + * compat.diff and compat/mq_compat.h */ +static inline u16 skb_get_queue_mapping(struct sk_buff *skb) +{ +#ifdef CONFIG_NETDEVICES_MULTIQUEUE + return skb->queue_mapping; +#else + return 0; +#endif +} +#endif /* Local 2.6.23 check */ + +/* On older kernels we handle this a bit differently, so we yield to that + * code for its implementation in mq_compat.h as we want to make + * use of the internal mac80211 __ieee80211_queue_stopped() which itself + * uses internal mac80211 data structure hacks. */ +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23)) /* Local check */ +/** + * netif_subqueue_stopped - test status of subqueue + * @dev: network device + * @queue_index: sub queue index + * + * Check individual transmit queue of a device with multiple transmit queues. + */ +static inline int __netif_subqueue_stopped(const struct net_device *dev, + u16 queue_index) +{ +#ifdef CONFIG_NETDEVICES_MULTIQUEUE + return test_bit(__LINK_STATE_XOFF, + &dev->egress_subqueue[queue_index].state); +#else + return 0; +#endif +} + +/* Note: although the backport implementation for netif_subqueue_stopped + * on older kernels is identical to upstream __netif_subqueue_stopped() + * (except for a const qualifier) we implement netif_subqueue_stopped() + * as part of mac80211 as it relies on internal mac80211 structures we + * use for MQ support. We this implement it in mq_compat.h */ + +#endif /* Local 2.6.23 check */ + +/* + * Force link bug if constructor is used, can't be done compatibly + * because constructor arguments were swapped since then! + */ +extern void __incompatible_kmem_cache_create(void); + +/* 2.6.21 and 2.6.22 kmem_cache_create() takes 6 arguments */ +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)) +#define kmem_cache_create(name, objsize, align, flags, ctor) \ + ({ \ + if (ctor) __incompatible_kmem_cache_create(); \ + kmem_cache_create((name), (objsize), (align), \ + (flags), NULL, NULL); \ + }) +#endif + +/* 2.6.23 kmem_cache_create() takes 5 arguments */ +#if (LINUX_VERSION_CODE == KERNEL_VERSION(2,6,23)) +#define kmem_cache_create(name, objsize, align, flags, ctor) \ + ({ \ + if (ctor) __incompatible_kmem_cache_create(); \ + kmem_cache_create((name), (objsize), (align), \ + (flags), NULL); \ + }) +#endif + +/* From include/linux/mod_devicetable.h */ + +/* SSB core, see drivers/ssb/ */ +#ifndef SSB_DEVICE +struct ssb_device_id { + __u16 vendor; + __u16 coreid; + __u8 revision; +}; +#define SSB_DEVICE(_vendor, _coreid, _revision) \ + { .vendor = _vendor, .coreid = _coreid, .revision = _revision, } +#define SSB_DEVTABLE_END \ + { 0, }, + +#define SSB_ANY_VENDOR 0xFFFF +#define SSB_ANY_ID 0xFFFF +#define SSB_ANY_REV 0xFF +#endif + + +/* Namespace stuff, introduced on 2.6.24 */ +#define dev_get_by_index(a, b) dev_get_by_index(b) +#define __dev_get_by_index(a, b) __dev_get_by_index(b) + +#define eth_header LINUX_BACKPORT(eth_header) +extern int eth_header(struct sk_buff *skb, struct net_device *dev, + unsigned short type, void *daddr, + void *saddr, unsigned len); +#define eth_rebuild_header LINUX_BACKPORT(eth_rebuild_header) +extern int eth_rebuild_header(struct sk_buff *skb); +#define eth_header_cache_update LINUX_BACKPORT(eth_header_cache_update) +extern void eth_header_cache_update(struct hh_cache *hh, struct net_device *dev, + unsigned char * haddr); +#define eth_header_cache LINUX_BACKPORT(eth_header_cache) +extern int eth_header_cache(struct neighbour *neigh, + struct hh_cache *hh); + +/* This structure is simply not present on 2.6.22 and 2.6.23 */ +struct header_ops { + int (*create) (struct sk_buff *skb, struct net_device *dev, + unsigned short type, void *daddr, + void *saddr, unsigned len); + int (*parse)(const struct sk_buff *skb, unsigned char *haddr); + int (*rebuild)(struct sk_buff *skb); + #define HAVE_HEADER_CACHE + int (*cache)(struct neighbour *neigh, struct hh_cache *hh); + void (*cache_update)(struct hh_cache *hh, + struct net_device *dev, + unsigned char *haddr); +}; + +/* net/ieee80211/ieee80211_crypt_tkip uses sg_init_table. This was added on + * 2.6.24. CONFIG_DEBUG_SG was added in 2.6.24 as well, so lets just ignore + * the debug stuff. Note that adding this required changes to the struct + * scatterlist on include/asm/scatterlist*, so the right way to port this + * is to simply ignore the new structure changes and zero the scatterlist + * array. We lave the kdoc intact for reference. + */ + +/** + * sg_mark_end - Mark the end of the scatterlist + * @sg: SG entryScatterlist + * + * Description: + * Marks the passed in sg entry as the termination point for the sg + * table. A call to sg_next() on this entry will return NULL. + * + **/ +static inline void sg_mark_end(struct scatterlist *sg) +{ +#ifdef CONFIG_DEBUG_SG + BUG_ON(sg->sg_magic != SG_MAGIC); +#endif +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)) + /* + * Set termination bit, clear potential chain bit + */ + sg->page_link |= 0x02; + sg->page_link &= ~0x01; +#endif +} + +/** + * sg_init_table - Initialize SG table + * @sgl: The SG table + * @nents: Number of entries in table + * + * Notes: + * If this is part of a chained sg table, sg_mark_end() should be + * used only on the last table part. + * + **/ +static inline void sg_init_table(struct scatterlist *sgl, unsigned int nents) +{ + memset(sgl, 0, sizeof(*sgl) * nents); +} + +/** + * usb_endpoint_num - get the endpoint's number + * @epd: endpoint to be checked + * + * Returns @epd's number: 0 to 15. + */ +static inline int usb_endpoint_num(const struct usb_endpoint_descriptor *epd) +{ + return epd->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK; +} + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)) */ + +#endif /* LINUX_26_24_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-2.6.25.h b/backport/backport-include/linux/compat-2.6.25.h new file mode 100644 index 000000000000..dd986f5c6013 --- /dev/null +++ b/backport/backport-include/linux/compat-2.6.25.h @@ -0,0 +1,361 @@ +#ifndef LINUX_26_25_COMPAT_H +#define LINUX_26_25_COMPAT_H + +#include + +/* Compat work for 2.6.24 */ +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)) + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define __inet_lookup_established __inet_lookup_established_old +#include +#undef __inet_lookup_established +#include + +struct sg_table { + struct scatterlist *sgl; /* the list */ + unsigned int nents; /* number of mapped entries */ + unsigned int orig_nents; /* original size of list */ +}; + +#define sg_alloc_fn LINUX_BACKPORT(sg_alloc_fn) +typedef struct scatterlist *(sg_alloc_fn)(unsigned int, gfp_t); + +#define sg_free_fn LINUX_BACKPORT(sg_free_fn) +typedef void (sg_free_fn)(struct scatterlist *, unsigned int); + +#define __sg_free_table LINUX_BACKPORT(__sg_free_table) +void __sg_free_table(struct sg_table *table, unsigned int max_ents, + sg_free_fn *free_fn); +#define sg_free_table LINUX_BACKPORT(sg_free_table) +void sg_free_table(struct sg_table *); +#define __sg_alloc_table LINUX_BACKPORT(__sg_alloc_table) +int __sg_alloc_table(struct sg_table *table, unsigned int nents, + unsigned int max_ents, gfp_t gfp_mask, + sg_alloc_fn *alloc_fn); +#define sg_alloc_table LINUX_BACKPORT(sg_alloc_table) +int sg_alloc_table(struct sg_table *table, unsigned int nents, gfp_t gfp_mask); + +/* + * Maximum number of entries that will be allocated in one piece, if + * a list larger than this is required then chaining will be utilized. + */ +#define SG_MAX_SINGLE_ALLOC (PAGE_SIZE / sizeof(struct scatterlist)) + + +/* + * Sockets in TCP_CLOSE state are _always_ taken out of the hash, so we need + * not check it for lookups anymore, thanks Alexey. -DaveM + * + * Local BH must be disabled here. + */ +static inline struct sock * + __inet_lookup_established(struct inet_hashinfo *hashinfo, + const __be32 saddr, const __be16 sport, + const __be32 daddr, const u16 hnum, + const int dif) +{ + INET_ADDR_COOKIE(acookie, saddr, daddr) + const __portpair ports = INET_COMBINED_PORTS(sport, hnum); + struct sock *sk; + /* Optimize here for direct hit, only listening connections can + * have wildcards anyways. + */ + unsigned int hash = inet_ehashfn(daddr, hnum, saddr, sport); + struct inet_ehash_bucket *head = inet_ehash_bucket(hashinfo, hash); + rwlock_t *lock = inet_ehash_lockp(hashinfo, hash); + + prefetch(head->chain.first); + read_lock(lock); + sk_for_each(sk, &head->chain) { + if (INET_MATCH(sk, hash, acookie, saddr, daddr, ports, dif)) + goto hit; /* You sunk my battleship! */ + } + + /* Must check for a TIME_WAIT'er before going to listener hash. */ + sk_for_each(sk, &head->twchain) { + if (INET_TW_MATCH(sk, hash, acookie, saddr, daddr, ports, dif)) + goto hit; + } + sk = NULL; +out: + read_unlock(lock); + return sk; +hit: + sock_hold(sk); + goto out; +} + +/* Backports b718989da7 */ +#define pci_enable_device_mem LINUX_BACKPORT(pci_enable_device_mem) +int __must_check pci_enable_device_mem(struct pci_dev *dev); + +/* + * Backports 312b1485fb509c9bc32eda28ad29537896658cb8 + * Author: Sam Ravnborg + * Date: Mon Jan 28 20:21:15 2008 +0100 + * + * Introduce new section reference annotations tags: __ref, __refdata, __refconst + */ +#define __ref __init_refok +#define __refdata __initdata_refok + +/* + * backports 2658fa803111dae1353602e7f586de8e537803e2 + */ + +static inline bool ipv4_is_loopback(__be32 addr) +{ + return (addr & htonl(0xff000000)) == htonl(0x7f000000); +} + +static inline bool ipv4_is_multicast(__be32 addr) +{ + return (addr & htonl(0xf0000000)) == htonl(0xe0000000); +} + +static inline bool ipv4_is_local_multicast(__be32 addr) +{ + return (addr & htonl(0xffffff00)) == htonl(0xe0000000); +} + +static inline bool ipv4_is_lbcast(__be32 addr) +{ + /* limited broadcast */ + return addr == htonl(INADDR_BROADCAST); +} + +static inline bool ipv4_is_zeronet(__be32 addr) +{ + return (addr & htonl(0xff000000)) == htonl(0x00000000); +} + +/* Special-Use IPv4 Addresses (RFC3330) */ + +static inline bool ipv4_is_private_10(__be32 addr) +{ + return (addr & htonl(0xff000000)) == htonl(0x0a000000); +} + +static inline bool ipv4_is_private_172(__be32 addr) +{ + return (addr & htonl(0xfff00000)) == htonl(0xac100000); +} + +static inline bool ipv4_is_private_192(__be32 addr) +{ + return (addr & htonl(0xffff0000)) == htonl(0xc0a80000); +} + +static inline bool ipv4_is_linklocal_169(__be32 addr) +{ + return (addr & htonl(0xffff0000)) == htonl(0xa9fe0000); +} + +static inline bool ipv4_is_anycast_6to4(__be32 addr) +{ + return (addr & htonl(0xffffff00)) == htonl(0xc0586300); +} + +static inline bool ipv4_is_test_192(__be32 addr) +{ + return (addr & htonl(0xffffff00)) == htonl(0xc0000200); +} + +static inline bool ipv4_is_test_198(__be32 addr) +{ + return (addr & htonl(0xfffe0000)) == htonl(0xc6120000); +} + +/* + * phys_addr_t was added as a generic arch typedef on 2.6.28, + * that backport is dealt with in compat-2.6.28.h + */ +#if defined(CONFIG_X86) || defined(CONFIG_X86_64) + +#if defined(CONFIG_64BIT) || defined(CONFIG_X86_PAE) || defined(CONFIG_PHYS_64BIT) +typedef u64 phys_addr_t; +#else +typedef u32 phys_addr_t; +#endif + +#endif /* x86 */ + +/* The macro below uses a const upstream, this differs */ + +/** + * DEFINE_PCI_DEVICE_TABLE - macro used to describe a pci device table + * @_table: device table name + * + * This macro is used to create a struct pci_device_id array (a device table) + * in a generic manner. + */ +#define DEFINE_PCI_DEVICE_TABLE(_table) \ + const struct pci_device_id _table[] __devinitdata + +/* + * Backport work for QoS dependencies (kernel/pm_qos_params.c) + * pm-qos stuff written by mark gross mgross@linux.intel.com. + * + * ipw2100 now makes use of: + * + * pm_qos_add_requirement(), + * pm_qos_update_requirement() and + * pm_qos_remove_requirement() from it + * + * mac80211 uses the network latency to determine if to enable or not + * dynamic PS. mac80211 also and registers a notifier for when + * the latency changes. Since older kernels do no thave pm-qos stuff + * we just implement it completley here and register it upon cfg80211 + * init. I haven't tested ipw2100 on 2.6.24 though. + * + * This pm-qos implementation is copied verbatim from the kernel + * written by mark gross mgross@linux.intel.com. You don't have + * to do anythinig to use pm-qos except use the same exported + * routines as used in newer kernels. The backport_pm_qos_power_init() + * defned below is used by the compat module to initialize pm-qos. + */ +int backport_pm_qos_power_init(void); +int backport_pm_qos_power_deinit(void); + +/* + * 2.6.25 adds PM_EVENT_HIBERNATE as well here but + * we don't have this on <= 2.6.23) + */ +#ifndef PM_EVENT_SLEEP /* some distribution have mucked with their own headers to add this.. */ +#define PM_EVENT_SLEEP (PM_EVENT_SUSPEND) +#endif + +/* Although we don't care about wimax this is needed for rfkill input stuff */ +#define KEY_WIMAX 246 + +/* Although pm_qos stuff is not implemented on <= 2.6.24 lets keep the define */ +#define PM_QOS_DEFAULT_VALUE -1 + +#define __WARN(foo) dump_stack() + +#define dev_emerg(dev, format, arg...) \ + dev_printk(KERN_EMERG , dev , format , ## arg) +#define dev_alert(dev, format, arg...) \ + dev_printk(KERN_ALERT , dev , format , ## arg) +#define dev_crit(dev, format, arg...) \ + dev_printk(KERN_CRIT , dev , format , ## arg) + +#define __dev_addr_sync LINUX_BACKPORT(__dev_addr_sync) +extern int __dev_addr_sync(struct dev_addr_list **to, int *to_count, struct dev_addr_list **from, int *from_count); +#define __dev_addr_unsync LINUX_BACKPORT(__dev_addr_unsync) +extern void __dev_addr_unsync(struct dev_addr_list **to, int *to_count, struct dev_addr_list **from, int *from_count); + +#define seq_file_net &init_net; + +enum nf_inet_hooks { + NF_INET_PRE_ROUTING = 0, + NF_INET_LOCAL_IN = 1, + NF_INET_FORWARD = 2, + NF_INET_LOCAL_OUT = 3, + NF_INET_POST_ROUTING = 4, + NF_INET_NUMHOOKS = 5 +}; + +/* The patch: + * commit 8b5f6883683c91ad7e1af32b7ceeb604d68e2865 + * Author: Marcin Slusarz + * Date: Fri Feb 8 04:20:12 2008 -0800 + * + * byteorder: move le32_add_cpu & friends from OCFS2 to core + * + * moves le*_add_cpu and be*_add_cpu functions from OCFS2 to core + * header (1st) and converted some existing code to it. We port + * it here as later kernels will most likely use it. + */ +static inline void le16_add_cpu(__le16 *var, u16 val) +{ + *var = cpu_to_le16(le16_to_cpu(*var) + val); +} + +static inline void le32_add_cpu(__le32 *var, u32 val) +{ + *var = cpu_to_le32(le32_to_cpu(*var) + val); +} + +static inline void le64_add_cpu(__le64 *var, u64 val) +{ + *var = cpu_to_le64(le64_to_cpu(*var) + val); +} + +static inline void be16_add_cpu(__be16 *var, u16 val) +{ + u16 v = be16_to_cpu(*var); + *var = cpu_to_be16(v + val); +} + +static inline void be32_add_cpu(__be32 *var, u32 val) +{ + u32 v = be32_to_cpu(*var); + *var = cpu_to_be32(v + val); +} + +static inline void be64_add_cpu(__be64 *var, u64 val) +{ + u64 v = be64_to_cpu(*var); + *var = cpu_to_be64(v + val); +} + +/* 2.6.25 changes hwrng_unregister()'s behaviour by supporting + * suspend of its parent device (the misc device, which is itself the + * hardware random number generator). It does this by passing a parameter to + * unregister_miscdev() which is not supported in older kernels. The suspend + * parameter allows us to enable access to the device's hardware + * number generator during suspend. As far as wireless is concerned this means + * if a driver goes to suspend it you won't have the HNR available in + * older kernels. */ +static inline void __hwrng_unregister(struct hwrng *rng, bool suspended) +{ + hwrng_unregister(rng); +} + +static inline void led_classdev_unregister_suspended(struct led_classdev *lcd) +{ + led_classdev_unregister(lcd); +} + +/** + * The following things are out of ./include/linux/kernel.h + * The new iwlwifi driver is using them. + */ +#define strict_strtoul LINUX_BACKPORT(strict_strtoul) +extern int strict_strtoul(const char *, unsigned int, unsigned long *); +#define strict_strtol LINUX_BACKPORT(strict_strtol) +extern int strict_strtol(const char *, unsigned int, long *); + +#else +/* + * Kernels >= 2.6.25 have pm-qos and its initialized as part of + * the bootup process + */ +static inline int backport_pm_qos_power_init(void) +{ + return 0; +} + +static inline int backport_pm_qos_power_deinit(void) +{ + return 0; +} +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)) */ + +#endif /* LINUX_26_25_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-2.6.26.h b/backport/backport-include/linux/compat-2.6.26.h new file mode 100644 index 000000000000..b8d9dc645377 --- /dev/null +++ b/backport/backport-include/linux/compat-2.6.26.h @@ -0,0 +1,456 @@ +#ifndef LINUX_26_26_COMPAT_H +#define LINUX_26_26_COMPAT_H + +#include + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26)) + +#include +#include +#include +#include +#include +#include +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)) +#include +#endif +#include +#include +#include + +/* These jiffie helpers added as of 2.6.26 */ + +/* + * These four macros compare jiffies and 'a' for convenience. + */ + +/* time_is_before_jiffies(a) return true if a is before jiffies */ +#define time_is_before_jiffies(a) time_after(jiffies, a) + +/* time_is_after_jiffies(a) return true if a is after jiffies */ +#define time_is_after_jiffies(a) time_before(jiffies, a) + +/* time_is_before_eq_jiffies(a) return true if a is before or equal to jiffies*/ +#define time_is_before_eq_jiffies(a) time_after_eq(jiffies, a) + +/* time_is_after_eq_jiffies(a) return true if a is after or equal to jiffies*/ +#define time_is_after_eq_jiffies(a) time_before_eq(jiffies, a) + +/* This comes from include/linux/input.h */ +#define SW_RFKILL_ALL 0x03 /* rfkill master switch, type "any" + set = radio enabled */ + +/* From kernel.h */ +#define USHORT_MAX ((u16)(~0U)) +#define SHORT_MAX ((s16)(USHORT_MAX>>1)) +#define SHORT_MIN (-SHORT_MAX - 1) + +#define dev_set_name LINUX_BACKPORT(dev_set_name) +extern int dev_set_name(struct device *dev, const char *name, ...) + __attribute__((format(printf, 2, 3))); + +/** + * clamp - return a value clamped to a given range with strict typechecking + * @val: current value + * @min: minimum allowable value + * @max: maximum allowable value + * + * This macro does strict typechecking of min/max to make sure they are of the + * same type as val. See the unnecessary pointer comparisons. + */ +#define clamp(val, min, max) ({ \ + typeof(val) __val = (val); \ + typeof(min) __min = (min); \ + typeof(max) __max = (max); \ + (void) (&__val == &__min); \ + (void) (&__val == &__max); \ + __val = __val < __min ? __min: __val; \ + __val > __max ? __max: __val; }) + +/** + * clamp_t - return a value clamped to a given range using a given type + * @type: the type of variable to use + * @val: current value + * @min: minimum allowable value + * @max: maximum allowable value + * + * This macro does no typechecking and uses temporary variables of type + * 'type' to make all the comparisons. + */ +#define clamp_t(type, val, min, max) ({ \ + type __val = (val); \ + type __min = (min); \ + type __max = (max); \ + __val = __val < __min ? __min: __val; \ + __val > __max ? __max: __val; }) + + +/* from include/linux/device.h */ +/* device_create_drvdata() is new */ +extern struct device *device_create_drvdata(struct class *cls, + struct device *parent, + dev_t devt, + void *drvdata, + const char *fmt, ...) +__attribute__((format(printf, 5, 6))); + +/* This is from include/linux/list.h */ + +/** + * list_is_singular - tests whether a list has just one entry. + * @head: the list to test. + */ +static inline int list_is_singular(const struct list_head *head) +{ + return !list_empty(head) && (head->next == head->prev); +} + +/* This is from include/linux/device.h, which was added as of 2.6.26 */ +static inline const char *dev_name(struct device *dev) +{ + /* will be changed into kobject_name(&dev->kobj) in the near future */ + return dev->bus_id; +} + +/* This is from include/linux/kernel.h, which was added as of 2.6.26 */ + +/** + * clamp_val - return a value clamped to a given range using val's type + * @val: current value + * @min: minimum allowable value + * @max: maximum allowable value + * + * This macro does no typechecking and uses temporary variables of whatever + * type the input argument 'val' is. This is useful when val is an unsigned + * type and min and max are literals that will otherwise be assigned a signed + * integer type. + */ + +#define clamp_val(val, min, max) ({ \ + typeof(val) __val = (val); \ + typeof(val) __min = (min); \ + typeof(val) __max = (max); \ + __val = __val < __min ? __min: __val; \ + __val > __max ? __max: __val; }) + +/* This comes from include/net/net_namespace.h */ + +#ifdef CONFIG_NET_NS +static inline +int net_eq(const struct net *net1, const struct net *net2) +{ + return net1 == net2; +} +#else +static inline +int net_eq(const struct net *net1, const struct net *net2) +{ + return 1; +} +#endif + +static inline +void dev_net_set(struct net_device *dev, struct net *net) +{ +#ifdef CONFIG_NET_NS + release_net(dev->nd_net); + dev->nd_net = hold_net(net); +#endif +} + +static inline +struct net *sock_net(const struct sock *sk) +{ +#ifdef CONFIG_NET_NS + return sk->sk_net; +#else + return &init_net; +#endif +} + +/* This comes from include/linux/netdevice.h */ + +/* + * Net namespace inlines + */ +static inline +struct net *dev_net(const struct net_device *dev) +{ +#ifdef CONFIG_NET_NS + /* + * compat-wirelss backport note: + * For older kernels we may just need to always return init_net, + * not sure when we added dev->nd_net. + */ + return dev->nd_net; +#else + return &init_net; +#endif +} + + +/* + * 2.6.26 added its own unaligned API which the + * new drivers can use. Lets port it here by including it in older + * kernels and also deal with the architecture handling here. + */ + +#ifdef CONFIG_ALPHA + +#include +#include +#include + +#endif /* alpha */ +#ifdef CONFIG_ARM + +/* arm */ +#include +#include +#include + +#endif /* arm */ +#ifdef CONFIG_AVR32 + +/* + * AVR32 can handle some unaligned accesses, depending on the + * implementation. The AVR32 AP implementation can handle unaligned + * words, but halfwords must be halfword-aligned, and doublewords must + * be word-aligned. + * + * However, swapped word loads must be word-aligned so we can't + * optimize word loads in general. + */ + +#include +#include +#include + +#endif +#ifdef CONFIG_BLACKFIN + +#include +#include +#include + +#endif /* blackfin */ +#ifdef CONFIG_CRIS + +/* + * CRIS can do unaligned accesses itself. + */ +#include +#include + +#endif /* cris */ +#ifdef CONFIG_FRV + +#include +#include +#include + +#endif /* frv */ +#ifdef CONFIG_H8300 + +#include +#include +#include + +#endif /* h8300 */ +#ifdef CONFIG_IA64 + +#include +#include +#include + +#endif /* ia64 */ +#ifdef CONFIG_M32R + +#if defined(__LITTLE_ENDIAN__) +# include +# include +# include +#else +# include +# include +# include +#endif + +#endif /* m32r */ +#ifdef CONFIG_M68K /* this handles both m68k and m68knommu */ + +#ifdef CONFIG_COLDFIRE +#include +#include +#include +#else + +/* + * The m68k can do unaligned accesses itself. + */ +#include +#include +#endif + +#endif /* m68k and m68knommu */ +#ifdef CONFIG_MIPS + +#if defined(__MIPSEB__) +# include +# include +# include +# define get_unaligned __get_unaligned_be +# define put_unaligned __put_unaligned_be +#elif defined(__MIPSEL__) +# include +# include +# include +#endif + +#endif /* mips */ +#ifdef CONFIG_MN10300 + +#include +#include + +#endif /* mn10300 */ +#ifdef CONFIG_PARISC + +#include +#include +#include + +#endif /* parisc */ +#ifdef CONFIG_PPC +/* + * The PowerPC can do unaligned accesses itself in big endian mode. + */ +#include +#include + +#endif /* ppc */ +#ifdef CONFIG_S390 + +/* + * The S390 can do unaligned accesses itself. + */ +#include +#include + +#endif /* s390 */ +#ifdef CONFIG_SUPERH + +/* SH can't handle unaligned accesses. */ +#ifdef __LITTLE_ENDIAN__ +# include +# include +# include +#else +# include +# include +# include +#endif + +#endif /* sh - SUPERH */ +#ifdef CONFIG_SPARC + +/* sparc and sparc64 */ +#include +#include +#include + +#endif /* sparc */ +#ifdef CONFIG_UML + +#include "asm/arch/unaligned.h" + +#endif /* um - uml */ +#ifdef CONFIG_V850 + +#include +#include +#include + +#endif /* v850 */ +#ifdef CONFIG_X86 +/* + * The x86 can do unaligned accesses itself. + */ +#include +#include + +#endif /* x86 */ +#ifdef CONFIG_XTENSA + +#ifdef __XTENSA_EL__ +# include +# include +# include +#elif defined(__XTENSA_EB__) +# include +# include +# include +#else +# error processor byte order undefined! +#endif + +#endif /* xtensa */ + +#define PCIE_LINK_STATE_L0S 1 +#define PCIE_LINK_STATE_L1 2 +#define PCIE_LINK_STATE_CLKPM 4 + +static inline void pci_disable_link_state(struct pci_dev *pdev, int state) +{ +} +/* source: include/linux/pci-aspm.h */ + + +#if BITS_PER_LONG == 64 + +/** + * div_u64_rem - unsigned 64bit divide with 32bit divisor with remainder + * + * This is commonly provided by 32bit archs to provide an optimized 64bit + * divide. + */ +static inline u64 div_u64_rem(u64 dividend, u32 divisor, u32 *remainder) +{ + *remainder = dividend % divisor; + return dividend / divisor; +} + +#elif BITS_PER_LONG == 32 + +#ifndef div_u64_rem +static inline u64 div_u64_rem(u64 dividend, u32 divisor, u32 *remainder) +{ + *remainder = do_div(dividend, divisor); + return dividend; +} +#endif + +#endif /* BITS_PER_LONG */ + +/** + * div_u64 - unsigned 64bit divide with 32bit divisor + * + * This is the most common 64bit divide and should be used if possible, + * as many 32bit archs can optimize this variant better than a full 64bit + * divide. + */ +#ifndef div_u64 +static inline u64 div_u64(u64 dividend, u32 divisor) +{ + u32 remainder; + return div_u64_rem(dividend, divisor, &remainder); +} +#endif +/* source: include/math64.h */ + +#define hex_asc_lo(x) hex_asc((x) & 0x0f) +#define hex_asc_hi(x) hex_asc(((x) & 0xf0) >> 4) + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26)) */ + +#endif /* LINUX_26_26_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-2.6.27.h b/backport/backport-include/linux/compat-2.6.27.h new file mode 100644 index 000000000000..b71a3b57a202 --- /dev/null +++ b/backport/backport-include/linux/compat-2.6.27.h @@ -0,0 +1,317 @@ +#ifndef LINUX_26_27_COMPAT_H +#define LINUX_26_27_COMPAT_H + +#include + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27)) + +#include +#include +#include +#include +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)) +#include +#include +#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24) */ +#include +#include +#include +#include +#include +#include +#include +#include + +static inline struct net_device *qdisc_dev(const struct Qdisc *qdisc) +{ + return qdisc->dev; +} + +/* + * Backports 378a2f09 and c27f339a + * This may need a bit more work. + */ +enum net_xmit_qdisc_t { + __NET_XMIT_STOLEN = 0x00010000, + __NET_XMIT_BYPASS = 0x00020000, +}; + +struct qdisc_skb_cb { + unsigned int pkt_len; + char data[]; +}; + +static inline struct qdisc_skb_cb *qdisc_skb_cb(struct sk_buff *skb) +{ + return (struct qdisc_skb_cb *)skb->cb; +} + +static inline unsigned int qdisc_pkt_len(struct sk_buff *skb) +{ + return qdisc_skb_cb(skb)->pkt_len; +} + +#define PCI_PM_CAP_PME_SHIFT 11 + +/* I can't find a more suitable replacement... */ +#define flush_work(work) cancel_work_sync(work) + +struct builtin_fw { + char *name; + void *data; + unsigned long size; +}; + +/* + * On older kernels we do not have net_device Multi Queue support, but + * since we no longer use MQ on mac80211 we can simply use the 0 queue. + * Note that if other fullmac drivers make use of this they then need + * to be backported somehow or deal with just 1 queueue from MQ. + */ +static inline void netif_tx_wake_all_queues(struct net_device *dev) +{ + netif_wake_queue(dev); +} +static inline void netif_tx_start_all_queues(struct net_device *dev) +{ + netif_start_queue(dev); +} +static inline void netif_tx_stop_all_queues(struct net_device *dev) +{ + netif_stop_queue(dev); +} + +/* Are all TX queues of the device empty? */ +static inline bool qdisc_all_tx_empty(const struct net_device *dev) +{ + return skb_queue_empty(&dev->qdisc->q); +} + +#define pci_pme_capable LINUX_BACKPORT(pci_pme_capable) +bool pci_pme_capable(struct pci_dev *dev, pci_power_t state); + +/* + * The net_device has a spin_lock on newer kernels, on older kernels we're out of luck + */ +#define netif_addr_lock_bh(dev) +#define netif_addr_unlock_bh(dev) + +/* + * To port this properly we'd have to port warn_slowpath_null(), + * which I'm lazy to do so just do a regular print for now. If you + * want to port this read kernel/panic.c + */ +#define __WARN_printf(arg...) do { printk(arg); __WARN(); } while (0) + +/* This is ported directly as-is on newer kernels */ +#ifndef WARN +#define WARN(condition, format...) ({ \ + int __ret_warn_on = !!(condition); \ + if (unlikely(__ret_warn_on)) \ + __WARN_printf(format); \ + unlikely(__ret_warn_on); \ +}) +#endif + +/* On 2.6.27 a second argument was added, on older kernels we ignore it */ +#define dma_mapping_error(pdev, dma_addr) dma_mapping_error(dma_addr) +#define pci_dma_mapping_error(pdev, dma_addr) dma_mapping_error(pdev, dma_addr) + +/* This is from include/linux/ieee80211.h */ +#define IEEE80211_HT_CAP_DSSSCCK40 0x1000 + +/* New link list changes added as of 2.6.27, needed for ath9k */ + +static inline void __list_cut_position(struct list_head *list, + struct list_head *head, struct list_head *entry) +{ + struct list_head *new_first = entry->next; + list->next = head->next; + list->next->prev = list; + list->prev = entry; + entry->next = list; + head->next = new_first; + new_first->prev = head; +} + +/** + * list_cut_position - cut a list into two + * @list: a new list to add all removed entries + * @head: a list with entries + * @entry: an entry within head, could be the head itself + * and if so we won't cut the list + * + * This helper moves the initial part of @head, up to and + * including @entry, from @head to @list. You should + * pass on @entry an element you know is on @head. @list + * should be an empty list or a list you do not care about + * losing its data. + * + */ +static inline void list_cut_position(struct list_head *list, + struct list_head *head, struct list_head *entry) +{ + if (list_empty(head)) + return; + if (list_is_singular(head) && + (head->next != entry && head != entry)) + return; + if (entry == head) + INIT_LIST_HEAD(list); + else + __list_cut_position(list, head, entry); +} + + +/* __list_splice as re-implemented on 2.6.27, we backport it */ +static inline void __compat_list_splice_new_27(const struct list_head *list, + struct list_head *prev, + struct list_head *next) +{ + struct list_head *first = list->next; + struct list_head *last = list->prev; + + first->prev = prev; + prev->next = first; + + last->next = next; + next->prev = last; +} + +/** + * list_splice_tail - join two lists, each list being a queue + * @list: the new list to add. + * @head: the place to add it in the first list. + */ +static inline void list_splice_tail(struct list_head *list, + struct list_head *head) +{ + if (!list_empty(list)) + __compat_list_splice_new_27(list, head->prev, head); +} + +/** + * list_splice_tail_init - join two lists and reinitialise the emptied list + * @list: the new list to add. + * @head: the place to add it in the first list. + * + * Each of the lists is a queue. + * The list at @list is reinitialised + */ +static inline void list_splice_tail_init(struct list_head *list, + struct list_head *head) +{ + if (!list_empty(list)) { + __compat_list_splice_new_27(list, head->prev, head); + INIT_LIST_HEAD(list); + } +} + +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)) +#define mmc_align_data_size LINUX_BACKPORT(mmc_align_data_size) +extern unsigned int mmc_align_data_size(struct mmc_card *, unsigned int); +#define sdio_align_size LINUX_BACKPORT(sdio_align_size) +extern unsigned int sdio_align_size(struct sdio_func *func, unsigned int sz); +#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24) */ + +#define iwe_stream_add_value(info, event, value, ends, iwe, event_len) iwe_stream_add_value(event, value, ends, iwe, event_len) +#define iwe_stream_add_point(info, stream, ends, iwe, extra) iwe_stream_add_point(stream, ends, iwe, extra) +#define iwe_stream_add_event(info, stream, ends, iwe, event_len) iwe_stream_add_event(stream, ends, iwe, event_len) + +/* Flags available in struct iw_request_info */ +#define IW_REQUEST_FLAG_COMPAT 0x0001 /* Compat ioctl call */ + +static inline int iwe_stream_lcp_len(struct iw_request_info *info) +{ +#ifdef CONFIG_COMPAT + if (info->flags & IW_REQUEST_FLAG_COMPAT) + return IW_EV_COMPAT_LCP_LEN; +#endif + return IW_EV_LCP_LEN; +} + +#ifdef CONFIG_ARM + +/* + * The caller asks to handle a range between offset and offset + size, + * but we process a larger range from 0 to offset + size due to lack of + * offset support. + */ + +static inline void dma_sync_single_range_for_cpu(struct device *dev, + dma_addr_t handle, unsigned long offset, size_t size, + enum dma_data_direction dir) +{ + dma_sync_single_for_cpu(dev, handle, offset + size, dir); +} + +static inline void dma_sync_single_range_for_device(struct device *dev, + dma_addr_t handle, unsigned long offset, size_t size, + enum dma_data_direction dir) +{ + dma_sync_single_for_device(dev, handle, offset + size, dir); +} + +#endif /* arm */ + +#define debugfs_remove_recursive LINUX_BACKPORT(debugfs_remove_recursive) + +#if defined(CONFIG_DEBUG_FS) +void debugfs_remove_recursive(struct dentry *dentry); +#else +static inline void debugfs_remove_recursive(struct dentry *dentry) +{ } +#endif + +#define device_create(cls, parent, devt, drvdata, fmt, ...) \ +({ \ + struct device *_dev; \ + _dev = (device_create)(cls, parent, devt, fmt, __VA_ARGS__); \ + dev_set_drvdata(_dev, drvdata); \ + _dev; \ +}) + +#define dev_name(dev) dev_name((struct device *)dev) + +static inline void ethtool_cmd_speed_set(struct ethtool_cmd *ep, + __u32 speed) +{ + ep->speed = (__u16)speed; +} + +static inline __u32 ethtool_cmd_speed(const struct ethtool_cmd *ep) +{ + return ep->speed; +} + +/** + * lower_32_bits - return bits 0-31 of a number + * @n: the number we're accessing + */ +#define lower_32_bits(n) ((u32)(n)) + +#define netif_wake_subqueue netif_start_subqueue + +/* Backport of: + * + * commit 3295f0ef9ff048a4619ede597ad9ec9cab725654 + * Author: Ingo Molnar + * Date: Mon Aug 11 10:30:30 2008 +0200 + * + * lockdep: rename map_[acquire|release]() => lock_map_[acquire|release]() + */ +#ifdef CONFIG_DEBUG_LOCK_ALLOC +# ifdef CONFIG_PROVE_LOCKING +# define lock_map_acquire(l) lock_acquire(l, 0, 0, 0, 2, NULL, _THIS_IP_) +# else +# define lock_map_acquire(l) lock_acquire(l, 0, 0, 0, 1, NULL, _THIS_IP_) +# endif +# define lock_map_release(l) lock_release(l, 1, _THIS_IP_) +#else +# define lock_map_acquire(l) do { } while (0) +# define lock_map_release(l) do { } while (0) +#endif + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27)) */ + +#endif /* LINUX_26_27_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-2.6.28.h b/backport/backport-include/linux/compat-2.6.28.h new file mode 100644 index 000000000000..3b5f3ea7141c --- /dev/null +++ b/backport/backport-include/linux/compat-2.6.28.h @@ -0,0 +1,305 @@ +#ifndef LINUX_26_28_COMPAT_H +#define LINUX_26_28_COMPAT_H + +#include + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)) + +#include +#include +#include +#include +#include +#include +#include +#include + +#define HID_ANY_ID (~0) + +#define HID_USB_DEVICE(ven, prod) \ + .bus = BUS_USB, .vendor = (ven), .product = (prod) +#define HID_BLUETOOTH_DEVICE(ven, prod) \ + .bus = BUS_BLUETOOTH, .vendor = (ven), .product = (prod) + + +struct hid_device_id { + __u16 bus; + __u32 vendor; + __u32 product; + kernel_ulong_t driver_data + __attribute__((aligned(sizeof(kernel_ulong_t)))); +}; + +#ifndef ETH_P_PAE +#define ETH_P_PAE 0x888E /* Port Access Entity (IEEE 802.1X) */ +#endif + +#include +#include +#include + +#define platform_device_register_data LINUX_BACKPORT(platform_device_register_data) +extern struct platform_device *platform_device_register_data(struct device *, + const char *, int, const void *, size_t); + +typedef struct cpumask { DECLARE_BITMAP(bits, NR_CPUS); } compat_cpumask_t; + +#if defined(CONFIG_X86) || defined(CONFIG_X86_64) || defined(CONFIG_PPC) +/* + * CONFIG_PHYS_ADDR_T_64BIT was added as new to all architectures + * as of 2.6.28 but x86 and ppc had it already. x86 only got phys_addr_t + * as of 2.6.25 but then is backported in compat-2.6.25.h + */ +#else +#if defined(CONFIG_64BIT) || defined(CONFIG_X86_PAE) || defned(CONFIG_PPC64) || defined(CONFIG_PHYS_64BIT) +#define CONFIG_PHYS_ADDR_T_64BIT 1 +typedef u64 phys_addr_t; +#else +typedef u32 phys_addr_t; +#endif + +#endif /* non x86 and ppc */ + +#ifndef WARN_ONCE +#define WARN_ONCE(condition, format...) ({ \ + static int __warned; \ + int __ret_warn_once = !!(condition); \ + \ + if (unlikely(__ret_warn_once)) \ + if (WARN(!__warned, format)) \ + __warned = 1; \ + unlikely(__ret_warn_once); \ +}) +#endif /* From include/asm-generic/bug.h */ + +#if defined(CONFIG_PCMCIA) || defined(CONFIG_PCMCIA_MODULE) + +#include +#include +#include +#ifdef pcmcia_parse_tuple +#undef pcmcia_parse_tuple +#define pcmcia_parse_tuple(tuple, parse) pccard_parse_tuple(tuple, parse) +#endif + +/* From : include/pcmcia/ds.h */ +/* loop CIS entries for valid configuration */ +#define pcmcia_loop_config LINUX_BACKPORT(pcmcia_loop_config) +int pcmcia_loop_config(struct pcmcia_device *p_dev, + int (*conf_check) (struct pcmcia_device *p_dev, + cistpl_cftable_entry_t *cfg, + cistpl_cftable_entry_t *dflt, + unsigned int vcc, + void *priv_data), + void *priv_data); + +#endif /* CONFIG_PCMCIA */ + +/* USB anchors were added as of 2.6.23 */ +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23)) + +#if defined(CONFIG_USB) || defined(CONFIG_USB_MODULE) +#if 0 +#define usb_poison_urb LINUX_BACKPORT(usb_poison_urb) +extern void usb_poison_urb(struct urb *urb); +#endif +#define usb_unpoison_urb LINUX_BACKPORT(usb_unpoison_urb) +extern void usb_unpoison_urb(struct urb *urb); + +#if 0 +#define usb_poison_anchored_urbs LINUX_BACKPORT(usb_poison_anchored_urbs) +extern void usb_poison_anchored_urbs(struct usb_anchor *anchor); +#endif + +#define usb_anchor_empty LINUX_BACKPORT(usb_anchor_empty) +extern int usb_anchor_empty(struct usb_anchor *anchor); +#endif /* CONFIG_USB */ +#endif + + +#define pci_ioremap_bar LINUX_BACKPORT(pci_ioremap_bar) +void __iomem *pci_ioremap_bar(struct pci_dev *pdev, int bar); + +/** + * skb_queue_is_last - check if skb is the last entry in the queue + * @list: queue head + * @skb: buffer + * + * Returns true if @skb is the last buffer on the list. + */ +static inline bool skb_queue_is_last(const struct sk_buff_head *list, + const struct sk_buff *skb) +{ + return (skb->next == (struct sk_buff *) list); +} + +/** + * skb_queue_next - return the next packet in the queue + * @list: queue head + * @skb: current buffer + * + * Return the next packet in @list after @skb. It is only valid to + * call this if skb_queue_is_last() evaluates to false. + */ +static inline struct sk_buff *skb_queue_next(const struct sk_buff_head *list, + const struct sk_buff *skb) +{ + /* This BUG_ON may seem severe, but if we just return then we + * are going to dereference garbage. + */ + BUG_ON(skb_queue_is_last(list, skb)); + return skb->next; +} + +/** + * __skb_queue_head_init - initialize non-spinlock portions of sk_buff_head + * @list: queue to initialize + * + * This initializes only the list and queue length aspects of + * an sk_buff_head object. This allows to initialize the list + * aspects of an sk_buff_head without reinitializing things like + * the spinlock. It can also be used for on-stack sk_buff_head + * objects where the spinlock is known to not be used. + */ +static inline void __skb_queue_head_init(struct sk_buff_head *list) +{ + list->prev = list->next = (struct sk_buff *)list; + list->qlen = 0; +} + +static inline void __skb_queue_splice(const struct sk_buff_head *list, + struct sk_buff *prev, + struct sk_buff *next) +{ + struct sk_buff *first = list->next; + struct sk_buff *last = list->prev; + + first->prev = prev; + prev->next = first; + + last->next = next; + next->prev = last; +} + +/** + * skb_queue_splice - join two skb lists, this is designed for stacks + * @list: the new list to add + * @head: the place to add it in the first list + */ +static inline void skb_queue_splice(const struct sk_buff_head *list, + struct sk_buff_head *head) +{ + if (!skb_queue_empty(list)) { + __skb_queue_splice(list, (struct sk_buff *) head, head->next); + head->qlen += list->qlen; + } +} + +/** + * skb_queue_splice - join two skb lists and reinitialise the emptied list + * @list: the new list to add + * @head: the place to add it in the first list + * + * The list at @list is reinitialised + */ +static inline void skb_queue_splice_init(struct sk_buff_head *list, + struct sk_buff_head *head) +{ + if (!skb_queue_empty(list)) { + __skb_queue_splice(list, (struct sk_buff *) head, head->next); + head->qlen += list->qlen; + __skb_queue_head_init(list); + } +} + +/** + * skb_queue_splice_tail - join two skb lists and reinitialise the emptied list + * @list: the new list to add + * @head: the place to add it in the first list + * + * Each of the lists is a queue. + * The list at @list is reinitialised + */ +static inline void skb_queue_splice_tail_init(struct sk_buff_head *list, + struct sk_buff_head *head) +{ + if (!skb_queue_empty(list)) { + __skb_queue_splice(list, head->prev, (struct sk_buff *) head); + head->qlen += list->qlen; + __skb_queue_head_init(list); + } +} /* From include/linux/skbuff.h */ + +/** + * skb_queue_splice_tail - join two skb lists, each list being a queue + * @list: the new list to add + * @head: the place to add it in the first list + */ +static inline void skb_queue_splice_tail(const struct sk_buff_head *list, + struct sk_buff_head *head) +{ + if (!skb_queue_empty(list)) { + __skb_queue_splice(list, head->prev, (struct sk_buff *) head); + head->qlen += list->qlen; + } +} + +#define skb_queue_walk_from(queue, skb) \ + for (; skb != (struct sk_buff *)(queue); \ + skb = skb->next) + +#ifndef DECLARE_TRACE + +#define TP_PROTO(args...) args +#define TP_ARGS(args...) args + +#define DECLARE_TRACE(name, proto, args) \ + static inline void _do_trace_##name(struct tracepoint *tp, proto) \ + { } \ + static inline void trace_##name(proto) \ + { } \ + static inline int register_trace_##name(void (*probe)(proto)) \ + { \ + return -ENOSYS; \ + } \ + static inline int unregister_trace_##name(void (*probe)(proto)) \ + { \ + return -ENOSYS; \ + } + +#define EXPORT_TRACEPOINT_SYMBOL_GPL(name) +#define EXPORT_TRACEPOINT_SYMBOL(name) + + +#endif + +#define round_jiffies_up LINUX_BACKPORT(round_jiffies_up) +unsigned long round_jiffies_up(unsigned long j); + +extern void v2_6_28_skb_add_rx_frag(struct sk_buff *skb, int i, struct page *page, + int off, int size); + +#define wake_up_interruptible_poll(x, m) \ + __wake_up(x, TASK_INTERRUPTIBLE, 1, (void *) (m)) + +#define n_tty_ioctl_helper LINUX_BACKPORT(n_tty_ioctl_helper) +extern int n_tty_ioctl_helper(struct tty_struct *tty, struct file *file, + unsigned int cmd, unsigned long arg); + +#define pci_wake_from_d3 LINUX_BACKPORT(pci_wake_from_d3) +int pci_wake_from_d3(struct pci_dev *dev, bool enable); + +#define alloc_workqueue(name, flags, max_active) __create_workqueue(name, flags, max_active) + +#ifndef pr_fmt +#define pr_fmt(fmt) fmt +#endif + +#define PCI_EXP_DEVCAP2 36 /* Device Capabilities 2 */ +#define PCI_EXP_DEVCAP2_ARI 0x20 /* Alternative Routing-ID */ +#define PCI_EXP_DEVCTL2 40 /* Device Control 2 */ +#define PCI_EXP_DEVCTL2_ARI 0x20 /* Alternative Routing-ID */ + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)) */ + +#endif /* LINUX_26_28_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-2.6.29.h b/backport/backport-include/linux/compat-2.6.29.h new file mode 100644 index 000000000000..c8cf89873ab5 --- /dev/null +++ b/backport/backport-include/linux/compat-2.6.29.h @@ -0,0 +1,430 @@ +#ifndef LINUX_26_29_COMPAT_H +#define LINUX_26_29_COMPAT_H + +#include +#include +#include + +/* + * I kow this looks odd.. but 2.6.32 added the netdev_tx_t + * and we backport that there so inlcude that header first + * as we need it for the netdev ops. + */ +#include + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29)) + +#include +#include +#include +#include + +#define napi_gro_receive(napi, skb) netif_receive_skb(skb) + +/* backports */ +static inline void usb_autopm_put_interface_async(struct usb_interface *intf) +{ } +static inline int usb_autopm_get_interface_async(struct usb_interface *intf) +{ return 0; } + +#if \ + defined(CONFIG_ALPHA) || defined(CONFIG_AVR32) || \ + defined(CONFIG_BLACKFIN) || defined(CONFIG_CRIS) || \ + defined(CONFIG_H8300) || defined(CONFIG_IA64) || \ + defined(CONFIG_M68K) || defined(CONFIG_MIPS) || \ + defined(CONFIG_PARISC) || defined(CONFIG_S390) || \ + defined(CONFIG_PPC64) || defined(CONFIG_PPC32) || \ + defined(CONFIG_SUPERH) || defined(CONFIG_SPARC) || \ + defined(CONFIG_FRV) || defined(CONFIG_X86) || \ + defined(CONFIG_M32R) || defined(CONFIG_M68K) || \ + defined(CONFIG_MN10300) || defined(CONFIG_XTENSA) || \ + defined(CONFIG_ARM) +#include +#else +typedef struct { + volatile int counter; +} atomic_t; + +#ifdef CONFIG_64BIT +typedef struct { + volatile long counter; +} atomic64_t; +#endif /* CONFIG_64BIT */ + +#endif + +#define PCI_EXP_LNKCTL_ES 0x0080 /* Extended Synch */ + +/* + * Older kernels do not have struct net_device_ops but what we can + * do is just define the data structure and use a caller to let us + * set the data structure's routines onto the old netdev, essentially + * doing it the old way. This avoids huge deltas on our backports. + */ + +/* + * This structure defines the management hooks for network devices. + * The following hooks can be defined; unless noted otherwise, they are + * optional and can be filled with a null pointer. + * + * int (*ndo_init)(struct net_device *dev); + * This function is called once when network device is registered. + * The network device can use this to any late stage initializaton + * or semantic validattion. It can fail with an error code which will + * be propogated back to register_netdev + * + * void (*ndo_uninit)(struct net_device *dev); + * This function is called when device is unregistered or when registration + * fails. It is not called if init fails. + * + * int (*ndo_open)(struct net_device *dev); + * This function is called when network device transistions to the up + * state. + * + * int (*ndo_stop)(struct net_device *dev); + * This function is called when network device transistions to the down + * state. + * + * netdev_tx_t (*ndo_start_xmit)(struct sk_buff *skb, + * struct net_device *dev); + * Called when a packet needs to be transmitted. + * Must return NETDEV_TX_OK , NETDEV_TX_BUSY. + * (can also return NETDEV_TX_LOCKED iff NETIF_F_LLTX) + * Required can not be NULL. + * + * u16 (*ndo_select_queue)(struct net_device *dev, struct sk_buff *skb); + * Called to decide which queue to when device supports multiple + * transmit queues. + * + * void (*ndo_change_rx_flags)(struct net_device *dev, int flags); + * This function is called to allow device receiver to make + * changes to configuration when multicast or promiscious is enabled. + * + * void (*ndo_set_rx_mode)(struct net_device *dev); + * This function is called device changes address list filtering. + * + * void (*ndo_set_multicast_list)(struct net_device *dev); + * This function is called when the multicast address list changes. + * + * int (*ndo_set_mac_address)(struct net_device *dev, void *addr); + * This function is called when the Media Access Control address + * needs to be changed. If this interface is not defined, the + * mac address can not be changed. + * + * int (*ndo_validate_addr)(struct net_device *dev); + * Test if Media Access Control address is valid for the device. + * + * int (*ndo_do_ioctl)(struct net_device *dev, struct ifreq *ifr, int cmd); + * Called when a user request an ioctl which can't be handled by + * the generic interface code. If not defined ioctl's return + * not supported error code. + * + * int (*ndo_set_config)(struct net_device *dev, struct ifmap *map); + * Used to set network devices bus interface parameters. This interface + * is retained for legacy reason, new devices should use the bus + * interface (PCI) for low level management. + * + * int (*ndo_change_mtu)(struct net_device *dev, int new_mtu); + * Called when a user wants to change the Maximum Transfer Unit + * of a device. If not defined, any request to change MTU will + * will return an error. + * + * void (*ndo_tx_timeout)(struct net_device *dev); + * Callback uses when the transmitter has not made any progress + * for dev->watchdog ticks. + * + * struct net_device_stats* (*ndo_get_stats)(struct net_device *dev); + * Called when a user wants to get the network device usage + * statistics. If not defined, the counters in dev->stats will + * be used. + * + * void (*ndo_vlan_rx_register)(struct net_device *dev, struct vlan_group *grp); + * If device support VLAN receive accleration + * (ie. dev->features & NETIF_F_HW_VLAN_RX), then this function is called + * when vlan groups for the device changes. Note: grp is NULL + * if no vlan's groups are being used. + * + * void (*ndo_vlan_rx_add_vid)(struct net_device *dev, unsigned short vid); + * If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER) + * this function is called when a VLAN id is registered. + * + * void (*ndo_vlan_rx_kill_vid)(struct net_device *dev, unsigned short vid); + * If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER) + * this function is called when a VLAN id is unregistered. + * + * void (*ndo_poll_controller)(struct net_device *dev); + * + * SR-IOV management functions. + * int (*ndo_set_vf_mac)(struct net_device *dev, int vf, u8* mac); + * int (*ndo_set_vf_vlan)(struct net_device *dev, int vf, u16 vlan, u8 qos); + * int (*ndo_set_vf_tx_rate)(struct net_device *dev, int vf, int rate); + * int (*ndo_get_vf_config)(struct net_device *dev, + * int vf, struct ifla_vf_info *ivf); + */ +#define HAVE_NET_DEVICE_OPS +struct net_device_ops { + int (*ndo_init)(struct net_device *dev); + void (*ndo_uninit)(struct net_device *dev); + int (*ndo_open)(struct net_device *dev); + int (*ndo_stop)(struct net_device *dev); + netdev_tx_t (*ndo_start_xmit) (struct sk_buff *skb, + struct net_device *dev); + u16 (*ndo_select_queue)(struct net_device *dev, + struct sk_buff *skb); + void (*ndo_change_rx_flags)(struct net_device *dev, + int flags); + void (*ndo_set_rx_mode)(struct net_device *dev); + void (*ndo_set_multicast_list)(struct net_device *dev); + int (*ndo_set_mac_address)(struct net_device *dev, + void *addr); + int (*ndo_validate_addr)(struct net_device *dev); + int (*ndo_do_ioctl)(struct net_device *dev, + struct ifreq *ifr, int cmd); + int (*ndo_set_config)(struct net_device *dev, + struct ifmap *map); + int (*ndo_change_mtu)(struct net_device *dev, + int new_mtu); + int (*ndo_neigh_setup)(struct net_device *dev, + struct neigh_parms *); + void (*ndo_tx_timeout) (struct net_device *dev); + +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36)) + struct rtnl_link_stats64* (*ndo_get_stats64)(struct net_device *dev, + struct rtnl_link_stats64 *storage); +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36)) */ + + struct net_device_stats* (*ndo_get_stats)(struct net_device *dev); + + void (*ndo_vlan_rx_register)(struct net_device *dev, + struct vlan_group *grp); + void (*ndo_vlan_rx_add_vid)(struct net_device *dev, + unsigned short vid); + void (*ndo_vlan_rx_kill_vid)(struct net_device *dev, + unsigned short vid); +#ifdef CONFIG_NET_POLL_CONTROLLER + void (*ndo_poll_controller)(struct net_device *dev); +#endif + int (*ndo_set_vf_mac)(struct net_device *dev, + int queue, u8 *mac); + int (*ndo_set_vf_vlan)(struct net_device *dev, + int queue, u16 vlan, u8 qos); + int (*ndo_set_vf_tx_rate)(struct net_device *dev, + int vf, int rate); +/* + * The struct ifla_vf_info was added via b280da8d54b8d82b52f368a8703b7ada6c1744d5 + * on the v2.6.34-rc1~233^2~338 release + */ +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34)) + int (*ndo_get_vf_config)(struct net_device *dev, + int vf, + struct ifla_vf_info *ivf); +#endif +#if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE) + int (*ndo_fcoe_enable)(struct net_device *dev); + int (*ndo_fcoe_disable)(struct net_device *dev); + int (*ndo_fcoe_ddp_setup)(struct net_device *dev, + u16 xid, + struct scatterlist *sgl, + unsigned int sgc); + int (*ndo_fcoe_ddp_done)(struct net_device *dev, + u16 xid); +#define NETDEV_FCOE_WWNN 0 +#define NETDEV_FCOE_WWPN 1 + int (*ndo_fcoe_get_wwn)(struct net_device *dev, + u64 *wwn, int type); +#endif +}; + +static inline int ndo_do_ioctl(struct net_device *dev, + struct ifreq *ifr, + int cmd) +{ + if (dev->do_ioctl) + return dev->do_ioctl(dev, ifr, cmd); + return -EOPNOTSUPP; +} + + +#define netdev_attach_ops LINUX_BACKPORT(netdev_attach_ops) +void netdev_attach_ops(struct net_device *dev, + const struct net_device_ops *ops); + +/** + * skb_queue_is_first - check if skb is the first entry in the queue + * @list: queue head + * @skb: buffer + * + * Returns true if @skb is the first buffer on the list. + */ +static inline bool skb_queue_is_first(const struct sk_buff_head *list, + const struct sk_buff *skb) +{ + return (skb->prev == (struct sk_buff *) list); +} + +/** + * skb_queue_prev - return the prev packet in the queue + * @list: queue head + * @skb: current buffer + * + * Return the prev packet in @list before @skb. It is only valid to + * call this if skb_queue_is_first() evaluates to false. + */ +static inline struct sk_buff *skb_queue_prev(const struct sk_buff_head *list, + const struct sk_buff *skb) +{ + /* This BUG_ON may seem severe, but if we just return then we + * are going to dereference garbage. + */ + BUG_ON(skb_queue_is_first(list, skb)); + return skb->prev; +} + + +static inline struct net_device_stats *dev_get_stats(struct net_device *dev) +{ + return dev->get_stats(dev); +} + +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23)) +#if defined(CONFIG_USB) || defined(CONFIG_USB_MODULE) +#define usb_unpoison_anchored_urbs LINUX_BACKPORT(usb_unpoison_anchored_urbs) +extern void usb_unpoison_anchored_urbs(struct usb_anchor *anchor); +#endif /* CONFIG_USB */ +#endif + +#define DIV_ROUND_CLOSEST(x, divisor)( \ +{ \ + typeof(divisor) __divisor = divisor; \ + (((x) + ((__divisor) / 2)) / (__divisor)); \ +} \ +) + +#define eth_mac_addr LINUX_BACKPORT(eth_mac_addr) +extern int eth_mac_addr(struct net_device *dev, void *p); +#define eth_change_mtu LINUX_BACKPORT(eth_change_mtu) +extern int eth_change_mtu(struct net_device *dev, int new_mtu); +#define eth_validate_addr LINUX_BACKPORT(eth_validate_addr) +extern int eth_validate_addr(struct net_device *dev); + +#ifdef CONFIG_NET_NS + +static inline void write_pnet(struct net **pnet, struct net *net) +{ + *pnet = net; +} + +static inline struct net *read_pnet(struct net * const *pnet) +{ + return *pnet; +} + +#else + +#define write_pnet(pnet, net) do { (void)(net);} while (0) +#define read_pnet(pnet) (&init_net) + +/* + * swap - swap value of @a and @b + */ +#define swap(a, b) \ + do { typeof(a) __tmp = (a); (a) = (b); (b) = __tmp; } while (0) + +#endif + +#define init_dummy_netdev LINUX_BACKPORT(init_dummy_netdev) +extern int init_dummy_netdev(struct net_device *dev); + +#else /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29)) */ + +/* Kernels >= 2.6.29 follows */ + +/* XXX: this can probably just go upstream ! */ +static inline void netdev_attach_ops(struct net_device *dev, + const struct net_device_ops *ops) +{ + dev->netdev_ops = ops; +} + +/* XXX: this can probably just go upstream! */ +static inline int ndo_do_ioctl(struct net_device *dev, + struct ifreq *ifr, + int cmd) +{ + if (dev->netdev_ops && dev->netdev_ops->ndo_do_ioctl) + return dev->netdev_ops->ndo_do_ioctl(dev, ifr, cmd); + return -EOPNOTSUPP; +} + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29)) */ + +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29) +#define compat_pci_suspend(fn) \ + int fn##_compat(struct pci_dev *pdev, pm_message_t state) \ + { \ + int r; \ + \ + r = fn(&pdev->dev); \ + if (r) \ + return r; \ + \ + pci_save_state(pdev); \ + pci_disable_device(pdev); \ + pci_set_power_state(pdev, PCI_D3hot); \ + \ + return 0; \ + } + +#define compat_pci_resume(fn) \ + int fn##_compat(struct pci_dev *pdev) \ + { \ + int r; \ + \ + pci_set_power_state(pdev, PCI_D0); \ + r = pci_enable_device(pdev); \ + if (r) \ + return r; \ + pci_restore_state(pdev); \ + \ + return fn(&pdev->dev); \ + } +#elif LINUX_VERSION_CODE == KERNEL_VERSION(2,6,29) +#define compat_pci_suspend(fn) \ + int fn##_compat(struct device *dev) \ + { \ + struct pci_dev *pdev = to_pci_dev(dev); \ + int r; \ + \ + r = fn(&pdev->dev); \ + if (r) \ + return r; \ + \ + pci_save_state(pdev); \ + pci_disable_device(pdev); \ + pci_set_power_state(pdev, PCI_D3hot); \ + \ + return 0; \ + } + +#define compat_pci_resume(fn) \ + int fn##_compat(struct device *dev) \ + { \ + struct pci_dev *pdev = to_pci_dev(dev); \ + int r; \ + \ + pci_set_power_state(pdev, PCI_D0); \ + r = pci_enable_device(pdev); \ + if (r) \ + return r; \ + pci_restore_state(pdev); \ + \ + return fn(&pdev->dev); \ + } +#else +#define compat_pci_suspend(fn) +#define compat_pci_resume(fn) +#endif + +#define PCI_EXP_SLTSTA_PDS 0x0040 /* Presence Detect State */ + +#endif /* LINUX_26_29_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-2.6.30.h b/backport/backport-include/linux/compat-2.6.30.h new file mode 100644 index 000000000000..5841b6c8e348 --- /dev/null +++ b/backport/backport-include/linux/compat-2.6.30.h @@ -0,0 +1,53 @@ +#ifndef LINUX_26_30_COMPAT_H +#define LINUX_26_30_COMPAT_H + +#include + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,30)) + +#include +#include + +#define HID_QUIRK_IGNORE 0x00000004 + +#ifndef TP_PROTO +#define TP_PROTO(args...) TPPROTO(args) +#endif +#ifndef TP_ARGS +#define TP_ARGS(args...) TPARGS(args) +#endif + +#define IRQ_WAKE_THREAD (2) + +/* From : include/linux/pm.h */ +/* How to reorder dpm_list after device_move() */ +enum dpm_order { + DPM_ORDER_NONE, + DPM_ORDER_DEV_AFTER_PARENT, + DPM_ORDER_PARENT_BEFORE_DEV, + DPM_ORDER_DEV_LAST, +}; + +static inline void dev_set_uevent_suppress(struct device *dev, int val) +{ + dev->uevent_suppress = val; +} + +/* + * Print a one-time message (analogous to WARN_ONCE() et al): + */ +#define printk_once(x...) ({ \ + static bool __print_once; \ + \ + if (!__print_once) { \ + __print_once = true; \ + printk(x); \ + } \ +}) + +#define PCI_EXP_LNKCTL2 48 /* Link Control 2 */ +#define PCI_EXP_SLTCTL2 56 /* Slot Control 2 */ + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,30)) */ + +#endif /* LINUX_26_30_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-2.6.31.h b/backport/backport-include/linux/compat-2.6.31.h new file mode 100644 index 000000000000..096c13183470 --- /dev/null +++ b/backport/backport-include/linux/compat-2.6.31.h @@ -0,0 +1,273 @@ +#ifndef LINUX_26_31_COMPAT_H +#define LINUX_26_31_COMPAT_H + +#include + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,31)) + +#include +#include +#include +#include +#include +#include +#include + +#define SUPPORTED_Backplane (1 << 16) +#define SUPPORTED_1000baseKX_Full (1 << 17) +#define SUPPORTED_10000baseKX4_Full (1 << 18) +#define SUPPORTED_10000baseKR_Full (1 << 19) +#define SUPPORTED_10000baseR_FEC (1 << 20) + +#define ADVERTISED_Backplane (1 << 16) +#define ADVERTISED_1000baseKX_Full (1 << 17) +#define ADVERTISED_10000baseKX4_Full (1 << 18) +#define ADVERTISED_10000baseKR_Full (1 << 19) +#define ADVERTISED_10000baseR_FEC (1 << 20) + +#define rfkill_get_led_trigger_name LINUX_BACKPORT(rfkill_get_led_trigger_name) +#define rfkill_set_led_trigger_name LINUX_BACKPORT(rfkill_set_led_trigger_name) +#define rfkill_set_hw_state LINUX_BACKPORT(rfkill_set_hw_state) +#define rfkill_set_sw_state LINUX_BACKPORT(rfkill_set_sw_state) +#define rfkill_init_sw_state LINUX_BACKPORT(rfkill_init_sw_state) +#define rfkill_set_states LINUX_BACKPORT(rfkill_set_states) +#define rfkill_pause_polling LINUX_BACKPORT(rfkill_pause_polling) +#define rfkill_resume_polling LINUX_BACKPORT(rfkill_resume_polling) +#define rfkill_blocked LINUX_BACKPORT(rfkill_blocked) +#define rfkill_alloc LINUX_BACKPORT(rfkill_alloc) +#define rfkill_register LINUX_BACKPORT(rfkill_register) +#define rfkill_unregister LINUX_BACKPORT(rfkill_unregister) +#define rfkill_destroy LINUX_BACKPORT(rfkill_destroy) + +#ifndef ERFKILL +#if !defined(CONFIG_ALPHA) && !defined(CONFIG_MIPS) && !defined(CONFIG_PARISC) && !defined(CONFIG_SPARC) +#define ERFKILL 132 /* Operation not possible due to RF-kill */ +#endif +#ifdef CONFIG_ALPHA +#define ERFKILL 138 /* Operation not possible due to RF-kill */ +#endif +#ifdef CONFIG_MIPS +#define ERFKILL 167 /* Operation not possible due to RF-kill */ +#endif +#ifdef CONFIG_PARISC +#define ERFKILL 256 /* Operation not possible due to RF-kill */ +#endif +#ifdef CONFIG_SPARC +#define ERFKILL 134 /* Operation not possible due to RF-kill */ +#endif +#endif + +#define mdio45_probe LINUX_BACKPORT(mdio45_probe) +#define mdio_set_flag LINUX_BACKPORT(mdio_set_flag) +#define mdio45_links_ok LINUX_BACKPORT(mdio45_links_ok) +#define mdio45_nway_restart LINUX_BACKPORT(mdio45_nway_restart) + +#define mdio45_ethtool_gset_npage LINUX_BACKPORT(mdio45_ethtool_gset_npage) +#define mdio45_ethtool_spauseparam_an LINUX_BACKPORT(mdio45_ethtool_spauseparam_an) +#define mdio_mii_ioctl LINUX_BACKPORT(mdio_mii_ioctl) + +#ifndef NETDEV_PRE_UP +#define NETDEV_PRE_UP 0x000D +#endif + +#ifndef SDIO_DEVICE_ID_MARVELL_8688WLAN +#define SDIO_DEVICE_ID_MARVELL_8688WLAN 0x9104 +#endif + +struct compat_threaded_irq { + unsigned int irq; + irq_handler_t handler; + irq_handler_t thread_fn; + void *dev_id; + char wq_name[64]; + struct workqueue_struct *wq; + struct work_struct work; +}; + +/* + * kmemleak was introduced on 2.6.31, since older kernels do not have + * we simply ignore its tuning. + */ +static inline void kmemleak_ignore(const void *ptr) +{ + return; +} + +static inline void kmemleak_not_leak(const void *ptr) +{ + return; +} + +static inline void kmemleak_no_scan(const void *ptr) +{ + return; +} + +/* + * Added via adf30907d63893e4208dfe3f5c88ae12bc2f25d5 + * + * There is no _sk_dst on older kernels, so just set the + * old dst to NULL and release it directly. + */ +static inline void skb_dst_drop(struct sk_buff *skb) +{ + dst_release(skb->dst); + skb->dst = NULL; +} + +static inline struct dst_entry *skb_dst(const struct sk_buff *skb) +{ + return (struct dst_entry *)skb->dst; +} + +static inline void skb_dst_set(struct sk_buff *skb, struct dst_entry *dst) +{ + skb->dst = dst; +} + +static inline struct rtable *skb_rtable(const struct sk_buff *skb) +{ + return (struct rtable *)skb_dst(skb); +} + +/* Backport threaded IRQ support */ + +static inline +void compat_irq_work(struct work_struct *work) +{ + struct compat_threaded_irq *comp = container_of(work, struct compat_threaded_irq, work); + comp->thread_fn(comp->irq, comp->dev_id); +} + +static inline +irqreturn_t compat_irq_dispatcher(int irq, void *dev_id) +{ + struct compat_threaded_irq *comp = dev_id; + irqreturn_t res; + + res = comp->handler(irq, comp->dev_id); + if (res == IRQ_WAKE_THREAD) { + queue_work(comp->wq, &comp->work); + res = IRQ_HANDLED; + } + + return res; +} + +static inline +int compat_request_threaded_irq(struct compat_threaded_irq *comp, + unsigned int irq, + irq_handler_t handler, + irq_handler_t thread_fn, + unsigned long flags, + const char *name, + void *dev_id) +{ + comp->irq = irq; + comp->handler = handler; + comp->thread_fn = thread_fn; + comp->dev_id = dev_id; + INIT_WORK(&comp->work, compat_irq_work); + + if (!comp->wq) { + snprintf(comp->wq_name, sizeof(comp->wq_name), + "compirq/%u-%s", irq, name); + comp->wq = create_singlethread_workqueue(comp->wq_name); + if (!comp->wq) { + printk(KERN_ERR "Failed to create compat-threaded-IRQ workqueue %s\n", + comp->wq_name); + return -ENOMEM; + } + } + return request_irq(irq, compat_irq_dispatcher, flags, name, comp); +} + +static inline +void compat_free_threaded_irq(struct compat_threaded_irq *comp) +{ + free_irq(comp->irq, comp); +} + +static inline +void compat_destroy_threaded_irq(struct compat_threaded_irq *comp) +{ + if (comp->wq) + destroy_workqueue(comp->wq); + comp->wq = NULL; +} + +static inline +void compat_synchronize_threaded_irq(struct compat_threaded_irq *comp) +{ + synchronize_irq(comp->irq); + cancel_work_sync(&comp->work); +} + +/** + * list_entry_rcu - get the struct for this entry + * @ptr: the &struct list_head pointer. + * @type: the type of the struct this is embedded in. + * @member: the name of the list_struct within the struct. + * + * This primitive may safely run concurrently with the _rcu list-mutation + * primitives such as list_add_rcu() as long as it's guarded by rcu_read_lock(). + */ +#define list_entry_rcu(ptr, type, member) \ + container_of(rcu_dereference(ptr), type, member) + +#define skb_walk_frags(skb, iter) \ + for (iter = skb_shinfo(skb)->frag_list; iter; iter = iter->next) + +#ifndef CONFIG_64BIT + +typedef struct { + long long counter; +} atomic64_t; + +#define atomic64_read LINUX_BACKPORT(atomic64_read) +extern long long atomic64_read(const atomic64_t *v); +#define atomic64_add_return LINUX_BACKPORT(atomic64_add_return) +extern long long atomic64_add_return(long long a, atomic64_t *v); + +#define atomic64_inc_return(v) atomic64_add_return(1LL, (v)) + +#endif + +/** + * sk_rmem_alloc_get - returns read allocations + * @sk: socket + * + * Returns sk_rmem_alloc + */ +static inline int sk_rmem_alloc_get(const struct sock *sk) +{ + return atomic_read(&sk->sk_rmem_alloc); +} + +/** + * sk_wmem_alloc_get - returns write allocations + * @sk: socket + * + * Returns sk_wmem_alloc minus initial offset of one + */ +static inline int sk_wmem_alloc_get(const struct sock *sk) +{ + return atomic_read(&sk->sk_wmem_alloc) - 1; +} + +/** + * sk_has_allocations - check if allocations are outstanding + * @sk: socket + * + * Returns true if socket has write or read allocations + */ +static inline bool sk_has_allocations(const struct sock *sk) +{ + return sk_wmem_alloc_get(sk) || sk_rmem_alloc_get(sk); +} + +#define USB_SUBCLASS_VENDOR_SPEC 0xff + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,31)) */ + +#endif /* LINUX_26_31_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-2.6.32.h b/backport/backport-include/linux/compat-2.6.32.h new file mode 100644 index 000000000000..d5b5df87a17b --- /dev/null +++ b/backport/backport-include/linux/compat-2.6.32.h @@ -0,0 +1,198 @@ +#ifndef LINUX_26_32_COMPAT_H +#define LINUX_26_32_COMPAT_H + +#include + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,32)) + +#include +#include +#include +#include +#include +#include + +#define TCQ_F_CAN_BYPASS 4 + +static inline int qdisc_qlen(const struct Qdisc *q) +{ + return q->q.qlen; +} + +#define SDIO_VENDOR_ID_INTEL 0x0089 +#define SDIO_DEVICE_ID_INTEL_IWMC3200WIMAX 0x1402 +#define SDIO_DEVICE_ID_INTEL_IWMC3200WIFI 0x1403 +#define SDIO_DEVICE_ID_INTEL_IWMC3200TOP 0x1404 +#define SDIO_DEVICE_ID_INTEL_IWMC3200GPS 0x1405 +#define SDIO_DEVICE_ID_INTEL_IWMC3200BT 0x1406 + +/* + * Backports 5e928f77a09a07f9dd595bb8a489965d69a83458 + * run-time power management cannot really be backported + * given that the implementation added bus specific + * callbacks that we won't have on older kernels. If + * you really want run-time power management or good + * power management upgrade your kernel. We'll just + * compile this out as if run-time power management was + * disabled just as the kernel disables run-time power management + * when CONFIG_PM_RUNTIME is disabled. + */ +static inline void pm_runtime_init(struct device *dev) {} +static inline void pm_runtime_remove(struct device *dev) {} +static inline int pm_runtime_get(struct device *dev) +{ + return 0; +} + +static inline int pm_runtime_get_sync(struct device *dev) +{ + return 0; +} + +static inline int pm_runtime_put(struct device *dev) +{ + return 0; +} + +static inline int pm_runtime_put_sync(struct device *dev) +{ + return 0; +} + +static inline int pm_runtime_set_active(struct device *dev) +{ + return 0; +} + +static inline void pm_runtime_set_suspended(struct device *dev) +{ +} + +static inline void pm_runtime_disable(struct device *dev) +{ +} + +static inline void pm_runtime_put_noidle(struct device *dev) {} +static inline void pm_runtime_get_noresume(struct device *dev) {} + +static inline void flush_delayed_work(struct delayed_work *dwork) +{ + if (del_timer_sync(&dwork->timer)) { + /* + * This is what would happen on 2.6.32 but since we don't have + * access to the singlethread_cpu we can't really backport this, + * so avoid really *flush*ing the work... Oh well. Any better ideas? + + struct cpu_workqueue_struct *cwq; + cwq = wq_per_cpu(keventd_wq, get_cpu()); + __queue_work(cwq, &dwork->work); + put_cpu(); + + */ + } + flush_work(&dwork->work); +} + +/* + * struct genl_multicast_group was made netns aware through + * patch "genetlink: make netns aware" by johannes, we just + * force this to always use the default init_net + */ +#define genl_info_net(x) &init_net +/* Just use init_net for older kernels */ +#define get_net_ns_by_pid(x) &init_net + +/* net namespace is lost */ +#define genlmsg_multicast_netns(a, b, c, d, e) genlmsg_multicast(b, c, d, e) +#define genlmsg_multicast_allns(a, b, c, d) genlmsg_multicast(a, b, c, d) +#define genlmsg_unicast(net, skb, pid) genlmsg_unicast(skb, pid) + +#define dev_change_net_namespace(a, b, c) (-EOPNOTSUPP) + +#define SET_NETDEV_DEVTYPE(netdev, type) + +#ifdef __KERNEL__ +/* Driver transmit return codes */ +enum netdev_tx { + BACKPORT_NETDEV_TX_OK = NETDEV_TX_OK, /* driver took care of packet */ + BACKPORT_NETDEV_TX_BUSY = NETDEV_TX_BUSY, /* driver tx path was busy*/ + BACKPORT_NETDEV_TX_LOCKED = NETDEV_TX_LOCKED, /* driver tx lock was already taken */ +}; +typedef enum netdev_tx netdev_tx_t; +#endif /* __KERNEL__ */ + +/* + * dev_pm_ops is only available on kernels >= 2.6.29, for + * older kernels we rely on reverting the work to old + * power management style stuff. On 2.6.29 the pci calls + * weren't included yet though, so include them here. + */ +#if (LINUX_VERSION_CODE == KERNEL_VERSION(2,6,29)) +#define SIMPLE_DEV_PM_OPS(name, suspend_fn, resume_fn) \ +struct dev_pm_ops name = { \ + .suspend = suspend_fn ## _compat, \ + .resume = resume_fn ## _compat, \ + .freeze = suspend_fn ## _compat, \ + .thaw = resume_fn ## _compat, \ + .poweroff = suspend_fn ## _compat, \ + .restore = resume_fn ## _compat, \ +} +#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,30)) +/* + * Use this if you want to use the same suspend and resume callbacks for suspend + * to RAM and hibernation. + */ +#define SIMPLE_DEV_PM_OPS(name, suspend_fn, resume_fn) \ +struct dev_pm_ops name = { \ + .suspend = suspend_fn, \ + .resume = resume_fn, \ + .freeze = suspend_fn, \ + .thaw = resume_fn, \ + .poweroff = suspend_fn, \ + .restore = resume_fn, \ +} +#else +#define SIMPLE_DEV_PM_OPS(name, suspend_fn, resume_fn) +#endif /* >= 2.6.29 */ + +#define wireless_send_event(a, b, c, d) wireless_send_event(a, b, c, (char * ) d) + +/* The export symbol in changed in compat/patches/15-symbol-export-conflicts.patch */ +#define ieee80211_rx(hw, skb) mac80211_ieee80211_rx(hw, skb) + +#define dev_to_sdio_func(d) container_of(d, struct sdio_func, dev) + +#define lockdep_assert_held(l) do { } while (0) + +/* + * Similar to the struct tm in userspace , but it needs to be here so + * that the kernel source is self contained. + */ +struct tm { + /* + * the number of seconds after the minute, normally in the range + * 0 to 59, but can be up to 60 to allow for leap seconds + */ + int tm_sec; + /* the number of minutes after the hour, in the range 0 to 59*/ + int tm_min; + /* the number of hours past midnight, in the range 0 to 23 */ + int tm_hour; + /* the day of the month, in the range 1 to 31 */ + int tm_mday; + /* the number of months since January, in the range 0 to 11 */ + int tm_mon; + /* the number of years since 1900 */ + long tm_year; + /* the number of days since Sunday, in the range 0 to 6 */ + int tm_wday; + /* the number of days since January 1, in the range 0 to 365 */ + int tm_yday; +}; + +#define time_to_tm LINUX_BACKPORT(time_to_tm) +void time_to_tm(time_t totalsecs, int offset, struct tm *result); + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,32)) */ + +#endif /* LINUX_26_32_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-2.6.33.h b/backport/backport-include/linux/compat-2.6.33.h new file mode 100644 index 000000000000..b03fe401cc80 --- /dev/null +++ b/backport/backport-include/linux/compat-2.6.33.h @@ -0,0 +1,190 @@ +#ifndef LINUX_26_33_COMPAT_H +#define LINUX_26_33_COMPAT_H + +#include + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,33)) + +#include +#include +#include +#if defined(CONFIG_PCCARD) || defined(CONFIG_PCCARD_MODULE) +#include +#include +#include +#endif +#include +#include + +#define usb_autopm_get_interface_no_resume LINUX_BACKPORT(usb_autopm_get_interface_no_resume) +#define usb_autopm_put_interface_no_suspend LINUX_BACKPORT(usb_autopm_put_interface_no_suspend) +#ifdef CONFIG_USB_SUSPEND +extern void usb_autopm_get_interface_no_resume(struct usb_interface *intf); +extern void usb_autopm_put_interface_no_suspend(struct usb_interface *intf); +#else +static inline void usb_autopm_get_interface_no_resume(struct usb_interface *intf) +{ + atomic_inc(&intf->pm_usage_cnt); +} +static inline void usb_autopm_put_interface_no_suspend(struct usb_interface *intf) +{ + atomic_dec(&intf->pm_usage_cnt); +} +#endif /* CONFIG_USB_SUSPEND */ + +#if defined(CPTCFG_BACKPORT_BUILD_FW_LOADER_MODULE) +#define request_firmware_nowait LINUX_BACKPORT(request_firmware_nowait) +#define request_firmware LINUX_BACKPORT(request_firmware) +#define release_firmware LINUX_BACKPORT(release_firmware) + +int request_firmware(const struct firmware **fw, const char *name, + struct device *device); +int request_firmware_nowait( + struct module *module, int uevent, + const char *name, struct device *device, gfp_t gfp, void *context, + void (*cont)(const struct firmware *fw, void *context)); + +void release_firmware(const struct firmware *fw); +#endif + +/* mask KEY_RFKILL as RHEL6 backports this */ +#if !defined(KEY_RFKILL) +#define KEY_RFKILL 247 /* Key that controls all radios */ +#endif + +/* mask IFF_DONT_BRIDGE as RHEL6 backports this */ +#if !defined(IFF_DONT_BRIDGE) +#define IFF_DONT_BRIDGE 0x800 /* disallow bridging this ether dev */ +/* source: include/linux/if.h */ +#endif + +/* mask NETDEV_POST_INIT as RHEL6 backports this */ +/* this will never happen on older kernels */ +#if !defined(NETDEV_POST_INIT) +#define NETDEV_POST_INIT 0xffff +#endif + +/* mask netdev_alloc_skb_ip_align as debian squeeze also backports this */ +#define netdev_alloc_skb_ip_align(a, b) compat_netdev_alloc_skb_ip_align(a, b) + +static inline struct sk_buff *netdev_alloc_skb_ip_align(struct net_device *dev, + unsigned int length) +{ + struct sk_buff *skb = netdev_alloc_skb(dev, length + NET_IP_ALIGN); + + if (NET_IP_ALIGN && skb) + skb_reserve(skb, NET_IP_ALIGN); + return skb; +} + +#if defined(CONFIG_PCCARD) || defined(CONFIG_PCCARD_MODULE) + +#if defined(CONFIG_PCMCIA) || defined(CONFIG_PCMCIA_MODULE) + +#define pcmcia_request_window(a, b, c) pcmcia_request_window(&a, b, c) + +#define pcmcia_map_mem_page(a, b, c) pcmcia_map_mem_page(b, c) + +/* loop over CIS entries */ +#define pcmcia_loop_tuple LINUX_BACKPORT(pcmcia_loop_tuple) +int pcmcia_loop_tuple(struct pcmcia_device *p_dev, cisdata_t code, + int (*loop_tuple) (struct pcmcia_device *p_dev, + tuple_t *tuple, + void *priv_data), + void *priv_data); + +#endif /* CONFIG_PCMCIA */ + +/* loop over CIS entries */ +#define pccard_loop_tuple LINUX_BACKPORT(pccard_loop_tuple) +int pccard_loop_tuple(struct pcmcia_socket *s, unsigned int function, + cisdata_t code, cisparse_t *parse, void *priv_data, + int (*loop_tuple) (tuple_t *tuple, + cisparse_t *parse, + void *priv_data)); + +#endif /* CONFIG_PCCARD */ + +/** + * list_for_each_entry_continue_rcu - continue iteration over list of given type + * @pos: the type * to use as a loop cursor. + * @head: the head for your list. + * @member: the name of the list_struct within the struct. + * + * Continue to iterate over list of given type, continuing after + * the current position. + */ +#define list_for_each_entry_continue_rcu(pos, head, member) \ + for (pos = list_entry_rcu(pos->member.next, typeof(*pos), member); \ + prefetch(pos->member.next), &pos->member != (head); \ + pos = list_entry_rcu(pos->member.next, typeof(*pos), member)) + +#define sock_recv_ts_and_drops(msg, sk, skb) sock_recv_timestamp(msg, sk, skb) + +/* mask pci_pcie_cap as debian squeeze also backports this */ +#define pci_pcie_cap(a) compat_pci_pcie_cap(a) + +/** + * pci_pcie_cap - get the saved PCIe capability offset + * @dev: PCI device + * + * PCIe capability offset is calculated at PCI device initialization + * time and saved in the data structure. This function returns saved + * PCIe capability offset. Using this instead of pci_find_capability() + * reduces unnecessary search in the PCI configuration space. If you + * need to calculate PCIe capability offset from raw device for some + * reasons, please use pci_find_capability() instead. + */ +static inline int pci_pcie_cap(struct pci_dev *dev) +{ + return pci_find_capability(dev, PCI_CAP_ID_EXP); +} + +/* mask pci_is_pcie as RHEL6 backports this */ +#define pci_is_pcie(a) compat_pci_is_pcie(a) + +/** + * pci_is_pcie - check if the PCI device is PCI Express capable + * @dev: PCI device + * + * Retrun true if the PCI device is PCI Express capable, false otherwise. + */ +static inline bool pci_is_pcie(struct pci_dev *dev) +{ +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)) + return dev->is_pcie; +#else + return !!pci_pcie_cap(dev); +#endif +} + +#ifdef __GNUC__ +#define __always_unused __attribute__((unused)) +#else +#define __always_unused /* unimplemented */ +#endif + +/* mask IS_ERR_OR_NULL as debian squeeze also backports this */ +#define IS_ERR_OR_NULL(a) compat_IS_ERR_OR_NULL(a) + +static inline long __must_check IS_ERR_OR_NULL(const void *ptr) +{ + return !ptr || IS_ERR_VALUE((unsigned long)ptr); +} + +#if (LINUX_VERSION_CODE == KERNEL_VERSION(2,6,32)) +#undef SIMPLE_DEV_PM_OPS +#define SIMPLE_DEV_PM_OPS(name, suspend_fn, resume_fn) \ +const struct dev_pm_ops name = { \ + .suspend = suspend_fn, \ + .resume = resume_fn, \ + .freeze = suspend_fn, \ + .thaw = resume_fn, \ + .poweroff = suspend_fn, \ + .restore = resume_fn, \ +} +#endif /* (LINUX_VERSION_CODE == KERNEL_VERSION(2,6,32)) */ + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,33)) */ + +#endif /* LINUX_26_33_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-2.6.34.h b/backport/backport-include/linux/compat-2.6.34.h new file mode 100644 index 000000000000..d444853a4f66 --- /dev/null +++ b/backport/backport-include/linux/compat-2.6.34.h @@ -0,0 +1,347 @@ +#ifndef LINUX_26_34_COMPAT_H +#define LINUX_26_34_COMPAT_H + +#include + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,34)) + +#include +#include +#include +#include + +/* + * Backports da68c4eb25 + * sdio: introduce API for special power management features + * + * We wimply carry around the data structures and flags, and + * make the host return no flags set by the driver. + */ +typedef unsigned int mmc_pm_flag_t; + +#define MMC_PM_KEEP_POWER (1 << 0) /* preserve card power during suspend */ +#define MMC_PM_WAKE_SDIO_IRQ (1 << 1) /* wake up host system on SDIO IRQ assertion */ + +extern mmc_pm_flag_t sdio_get_host_pm_caps(struct sdio_func *func); +extern int sdio_set_host_pm_flags(struct sdio_func *func, mmc_pm_flag_t flags); + +#define netdev_mc_count(dev) ((dev)->mc_count) +#define netdev_mc_empty(dev) (netdev_mc_count(dev) == 0) + +/* mask netdev_for_each_mc_addr as RHEL6 backports this */ +#if !defined(netdev_for_each_mc_addr) +#define netdev_for_each_mc_addr(mclist, dev) \ + for (mclist = dev->mc_list; mclist; mclist = mclist->next) +#endif +/* source: include/linux/netdevice.h */ + + +/* Logging, debugging and troubleshooting/diagnostic helpers. */ + +/* netdev_printk helpers, similar to dev_printk */ + +#ifndef netdev_name +#define netdev_name(__dev) \ + ((__dev->reg_state != NETREG_REGISTERED) ? \ + "(unregistered net_device)" : __dev->name) +#endif + +#define netdev_printk(level, netdev, format, args...) \ + dev_printk(level, (netdev)->dev.parent, \ + "%s: " format, \ + netdev_name(netdev), ##args) + +#define netdev_emerg(dev, format, args...) \ + netdev_printk(KERN_EMERG, dev, format, ##args) +#define netdev_alert(dev, format, args...) \ + netdev_printk(KERN_ALERT, dev, format, ##args) +#define netdev_crit(dev, format, args...) \ + netdev_printk(KERN_CRIT, dev, format, ##args) +#define netdev_err(dev, format, args...) \ + netdev_printk(KERN_ERR, dev, format, ##args) +#define netdev_warn(dev, format, args...) \ + netdev_printk(KERN_WARNING, dev, format, ##args) +#define netdev_notice(dev, format, args...) \ + netdev_printk(KERN_NOTICE, dev, format, ##args) +#define netdev_info(dev, format, args...) \ + netdev_printk(KERN_INFO, dev, format, ##args) + +/* mask netdev_dbg as RHEL6 backports this */ +#if !defined(netdev_dbg) + +#if defined(DEBUG) +#define netdev_dbg(__dev, format, args...) \ + netdev_printk(KERN_DEBUG, __dev, format, ##args) +#elif defined(CONFIG_DYNAMIC_DEBUG) +#define netdev_dbg(__dev, format, args...) \ +do { \ + dynamic_dev_dbg((__dev)->dev.parent, "%s: " format, \ + netdev_name(__dev), ##args); \ +} while (0) +#else +#define netdev_dbg(__dev, format, args...) \ +({ \ + if (0) \ + netdev_printk(KERN_DEBUG, __dev, format, ##args); \ + 0; \ +}) +#endif + +#endif + +/* mask netdev_vdbg as RHEL6 backports this */ +#if !defined(netdev_dbg) + +#if defined(VERBOSE_DEBUG) +#define netdev_vdbg netdev_dbg +#else + +#define netdev_vdbg(dev, format, args...) \ +({ \ + if (0) \ + netdev_printk(KERN_DEBUG, dev, format, ##args); \ + 0; \ +}) +#endif + +#endif + +/* + * netdev_WARN() acts like dev_printk(), but with the key difference + * of using a WARN/WARN_ON to get the message out, including the + * file/line information and a backtrace. + */ +#define netdev_WARN(dev, format, args...) \ + WARN(1, "netdevice: %s\n" format, netdev_name(dev), ##args); + +/* netif printk helpers, similar to netdev_printk */ + +#define netif_printk(priv, type, level, dev, fmt, args...) \ +do { \ + if (netif_msg_##type(priv)) \ + netdev_printk(level, (dev), fmt, ##args); \ +} while (0) + +#define netif_emerg(priv, type, dev, fmt, args...) \ + netif_printk(priv, type, KERN_EMERG, dev, fmt, ##args) +#define netif_alert(priv, type, dev, fmt, args...) \ + netif_printk(priv, type, KERN_ALERT, dev, fmt, ##args) +#define netif_crit(priv, type, dev, fmt, args...) \ + netif_printk(priv, type, KERN_CRIT, dev, fmt, ##args) +#define netif_err(priv, type, dev, fmt, args...) \ + netif_printk(priv, type, KERN_ERR, dev, fmt, ##args) +#define netif_warn(priv, type, dev, fmt, args...) \ + netif_printk(priv, type, KERN_WARNING, dev, fmt, ##args) +#define netif_notice(priv, type, dev, fmt, args...) \ + netif_printk(priv, type, KERN_NOTICE, dev, fmt, ##args) +#define netif_info(priv, type, dev, fmt, args...) \ + netif_printk(priv, type, KERN_INFO, (dev), fmt, ##args) + +/* mask netif_dbg as RHEL6 backports this */ +#if !defined(netif_dbg) + +#if defined(DEBUG) +#define netif_dbg(priv, type, dev, format, args...) \ + netif_printk(priv, type, KERN_DEBUG, dev, format, ##args) +#elif defined(CONFIG_DYNAMIC_DEBUG) +#define netif_dbg(priv, type, netdev, format, args...) \ +do { \ + if (netif_msg_##type(priv)) \ + dynamic_dev_dbg((netdev)->dev.parent, \ + "%s: " format, \ + netdev_name(netdev), ##args); \ +} while (0) +#else +#define netif_dbg(priv, type, dev, format, args...) \ +({ \ + if (0) \ + netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \ + 0; \ +}) +#endif + +#endif + +/* mask netif_vdbg as RHEL6 backports this */ +#if !defined(netif_vdbg) + +#if defined(VERBOSE_DEBUG) +#define netif_vdbg netdev_dbg +#else +#define netif_vdbg(priv, type, dev, format, args...) \ +({ \ + if (0) \ + netif_printk(KERN_DEBUG, dev, format, ##args); \ + 0; \ +}) +#endif +#endif +/* source: include/linux/netdevice.h */ + + +static inline void device_lock(struct device *dev) +{ +#if defined(CONFIG_PREEMPT_RT) || defined(CONFIG_PREEMPT_DESKTOP) + mutex_lock(&dev->mutex); +#else + down(&dev->sem); +#endif +} + +static inline int device_trylock(struct device *dev) +{ +#if defined(CONFIG_PREEMPT_RT) || defined(CONFIG_PREEMPT_DESKTOP) + return mutex_trylock(&dev->mutex); +#else + return down_trylock(&dev->sem); +#endif +} + +static inline void device_unlock(struct device *dev) +{ +#if defined(CONFIG_PREEMPT_RT) || defined(CONFIG_PREEMPT_DESKTOP) + mutex_unlock(&dev->mutex); +#else + up(&dev->sem); +#endif +} + +#if defined(CONFIG_PCMCIA) || defined(CONFIG_PCMCIA_MODULE) +#define PCMCIA_DEVICE_PROD_ID3(v3, vh3) { \ + .match_flags = PCMCIA_DEV_ID_MATCH_PROD_ID3, \ + .prod_id = { NULL, NULL, (v3), NULL }, \ + .prod_id_hash = { 0, 0, (vh3), 0 }, } +#endif + +#define rcu_dereference_check(p, c) rcu_dereference(p) + +/** + * sysfs_attr_init - initialize a dynamically allocated sysfs attribute + * @attr: struct attribute to initialize + * + * Initialize a dynamically allocated struct attribute so we can + * make lockdep happy. This is a new requirement for attributes + * and initially this is only needed when lockdep is enabled. + * Lockdep gives a nice error when your attribute is added to + * sysfs if you don't have this. + */ +#ifdef CONFIG_DEBUG_LOCK_ALLOC +#define sysfs_attr_init(attr) \ +do { \ + static struct lock_class_key __key; \ + \ + (attr)->key = &__key; \ +} while(0) +#else +#define sysfs_attr_init(attr) do {} while(0) +#endif + +/* mask sysfs_bin_attr_init as RHEL6 backports this */ +#if !defined(sysfs_bin_attr_init) +/** + * sysfs_bin_attr_init - initialize a dynamically allocated bin_attribute + * @attr: struct bin_attribute to initialize + * + * Initialize a dynamically allocated struct bin_attribute so we + * can make lockdep happy. This is a new requirement for + * attributes and initially this is only needed when lockdep is + * enabled. Lockdep gives a nice error when your attribute is + * added to sysfs if you don't have this. + */ +#define sysfs_bin_attr_init(bin_attr) sysfs_attr_init(&(bin_attr)->attr) +#endif + +#define usb_alloc_coherent(dev, size, mem_flags, dma) usb_buffer_alloc(dev, size, mem_flags, dma) +#define usb_free_coherent(dev, size, addr, dma) usb_buffer_free(dev, size, addr, dma) + +/* only include this if DEFINE_DMA_UNMAP_ADDR is not set as debian squeeze also backports this */ +#ifndef DEFINE_DMA_UNMAP_ADDR +#ifdef CONFIG_NEED_DMA_MAP_STATE +#define DEFINE_DMA_UNMAP_ADDR(ADDR_NAME) dma_addr_t ADDR_NAME +#define DEFINE_DMA_UNMAP_LEN(LEN_NAME) __u32 LEN_NAME +#define dma_unmap_addr(PTR, ADDR_NAME) ((PTR)->ADDR_NAME) +#define dma_unmap_addr_set(PTR, ADDR_NAME, VAL) (((PTR)->ADDR_NAME) = (VAL)) +#define dma_unmap_len(PTR, LEN_NAME) ((PTR)->LEN_NAME) +#define dma_unmap_len_set(PTR, LEN_NAME, VAL) (((PTR)->LEN_NAME) = (VAL)) +#else +#define DEFINE_DMA_UNMAP_ADDR(ADDR_NAME) +#define DEFINE_DMA_UNMAP_LEN(LEN_NAME) +#define dma_unmap_addr(PTR, ADDR_NAME) (0) +#define dma_unmap_addr_set(PTR, ADDR_NAME, VAL) do { } while (0) +#define dma_unmap_len(PTR, LEN_NAME) (0) +#define dma_unmap_len_set(PTR, LEN_NAME, VAL) do { } while (0) +#endif +#endif + +/* mask dma_set_coherent_mask as debian squeeze also backports this */ +#define dma_set_coherent_mask(a, b) compat_dma_set_coherent_mask(a, b) + +static inline int dma_set_coherent_mask(struct device *dev, u64 mask) +{ + if (!dma_supported(dev, mask)) + return -EIO; + dev->coherent_dma_mask = mask; + return 0; +} + +/* USB autosuspend and autoresume */ +static inline int usb_enable_autosuspend(struct usb_device *udev) +{ return 0; } +static inline int usb_disable_autosuspend(struct usb_device *udev) +{ return 0; } + +#if !defined(rcu_dereference_protected) +#define rcu_dereference_protected(p, c) (p) +#endif +#define rcu_access_pointer(p) ACCESS_ONCE(p) + +#define rcu_dereference_raw(p) rcu_dereference(p) + +#define KEY_WPS_BUTTON 0x211 /* WiFi Protected Setup key */ + +/* + * This looks more complex than it should be. But we need to + * get the type for the ~ right in round_down (it needs to be + * as wide as the result!), and we want to evaluate the macro + * arguments just once each. + */ +#define __round_mask(x, y) ((__typeof__(x))((y)-1)) +#define round_up(x, y) ((((x)-1) | __round_mask(x, y))+1) +#define round_down(x, y) ((x) & ~__round_mask(x, y)) + +static inline int rcu_read_lock_held(void) +{ + return 1; +} + +#ifdef CONFIG_PROVE_LOCKING +/* + * Obviously, this is wrong. But the base kernel will have rtnl_mutex + * declared static, with no way to access it. I think this is the best + * we can do... + */ +static inline int lockdep_rtnl_is_held(void) +{ + return 1; +} +#endif /* #ifdef CONFIG_PROVE_LOCKING */ + +#define seq_hlist_start_head LINUX_BACKPORT(seq_hlist_start_head) +extern struct hlist_node *seq_hlist_start_head(struct hlist_head *head, + loff_t pos); + +#define seq_hlist_next LINUX_BACKPORT(seq_hlist_next) +extern struct hlist_node *seq_hlist_next(void *v, struct hlist_head *head, + loff_t *ppos); + +static inline struct sock *sk_entry(const struct hlist_node *node) +{ + return hlist_entry(node, struct sock, sk_node); +} + +#else /* Kernels >= 2.6.34 */ + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,34)) */ + + +#endif /* LINUX_26_34_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-2.6.35.h b/backport/backport-include/linux/compat-2.6.35.h new file mode 100644 index 000000000000..cb434728ec05 --- /dev/null +++ b/backport/backport-include/linux/compat-2.6.35.h @@ -0,0 +1,100 @@ +#ifndef LINUX_26_35_COMPAT_H +#define LINUX_26_35_COMPAT_H + +#include + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35)) +#include +#include +#include +#include +#include +#include + +#define HID_QUIRK_NO_IGNORE 0x40000000 +#define HID_QUIRK_HIDDEV_FORCE 0x00000010 + +/* added on linux/kernel.h */ +#define USHRT_MAX ((u16)(~0U)) +#define SHRT_MAX ((s16)(USHRT_MAX>>1)) +#define SHRT_MIN ((s16)(-SHRT_MAX - 1)) + +#define SDIO_BUS_ECSI 0x20 /* Enable continuous SPI interrupt */ +#define SDIO_BUS_SCSI 0x40 /* Support continuous SPI interrupt */ + +#define netdev_hw_addr dev_mc_list + +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)) + +#define qdisc_reset_all_tx_gt LINUX_BACKPORT(qdisc_reset_all_tx_gt) + +/* Reset all TX qdiscs greater then index of a device. */ +static inline void qdisc_reset_all_tx_gt(struct net_device *dev, unsigned int i) +{ + struct Qdisc *qdisc; + + for (; i < dev->num_tx_queues; i++) { + qdisc = netdev_get_tx_queue(dev, i)->qdisc; + if (qdisc) { + spin_lock_bh(qdisc_lock(qdisc)); + qdisc_reset(qdisc); + spin_unlock_bh(qdisc_lock(qdisc)); + } + } +} +#else +static inline void qdisc_reset_all_tx_gt(struct net_device *dev, unsigned int i) +{ +} +#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)) */ + +#define netif_set_real_num_tx_queues LINUX_BACKPORT(netif_set_real_num_tx_queues) +extern int netif_set_real_num_tx_queues(struct net_device *dev, + unsigned int txq); + +/* mask irq_set_affinity_hint as RHEL6 backports this */ +#define irq_set_affinity_hint(a,b) compat_irq_set_affinity_hint(a,b) +/* + * We cannot backport this guy as the IRQ data structure + * was modified in the kernel itself to support this. We + * treat the system as uni-processor in this case. + */ +static inline int irq_set_affinity_hint(unsigned int irq, + const struct cpumask *m) +{ + return -EINVAL; +} + +static inline wait_queue_head_t *sk_sleep(struct sock *sk) +{ + return sk->sk_sleep; +} + +#define sdio_writeb_readb(func, write_byte, addr, err_ret) sdio_readb(func, addr, err_ret) + +#define hex_to_bin LINUX_BACKPORT(hex_to_bin) +int hex_to_bin(char ch); + +#define noop_llseek LINUX_BACKPORT(noop_llseek) +extern loff_t noop_llseek(struct file *file, loff_t offset, int origin); + +#define pm_qos_request(_qos) pm_qos_requirement(_qos) + +/* mask usb_pipe_endpoint as RHEL6 backports this */ +#define usb_pipe_endpoint(a,b) compat_usb_pipe_endpoint(a,b) + +static inline struct usb_host_endpoint * +usb_pipe_endpoint(struct usb_device *dev, unsigned int pipe) +{ + struct usb_host_endpoint **eps; + eps = usb_pipein(pipe) ? dev->ep_in : dev->ep_out; + return eps[usb_pipeendpoint(pipe)]; +} + +#define simple_write_to_buffer LINUX_BACKPORT(simple_write_to_buffer) +extern ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos, + const void __user *from, size_t count); + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35)) */ + +#endif /* LINUX_26_35_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-2.6.36.h b/backport/backport-include/linux/compat-2.6.36.h new file mode 100644 index 000000000000..ff6a53f191db --- /dev/null +++ b/backport/backport-include/linux/compat-2.6.36.h @@ -0,0 +1,217 @@ +#ifndef LINUX_26_36_COMPAT_H +#define LINUX_26_36_COMPAT_H + +#include + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36)) + +#include +#include +#include +#include +#include + +#define kparam_block_sysfs_write(a) +#define kparam_unblock_sysfs_write(a) + +/* mask va_format as RHEL6 backports this */ +#define va_format compat_va_format + +struct va_format { + const char *fmt; + va_list *va; +}; + +#define device_rename(dev, new_name) device_rename(dev, (char *)new_name) + +#ifdef CPTCFG_BACKPORT_OPTION_USB_URB_THREAD_FIX +#define usb_scuttle_anchored_urbs LINUX_BACKPORT(usb_scuttle_anchored_urbs) +#define usb_get_from_anchor LINUX_BACKPORT(usb_get_from_anchor) +#define usb_unlink_anchored_urbs LINUX_BACKPORT(usb_unlink_anchored_urbs) + +extern void usb_unlink_anchored_urbs(struct usb_anchor *anchor); +extern struct urb *usb_get_from_anchor(struct usb_anchor *anchor); +extern void usb_scuttle_anchored_urbs(struct usb_anchor *anchor); +#endif + +/** + * pcmcia_read_config_byte() - read a byte from a card configuration register + * + * pcmcia_read_config_byte() reads a byte from a configuration register in + * attribute memory. + */ +static inline int pcmcia_read_config_byte(struct pcmcia_device *p_dev, off_t where, u8 *val) +{ + int ret; + conf_reg_t reg = { 0, CS_READ, where, 0 }; + ret = pcmcia_access_configuration_register(p_dev, ®); + *val = reg.Value; + return ret; +} + +/** + * pcmcia_write_config_byte() - write a byte to a card configuration register + * + * pcmcia_write_config_byte() writes a byte to a configuration register in + * attribute memory. + */ +static inline int pcmcia_write_config_byte(struct pcmcia_device *p_dev, off_t where, u8 val) +{ + conf_reg_t reg = { 0, CS_WRITE, where, val }; + return pcmcia_access_configuration_register(p_dev, ®); +} + +struct pm_qos_request_list { + u32 qos; + void *request; +}; + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35)) + +#define pm_qos_add_request(_req, _class, _value) do { \ + (_req)->request = #_req; \ + (_req)->qos = _class; \ + pm_qos_add_requirement((_class), (_req)->request, (_value)); \ + } while(0) + +#define pm_qos_update_request(_req, _value) \ + pm_qos_update_requirement((_req)->qos, (_req)->request, (_value)) + +#define pm_qos_remove_request(_req) \ + pm_qos_remove_requirement((_req)->qos, (_req)->request) + +#else + +#define pm_qos_add_request(_req, _class, _value) do { \ + (_req)->request = pm_qos_add_request((_class), (_value)); \ + } while (0) + +#define pm_qos_update_request(_req, _value) \ + pm_qos_update_request((_req)->request, (_value)) + +#define pm_qos_remove_request(_req) \ + pm_qos_remove_request((_req)->request) + +#endif + +/* + * Dummy printk for disabled debugging statements to use whilst maintaining + * gcc's format and side-effect checking. + */ +/* mask no_printk as RHEL6 backports this */ +#define no_printk(a, ...) compat_no_printk(a, ##__VA_ARGS__) +static inline __attribute__ ((format (printf, 1, 2))) +int no_printk(const char *s, ...) { return 0; } + +#ifndef alloc_workqueue +#define alloc_workqueue(name, flags, max_active) __create_workqueue(name, flags, max_active, 0) +#endif + +#define EXTPROC 0200000 +#define TIOCPKT_IOCTL 64 + +static inline void tty_lock(void) __acquires(kernel_lock) +{ +#ifdef CONFIG_LOCK_KERNEL + /* kernel_locked is 1 for !CONFIG_LOCK_KERNEL */ + WARN_ON(kernel_locked()); +#endif + lock_kernel(); +} +static inline void tty_unlock(void) __releases(kernel_lock) +{ + unlock_kernel(); +} +#define tty_locked() (kernel_locked()) + +#define usleep_range(_min, _max) msleep((_max) / 1000) + +#define __rcu + +static inline void pm_wakeup_event(struct device *dev, unsigned int msec) {} + +static inline bool skb_defer_rx_timestamp(struct sk_buff *skb) +{ + return false; +} + +static inline void skb_tx_timestamp(struct sk_buff *skb) +{ +} + +/* + * System-wide workqueues which are always present. + * + * system_wq is the one used by schedule[_delayed]_work[_on](). + * Multi-CPU multi-threaded. There are users which expect relatively + * short queue flush time. Don't queue works which can run for too + * long. + * + * system_long_wq is similar to system_wq but may host long running + * works. Queue flushing might take relatively long. + * + * system_nrt_wq is non-reentrant and guarantees that any given work + * item is never executed in parallel by multiple CPUs. Queue + * flushing might take relatively long. + */ +#define system_wq LINUX_BACKPORT(system_wq) +extern struct workqueue_struct *system_wq; +#define system_long_wq LINUX_BACKPORT(system_long_wq) +extern struct workqueue_struct *system_long_wq; +#define system_nrt_wq LINUX_BACKPORT(system_nrt_wq) +extern struct workqueue_struct *system_nrt_wq; + +void backport_system_workqueue_create(void); +void backport_system_workqueue_destroy(void); + +#define schedule_work LINUX_BACKPORT(schedule_work) +int schedule_work(struct work_struct *work); +#define schedule_work_on LINUX_BACKPORT(schedule_work_on) +int schedule_work_on(int cpu, struct work_struct *work); +#define schedule_delayed_work LINUX_BACKPORT(schedule_delayed_work) +int schedule_delayed_work(struct delayed_work *dwork, + unsigned long delay); +#define schedule_delayed_work_on LINUX_BACKPORT(schedule_delayed_work_on) +int schedule_delayed_work_on(int cpu, + struct delayed_work *dwork, + unsigned long delay); +#define flush_scheduled_work LINUX_BACKPORT(flush_scheduled_work) +void flush_scheduled_work(void); + +enum { + /* bit mask for work_busy() return values */ + WORK_BUSY_PENDING = 1 << 0, + WORK_BUSY_RUNNING = 1 << 1, +}; + +#define work_busy LINUX_BACKPORT(work_busy) +extern unsigned int work_busy(struct work_struct *work); + +#define br_port_exists(dev) (dev->br_port) + +#else + +static inline void backport_system_workqueue_create(void) +{ +} + +static inline void backport_system_workqueue_destroy(void) +{ +} + +/* + * This is not part of The 2.6.37 kernel yet but we + * we use it to optimize the backport code we + * need to implement. Instead of using ifdefs + * to check what version of the check we use + * we just replace all checks on current code + * with this. I'll submit this upstream too, that + * way all we'd have to do is to implement this + * for older kernels, then we would not have to + * edit the upstrema code for backport efforts. + */ +#define br_port_exists(dev) (dev->priv_flags & IFF_BRIDGE_PORT) + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36)) */ + +#endif /* LINUX_26_36_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-2.6.37.h b/backport/backport-include/linux/compat-2.6.37.h new file mode 100644 index 000000000000..317ae6fe88d4 --- /dev/null +++ b/backport/backport-include/linux/compat-2.6.37.h @@ -0,0 +1,182 @@ +#ifndef LINUX_26_37_COMPAT_H +#define LINUX_26_37_COMPAT_H + +#include + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,37)) + +#include +#include +#include +#include +#include + +#ifdef CONFIG_RPS +extern int netif_set_real_num_rx_queues(struct net_device *dev, + unsigned int rxq); +#else +static inline int netif_set_real_num_rx_queues(struct net_device *dev, + unsigned int rxq) +{ + return 0; +} +#endif + +static inline int proto_ports_offset(int proto) +{ + switch (proto) { + case IPPROTO_TCP: + case IPPROTO_UDP: + case IPPROTO_DCCP: + case IPPROTO_ESP: /* SPI */ + case IPPROTO_SCTP: + case IPPROTO_UDPLITE: + return 0; + case IPPROTO_AH: /* SPI */ + return 4; + default: + return -EINVAL; + } +} + +#define SDIO_CLASS_BT_AMP 0x09 /* Type-A Bluetooth AMP interface */ + +#define net_ns_type_operations LINUX_BACKPORT(net_ns_type_operations) +extern struct kobj_ns_type_operations net_ns_type_operations; + +/* mask skb_checksum_none_assert as RHEL6 backports this */ +#define skb_checksum_none_assert(a) compat_skb_checksum_none_assert(a) + +/** + * skb_checksum_none_assert - make sure skb ip_summed is CHECKSUM_NONE + * @skb: skb to check + * + * fresh skbs have their ip_summed set to CHECKSUM_NONE. + * Instead of forcing ip_summed to CHECKSUM_NONE, we can + * use this helper, to document places where we make this assertion. + */ +static inline void skb_checksum_none_assert(struct sk_buff *skb) +{ +#ifdef DEBUG + BUG_ON(skb->ip_summed != CHECKSUM_NONE); +#endif +} + +#define pcmcia_enable_device(link) pcmcia_request_configuration(link, &link->conf) + +#include + +struct compat_genl_info { + struct genl_info *info; + + u32 snd_seq; + u32 snd_pid; + struct genlmsghdr *genlhdr; + struct nlattr **attrs; + void *user_ptr[2]; +}; +#define genl_info compat_genl_info + +struct compat_genl_ops { + struct genl_ops ops; + + u8 cmd; + u8 internal_flags; + unsigned int flags; + const struct nla_policy *policy; + + int (*doit)(struct sk_buff *skb, struct genl_info *info); + int (*dumpit)(struct sk_buff *skb, struct netlink_callback *cb); + int (*done)(struct netlink_callback *cb); +}; +#define genl_ops compat_genl_ops + +struct compat_genl_family { + struct genl_family family; + + struct list_head list; + + unsigned int id, hdrsize, version, maxattr; + const char *name; + bool netnsok; + + struct nlattr **attrbuf; + + int (*pre_doit)(struct genl_ops *ops, struct sk_buff *skb, + struct genl_info *info); + + void (*post_doit)(struct genl_ops *ops, struct sk_buff *skb, + struct genl_info *info); +}; + +#define genl_family compat_genl_family + +#define genl_register_family_with_ops compat_genl_register_family_with_ops + +int genl_register_family_with_ops(struct genl_family *family, + struct genl_ops *ops, size_t n_ops); + +#define genl_unregister_family compat_genl_unregister_family + +int genl_unregister_family(struct genl_family *family); + +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)) +#define genl_info_net(_info) genl_info_net((_info)->info) +#endif + +#define genlmsg_reply(_msg, _info) genlmsg_reply(_msg, (_info)->info) +#define genlmsg_put(_skb, _pid, _seq, _fam, _flags, _cmd) genlmsg_put(_skb, _pid, _seq, &(_fam)->family, _flags, _cmd) +#define genl_register_mc_group(_fam, _grp) genl_register_mc_group(&(_fam)->family, _grp) +#define genl_unregister_mc_group(_fam, _grp) genl_unregister_mc_group(&(_fam)->family, _grp) + + +extern void led_blink_set(struct led_classdev *led_cdev, + unsigned long *delay_on, + unsigned long *delay_off); + +#define led_classdev_unregister compat_led_classdev_unregister +extern void compat_led_classdev_unregister(struct led_classdev *led_cdev); + +#define led_brightness_set compat_led_brightness_set +extern void compat_led_brightness_set(struct led_classdev *led_cdev, + enum led_brightness brightness); + +#define alloc_ordered_workqueue(name, flags) create_singlethread_workqueue(name) + +#define netdev_refcnt_read(a) atomic_read(&a->refcnt) + +#define vzalloc LINUX_BACKPORT(vzalloc) +extern void *vzalloc(unsigned long size); + +#define rtnl_dereference(p) \ + rcu_dereference_protected(p, lockdep_rtnl_is_held()) + +/** + * RCU_INIT_POINTER() - initialize an RCU protected pointer + * + * Initialize an RCU-protected pointer in such a way to avoid RCU-lockdep + * splats. + */ +#define RCU_INIT_POINTER(p, v) \ + p = (typeof(*v) __force __rcu *)(v) + +static inline bool skb_has_frag_list(const struct sk_buff *skb) +{ + return skb_shinfo(skb)->frag_list != NULL; +} + +/** + * backport: + * + * commit 67bdbffd696f29a0b68aa8daa285783a06651583 + * Author: Arnd Bergmann + * Date: Thu Feb 25 16:55:13 2010 +0100 + * + * rculist: avoid __rcu annotations + */ +#define hlist_first_rcu(head) (*((struct hlist_node __rcu **)(&(head)->first))) +#define hlist_next_rcu(node) (*((struct hlist_node __rcu **)(&(node)->next))) + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,37)) */ + +#endif /* LINUX_26_37_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-2.6.38.h b/backport/backport-include/linux/compat-2.6.38.h new file mode 100644 index 000000000000..4a823108c4d6 --- /dev/null +++ b/backport/backport-include/linux/compat-2.6.38.h @@ -0,0 +1,165 @@ +#ifndef LINUX_26_38_COMPAT_H +#define LINUX_26_38_COMPAT_H + +#include + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,38)) + +#include +#include +#include +#include + +#define PCI_MSIX_ENTRY_CTRL_MASKBIT 1 + +#define alloc_etherdev_mqs(sizeof_priv, tx_q, rx_q) alloc_etherdev_mq(sizeof_priv, tx_q) + +/* MSI-X entry's format */ +#define PCI_MSIX_ENTRY_SIZE 16 +#define PCI_MSIX_ENTRY_LOWER_ADDR 0 +#define PCI_MSIX_ENTRY_UPPER_ADDR 4 +#define PCI_MSIX_ENTRY_DATA 8 +#define PCI_MSIX_ENTRY_VECTOR_CTRL 12 + +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,30)) +static inline void bstats_update(struct gnet_stats_basic_packed *bstats, + const struct sk_buff *skb) +{ + bstats->bytes += qdisc_pkt_len((struct sk_buff *) skb); + bstats->packets += skb_is_gso(skb) ? skb_shinfo(skb)->gso_segs : 1; +} +static inline void qdisc_bstats_update(struct Qdisc *sch, + const struct sk_buff *skb) +{ + bstats_update(&sch->bstats, skb); +} +#else +/* + * kernels <= 2.6.30 do not pass a const skb to qdisc_pkt_len, and + * gnet_stats_basic_packed did not exist (see c1a8f1f1c8) + */ +static inline void bstats_update(struct gnet_stats_basic *bstats, + struct sk_buff *skb) +{ + bstats->bytes += qdisc_pkt_len(skb); + bstats->packets += skb_is_gso(skb) ? skb_shinfo(skb)->gso_segs : 1; +} +static inline void qdisc_bstats_update(struct Qdisc *sch, + struct sk_buff *skb) +{ + bstats_update(&sch->bstats, skb); +} +#endif + + +/* rename member in struct mmc_host in include/linux/mmc/host.h */ +#define max_segs max_hw_segs + + +#define pr_warn pr_warning +#define create_freezable_workqueue create_freezeable_workqueue + +static inline int skb_checksum_start_offset(const struct sk_buff *skb) +{ + return skb->csum_start - skb_headroom(skb); +} + +/* from include/linux/printk.h */ +#define pr_emerg_once(fmt, ...) \ + printk_once(KERN_EMERG pr_fmt(fmt), ##__VA_ARGS__) +#define pr_alert_once(fmt, ...) \ + printk_once(KERN_ALERT pr_fmt(fmt), ##__VA_ARGS__) +#define pr_crit_once(fmt, ...) \ + printk_once(KERN_CRIT pr_fmt(fmt), ##__VA_ARGS__) +#define pr_err_once(fmt, ...) \ + printk_once(KERN_ERR pr_fmt(fmt), ##__VA_ARGS__) +#define pr_warn_once(fmt, ...) \ + printk_once(KERN_WARNING pr_fmt(fmt), ##__VA_ARGS__) +#define pr_notice_once(fmt, ...) \ + printk_once(KERN_NOTICE pr_fmt(fmt), ##__VA_ARGS__) +#define pr_info_once(fmt, ...) \ + printk_once(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__) +#define pr_cont_once(fmt, ...) \ + printk_once(KERN_CONT pr_fmt(fmt), ##__VA_ARGS__) +#if defined(DEBUG) +#define pr_debug_once(fmt, ...) \ + printk_once(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__) +#else +#define pr_debug_once(fmt, ...) \ + no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__) +#endif + +/* include/linux/netdevice.h */ +#define alloc_netdev_mqs(sizeof_priv, name, setup, txqs, rxqs) \ + alloc_netdev_mq(sizeof_priv, name, setup, \ + max_t(unsigned int, txqs, rxqs)) + +#define ETH_P_LINK_CTL 0x886c /* HPNA, wlan link local tunnel */ + +/** + * is_unicast_ether_addr - Determine if the Ethernet address is unicast + * @addr: Pointer to a six-byte array containing the Ethernet address + * + * Return true if the address is a unicast address. + */ +static inline int is_unicast_ether_addr(const u8 *addr) +{ + return !is_multicast_ether_addr(addr); +} + +/* Backport of: + * + * commit 7ef88ad561457c0346355dfd1f53e503ddfde719 + * Author: Rusty Russell + * Date: Mon Jan 24 14:45:10 2011 -0600 + * + * BUILD_BUG_ON: make it handle more cases + */ +#undef BUILD_BUG_ON +/** + * BUILD_BUG_ON - break compile if a condition is true. + * @condition: the condition which the compiler should know is false. + * + * If you have some code which relies on certain constants being equal, or + * other compile-time-evaluated condition, you should use BUILD_BUG_ON to + * detect if someone changes it. + * + * The implementation uses gcc's reluctance to create a negative array, but + * gcc (as of 4.4) only emits that error for obvious cases (eg. not arguments + * to inline functions). So as a fallback we use the optimizer; if it can't + * prove the condition is false, it will cause a link error on the undefined + * "__build_bug_on_failed". This error message can be harder to track down + * though, hence the two different methods. + */ +#ifndef __OPTIMIZE__ +#define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)])) +#else +extern int __build_bug_on_failed; +#define BUILD_BUG_ON(condition) \ + do { \ + ((void)sizeof(char[1 - 2*!!(condition)])); \ + if (condition) __build_bug_on_failed = 1; \ + } while(0) +#endif + +/* Backport of: + * + * commit e159489baa717dbae70f9903770a6a4990865887 + * Author: Tejun Heo + * Date: Sun Jan 9 23:32:15 2011 +0100 + * + * workqueue: relax lockdep annotation on flush_work() + */ +#ifdef CONFIG_DEBUG_LOCK_ALLOC +# ifdef CONFIG_PROVE_LOCKING +# define lock_map_acquire_read(l) lock_acquire(l, 0, 0, 2, 2, NULL, _THIS_IP_) +# else +# define lock_map_acquire_read(l) lock_acquire(l, 0, 0, 2, 1, NULL, _THIS_IP_) +# endif +#else +# define lock_map_acquire_read(l) do { } while (0) +#endif + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,38)) */ + +#endif /* LINUX_26_38_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-2.6.39.h b/backport/backport-include/linux/compat-2.6.39.h new file mode 100644 index 000000000000..863afa4e9833 --- /dev/null +++ b/backport/backport-include/linux/compat-2.6.39.h @@ -0,0 +1,183 @@ +#ifndef LINUX_26_39_COMPAT_H +#define LINUX_26_39_COMPAT_H + +#include + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39)) + +#include +#include +#include +#include + +static inline int __must_check PTR_RET(const void *ptr) +{ + if (IS_ERR(ptr)) + return PTR_ERR(ptr); + else + return 0; +} + +#if !defined(NETIF_F_RXCSUM) +#define NETIF_F_RXCSUM 0 +#endif + +#define tiocmget(tty) tiocmget(tty, NULL) +#define tiocmset(tty, set, clear) tiocmset(tty, NULL, set, clear) + +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)) +#define tty_set_termios LINUX_BACKPORT(tty_set_termios) +extern int tty_set_termios(struct tty_struct *tty, struct ktermios *kt); +#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)) */ + +static inline int irq_set_irq_wake(unsigned int irq, unsigned int on) +{ + return set_irq_wake(irq, on); +} +static inline int irq_set_chip(unsigned int irq, struct irq_chip *chip) +{ + return set_irq_chip(irq, chip); +} +static inline int irq_set_handler_data(unsigned int irq, void *data) +{ + return set_irq_data(irq, data); +} +static inline int irq_set_chip_data(unsigned int irq, void *data) +{ + return set_irq_chip_data(irq, data); +} +static inline int irq_set_irq_type(unsigned int irq, unsigned int type) +{ + return set_irq_type(irq, type); +} +static inline int irq_set_msi_desc(unsigned int irq, struct msi_desc *entry) +{ + return set_irq_msi(irq, entry); +} +static inline struct irq_chip *irq_get_chip(unsigned int irq) +{ + return get_irq_chip(irq); +} +static inline void *irq_get_chip_data(unsigned int irq) +{ + return get_irq_chip_data(irq); +} +static inline void *irq_get_handler_data(unsigned int irq) +{ + return get_irq_data(irq); +} + +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37)) +static inline void *irq_data_get_irq_handler_data(struct irq_data *d) +{ + return irq_data_get_irq_data(d); +} +#endif + +static inline struct msi_desc *irq_get_msi_desc(unsigned int irq) +{ + return get_irq_msi(irq); +} + +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)) +static inline void irq_set_noprobe(unsigned int irq) +{ + set_irq_noprobe(irq); +} +static inline void irq_set_probe(unsigned int irq) +{ + set_irq_probe(irq); +} +#endif + +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29)) +static inline struct irq_chip *irq_desc_get_chip(struct irq_desc *desc) +{ + return get_irq_desc_chip(desc); +} +static inline void *irq_desc_get_handler_data(struct irq_desc *desc) +{ + return get_irq_desc_data(desc); +} + +static inline void *irq_desc_get_chip_data(struct irq_desc *desc) +{ + return get_irq_desc_chip_data(desc); +} + +static inline struct msi_desc *irq_desc_get_msi_desc(struct irq_desc *desc) +{ + return get_irq_desc_msi(desc); +} +#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29)) */ + +/* + * kstrto* was included in kernel 2.6.38.4 and causes conflicts with the + * version included in compat-drivers. We use strict_strtol to check if + * kstrto* is already available. + */ +#ifndef strict_strtoull +/* Internal, do not use. */ +int __must_check _kstrtoul(const char *s, unsigned int base, unsigned long *res); +int __must_check _kstrtol(const char *s, unsigned int base, long *res); + +int __must_check kstrtoull(const char *s, unsigned int base, unsigned long long *res); +int __must_check kstrtoll(const char *s, unsigned int base, long long *res); +static inline int __must_check kstrtoul(const char *s, unsigned int base, unsigned long *res) +{ + /* + * We want to shortcut function call, but + * __builtin_types_compatible_p(unsigned long, unsigned long long) = 0. + */ + if (sizeof(unsigned long) == sizeof(unsigned long long) && + __alignof__(unsigned long) == __alignof__(unsigned long long)) + return kstrtoull(s, base, (unsigned long long *)res); + else + return _kstrtoul(s, base, res); +} + +static inline int __must_check kstrtol(const char *s, unsigned int base, long *res) +{ + /* + * We want to shortcut function call, but + * __builtin_types_compatible_p(long, long long) = 0. + */ + if (sizeof(long) == sizeof(long long) && + __alignof__(long) == __alignof__(long long)) + return kstrtoll(s, base, (long long *)res); + else + return _kstrtol(s, base, res); +} + +int __must_check kstrtouint(const char *s, unsigned int base, unsigned int *res); +int __must_check kstrtoint(const char *s, unsigned int base, int *res); + +static inline int __must_check kstrtou64(const char *s, unsigned int base, u64 *res) +{ + return kstrtoull(s, base, res); +} + +static inline int __must_check kstrtos64(const char *s, unsigned int base, s64 *res) +{ + return kstrtoll(s, base, res); +} + +static inline int __must_check kstrtou32(const char *s, unsigned int base, u32 *res) +{ + return kstrtouint(s, base, res); +} + +static inline int __must_check kstrtos32(const char *s, unsigned int base, s32 *res) +{ + return kstrtoint(s, base, res); +} + +int __must_check kstrtou16(const char *s, unsigned int base, u16 *res); +int __must_check kstrtos16(const char *s, unsigned int base, s16 *res); +int __must_check kstrtou8(const char *s, unsigned int base, u8 *res); +int __must_check kstrtos8(const char *s, unsigned int base, s8 *res); +#endif /* ifndef strict_strtol */ + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39)) */ + +#endif /* LINUX_26_39_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-3.0.h b/backport/backport-include/linux/compat-3.0.h new file mode 100644 index 000000000000..0bf179dd0218 --- /dev/null +++ b/backport/backport-include/linux/compat-3.0.h @@ -0,0 +1,163 @@ +#ifndef LINUX_3_0_COMPAT_H +#define LINUX_3_0_COMPAT_H + +#include + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,0,0)) + +#include + +/* This pulls-in a lot of non-exported symbol backports + * on kernels older than 2.6.32. There's no harm for not + * making this available on kernels < 2.6.32. */ +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)) +#include + +/* This backports the 2nd part of: + * + * commit d9d90e5eb70e09903dadff42099b6c948f814050 + * Author: Hugh Dickins + * Date: Mon Jun 27 16:18:04 2011 -0700 + * + * tmpfs: add shmem_read_mapping_page_gfp + * + * First part is in compat-3.0.c. + */ +#define shmem_read_mapping_page_gfp LINUX_BACKPORT(shmem_read_mapping_page_gfp) +extern struct page *shmem_read_mapping_page_gfp(struct address_space *mapping, + pgoff_t index, gfp_t gfp); + + +#define shmem_read_mapping_page LINUX_BACKPORT(shmem_read_mapping_page) +static inline struct page *shmem_read_mapping_page( + struct address_space *mapping, pgoff_t index) +{ + return shmem_read_mapping_page_gfp(mapping, index, + mapping_gfp_mask(mapping)); +} +#endif + + +/* + * since commit 1c5cae815d19ffe02bdfda1260949ef2b1806171 + * "net: call dev_alloc_name from register_netdevice" dev_alloc_name is + * called automatically. This is not implemented in older kernel + * versions so it will result in device wrong names. + */ +static inline int register_netdevice_name(struct net_device *dev) +{ + int err; + + if (strchr(dev->name, '%')) { + err = dev_alloc_name(dev, dev->name); + if (err < 0) + return err; + } + + return register_netdevice(dev); +} + +#define register_netdevice(dev) register_netdevice_name(dev) + +/* BCMA core, see drivers/bcma/ */ +#ifndef BCMA_CORE +/* Broadcom's specific AMBA core, see drivers/bcma/ */ +struct bcma_device_id { + __u16 manuf; + __u16 id; + __u8 rev; + __u8 class; +}; +#define BCMA_CORE(_manuf, _id, _rev, _class) \ + { .manuf = _manuf, .id = _id, .rev = _rev, .class = _class, } +#define BCMA_CORETABLE_END \ + { 0, }, + +#define BCMA_ANY_MANUF 0xFFFF +#define BCMA_ANY_ID 0xFFFF +#define BCMA_ANY_REV 0xFF +#define BCMA_ANY_CLASS 0xFF +#endif /* BCMA_CORE */ + +#define mac_pton LINUX_BACKPORT(mac_pton) +int mac_pton(const char *s, u8 *mac); + +int __must_check kstrtoull_from_user(const char __user *s, size_t count, unsigned int base, unsigned long long *res); +int __must_check kstrtoll_from_user(const char __user *s, size_t count, unsigned int base, long long *res); +int __must_check kstrtoul_from_user(const char __user *s, size_t count, unsigned int base, unsigned long *res); +int __must_check kstrtol_from_user(const char __user *s, size_t count, unsigned int base, long *res); +int __must_check kstrtouint_from_user(const char __user *s, size_t count, unsigned int base, unsigned int *res); +int __must_check kstrtoint_from_user(const char __user *s, size_t count, unsigned int base, int *res); +int __must_check kstrtou16_from_user(const char __user *s, size_t count, unsigned int base, u16 *res); +int __must_check kstrtos16_from_user(const char __user *s, size_t count, unsigned int base, s16 *res); +int __must_check kstrtou8_from_user(const char __user *s, size_t count, unsigned int base, u8 *res); +int __must_check kstrtos8_from_user(const char __user *s, size_t count, unsigned int base, s8 *res); + +static inline int __must_check kstrtou64_from_user(const char __user *s, size_t count, unsigned int base, u64 *res) +{ + return kstrtoull_from_user(s, count, base, res); +} + +static inline int __must_check kstrtos64_from_user(const char __user *s, size_t count, unsigned int base, s64 *res) +{ + return kstrtoll_from_user(s, count, base, res); +} + +static inline int __must_check kstrtou32_from_user(const char __user *s, size_t count, unsigned int base, u32 *res) +{ + return kstrtouint_from_user(s, count, base, res); +} + +static inline int __must_check kstrtos32_from_user(const char __user *s, size_t count, unsigned int base, s32 *res) +{ + return kstrtoint_from_user(s, count, base, res); +} + +/* + * This adds a nested function everywhere kfree_rcu() was called. This + * function frees the memory and is given as a function to call_rcu(). + * The rcu callback could happen every time also after the module was + * unloaded and this will cause problems. + */ +#if !defined(kfree_rcu) +#define kfree_rcu(data, rcuhead) do { \ + void __kfree_rcu_fn(struct rcu_head *rcu_head) \ + { \ + void *___ptr; \ + ___ptr = container_of(rcu_head, typeof(*(data)), rcuhead);\ + kfree(___ptr); \ + } \ + call_rcu(&(data)->rcuhead, __kfree_rcu_fn); \ + } while (0) +#endif +#ifdef MODULE + +/* + * The define overwriting module_exit is based on the original module_exit + * which looks like this: + * #define module_exit(exitfn) \ + * static inline exitcall_t __exittest(void) \ + * { return exitfn; } \ + * void cleanup_module(void) __attribute__((alias(#exitfn))); + * + * We replaced the call to the actual function exitfn() with a call to our + * function which calls the original exitfn() and then rcu_barrier() + * + * As a module will not be unloaded that ofter it should not have a big + * performance impact when rcu_barrier() is called on every module exit, + * also when no kfree_rcu() backport is used in that module. + */ +#undef module_exit +#define module_exit(exitfn) \ + static void __exit __exit_compat(void) \ + { \ + exitfn(); \ + rcu_barrier(); \ + } \ + void cleanup_module(void) __attribute__((alias("__exit_compat"))); + +#endif + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(3,0,0)) */ + +#endif /* LINUX_3_0_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-3.1.h b/backport/backport-include/linux/compat-3.1.h new file mode 100644 index 000000000000..d2ac0db2ec7d --- /dev/null +++ b/backport/backport-include/linux/compat-3.1.h @@ -0,0 +1,100 @@ +#ifndef LINUX_3_1_COMPAT_H +#define LINUX_3_1_COMPAT_H + +#include + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0)) + +#include +#include +#include +#include +#include + +#define HID_TYPE_USBNONE 2 + +/* This backports: + * + * commit 36a26c69b4c70396ef569c3452690fba0c1dec08 + * Author: Nicholas Bellinger + * Date: Tue Jul 26 00:35:26 2011 -0700 + * + * kernel.h: Add DIV_ROUND_UP_ULL and DIV_ROUND_UP_SECTOR_T macro usage + */ + +#define DIV_ROUND_UP_ULL(ll,d) \ + ({ unsigned long long _tmp = (ll)+(d)-1; do_div(_tmp, d); _tmp; }) + +/* Backports 56f8a75c */ +static inline bool ip_is_fragment(const struct iphdr *iph) +{ + return (iph->frag_off & htons(IP_MF | IP_OFFSET)) != 0; +} + +/* mask __netdev_alloc_skb_ip_align as RHEL6 backports this */ +#define __netdev_alloc_skb_ip_align(a,b,c) compat__netdev_alloc_skb_ip_align(a,b,c) +static inline struct sk_buff *__netdev_alloc_skb_ip_align(struct net_device *dev, + unsigned int length, gfp_t gfp) +{ + struct sk_buff *skb = __netdev_alloc_skb(dev, length + NET_IP_ALIGN, gfp); + + if (NET_IP_ALIGN && skb) + skb_reserve(skb, NET_IP_ALIGN); + return skb; +} + +#define genl_dump_check_consistent(cb, user_hdr, family) + +#define IFF_TX_SKB_SHARING 0x10000 /* The interface supports sharing + * skbs on transmit */ + +#define PCMCIA_DEVICE_MANF_CARD_PROD_ID3(manf, card, v3, vh3) { \ + .match_flags = PCMCIA_DEV_ID_MATCH_MANF_ID| \ + PCMCIA_DEV_ID_MATCH_CARD_ID| \ + PCMCIA_DEV_ID_MATCH_PROD_ID3, \ + .manf_id = (manf), \ + .card_id = (card), \ + .prod_id = { NULL, NULL, (v3), NULL }, \ + .prod_id_hash = { 0, 0, (vh3), 0 }, } + +/* + * This has been defined in include/linux/security.h for some time, but was + * only given an EXPORT_SYMBOL for 3.1. Add a compat_* definition to avoid + * breaking the compile. + */ +#define security_sk_clone(a, b) compat_security_sk_clone(a, b) + +static inline void security_sk_clone(const struct sock *sk, struct sock *newsk) +{ +} + +/* + * In many versions, several architectures do not seem to include an + * atomic64_t implementation, and do not include the software emulation from + * asm-generic/atomic64_t. + * Detect and handle this here. + */ +#include + +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,31)) && !defined(ATOMIC64_INIT) && !defined(CONFIG_X86) && !((LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33)) && defined(CONFIG_ARM) && !defined(CONFIG_GENERIC_ATOMIC64)) +#include +#endif + +#define ida_simple_get LINUX_BACKPORT(ida_simple_get) +int ida_simple_get(struct ida *ida, unsigned int start, unsigned int end, + gfp_t gfp_mask); + +#define ida_simple_remove LINUX_BACKPORT(ida_simple_remove) +void ida_simple_remove(struct ida *ida, unsigned int id); + +#ifdef CONFIG_CPU_FREQ +#define cpufreq_quick_get_max LINUX_BACKPORT(cpufreq_quick_get_max) +unsigned int cpufreq_quick_get_max(unsigned int cpu); +#endif + +struct watchdog_device { +}; + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0)) */ + +#endif /* LINUX_3_1_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-3.10.h b/backport/backport-include/linux/compat-3.10.h new file mode 100644 index 000000000000..b4d8bc5affb6 --- /dev/null +++ b/backport/backport-include/linux/compat-3.10.h @@ -0,0 +1,145 @@ +#ifndef LINUX_3_10_COMPAT_H +#define LINUX_3_10_COMPAT_H + +#include + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)) + +#include +#include +#include +#include +#include + +#define sg_page_iter_page LINUX_BACKPORT(sg_page_iter_page) +/** + * sg_page_iter_page - get the current page held by the page iterator + * @piter: page iterator holding the page + */ +static inline struct page *sg_page_iter_page(struct sg_page_iter *piter) +{ + return nth_page(sg_page(piter->sg), piter->sg_pgoffset); +} + +#define sg_page_iter_dma_address LINUX_BACKPORT(sg_page_iter_dma_address) +/** + * sg_page_iter_dma_address - get the dma address of the current page held by + * the page iterator. + * @piter: page iterator holding the page + */ +static inline dma_addr_t sg_page_iter_dma_address(struct sg_page_iter *piter) +{ + return sg_dma_address(piter->sg) + (piter->sg_pgoffset << PAGE_SHIFT); +} + +/* + * This is a linux-next data structure element collateral evolution, + * we use a wrapper to avoid #ifdef hell to backport it. This allows + * us to use a simple fb_info_skip_vt_switch() replacement for when + * the new data structure element is used. If coccinelle SmPL grammar + * could be used to express the transformation for us on compat-drivers + * it means we'd need to express it only once. If the structure element + * collateral evolution were to be used *at development* time and we'd + * have a way to express the inverse through SmPL we'd be able to + * backport this collateral evolution automatically for any new driver + * that used it. We'd use coccinelle to look for it and do the + * transformations for us based on the original commit (maybe SmPL + * would be listed on the commit log. + * + * We may need the LINUX_BACKPORT() call that adds the backport_ + * prefix for older kernels than 3.10 if distros decide to + * add this same static inline themselves (although unlikely). + */ +#define fb_enable_skip_vt_switch LINUX_BACKPORT(fb_enable_skip_vt_switch) +static inline void fb_enable_skip_vt_switch(struct fb_info *info) +{ +} + +/** + * backport of: + * + * commit 6ed7ffddcf61f668114edb676417e5fb33773b59 + * Author: H Hartley Sweeten + * Date: Wed Mar 6 11:24:44 2013 -0700 + * + * pcmcia/ds.h: introduce helper for pcmcia_driver module boilerplate + */ + +/** + * module_pcmcia_driver() - Helper macro for registering a pcmcia driver + * @__pcmcia_driver: pcmcia_driver struct + * + * Helper macro for pcmcia drivers which do not do anything special in module + * init/exit. This eliminates a lot of boilerplate. Each module may only use + * this macro once, and calling it replaces module_init() and module_exit(). + */ +#define module_pcmcia_driver(__pcmcia_driver) \ + module_driver(__pcmcia_driver, pcmcia_register_driver, \ + pcmcia_unregister_driver) + +/* + * backport of: + * commit e5c5d22e8dcf7c2d430336cbf8e180bd38e8daf1 + * Author: Simon Horman + * Date: Thu Mar 28 13:38:25 2013 +0900 + * + * net: add ETH_P_802_3_MIN + */ +#ifndef ETH_P_802_3_MIN +#define ETH_P_802_3_MIN 0x0600 +#endif + +/* + * backport of: + * procfs: new helper - PDE_DATA(inode) + */ +static inline void *PDE_DATA(const struct inode *inode) +{ + return PROC_I(inode)->pde->data; +} + +/* + * backport SOCK_SELECT_ERR_QUEUE -- see commit + * "net: add option to enable error queue packets waking select" + * + * Adding 14 to SOCK_QUEUE_SHRUNK will reach a bet that can't be + * set on older kernels, so sock_flag() will always return false. + */ +#define SOCK_SELECT_ERR_QUEUE (SOCK_QUEUE_SHRUNK + 14) + +/* + * DRM requires this, but we can't really backport it well + */ +static inline void __iomem *pci_platform_rom(struct pci_dev *pdev, size_t *size) +{ + printk(KERN_WARNING "compat: not providing pci_platform_rom!\n"); + return NULL; +} + +/* + * backport SOL_NFC -- see commit: + * NFC: llcp: Implement socket options + */ +#define SOL_NFC 280 + +#else /* kernel is >= 3.10 */ +/* + * We'd delete this upstream ever got this, we use our + * backport_ prefix with LINUX_BACKPORT() so that if this + * does get upstream we would not have to add another ifdef + * here for the kernels in between v3.10.. up to the point + * the routine would have gotten added, we'd just delete this + * #else condition completely. If we didn't have this and + * say 3.12 added the static inline upstream, we'd have a + * clash on the backport for 3.12 as the routine would + * already be defined *but* we'd need it for 3.11. + */ +#define fb_enable_skip_vt_switch LINUX_BACKPORT(fb_enable_skip_vt_switch) +static inline void fb_enable_skip_vt_switch(struct fb_info *info) +{ + info->skip_vt_switch = true; +} + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)) */ + +#endif /* LINUX_3_10_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-3.2.h b/backport/backport-include/linux/compat-3.2.h new file mode 100644 index 000000000000..982b9898d9ce --- /dev/null +++ b/backport/backport-include/linux/compat-3.2.h @@ -0,0 +1,111 @@ +#ifndef LINUX_3_2_COMPAT_H +#define LINUX_3_2_COMPAT_H + +#include + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,2,0)) + +#include +#include +#include + +/* backports 07613b0b */ +#if defined(CONFIG_DYNAMIC_DEBUG) +#define DEFINE_DYNAMIC_DEBUG_METADATA(name, fmt) \ + static struct _ddebug __used __aligned(8) \ + __attribute__((section("__verbose"))) name = { \ + .modname = KBUILD_MODNAME, \ + .function = __func__, \ + .filename = __FILE__, \ + .format = (fmt), \ + .lineno = __LINE__, \ + .flags = _DPRINTK_FLAGS_DEFAULT, \ + .enabled = false, \ + } +#endif /* defined(CONFIG_DYNAMIC_DEBUG) */ + +/* backports b4625dab */ +#define SDIO_CCCR_REV_3_00 3 /* CCCR/FBR Version 3.00 */ +#define SDIO_SDIO_REV_3_00 4 /* SDIO Spec Version 3.00 */ + +#define PMSG_IS_AUTO(msg) (((msg).event & PM_EVENT_AUTO) != 0) + +/* mask skb_frag_page as RHEL6 backports this */ +#define skb_frag_page(a) compat_skb_frag_page(a) + +/** + * skb_frag_page - retrieve the page refered to by a paged fragment + * @frag: the paged fragment + * + * Returns the &struct page associated with @frag. + */ +static inline struct page *skb_frag_page(const skb_frag_t *frag) +{ + return frag->page; +} + +/* mask skb_frag_dma_map as RHEL6 backports this */ +#define skb_frag_dma_map(a,b,c,d,e) compat_skb_frag_dma_map(a,b,c,d,e) + +/** + * skb_frag_dma_map - maps a paged fragment via the DMA API + * @device: the device to map the fragment to + * @frag: the paged fragment to map + * @offset: the offset within the fragment (starting at the + * fragment's own offset) + * @size: the number of bytes to map + * @direction: the direction of the mapping (%PCI_DMA_*) + * + * Maps the page associated with @frag to @device. + */ +static inline dma_addr_t skb_frag_dma_map(struct device *dev, + const skb_frag_t *frag, + size_t offset, size_t size, + enum dma_data_direction dir) +{ + return dma_map_page(dev, skb_frag_page(frag), + frag->page_offset + offset, size, dir); +} + +#define ETH_P_TDLS 0x890D /* TDLS */ + +/* mask skb_frag_size as RHEL6 backports this */ +#define skb_frag_size(a) compat_skb_frag_size(a) + +static inline unsigned int skb_frag_size(const skb_frag_t *frag) +{ + return frag->size; +} + +static inline char *hex_byte_pack(char *buf, u8 byte) +{ + *buf++ = hex_asc_hi(byte); + *buf++ = hex_asc_lo(byte); + return buf; +} + +/* module_platform_driver() - Helper macro for drivers that don't do + * anything special in module init/exit. This eliminates a lot of + * boilerplate. Each module may only use this macro once, and + * calling it replaces module_init() and module_exit() + */ +#define module_platform_driver(__platform_driver) \ + module_driver(__platform_driver, platform_driver_register, \ + platform_driver_unregister) + +static inline void *dma_zalloc_coherent(struct device *dev, size_t size, + dma_addr_t *dma_handle, gfp_t flag) +{ + void *ret = dma_alloc_coherent(dev, size, dma_handle, flag); + if (ret) + memset(ret, 0, size); + return ret; +} + +#define __netdev_printk LINUX_BACKPORT(__netdev_printk) +extern int __netdev_printk(const char *level, const struct net_device *dev, + struct va_format *vaf); + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(3,2,0)) */ + +#endif /* LINUX_3_2_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-3.3.h b/backport/backport-include/linux/compat-3.3.h new file mode 100644 index 000000000000..ce7e776bf390 --- /dev/null +++ b/backport/backport-include/linux/compat-3.3.h @@ -0,0 +1,397 @@ +#ifndef LINUX_3_3_COMPAT_H +#define LINUX_3_3_COMPAT_H + +#include + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0)) + +#include + +/* include to override NL80211_FEATURE_SK_TX_STATUS */ +#include +#include +#include +#include +#include + +/* + * BQL was added as of v3.3 but some Linux distributions + * have backported BQL to their v3.2 kernels or older. To + * address this we assume that they also enabled CONFIG_BQL + * and test for that here and simply avoid adding the static + * inlines if it was defined + */ +#ifndef CONFIG_BQL +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26)) +static inline void netdev_tx_sent_queue(struct netdev_queue *dev_queue, + unsigned int bytes) +{ +} +#endif + +static inline void netdev_sent_queue(struct net_device *dev, unsigned int bytes) +{ +} + +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26)) +static inline void netdev_tx_completed_queue(struct netdev_queue *dev_queue, + unsigned pkts, unsigned bytes) +{ +} +#endif + +static inline void netdev_completed_queue(struct net_device *dev, + unsigned pkts, unsigned bytes) +{ +} + +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26)) +static inline void netdev_tx_reset_queue(struct netdev_queue *q) +{ +} +#endif + +static inline void netdev_reset_queue(struct net_device *dev_queue) +{ +} +#endif /* CONFIG_BQL */ + + +#define ethtool_adv_to_mii_adv_t LINUX_BACKPORT(ethtool_adv_to_mii_adv_t) + +/** + * ethtool_adv_to_mii_adv_t + * @ethadv: the ethtool advertisement settings + * + * A small helper function that translates ethtool advertisement + * settings to phy autonegotiation advertisements for the + * MII_ADVERTISE register. + */ +static inline u32 ethtool_adv_to_mii_adv_t(u32 ethadv) +{ + u32 result = 0; + + if (ethadv & ADVERTISED_10baseT_Half) + result |= ADVERTISE_10HALF; + if (ethadv & ADVERTISED_10baseT_Full) + result |= ADVERTISE_10FULL; + if (ethadv & ADVERTISED_100baseT_Half) + result |= ADVERTISE_100HALF; + if (ethadv & ADVERTISED_100baseT_Full) + result |= ADVERTISE_100FULL; + if (ethadv & ADVERTISED_Pause) + result |= ADVERTISE_PAUSE_CAP; + if (ethadv & ADVERTISED_Asym_Pause) + result |= ADVERTISE_PAUSE_ASYM; + + return result; +} + +#define mii_adv_to_ethtool_adv_t LINUX_BACKPORT(mii_adv_to_ethtool_adv_t) + +/** + * mii_adv_to_ethtool_adv_t + * @adv: value of the MII_ADVERTISE register + * + * A small helper function that translates MII_ADVERTISE bits + * to ethtool advertisement settings. + */ +static inline u32 mii_adv_to_ethtool_adv_t(u32 adv) +{ + u32 result = 0; + + if (adv & ADVERTISE_10HALF) + result |= ADVERTISED_10baseT_Half; + if (adv & ADVERTISE_10FULL) + result |= ADVERTISED_10baseT_Full; + if (adv & ADVERTISE_100HALF) + result |= ADVERTISED_100baseT_Half; + if (adv & ADVERTISE_100FULL) + result |= ADVERTISED_100baseT_Full; + if (adv & ADVERTISE_PAUSE_CAP) + result |= ADVERTISED_Pause; + if (adv & ADVERTISE_PAUSE_ASYM) + result |= ADVERTISED_Asym_Pause; + + return result; +} + +#define ethtool_adv_to_mii_ctrl1000_t LINUX_BACKPORT(ethtool_adv_to_mii_ctrl1000_t) + +/** + * ethtool_adv_to_mii_ctrl1000_t + * @ethadv: the ethtool advertisement settings + * + * A small helper function that translates ethtool advertisement + * settings to phy autonegotiation advertisements for the + * MII_CTRL1000 register when in 1000T mode. + */ +static inline u32 ethtool_adv_to_mii_ctrl1000_t(u32 ethadv) +{ + u32 result = 0; + + if (ethadv & ADVERTISED_1000baseT_Half) + result |= ADVERTISE_1000HALF; + if (ethadv & ADVERTISED_1000baseT_Full) + result |= ADVERTISE_1000FULL; + + return result; +} + +#define mii_ctrl1000_to_ethtool_adv_t LINUX_BACKPORT(mii_ctrl1000_to_ethtool_adv_t) + +/** + * mii_ctrl1000_to_ethtool_adv_t + * @adv: value of the MII_CTRL1000 register + * + * A small helper function that translates MII_CTRL1000 + * bits, when in 1000Base-T mode, to ethtool + * advertisement settings. + */ +static inline u32 mii_ctrl1000_to_ethtool_adv_t(u32 adv) +{ + u32 result = 0; + + if (adv & ADVERTISE_1000HALF) + result |= ADVERTISED_1000baseT_Half; + if (adv & ADVERTISE_1000FULL) + result |= ADVERTISED_1000baseT_Full; + + return result; +} + +#define mii_lpa_to_ethtool_lpa_t LINUX_BACKPORT(mii_lpa_to_ethtool_lpa_t) + +/** + * mii_lpa_to_ethtool_lpa_t + * @adv: value of the MII_LPA register + * + * A small helper function that translates MII_LPA + * bits, when in 1000Base-T mode, to ethtool + * LP advertisement settings. + */ +static inline u32 mii_lpa_to_ethtool_lpa_t(u32 lpa) +{ + u32 result = 0; + + if (lpa & LPA_LPACK) + result |= ADVERTISED_Autoneg; + + return result | mii_adv_to_ethtool_adv_t(lpa); +} + +#define mii_stat1000_to_ethtool_lpa_t LINUX_BACKPORT(mii_stat1000_to_ethtool_lpa_t) + +/** + * mii_stat1000_to_ethtool_lpa_t + * @adv: value of the MII_STAT1000 register + * + * A small helper function that translates MII_STAT1000 + * bits, when in 1000Base-T mode, to ethtool + * advertisement settings. + */ +static inline u32 mii_stat1000_to_ethtool_lpa_t(u32 lpa) +{ + u32 result = 0; + + if (lpa & LPA_1000HALF) + result |= ADVERTISED_1000baseT_Half; + if (lpa & LPA_1000FULL) + result |= ADVERTISED_1000baseT_Full; + + return result; +} + +#define ethtool_adv_to_mii_adv_x LINUX_BACKPORT(ethtool_adv_to_mii_adv_x) +/** + * ethtool_adv_to_mii_adv_x + * @ethadv: the ethtool advertisement settings + * + * A small helper function that translates ethtool advertisement + * settings to phy autonegotiation advertisements for the + * MII_CTRL1000 register when in 1000Base-X mode. + */ +static inline u32 ethtool_adv_to_mii_adv_x(u32 ethadv) +{ + u32 result = 0; + + if (ethadv & ADVERTISED_1000baseT_Half) + result |= ADVERTISE_1000XHALF; + if (ethadv & ADVERTISED_1000baseT_Full) + result |= ADVERTISE_1000XFULL; + if (ethadv & ADVERTISED_Pause) + result |= ADVERTISE_1000XPAUSE; + if (ethadv & ADVERTISED_Asym_Pause) + result |= ADVERTISE_1000XPSE_ASYM; + + return result; +} + +#define mii_adv_to_ethtool_adv_x LINUX_BACKPORT(mii_adv_to_ethtool_adv_x) + +/** + * mii_adv_to_ethtool_adv_x + * @adv: value of the MII_CTRL1000 register + * + * A small helper function that translates MII_CTRL1000 + * bits, when in 1000Base-X mode, to ethtool + * advertisement settings. + */ +static inline u32 mii_adv_to_ethtool_adv_x(u32 adv) +{ + u32 result = 0; + + if (adv & ADVERTISE_1000XHALF) + result |= ADVERTISED_1000baseT_Half; + if (adv & ADVERTISE_1000XFULL) + result |= ADVERTISED_1000baseT_Full; + if (adv & ADVERTISE_1000XPAUSE) + result |= ADVERTISED_Pause; + if (adv & ADVERTISE_1000XPSE_ASYM) + result |= ADVERTISED_Asym_Pause; + + return result; +} + +#define mii_lpa_to_ethtool_lpa_x LINUX_BACKPORT(mii_lpa_to_ethtool_lpa_x) + +/** + * mii_lpa_to_ethtool_lpa_x + * @adv: value of the MII_LPA register + * + * A small helper function that translates MII_LPA + * bits, when in 1000Base-X mode, to ethtool + * LP advertisement settings. + */ +static inline u32 mii_lpa_to_ethtool_lpa_x(u32 lpa) +{ + u32 result = 0; + + if (lpa & LPA_LPACK) + result |= ADVERTISED_Autoneg; + + return result | mii_adv_to_ethtool_adv_x(lpa); +} + +/** + * ethtool_rxfh_indir_default - get default value for RX flow hash indirection + * @index: Index in RX flow hash indirection table + * @n_rx_rings: Number of RX rings to use + * + * This function provides the default policy for RX flow hash indirection. + */ +static inline u32 ethtool_rxfh_indir_default(u32 index, u32 n_rx_rings) +{ + return index % n_rx_rings; +} + +#define ETHTOOL_FWVERS_LEN 32 + +#if !((LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,9) && LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0)) || (LINUX_VERSION_CODE >= KERNEL_VERSION(3,0,23) && LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))) +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,37)) +/* mask qdisc_cb_private_validate as RHEL6 backports this */ +#define qdisc_cb_private_validate(a,b) compat_qdisc_cb_private_validate(a,b) +static inline void qdisc_cb_private_validate(const struct sk_buff *skb, int sz) +{ + BUILD_BUG_ON(sizeof(skb->cb) < sizeof(struct qdisc_skb_cb) + sz); +} +#else +/* mask qdisc_cb_private_validate as RHEL6 backports this */ +#define qdisc_cb_private_validate(a,b) compat_qdisc_cb_private_validate(a,b) +static inline void qdisc_cb_private_validate(const struct sk_buff *skb, int sz) +{ + /* XXX ? */ +} +#endif +#endif + +#define __pskb_copy LINUX_BACKPORT(__pskb_copy) +extern struct sk_buff *__pskb_copy(struct sk_buff *skb, + int headroom, gfp_t gfp_mask); + +static inline void skb_complete_wifi_ack(struct sk_buff *skb, bool acked) +{ + WARN_ON(1); +} +#define NL80211_FEATURE_SK_TX_STATUS 0 + +typedef u32 netdev_features_t; + +/* source include/linux/device.h */ +/** + * module_driver() - Helper macro for drivers that don't do anything + * special in module init/exit. This eliminates a lot of boilerplate. + * Each module may only use this macro once, and calling it replaces + * module_init() and module_exit(). + * + * Use this macro to construct bus specific macros for registering + * drivers, and do not use it on its own. + */ +#define module_driver(__driver, __register, __unregister) \ +static int __init __driver##_init(void) \ +{ \ + return __register(&(__driver)); \ +} \ +module_init(__driver##_init); \ +static void __exit __driver##_exit(void) \ +{ \ + __unregister(&(__driver)); \ +} \ +module_exit(__driver##_exit); + +/* source include/linux/usb.h */ +/** + * module_usb_driver() - Helper macro for registering a USB driver + * @__usb_driver: usb_driver struct + * + * Helper macro for USB drivers which do not do anything special in module + * init/exit. This eliminates a lot of boilerplate. Each module may only + * use this macro once, and calling it replaces module_init() and module_exit() + */ +#define module_usb_driver(__usb_driver) \ + module_driver(__usb_driver, usb_register, \ + usb_deregister) + + +/* + * PCI_EXP_TYPE_RC_EC was added via 1b6b8ce2 on v2.6.30-rc4~20 : + * + * mcgrof@frijol ~/linux-next (git::master)$ git describe --contains 1b6b8ce2 + * v2.6.30-rc4~20^2 + * + * but the fix for its definition was merged on v3.3-rc1~101^2~67 + * + * mcgrof@frijol ~/linux-next (git::master)$ git describe --contains 1830ea91 + * v3.3-rc1~101^2~67 + * + * while we can assume it got merged and backported on v3.2.28 (which it did + * see c1c3cd9) we cannot assume every kernel has it fixed so lets just undef + * it here and redefine it. + */ +#undef PCI_EXP_TYPE_RC_EC +#define PCI_EXP_TYPE_RC_EC 0xa /* Root Complex Event Collector */ + + +/* This backports: + * + * commit 7c92784a546d2945b6d6973a30f7134be78eb7a4 + * Author: Lars-Peter Clausen + * Date: Wed Nov 16 10:13:36 2011 +0100 + * + * I2C: Add helper macro for i2c_driver boilerplate + */ +/** + * module_i2c_driver() - Helper macro for registering a I2C driver + * @__i2c_driver: i2c_driver struct + * + * Helper macro for I2C drivers which do not do anything special in module + * init/exit. This eliminates a lot of boilerplate. Each module may only + * use this macro once, and calling it replaces module_init() and module_exit() + */ +#define module_i2c_driver(__i2c_driver) \ + module_driver(__i2c_driver, i2c_add_driver, \ + i2c_del_driver) + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0)) */ + +#endif /* LINUX_3_3_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-3.4.h b/backport/backport-include/linux/compat-3.4.h new file mode 100644 index 000000000000..a152d517a824 --- /dev/null +++ b/backport/backport-include/linux/compat-3.4.h @@ -0,0 +1,225 @@ +#ifndef LINUX_3_4_COMPAT_H +#define LINUX_3_4_COMPAT_H + +#include + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,4,0)) + +#include +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0)) +/* need to import it, but it only exists since kernel 3.1 */ +#include +#endif + +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0)) +#if defined(CONFIG_REGMAP) +#include +#define devm_regmap_init LINUX_BACKPORT(devm_regmap_init) +struct regmap *devm_regmap_init(struct device *dev, + const struct regmap_bus *bus, + const struct regmap_config *config); +#if defined(CONFIG_REGMAP_I2C) +#define devm_regmap_init_i2c LINUX_BACKPORT(devm_regmap_init_i2c) +struct regmap *devm_regmap_init_i2c(struct i2c_client *i2c, + const struct regmap_config *config); +#endif /* defined(CONFIG_REGMAP_I2C) */ +#if defined(CONFIG_REGMAP_SPI) +#define devm_regmap_init_spi LINUX_BACKPORT(devm_regmap_init_spi) +struct regmap *devm_regmap_init_spi(struct spi_device *dev, + const struct regmap_config *config); +#endif /* defined(CONFIG_REGMAP_SPI) */ + +/* + * We can't backport these unless we try to backport + * the full regmap into core so warn if used. + * No drivers are using this yet anyway. + */ +#define regmap_raw_write_async LINUX_BACKPORT(regmap_raw_write_async) +static inline int regmap_raw_write_async(struct regmap *map, unsigned int reg, + const void *val, size_t val_len) +{ + WARN_ONCE(1, "regmap API is disabled"); + return -EINVAL; +} + +#define regmap_async_complete LINUX_BACKPORT(regmap_async_complete) +static inline void regmap_async_complete(struct regmap *map) +{ + WARN_ONCE(1, "regmap API is disabled"); +} + +#endif /* defined(CONFIG_REGMAP) */ +#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0)) */ + +/* + * defined here to allow things to compile but technically + * using this for memory regions will yield in a no-op on newer + * kernels but on older kernels (v3.3 and older) this bit was used + * for VM_ALWAYSDUMP. The goal was to remove this bit moving forward + * and since we can't skip the core dump on old kernels we just make + * this bit name now a no-op. + * + * For details see commits: 909af7 accb61fe cdaaa7003 + */ +#define VM_NODUMP 0x0 + +/* This backports: + * + * commit 63b2001169e75cd71e917ec953fdab572e3f944a + * Author: Thomas Gleixner + * Date: Thu Dec 1 00:04:00 2011 +0100 + + * sched/wait: Add __wake_up_all_locked() API + */ +#include +extern void compat_wake_up_locked(wait_queue_head_t *q, unsigned int mode, int nr); +#define wake_up_all_locked(x) compat_wake_up_locked((x), TASK_NORMAL, 0) + +/* This backports: + * + * commit a8203725dfded5c1f79dca3368a4a273e24b59bb + * Author: Xi Wang + * Date: Mon Mar 5 15:14:41 2012 -0800 + * + * slab: introduce kmalloc_array() + */ + +/* SIZE_MAX is backported in compat-3.5.h so include it */ +#include +#define kmalloc_array LINUX_BACKPORT(kmalloc_array) +static inline void *kmalloc_array(size_t n, size_t size, gfp_t flags) +{ + if (size != 0 && n > SIZE_MAX / size) + return NULL; + return __kmalloc(n * size, flags); +} + +#include +#include + +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34)) +#define i2c_bit_algo LINUX_BACKPORT(i2c_bit_algo) +extern const struct i2c_algorithm i2c_bit_algo; +#endif + +#define simple_open LINUX_BACKPORT(simple_open) +extern int simple_open(struct inode *inode, struct file *file); + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)) +#define skb_add_rx_frag(skb, i, page, off, size, truesize) \ + v2_6_28_skb_add_rx_frag(skb, i, page, off, size) +#else +#define skb_add_rx_frag(skb, i, page, off, size, truesize) \ + skb_add_rx_frag(skb, i, page, off, size) +#endif + +#ifdef CONFIG_X86_X32_ABI +#define COMPAT_USE_64BIT_TIME \ + (!!(task_pt_regs(current)->orig_ax & __X32_SYSCALL_BIT)) +#else +#define COMPAT_USE_64BIT_TIME 0 +#endif + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,12)) +#define eth_hw_addr_random LINUX_BACKPORT(eth_hw_addr_random) +static inline void eth_hw_addr_random(struct net_device *dev) +{ +#error eth_hw_addr_random() needs to be implemented for < 2.6.12 +} +#else /* kernels >= 2.6.12 */ + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,31)) +#define eth_hw_addr_random LINUX_BACKPORT(eth_hw_addr_random) +static inline void eth_hw_addr_random(struct net_device *dev) +{ + get_random_bytes(dev->dev_addr, ETH_ALEN); + dev->dev_addr[0] &= 0xfe; /* clear multicast bit */ + dev->dev_addr[0] |= 0x02; /* set local assignment bit (IEEE802) */ +} +#else /* kernels >= 2.6.31 */ + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36)) +/* So this is 2.6.31..2.6.35 */ + +/* Just have the flags present, they won't really mean anything though */ +#define NET_ADDR_PERM 0 /* address is permanent (default) */ +#define NET_ADDR_RANDOM 1 /* address is generated randomly */ +#define NET_ADDR_STOLEN 2 /* address is stolen from other device */ + +#define eth_hw_addr_random LINUX_BACKPORT(eth_hw_addr_random) +static inline void eth_hw_addr_random(struct net_device *dev) +{ + random_ether_addr(dev->dev_addr); +} + +#else /* 2.6.36 and on */ +#define eth_hw_addr_random LINUX_BACKPORT(eth_hw_addr_random) +static inline void eth_hw_addr_random(struct net_device *dev) +{ + dev_hw_addr_random(dev, dev->dev_addr); +} +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,31)) */ + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,31)) */ +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,12)) */ + +/* source include/linux/pci.h */ +/** + * module_pci_driver() - Helper macro for registering a PCI driver + * @__pci_driver: pci_driver struct + * + * Helper macro for PCI drivers which do not do anything special in module + * init/exit. This eliminates a lot of boilerplate. Each module may only + * use this macro once, and calling it replaces module_init() and module_exit() + */ +#define module_pci_driver(__pci_driver) \ + module_driver(__pci_driver, pci_register_driver, \ + pci_unregister_driver) + +/* + * Getting something that works in C and CPP for an arg that may or may + * not be defined is tricky. Here, if we have "#define CONFIG_BOOGER 1" + * we match on the placeholder define, insert the "0," for arg1 and generate + * the triplet (0, 1, 0). Then the last step cherry picks the 2nd arg (a one). + * When CONFIG_BOOGER is not defined, we generate a (... 1, 0) pair, and when + * the last step cherry picks the 2nd arg, we get a zero. + */ +#define __ARG_PLACEHOLDER_1 0, +#define config_enabled(cfg) _config_enabled(cfg) +#define _config_enabled(value) __config_enabled(__ARG_PLACEHOLDER_##value) +#define __config_enabled(arg1_or_junk) ___config_enabled(arg1_or_junk 1, 0) +#define ___config_enabled(__ignored, val, ...) val + +/* 3.1 - 3.3 had a broken version of this, so undef */ +#undef IS_ENABLED +#define IS_ENABLED(option) \ + (config_enabled(option) || config_enabled(option##_MODULE)) + +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,31)) +/* + * Return true if it is guaranteed that poll will not wait. This is the case + * if the poll() of another file descriptor in the set got an event, so there + * is no need for waiting. + */ +#define poll_does_not_wait LINUX_BACKPORT(poll_does_not_wait) +static inline bool poll_does_not_wait(const poll_table *p) +{ + return p == NULL || p->qproc == NULL; +} + +/* + * Return the set of events that the application wants to poll for. + * This is useful for drivers that need to know whether a DMA transfer has + * to be started implicitly on poll(). You typically only want to do that + * if the application is actually polling for POLLIN and/or POLLOUT. + */ +#define poll_requested_events LINUX_BACKPORT(poll_requested_events) +static inline unsigned long poll_requested_events(const poll_table *p) +{ + return p ? p->key : ~0UL; +} +#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,31)) */ + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(3,4,0)) */ + +#endif /* LINUX_5_4_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-3.5.h b/backport/backport-include/linux/compat-3.5.h new file mode 100644 index 000000000000..e21048dd3fd1 --- /dev/null +++ b/backport/backport-include/linux/compat-3.5.h @@ -0,0 +1,378 @@ +#ifndef LINUX_3_5_COMPAT_H +#define LINUX_3_5_COMPAT_H + +#include +#include +#include +#include + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0)) + +#include + +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0)) +#include + +#define dev_get_regmap LINUX_BACKPORT(dev_get_regmap) +static inline +struct regmap *dev_get_regmap(struct device *dev, const char *name) +{ + return NULL; +} + +#define devres_release LINUX_BACKPORT(devres_release) +extern int devres_release(struct device *dev, dr_release_t release, + dr_match_t match, void *match_data); +#endif + +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)) +#include +#define dev_level_ratelimited(dev_level, dev, fmt, ...) \ +do { \ + static DEFINE_RATELIMIT_STATE(_rs, \ + DEFAULT_RATELIMIT_INTERVAL, \ + DEFAULT_RATELIMIT_BURST); \ + if (__ratelimit(&_rs)) \ + dev_level(dev, fmt, ##__VA_ARGS__); \ +} while (0) + +#define dev_emerg_ratelimited(dev, fmt, ...) \ + dev_level_ratelimited(dev_emerg, dev, fmt, ##__VA_ARGS__) +#define dev_alert_ratelimited(dev, fmt, ...) \ + dev_level_ratelimited(dev_alert, dev, fmt, ##__VA_ARGS__) + + +#if defined(CONFIG_DYNAMIC_DEBUG) || defined(DEBUG) +#define dev_dbg_ratelimited(dev, fmt, ...) \ +do { \ + static DEFINE_RATELIMIT_STATE(_rs, \ + DEFAULT_RATELIMIT_INTERVAL, \ + DEFAULT_RATELIMIT_BURST); \ + DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt); \ + if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT) && \ + __ratelimit(&_rs)) \ + __dynamic_pr_debug(&descriptor, pr_fmt(fmt), \ + ##__VA_ARGS__); \ +} while (0) +#else +#define dev_dbg_ratelimited(dev, fmt, ...) \ + no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__) +#endif + +#endif + +/* + * This backports: + * commit 569a8fc38367dfafd87454f27ac646c8e6b54bca + * Author: David S. Miller + * Date: Thu Mar 29 23:18:53 2012 -0400 + * + * netlink: Add nla_put_be{16,32,64}() helpers. + */ + +static inline int nla_put_be16(struct sk_buff *skb, int attrtype, __be16 value) +{ + return nla_put(skb, attrtype, sizeof(__be16), &value); +} + +static inline int nla_put_be32(struct sk_buff *skb, int attrtype, __be32 value) +{ + return nla_put(skb, attrtype, sizeof(__be32), &value); +} + +static inline int nla_put_be64(struct sk_buff *skb, int attrtype, __be64 value) +{ + return nla_put(skb, attrtype, sizeof(__be64), &value); +} + +/* + * This backports: + * + * commit f56f821feb7b36223f309e0ec05986bb137ce418 + * Author: Daniel Vetter + * Date: Sun Mar 25 19:47:41 2012 +0200 + * + * mm: extend prefault helpers to fault in more than PAGE_SIZE + * + * The new functions are used by drm/i915 driver. + * + */ + +static inline int fault_in_multipages_writeable(char __user *uaddr, int size) +{ + int ret = 0; + char __user *end = uaddr + size - 1; + + if (unlikely(size == 0)) + return ret; + + /* + * Writing zeroes into userspace here is OK, because we know that if + * the zero gets there, we'll be overwriting it. + */ + while (uaddr <= end) { + ret = __put_user(0, uaddr); + if (ret != 0) + return ret; + uaddr += PAGE_SIZE; + } + + /* Check whether the range spilled into the next page. */ + if (((unsigned long)uaddr & PAGE_MASK) == + ((unsigned long)end & PAGE_MASK)) + ret = __put_user(0, end); + + return ret; +} + +static inline int fault_in_multipages_readable(const char __user *uaddr, + int size) +{ + volatile char c; + int ret = 0; + const char __user *end = uaddr + size - 1; + + if (unlikely(size == 0)) + return ret; + + while (uaddr <= end) { + ret = __get_user(c, uaddr); + if (ret != 0) + return ret; + uaddr += PAGE_SIZE; + } + + /* Check whether the range spilled into the next page. */ + if (((unsigned long)uaddr & PAGE_MASK) == + ((unsigned long)end & PAGE_MASK)) { + ret = __get_user(c, end); + (void)c; + } + + return ret; +} + +/* switcheroo is available on >= 2.6.34 */ +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34)) +#include +/* + * This backports: + * + * From 26ec685ff9d9c16525d8ec4c97e52fcdb187b302 Mon Sep 17 00:00:00 2001 + * From: Takashi Iwai + * Date: Fri, 11 May 2012 07:51:17 +0200 + * Subject: [PATCH] vga_switcheroo: Introduce struct vga_switcheroo_client_ops + * + */ + +struct vga_switcheroo_client_ops { + void (*set_gpu_state)(struct pci_dev *dev, enum vga_switcheroo_state); + void (*reprobe)(struct pci_dev *dev); + bool (*can_switch)(struct pci_dev *dev); +}; + +/* Wrap around the old code and redefine vga_switcheroo_register_client() + * for older kernels < 3.5.0. + */ +static inline int compat_vga_switcheroo_register_client(struct pci_dev *dev, + const struct vga_switcheroo_client_ops *ops) { + + return vga_switcheroo_register_client(dev, + ops->set_gpu_state, +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,38)) + ops->reprobe, +#endif + ops->can_switch); +} + +#define vga_switcheroo_register_client(_dev, _ops) \ + compat_vga_switcheroo_register_client(_dev, _ops) + +#endif + +/* This backports + * + * commit 14674e70119ea01549ce593d8901a797f8a90f74 + * Author: Mark Brown + * Date: Wed May 30 10:55:34 2012 +0200 + * + * i2c: Split I2C_M_NOSTART support out of I2C_FUNC_PROTOCOL_MANGLING + */ + +#define I2C_FUNC_NOSTART 0x00000010 /* I2C_M_NOSTART */ + +/* + * This backports: + * + * From a3860c1c5dd1137db23d7786d284939c5761d517 Mon Sep 17 00:00:00 2001 + * From: Xi Wang + * Date: Thu, 31 May 2012 16:26:04 -0700 + * Subject: [PATCH] introduce SIZE_MAX + */ + +#define SIZE_MAX (~(size_t)0) + + +#include + +/* + * This backports: + * + * From 76e3cc126bb223013a6b9a0e2a51238d1ef2e409 Mon Sep 17 00:00:00 2001 + * From: Eric Dumazet + * Date: Thu, 10 May 2012 07:51:25 +0000 + * Subject: [PATCH] codel: Controlled Delay AQM + */ + +#ifndef TCA_CODEL_MAX +/* CODEL */ + +#define COMPAT_CODEL_BACKPORT + +enum { + TCA_CODEL_UNSPEC, + TCA_CODEL_TARGET, + TCA_CODEL_LIMIT, + TCA_CODEL_INTERVAL, + TCA_CODEL_ECN, + __TCA_CODEL_MAX +}; + +#define TCA_CODEL_MAX (__TCA_CODEL_MAX - 1) + +struct tc_codel_xstats { + __u32 maxpacket; /* largest packet we've seen so far */ + __u32 count; /* how many drops we've done since the last time we + * entered dropping state + */ + __u32 lastcount; /* count at entry to dropping state */ + __u32 ldelay; /* in-queue delay seen by most recently dequeued packet */ + __s32 drop_next; /* time to drop next packet */ + __u32 drop_overlimit; /* number of time max qdisc packet limit was hit */ + __u32 ecn_mark; /* number of packets we ECN marked instead of dropped */ + __u32 dropping; /* are we in dropping state ? */ +}; + +/* This backports: + * + * commit 4b549a2ef4bef9965d97cbd992ba67930cd3e0fe + * Author: Eric Dumazet + * Date: Fri May 11 09:30:50 2012 +0000 + * fq_codel: Fair Queue Codel AQM + */ + +/* FQ_CODEL */ + +enum { + TCA_FQ_CODEL_UNSPEC, + TCA_FQ_CODEL_TARGET, + TCA_FQ_CODEL_LIMIT, + TCA_FQ_CODEL_INTERVAL, + TCA_FQ_CODEL_ECN, + TCA_FQ_CODEL_FLOWS, + TCA_FQ_CODEL_QUANTUM, + __TCA_FQ_CODEL_MAX +}; + +#define TCA_FQ_CODEL_MAX (__TCA_FQ_CODEL_MAX - 1) + +enum { + TCA_FQ_CODEL_XSTATS_QDISC, + TCA_FQ_CODEL_XSTATS_CLASS, +}; + +struct tc_fq_codel_qd_stats { + __u32 maxpacket; /* largest packet we've seen so far */ + __u32 drop_overlimit; /* number of time max qdisc + * packet limit was hit + */ + __u32 ecn_mark; /* number of packets we ECN marked + * instead of being dropped + */ + __u32 new_flow_count; /* number of time packets + * created a 'new flow' + */ + __u32 new_flows_len; /* count of flows in new list */ + __u32 old_flows_len; /* count of flows in old list */ +}; + +struct tc_fq_codel_cl_stats { + __s32 deficit; + __u32 ldelay; /* in-queue delay seen by most recently + * dequeued packet + */ + __u32 count; + __u32 lastcount; + __u32 dropping; + __s32 drop_next; +}; + +struct tc_fq_codel_xstats { + __u32 type; + union { + struct tc_fq_codel_qd_stats qdisc_stats; + struct tc_fq_codel_cl_stats class_stats; + }; +}; +#endif /* TCA_CODEL_MAX */ + +/* Backport ether_addr_equal */ +static inline bool ether_addr_equal(const u8 *addr1, const u8 *addr2) +{ + return !compare_ether_addr(addr1, addr2); +} + +#define net_ratelimited_function(function, ...) \ +do { \ + if (net_ratelimit()) \ + function(__VA_ARGS__); \ +} while (0) + +#define net_emerg_ratelimited(fmt, ...) \ + net_ratelimited_function(pr_emerg, fmt, ##__VA_ARGS__) +#define net_alert_ratelimited(fmt, ...) \ + net_ratelimited_function(pr_alert, fmt, ##__VA_ARGS__) +#define net_crit_ratelimited(fmt, ...) \ + net_ratelimited_function(pr_crit, fmt, ##__VA_ARGS__) +#define net_err_ratelimited(fmt, ...) \ + net_ratelimited_function(pr_err, fmt, ##__VA_ARGS__) +#define net_notice_ratelimited(fmt, ...) \ + net_ratelimited_function(pr_notice, fmt, ##__VA_ARGS__) +#define net_warn_ratelimited(fmt, ...) \ + net_ratelimited_function(pr_warn, fmt, ##__VA_ARGS__) +#define net_info_ratelimited(fmt, ...) \ + net_ratelimited_function(pr_info, fmt, ##__VA_ARGS__) +#define net_dbg_ratelimited(fmt, ...) \ + net_ratelimited_function(pr_debug, fmt, ##__VA_ARGS__) + +#define ktime_get_monotonic_offset LINUX_BACKPORT(ktime_get_monotonic_offset) +extern ktime_t ktime_get_monotonic_offset(void); + +/* This backports: + * + * commit 2033e9bf06f07e049bbc77e9452856df846714cc + * Author: Neil Horman + * Date: Tue May 29 09:30:40 2012 +0000 + * + * net: add MODULE_ALIAS_NET_PF_PROTO_NAME + */ + +#define MODULE_ALIAS_NET_PF_PROTO_NAME(pf, proto, name) \ + MODULE_ALIAS("net-pf-" __stringify(pf) "-proto-" __stringify(proto) \ + name) + +/* This backports: + * + * commit e9412c37082b5c932e83364aaed0c38c2ce33acb + * Author: Neil Horman + * Date: Tue May 29 09:30:41 2012 +0000 + * + * genetlink: Build a generic netlink family module alias + */ + +#define MODULE_ALIAS_GENL_FAMILY(family)\ + MODULE_ALIAS_NET_PF_PROTO_NAME(PF_NETLINK, NETLINK_GENERIC, "-family-" family) + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0)) */ + +#endif /* LINUX_3_5_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-3.6.h b/backport/backport-include/linux/compat-3.6.h new file mode 100644 index 000000000000..f2c1a9098e82 --- /dev/null +++ b/backport/backport-include/linux/compat-3.6.h @@ -0,0 +1,138 @@ +#ifndef LINUX_3_6_COMPAT_H +#define LINUX_3_6_COMPAT_H + +#include + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0)) + +#include + +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0)) +#include +#include +/* Unlocked flavor */ +#define __i2c_transfer LINUX_BACKPORT(__i2c_transfer) +extern int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, + int num); +#endif + + +#define memweight LINUX_BACKPORT(memweight) +extern size_t memweight(const void *ptr, size_t bytes); + +/* backports efc42bc9 */ +#define sg_alloc_table_from_pages LINUX_BACKPORT(sg_alloc_table_from_pages) +int sg_alloc_table_from_pages(struct sg_table *sgt, + struct page **pages, unsigned int n_pages, + unsigned long offset, unsigned long size, + gfp_t gfp_mask); + +#define dma_common_get_sgtable LINUX_BACKPORT(dma_common_get_sgtable) +int +dma_common_get_sgtable(struct device *dev, struct sg_table *sgt, + void *cpu_addr, dma_addr_t dma_addr, size_t size); + +#define dma_get_sgtable_attrs LINUX_BACKPORT(dma_get_sgtable_attrs) +static inline int +dma_get_sgtable_attrs(struct device *dev, struct sg_table *sgt, void *cpu_addr, + dma_addr_t dma_addr, size_t size, struct dma_attrs *attrs) +{ + return dma_common_get_sgtable(dev, sgt, cpu_addr, dma_addr, size); +} + +#define dma_get_sgtable(d, t, v, h, s) dma_get_sgtable_attrs(d, t, v, h, s, NULL) + + +/** + * Backports + * + * commit d81a5d1956731c453b85c141458d4ff5d6cc5366 + * Author: Gustavo Padovan + * Date: Tue Jul 10 19:10:06 2012 -0300 + * + * USB: add USB_VENDOR_AND_INTERFACE_INFO() macro + */ +#include +#define USB_VENDOR_AND_INTERFACE_INFO(vend, cl, sc, pr) \ + .match_flags = USB_DEVICE_ID_MATCH_INT_INFO \ + | USB_DEVICE_ID_MATCH_VENDOR, \ + .idVendor = (vend), \ + .bInterfaceClass = (cl), \ + .bInterfaceSubClass = (sc), \ + .bInterfaceProtocol = (pr) + +/** + * Backports + * + * commit cdcac9cd7741af2c2b9255cbf060f772596907bb + * Author: Dave Airlie + * Date: Wed Jun 27 08:35:52 2012 +0100 + * + * pci_regs: define LNKSTA2 pcie cap + bits. + * + * We need these for detecting the max link speed for drm drivers. + * + * Acked-by: Bjorn Helgaas + * Signed-off-by: Dave Airlie + */ + +#define PCI_EXP_LNKCAP2 44 /* Link Capability 2 */ +#define PCI_EXP_LNKCAP2_SLS_2_5GB 0x01 /* Current Link Speed 2.5GT/s */ +#define PCI_EXP_LNKCAP2_SLS_5_0GB 0x02 /* Current Link Speed 5.0GT/s */ +#define PCI_EXP_LNKCAP2_SLS_8_0GB 0x04 /* Current Link Speed 8.0GT/s */ +#define PCI_EXP_LNKCAP2_CROSSLINK 0x100 /* Crosslink supported */ + +#include +#include + +/** + * eth_broadcast_addr - Assign broadcast address + * @addr: Pointer to a six-byte array containing the Ethernet address + * + * Assign the broadcast address to the given address array. + */ +static inline void eth_broadcast_addr(u8 *addr) +{ + memset(addr, 0xff, ETH_ALEN); +} + +/** + * eth_random_addr - Generate software assigned random Ethernet address + * @addr: Pointer to a six-byte array containing the Ethernet address + * + * Generate a random Ethernet address (MAC) that is not multicast + * and has the local assigned bit set. + */ +static inline void eth_random_addr(u8 *addr) +{ + get_random_bytes(addr, ETH_ALEN); + addr[0] &= 0xfe; /* clear multicast bit */ + addr[0] |= 0x02; /* set local assignment bit (IEEE802) */ +} + +#define GENLMSG_DEFAULT_SIZE (NLMSG_DEFAULT_SIZE - GENL_HDRLEN) + +/* + * Backports + * + * commit 959d62fa865d2e616b61a509e1cc5b88741f065e + * Author: Shuah Khan + * Date: Thu Jun 14 04:34:30 2012 +0800 + * + * leds: Rename led_brightness_set() to led_set_brightness() + * + * Rename leds external interface led_brightness_set() to led_set_brightness(). + * This is the second phase of the change to reduce confusion between the + * leds internal and external interfaces that set brightness. With this change, + * now the external interface is led_set_brightness(). The first phase renamed + * the internal interface led_set_brightness() to __led_set_brightness(). + * There are no changes to the interface implementations. + * + * Signed-off-by: Shuah Khan + * Signed-off-by: Bryan Wu + */ +#define led_set_brightness(_dev, _switch) led_brightness_set(_dev, _switch) + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0)) */ + +#endif /* LINUX_3_6_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-3.7.h b/backport/backport-include/linux/compat-3.7.h new file mode 100644 index 000000000000..c7a4ebc2ee1c --- /dev/null +++ b/backport/backport-include/linux/compat-3.7.h @@ -0,0 +1,218 @@ +#ifndef LINUX_3_7_COMPAT_H +#define LINUX_3_7_COMPAT_H + +#include + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,7,0)) + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define VM_DONTDUMP VM_NODUMP + +#define IORESOURCE_REG 0x00000300 /* Register offsets */ + +#ifdef CONFIG_USER_NS + +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,38)) +static inline struct user_namespace *seq_user_ns(struct seq_file *seq) +{ + struct file *f = container_of((void *) seq, struct file, private_data); + + return f->f_cred->user_ns; +} +#else +static inline struct user_namespace *seq_user_ns(struct seq_file *seq) +{ + return current_user_ns(); +} +#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,38)) */ + +#else +static inline struct user_namespace *seq_user_ns(struct seq_file *seq) +{ + extern struct user_namespace init_user_ns; + return &init_user_ns; +} +#endif /* CONFIG_USER_NS */ + +#define netlink_notify_portid(__notify) (__notify->pid) +#define genl_info_snd_portid(__genl_info) (__genl_info->snd_pid) +#define NETLINK_CB_PORTID(__skb) NETLINK_CB(cb->skb).pid + +#define mod_delayed_work LINUX_BACKPORT(mod_delayed_work) +bool mod_delayed_work(struct workqueue_struct *wq, struct delayed_work *dwork, + unsigned long delay); + +/* Backports tty_lock: Localise the lock */ +#define tty_lock(__tty) tty_lock() +#define tty_unlock(__tty) tty_unlock() + +#define tty_port_register_device(port, driver, index, device) \ + tty_register_device(driver, index, device) + +#define pcie_capability_read_word LINUX_BACKPORT(pcie_capability_read_word) +int pcie_capability_read_word(struct pci_dev *dev, int pos, u16 *val); +#define pcie_capability_read_dword LINUX_BACKPORT(pcie_capability_read_dword) +int pcie_capability_read_dword(struct pci_dev *dev, int pos, u32 *val); +#define pcie_capability_write_word LINUX_BACKPORT(pcie_capability_write_word) +int pcie_capability_write_word(struct pci_dev *dev, int pos, u16 val); +#define pcie_capability_write_dword LINUX_BACKPORT(pcie_capability_write_dword) +int pcie_capability_write_dword(struct pci_dev *dev, int pos, u32 val); +#define pcie_capability_clear_and_set_word LINUX_BACKPORT(pcie_capability_clear_and_set_word) +int pcie_capability_clear_and_set_word(struct pci_dev *dev, int pos, + u16 clear, u16 set); +#define pcie_capability_clear_and_set_dword LINUX_BACKPORT(pcie_capability_clear_and_set_dword) +int pcie_capability_clear_and_set_dword(struct pci_dev *dev, int pos, + u32 clear, u32 set); + +static inline int pcie_capability_set_word(struct pci_dev *dev, int pos, + u16 set) +{ + return pcie_capability_clear_and_set_word(dev, pos, 0, set); +} + +static inline int pcie_capability_set_dword(struct pci_dev *dev, int pos, + u32 set) +{ + return pcie_capability_clear_and_set_dword(dev, pos, 0, set); +} + +static inline int pcie_capability_clear_word(struct pci_dev *dev, int pos, + u16 clear) +{ + return pcie_capability_clear_and_set_word(dev, pos, clear, 0); +} + +static inline int pcie_capability_clear_dword(struct pci_dev *dev, int pos, + u32 clear) +{ + return pcie_capability_clear_and_set_dword(dev, pos, clear, 0); +} + +#define PCI_EXP_LNKSTA2 50 /* Link Status 2 */ + +/* This backports: + * + * commit 6d57e9078e880a3dd232d579f42ac437a8f1ef7b + * Author: Duan Jiong + * Date: Sat Sep 8 16:32:28 2012 +0000 + * + * etherdevice: introduce help function eth_zero_addr() + */ +/** + * eth_zero_addr - Assign zero address + * @addr: Pointer to a six-byte array containing the Ethernet address + * + * Assign the zero address to the given address array. + */ +static inline void eth_zero_addr(u8 *addr) +{ + memset(addr, 0x00, ETH_ALEN); +} + +/** + * nla_put_s8 - Add a s8 netlink attribute to a socket buffer + * @skb: socket buffer to add attribute to + * @attrtype: attribute type + * @value: numeric value + */ +static inline int nla_put_s8(struct sk_buff *skb, int attrtype, s8 value) +{ + return nla_put(skb, attrtype, sizeof(s8), &value); +} + +/** + * nla_put_s16 - Add a s16 netlink attribute to a socket buffer + * @skb: socket buffer to add attribute to + * @attrtype: attribute type + * @value: numeric value + */ +static inline int nla_put_s16(struct sk_buff *skb, int attrtype, s16 value) +{ + return nla_put(skb, attrtype, sizeof(s16), &value); +} + +/** + * nla_put_s32 - Add a s32 netlink attribute to a socket buffer + * @skb: socket buffer to add attribute to + * @attrtype: attribute type + * @value: numeric value + */ +static inline int nla_put_s32(struct sk_buff *skb, int attrtype, s32 value) +{ + return nla_put(skb, attrtype, sizeof(s32), &value); +} + +/** + * nla_put_s64 - Add a s64 netlink attribute to a socket buffer + * @skb: socket buffer to add attribute to + * @attrtype: attribute type + * @value: numeric value + */ +static inline int nla_put_s64(struct sk_buff *skb, int attrtype, s64 value) +{ + return nla_put(skb, attrtype, sizeof(s64), &value); +} + +/** + * nla_get_s32 - return payload of s32 attribute + * @nla: s32 netlink attribute + */ +static inline s32 nla_get_s32(const struct nlattr *nla) +{ + return *(s32 *) nla_data(nla); +} + +/** + * nla_get_s16 - return payload of s16 attribute + * @nla: s16 netlink attribute + */ +static inline s16 nla_get_s16(const struct nlattr *nla) +{ + return *(s16 *) nla_data(nla); +} + +/** + * nla_get_s8 - return payload of s8 attribute + * @nla: s8 netlink attribute + */ +static inline s8 nla_get_s8(const struct nlattr *nla) +{ + return *(s8 *) nla_data(nla); +} + +/** + * nla_get_s64 - return payload of s64 attribute + * @nla: s64 netlink attribute + */ +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29)) +static inline s64 nla_get_s64(const struct nlattr *nla) +#else +static inline s64 nla_get_s64(struct nlattr *nla) +#endif +{ + s64 tmp; + + nla_memcpy(&tmp, nla, sizeof(tmp)); + + return tmp; +} + +#define PLATFORM_DEVID_NONE (-1) +#define PLATFORM_DEVID_AUTO (-1) + +#else /* (LINUX_VERSION_CODE > KERNEL_VERSION(3,7,0)) */ +#define netlink_notify_portid(__notify) (__notify->portid) +#define genl_info_snd_portid(__genl_info) (__genl_info->snd_portid) +#define NETLINK_CB_PORTID(__skb) NETLINK_CB(cb->skb).portid +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(3,7,0)) */ + +#endif /* LINUX_3_7_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-3.8.h b/backport/backport-include/linux/compat-3.8.h new file mode 100644 index 000000000000..55fdc165422f --- /dev/null +++ b/backport/backport-include/linux/compat-3.8.h @@ -0,0 +1,131 @@ +#ifndef LINUX_3_8_COMPAT_H +#define LINUX_3_8_COMPAT_H + +#include + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,8,0)) + +#include +#include +#include +#include + +/* backports 496f2f9 */ +#define prandom_seed(_seed) srandom32(_seed) +#define prandom_u32() random32() +#define prandom_u32_state(_state) prandom32(_state) + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,7,8)) +#define netdev_set_default_ethtool_ops LINUX_BACKPORT(netdev_set_default_ethtool_ops) +extern void netdev_set_default_ethtool_ops(struct net_device *dev, + const struct ethtool_ops *ops); +#endif + +#define HID_BUS_ANY 0xffff +#define HID_GROUP_ANY 0x0000 + +#define PCI_EXP_LNKCTL_ASPM_L0S 0x01 /* L0s Enable */ +#define PCI_EXP_LNKCTL_ASPM_L1 0x02 /* L1 Enable */ + +#define hid_ignore LINUX_BACKPORT(hid_ignore) +extern bool hid_ignore(struct hid_device *); + +/* This backports: + * + * commit 4b20db3de8dab005b07c74161cb041db8c5ff3a7 + * Author: Thomas Hellstrom + * Date: Tue Nov 6 11:31:49 2012 +0000 + * + * kref: Implement kref_get_unless_zero v3 + */ +/** + * kref_get_unless_zero - Increment refcount for object unless it is zero. + * @kref: object. + * + * Return non-zero if the increment succeeded. Otherwise return 0. + * + * This function is intended to simplify locking around refcounting for + * objects that can be looked up from a lookup structure, and which are + * removed from that lookup structure in the object destructor. + * Operations on such objects require at least a read lock around + * lookup + kref_get, and a write lock around kref_put + remove from lookup + * structure. Furthermore, RCU implementations become extremely tricky. + * With a lookup followed by a kref_get_unless_zero *with return value check* + * locking in the kref_put path can be deferred to the actual removal from + * the lookup structure and RCU lookups become trivial. + */ +static inline int __must_check kref_get_unless_zero(struct kref *kref) +{ + return atomic_add_unless(&kref->refcount, 1, 0); +} + +/* This backports: + * + * commit 83e68189745ad931c2afd45d8ee3303929233e7f + * Author: Matt Fleming + * Date: Wed Nov 14 09:42:35 2012 +0000 + * + * efi: Make 'efi_enabled' a function to query EFI facilities + * + */ +/* check first if this was already backported */ +#ifndef EFI_BOOT +/* + * We play games with efi_enabled so that the compiler will, if + * possible, remove EFI-related code altogether. + */ +#define EFI_BOOT 0 /* Were we booted from EFI? */ +#define EFI_SYSTEM_TABLES 1 /* Can we use EFI system tables? */ +#define EFI_CONFIG_TABLES 2 /* Can we use EFI config tables? */ +#define EFI_RUNTIME_SERVICES 3 /* Can we use runtime services? */ +#define EFI_MEMMAP 4 /* Can we use EFI memory map? */ +#define EFI_64BIT 5 /* Is the firmware 64-bit? */ + +#ifdef CONFIG_EFI +# ifdef CONFIG_X86 +static inline int compat_efi_enabled(int facility) +{ + switch (facility) { + case EFI_BOOT: + return efi_enabled; +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0)) + case EFI_64BIT: + return efi_64bit; +#endif + default: + printk(KERN_ERR "can not translate efi_enabled() to old values completly\n"); + return efi_enabled; + } +} +# else +static inline int compat_efi_enabled(int facility) +{ + return 1; +} +# endif +#else +static inline int compat_efi_enabled(int facility) +{ + return 0; +} +#endif +#ifdef efi_enabled +#undef efi_enabled +#endif +#define efi_enabled(facility) compat_efi_enabled(facility) +#endif /* EFI_BOOT */ + +/* This backports: + * + * commit 130f1b8f35f14d27c43da755f3c9226318c17f57 + * Author: Bjorn Helgaas + * Date: Wed Dec 26 10:39:23 2012 -0700 + * + * PCI: Add PCIe Link Capability link speed and width names + */ +#define PCI_EXP_LNKCAP_SLS_2_5GB 0x1 /* LNKCAP2 SLS Vector bit 0 (2.5GT/s) */ +#define PCI_EXP_LNKCAP_SLS_5_0GB 0x2 /* LNKCAP2 SLS Vector bit 1 (5.0GT/s) */ + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(3,8,0)) */ + +#endif /* LINUX_3_8_COMPAT_H */ diff --git a/backport/backport-include/linux/compat-3.9.h b/backport/backport-include/linux/compat-3.9.h new file mode 100644 index 000000000000..a939e0b9270e --- /dev/null +++ b/backport/backport-include/linux/compat-3.9.h @@ -0,0 +1,243 @@ +#ifndef LINUX_3_9_COMPAT_H +#define LINUX_3_9_COMPAT_H + +#include + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,9,0)) + +#include +#include +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,25)) +#include +#endif +#include +#include +#include +#include +#include +#include +#include + +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0)) +int vb2_mmap_pfn_range(struct vm_area_struct *vma, unsigned long paddr, + unsigned long size, + const struct vm_operations_struct *vm_ops, + void *priv); +#endif + +/* module_platform_driver_probe() - Helper macro for drivers that don't do + * anything special in module init/exit. This eliminates a lot of + * boilerplate. Each module may only use this macro once, and + * calling it replaces module_init() and module_exit() + */ +#define module_platform_driver_probe(__platform_driver, __platform_probe) \ +static int __init __platform_driver##_init(void) \ +{ \ + return platform_driver_probe(&(__platform_driver), \ + __platform_probe); \ +} \ +module_init(__platform_driver##_init); \ +static void __exit __platform_driver##_exit(void) \ +{ \ + platform_driver_unregister(&(__platform_driver)); \ +} \ +module_exit(__platform_driver##_exit); + + +/* include this before changing hlist_for_each_* to use the old versions. */ +#include + +/* Lets expect distributions might backport this */ + +#ifndef for_each_sg_page +/* + * sg page iterator + * + * Iterates over sg entries page-by-page. On each successful iteration, + * @piter->page points to the current page, @piter->sg to the sg holding this + * page and @piter->sg_pgoffset to the page's page offset within the sg. The + * iteration will stop either when a maximum number of sg entries was reached + * or a terminating sg (sg_last(sg) == true) was reached. + */ +struct sg_page_iter { + struct page *page; /* current page */ + struct scatterlist *sg; /* sg holding the page */ + unsigned int sg_pgoffset; /* page offset within the sg */ + + /* these are internal states, keep away */ + unsigned int __nents; /* remaining sg entries */ + int __pg_advance; /* nr pages to advance at the + * next step */ +}; + +#define __sg_page_iter_next LINUX_BACKPORT(__sg_page_iter_next) +bool __sg_page_iter_next(struct sg_page_iter *piter); +#define __sg_page_iter_start LINUX_BACKPORT(__sg_page_iter_start) +void __sg_page_iter_start(struct sg_page_iter *piter, + struct scatterlist *sglist, unsigned int nents, + unsigned long pgoffset); + +/** + * for_each_sg_page - iterate over the pages of the given sg list + * @sglist: sglist to iterate over + * @piter: page iterator to hold current page, sg, sg_pgoffset + * @nents: maximum number of sg entries to iterate over + * @pgoffset: starting page offset + */ +#define for_each_sg_page(sglist, piter, nents, pgoffset) \ + for (__sg_page_iter_start((piter), (sglist), (nents), (pgoffset)); \ + __sg_page_iter_next(piter);) + +#endif /* for_each_sg_page assumption */ + +/* backports 7a555613 */ +#if defined(CONFIG_DYNAMIC_DEBUG) +#define dynamic_hex_dump(prefix_str, prefix_type, rowsize, \ + groupsize, buf, len, ascii) \ +do { \ + DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, \ + __builtin_constant_p(prefix_str) ? prefix_str : "hexdump");\ + if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT)) \ + print_hex_dump(KERN_DEBUG, prefix_str, \ + prefix_type, rowsize, groupsize, \ + buf, len, ascii); \ +} while (0) +#define print_hex_dump_debug(prefix_str, prefix_type, rowsize, \ + groupsize, buf, len, ascii) \ + dynamic_hex_dump(prefix_str, prefix_type, rowsize, \ + groupsize, buf, len, ascii) +#else +#define print_hex_dump_debug(prefix_str, prefix_type, rowsize, \ + groupsize, buf, len, ascii) \ + print_hex_dump(KERN_DEBUG, prefix_str, prefix_type, rowsize, \ + groupsize, buf, len, ascii) +#endif /* defined(CONFIG_DYNAMIC_DEBUG) */ + + +/** + * backport of idr idr_alloc() usage + * + * This backports a patch series send by Tejun Heo: + * https://lkml.org/lkml/2013/2/2/159 + */ +static inline void compat_idr_destroy(struct idr *idp) +{ + idr_remove_all(idp); + idr_destroy(idp); +} +#define idr_destroy(idp) compat_idr_destroy(idp) + +static inline int idr_alloc(struct idr *idr, void *ptr, int start, int end, + gfp_t gfp_mask) +{ + int id, ret; + + do { + if (!idr_pre_get(idr, gfp_mask)) + return -ENOMEM; + ret = idr_get_new_above(idr, ptr, start, &id); + if (!ret && id > end) { + idr_remove(idr, id); + ret = -ENOSPC; + } + } while (ret == -EAGAIN); + + return ret ? ret : id; +} + +static inline void idr_preload(gfp_t gfp_mask) +{ +} + +static inline void idr_preload_end(void) +{ +} + + +/** + * backport: + * + * commit 0bbacca7c3911451cea923b0ad6389d58e3d9ce9 + * Author: Sasha Levin + * Date: Thu Feb 7 12:32:18 2013 +1100 + * + * hlist: drop the node parameter from iterators + */ + +#define hlist_entry_safe(ptr, type, member) \ + (ptr) ? hlist_entry(ptr, type, member) : NULL + +#undef hlist_for_each_entry +/** + * hlist_for_each_entry - iterate over list of given type + * @pos: the type * to use as a loop cursor. + * @head: the head for your list. + * @member: the name of the hlist_node within the struct. + */ +#define hlist_for_each_entry(pos, head, member) \ + for (pos = hlist_entry_safe((head)->first, typeof(*(pos)), member); \ + pos; \ + pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member)) + +#undef hlist_for_each_entry_safe +/** + * hlist_for_each_entry_safe - iterate over list of given type safe against removal of list entry + * @pos: the type * to use as a loop cursor. + * @n: another &struct hlist_node to use as temporary storage + * @head: the head for your list. + * @member: the name of the hlist_node within the struct. + */ +#define hlist_for_each_entry_safe(pos, n, head, member) \ + for (pos = hlist_entry_safe((head)->first, typeof(*pos), member); \ + pos && ({ n = pos->member.next; 1; }); \ + pos = hlist_entry_safe(n, typeof(*pos), member)) + +#undef hlist_for_each_entry_rcu +/** + * hlist_for_each_entry_rcu - iterate over rcu list of given type + * @pos: the type * to use as a loop cursor. + * @head: the head for your list. + * @member: the name of the hlist_node within the struct. + * + * This list-traversal primitive may safely run concurrently with + * the _rcu list-mutation primitives such as hlist_add_head_rcu() + * as long as the traversal is guarded by rcu_read_lock(). + */ +#define hlist_for_each_entry_rcu(pos, head, member) \ + for (pos = hlist_entry_safe (rcu_dereference_raw(hlist_first_rcu(head)),\ + typeof(*(pos)), member); \ + pos; \ + pos = hlist_entry_safe(rcu_dereference_raw(hlist_next_rcu( \ + &(pos)->member)), typeof(*(pos)), member)) + +#undef sk_for_each +#define sk_for_each(__sk, list) \ + hlist_for_each_entry(__sk, list, sk_node) + +#undef sk_for_each_safe +#define sk_for_each_safe(__sk, tmp, list) \ + hlist_for_each_entry_safe(__sk, tmp, list, sk_node) + +#define tty_flip_buffer_push(port) tty_flip_buffer_push((port)->tty) +#define tty_insert_flip_string(port, chars, size) tty_insert_flip_string((port)->tty, chars, size) + +/** + * backport of: + * + * commit 496ad9aa8ef448058e36ca7a787c61f2e63f0f54 + * Author: Al Viro + * Date: Wed Jan 23 17:07:38 2013 -0500 + * + * new helper: file_inode(file) + */ +static inline struct inode *file_inode(struct file *f) +{ + return f->f_path.dentry->d_inode; +} + +#define devm_ioremap_resource LINUX_BACKPORT(devm_ioremap_resource) +void __iomem *devm_ioremap_resource(struct device *dev, struct resource *res); + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(3,9,0)) */ + +#endif /* LINUX_3_9_COMPAT_H */ diff --git a/backport/backport-include/linux/cordic.h b/backport/backport-include/linux/cordic.h new file mode 100644 index 000000000000..7f27b007e650 --- /dev/null +++ b/backport/backport-include/linux/cordic.h @@ -0,0 +1,60 @@ +#ifndef _BACKPORT_LINUX_CORDIC_H +#define _BACKPORT_LINUX_CORDIC_H 1 + +#include + +#if (LINUX_VERSION_CODE > KERNEL_VERSION(3,1,0)) +#include_next +#else + +/* + * Copyright (c) 2011 Broadcom Corporation + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ +#ifndef __CORDIC_H_ +#define __CORDIC_H_ + +#include + +/** + * struct cordic_iq - i/q coordinate. + * + * @i: real part of coordinate (in phase). + * @q: imaginary part of coordinate (quadrature). + */ +struct cordic_iq { + s32 i; + s32 q; +}; + +/** + * cordic_calc_iq() - calculates the i/q coordinate for given angle. + * + * @theta: angle in degrees for which i/q coordinate is to be calculated. + * @coord: function output parameter holding the i/q coordinate. + * + * The function calculates the i/q coordinate for a given angle using + * cordic algorithm. The coordinate consists of a real (i) and an + * imaginary (q) part. The real part is essentially the cosine of the + * angle and the imaginary part is the sine of the angle. The returned + * values are scaled by 2^16 for precision. The range for theta is + * for -180 degrees to +180 degrees. Passed values outside this range are + * converted before doing the actual calculation. + */ +#define cordic_calc_iq LINUX_BACKPORT(cordic_calc_iq) +struct cordic_iq cordic_calc_iq(s32 theta); + +#endif /* __CORDIC_H_ */ +#endif /* LINUX_VERSION_CODE > KERNEL_VERSION(3,1,0)) */ +#endif /* _BACKPORT_LINUX_CORDIC_H */ diff --git a/backport/backport-include/linux/crc8.h b/backport/backport-include/linux/crc8.h new file mode 100644 index 000000000000..611ba0d43de0 --- /dev/null +++ b/backport/backport-include/linux/crc8.h @@ -0,0 +1,109 @@ +/* + * Copyright (c) 2011 Broadcom Corporation + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ +#ifndef CPTCFG_BACKPORT_BUILD_CRC8_MODULE +#include_next +#else + +#ifndef __CRC8_H_ +#define __CRC8_H_ + +#include + +/* see usage of this value in crc8() description */ +#define CRC8_INIT_VALUE 0xFF + +/* + * Return value of crc8() indicating valid message+crc. This is true + * if a CRC is inverted before transmission. The CRC computed over the + * whole received bitstream is _table[x], where x is the bit pattern + * of the modification (almost always 0xff). + */ +#define CRC8_GOOD_VALUE(_table) (_table[0xFF]) + +/* required table size for crc8 algorithm */ +#define CRC8_TABLE_SIZE 256 + +/* helper macro assuring right table size is used */ +#define DECLARE_CRC8_TABLE(_table) \ + static u8 _table[CRC8_TABLE_SIZE] + +/** + * crc8_populate_lsb - fill crc table for given polynomial in regular bit order. + * + * @table: table to be filled. + * @polynomial: polynomial for which table is to be filled. + * + * This function fills the provided table according the polynomial provided for + * regular bit order (lsb first). Polynomials in CRC algorithms are typically + * represented as shown below. + * + * poly = x^8 + x^7 + x^6 + x^4 + x^2 + 1 + * + * For lsb first direction x^7 maps to the lsb. So the polynomial is as below. + * + * - lsb first: poly = 10101011(1) = 0xAB + */ +#define crc8_populate_lsb LINUX_BACKPORT(crc8_populate_lsb) +void crc8_populate_lsb(u8 table[CRC8_TABLE_SIZE], u8 polynomial); + +/** + * crc8_populate_msb - fill crc table for given polynomial in reverse bit order. + * + * @table: table to be filled. + * @polynomial: polynomial for which table is to be filled. + * + * This function fills the provided table according the polynomial provided for + * reverse bit order (msb first). Polynomials in CRC algorithms are typically + * represented as shown below. + * + * poly = x^8 + x^7 + x^6 + x^4 + x^2 + 1 + * + * For msb first direction x^7 maps to the msb. So the polynomial is as below. + * + * - msb first: poly = (1)11010101 = 0xD5 + */ +#define crc8_populate_msb LINUX_BACKPORT(crc8_populate_msb) +void crc8_populate_msb(u8 table[CRC8_TABLE_SIZE], u8 polynomial); + +/** + * crc8() - calculate a crc8 over the given input data. + * + * @table: crc table used for calculation. + * @pdata: pointer to data buffer. + * @nbytes: number of bytes in data buffer. + * @crc: previous returned crc8 value. + * + * The CRC8 is calculated using the polynomial given in crc8_populate_msb() + * or crc8_populate_lsb(). + * + * The caller provides the initial value (either %CRC8_INIT_VALUE + * or the previous returned value) to allow for processing of + * discontiguous blocks of data. When generating the CRC the + * caller is responsible for complementing the final return value + * and inserting it into the byte stream. When validating a byte + * stream (including CRC8), a final return value of %CRC8_GOOD_VALUE + * indicates the byte stream data can be considered valid. + * + * Reference: + * "A Painless Guide to CRC Error Detection Algorithms", ver 3, Aug 1993 + * Williams, Ross N., rossross.net + * (see URL http://www.ross.net/crc/download/crc_v3.txt). + */ +#define crc8 LINUX_BACKPORT(crc8) +u8 crc8(const u8 table[CRC8_TABLE_SIZE], u8 *pdata, size_t nbytes, u8 crc); + +#endif /* __CRC8_H_ */ +#endif /* BACKPORT_BUILD_CRC8_MODULE */ diff --git a/backport/backport-include/linux/export.h b/backport/backport-include/linux/export.h new file mode 100644 index 000000000000..f7842b7a582d --- /dev/null +++ b/backport/backport-include/linux/export.h @@ -0,0 +1,12 @@ +#ifndef _COMPAT_LINUX_EXPORT_H +#define _COMPAT_LINUX_EXPORT_H 1 + +#include + +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0)) +#include_next +#else +#include +#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0)) */ + +#endif /* _COMPAT_LINUX_EXPORT_H */ diff --git a/backport/backport-include/linux/gpio.h b/backport/backport-include/linux/gpio.h new file mode 100644 index 000000000000..d31e14ee00ba --- /dev/null +++ b/backport/backport-include/linux/gpio.h @@ -0,0 +1,10 @@ +#ifndef _COMPAT_LINUX_GPIO_H +#define _COMPAT_LINUX_GPIO_H 1 + +#include + +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)) +#include_next +#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)) */ + +#endif /* _COMPAT_LINUX_GPIO_H */ diff --git a/backport/backport-include/linux/kfifo.h b/backport/backport-include/linux/kfifo.h new file mode 100644 index 000000000000..398b00d0196c --- /dev/null +++ b/backport/backport-include/linux/kfifo.h @@ -0,0 +1,877 @@ +#include +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36)) +#include_next +#else +/* + * A generic kernel FIFO implementation + * + * Copyright (C) 2009/2010 Stefani Seibold + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + */ + +#ifndef _LINUX_KFIFO_H +#define _LINUX_KFIFO_H + +/* + * How to porting drivers to the new generic FIFO API: + * + * - Modify the declaration of the "struct kfifo *" object into a + * in-place "struct kfifo" object + * - Init the in-place object with kfifo_alloc() or kfifo_init() + * Note: The address of the in-place "struct kfifo" object must be + * passed as the first argument to this functions + * - Replace the use of __kfifo_put into kfifo_in and __kfifo_get + * into kfifo_out + * - Replace the use of kfifo_put into kfifo_in_spinlocked and kfifo_get + * into kfifo_out_spinlocked + * Note: the spinlock pointer formerly passed to kfifo_init/kfifo_alloc + * must be passed now to the kfifo_in_spinlocked and kfifo_out_spinlocked + * as the last parameter + * - The formerly __kfifo_* functions are renamed into kfifo_* + */ + +/* + * Note about locking : There is no locking required until only * one reader + * and one writer is using the fifo and no kfifo_reset() will be * called + * kfifo_reset_out() can be safely used, until it will be only called + * in the reader thread. + * For multiple writer and one reader there is only a need to lock the writer. + * And vice versa for only one writer and multiple reader there is only a need + * to lock the reader. + */ + +#include +#include +#include +#include + +struct __kfifo { + unsigned int in; + unsigned int out; + unsigned int mask; + unsigned int esize; + void *data; +}; + +#define __STRUCT_KFIFO_COMMON(datatype, recsize, ptrtype) \ + union { \ + struct __kfifo kfifo; \ + datatype *type; \ + char (*rectype)[recsize]; \ + ptrtype *ptr; \ + const ptrtype *ptr_const; \ + } + +#define __STRUCT_KFIFO(type, size, recsize, ptrtype) \ +{ \ + __STRUCT_KFIFO_COMMON(type, recsize, ptrtype); \ + type buf[((size < 2) || (size & (size - 1))) ? -1 : size]; \ +} + +#define STRUCT_KFIFO(type, size) \ + struct __STRUCT_KFIFO(type, size, 0, type) + +#define __STRUCT_KFIFO_PTR(type, recsize, ptrtype) \ +{ \ + __STRUCT_KFIFO_COMMON(type, recsize, ptrtype); \ + type buf[0]; \ +} + +#define STRUCT_KFIFO_PTR(type) \ + struct __STRUCT_KFIFO_PTR(type, 0, type) + +/* + * define compatibility "struct kfifo" for dynamic allocated fifos + */ +struct kfifo __STRUCT_KFIFO_PTR(unsigned char, 0, void); + +#define STRUCT_KFIFO_REC_1(size) \ + struct __STRUCT_KFIFO(unsigned char, size, 1, void) + +#define STRUCT_KFIFO_REC_2(size) \ + struct __STRUCT_KFIFO(unsigned char, size, 2, void) + +/* + * define kfifo_rec types + */ +struct kfifo_rec_ptr_1 __STRUCT_KFIFO_PTR(unsigned char, 1, void); +struct kfifo_rec_ptr_2 __STRUCT_KFIFO_PTR(unsigned char, 2, void); + +/* + * helper macro to distinguish between real in place fifo where the fifo + * array is a part of the structure and the fifo type where the array is + * outside of the fifo structure. + */ +#define __is_kfifo_ptr(fifo) (sizeof(*fifo) == sizeof(struct __kfifo)) + +/** + * DECLARE_KFIFO_PTR - macro to declare a fifo pointer object + * @fifo: name of the declared fifo + * @type: type of the fifo elements + */ +#define DECLARE_KFIFO_PTR(fifo, type) STRUCT_KFIFO_PTR(type) fifo + +/** + * DECLARE_KFIFO - macro to declare a fifo object + * @fifo: name of the declared fifo + * @type: type of the fifo elements + * @size: the number of elements in the fifo, this must be a power of 2 + */ +#define DECLARE_KFIFO(fifo, type, size) STRUCT_KFIFO(type, size) fifo + +/** + * INIT_KFIFO - Initialize a fifo declared by DECLARE_KFIFO + * @fifo: name of the declared fifo datatype + */ +#define INIT_KFIFO(fifo) \ +(void)({ \ + typeof(&(fifo)) __tmp = &(fifo); \ + struct __kfifo *__kfifo = &__tmp->kfifo; \ + __kfifo->in = 0; \ + __kfifo->out = 0; \ + __kfifo->mask = __is_kfifo_ptr(__tmp) ? 0 : ARRAY_SIZE(__tmp->buf) - 1;\ + __kfifo->esize = sizeof(*__tmp->buf); \ + __kfifo->data = __is_kfifo_ptr(__tmp) ? NULL : __tmp->buf; \ +}) + +/** + * DEFINE_KFIFO - macro to define and initialize a fifo + * @fifo: name of the declared fifo datatype + * @type: type of the fifo elements + * @size: the number of elements in the fifo, this must be a power of 2 + * + * Note: the macro can be used for global and local fifo data type variables. + */ +#define DEFINE_KFIFO(fifo, type, size) \ + DECLARE_KFIFO(fifo, type, size) = \ + (typeof(fifo)) { \ + { \ + { \ + .in = 0, \ + .out = 0, \ + .mask = __is_kfifo_ptr(&(fifo)) ? \ + 0 : \ + ARRAY_SIZE((fifo).buf) - 1, \ + .esize = sizeof(*(fifo).buf), \ + .data = __is_kfifo_ptr(&(fifo)) ? \ + NULL : \ + (fifo).buf, \ + } \ + } \ + } + + +static inline unsigned int __must_check +__kfifo_uint_must_check_helper(unsigned int val) +{ + return val; +} + +static inline int __must_check +__kfifo_int_must_check_helper(int val) +{ + return val; +} + +#define __kfifo_alloc LINUX_BACKPORT(__kfifo_alloc) +extern int __kfifo_alloc(struct __kfifo *fifo, unsigned int size, + size_t esize, gfp_t gfp_mask); +#define __kfifo_free LINUX_BACKPORT(__kfifo_free) +extern void __kfifo_free(struct __kfifo *fifo); + +#define __kfifo_init LINUX_BACKPORT(__kfifo_init) +extern int __kfifo_init(struct __kfifo *fifo, void *buffer, + unsigned int size, size_t esize); + +#define __kfifo_in LINUX_BACKPORT(__kfifo_in) +extern unsigned int __kfifo_in(struct __kfifo *fifo, + const void *buf, unsigned int len); + +#define __kfifo_out LINUX_BACKPORT(__kfifo_out) +extern unsigned int __kfifo_out(struct __kfifo *fifo, + void *buf, unsigned int len); + +#define __kfifo_from_user LINUX_BACKPORT(__kfifo_from_user) +extern int __kfifo_from_user(struct __kfifo *fifo, + const void __user *from, unsigned long len, unsigned int *copied); + +#define __kfifo_to_user LINUX_BACKPORT(__kfifo_to_user) +extern int __kfifo_to_user(struct __kfifo *fifo, + void __user *to, unsigned long len, unsigned int *copied); + +#define __kfifo_dma_in_prepare LINUX_BACKPORT(__kfifo_dma_in_prepare) +extern unsigned int __kfifo_dma_in_prepare(struct __kfifo *fifo, + struct scatterlist *sgl, int nents, unsigned int len); + +#define __kfifo_dma_out_prepare LINUX_BACKPORT(__kfifo_dma_out_prepare) +extern unsigned int __kfifo_dma_out_prepare(struct __kfifo *fifo, + struct scatterlist *sgl, int nents, unsigned int len); + +#define __kfifo_out_peek LINUX_BACKPORT(__kfifo_out_peek) +extern unsigned int __kfifo_out_peek(struct __kfifo *fifo, + void *buf, unsigned int len); + +#define __kfifo_in_r LINUX_BACKPORT(__kfifo_in_r) +extern unsigned int __kfifo_in_r(struct __kfifo *fifo, + const void *buf, unsigned int len, size_t recsize); + +#define __kfifo_out_r LINUX_BACKPORT(__kfifo_out_r) +extern unsigned int __kfifo_out_r(struct __kfifo *fifo, + void *buf, unsigned int len, size_t recsize); + +#define __kfifo_from_user_r LINUX_BACKPORT(__kfifo_from_user_r) +extern int __kfifo_from_user_r(struct __kfifo *fifo, + const void __user *from, unsigned long len, unsigned int *copied, + size_t recsize); + +#define __kfifo_to_user_r LINUX_BACKPORT(__kfifo_to_user_r) +extern int __kfifo_to_user_r(struct __kfifo *fifo, void __user *to, + unsigned long len, unsigned int *copied, size_t recsize); + +#define __kfifo_dma_in_prepare_r LINUX_BACKPORT(__kfifo_dma_in_prepare_r) +extern unsigned int __kfifo_dma_in_prepare_r(struct __kfifo *fifo, + struct scatterlist *sgl, int nents, unsigned int len, size_t recsize); + +#define __kfifo_dma_in_finish_r LINUX_BACKPORT(__kfifo_dma_in_finish_r) +extern void __kfifo_dma_in_finish_r(struct __kfifo *fifo, + unsigned int len, size_t recsize); + +#define __kfifo_dma_out_prepare_r LINUX_BACKPORT(__kfifo_dma_out_prepare_r) +extern unsigned int __kfifo_dma_out_prepare_r(struct __kfifo *fifo, + struct scatterlist *sgl, int nents, unsigned int len, size_t recsize); + +#define __kfifo_dma_out_finish_r LINUX_BACKPORT(__kfifo_dma_out_finish_r) +extern void __kfifo_dma_out_finish_r(struct __kfifo *fifo, size_t recsize); + +#define __kfifo_len_r LINUX_BACKPORT(__kfifo_len_r) +extern unsigned int __kfifo_len_r(struct __kfifo *fifo, size_t recsize); + +#define __kfifo_skip_r LINUX_BACKPORT(__kfifo_skip_r) +extern void __kfifo_skip_r(struct __kfifo *fifo, size_t recsize); + +#define __kfifo_out_peek_r LINUX_BACKPORT(__kfifo_out_peek_r) +extern unsigned int __kfifo_out_peek_r(struct __kfifo *fifo, + void *buf, unsigned int len, size_t recsize); + +#define __kfifo_max_r LINUX_BACKPORT(__kfifo_max_r) +extern unsigned int __kfifo_max_r(unsigned int len, size_t recsize); + +/** + * kfifo_initialized - Check if the fifo is initialized + * @fifo: address of the fifo to check + * + * Return %true if fifo is initialized, otherwise %false. + * Assumes the fifo was 0 before. + */ +#define kfifo_initialized(fifo) ((fifo)->kfifo.mask) + +/** + * kfifo_esize - returns the size of the element managed by the fifo + * @fifo: address of the fifo to be used + */ +#define kfifo_esize(fifo) ((fifo)->kfifo.esize) + +/** + * kfifo_recsize - returns the size of the record length field + * @fifo: address of the fifo to be used + */ +#define kfifo_recsize(fifo) (sizeof(*(fifo)->rectype)) + +/** + * kfifo_size - returns the size of the fifo in elements + * @fifo: address of the fifo to be used + */ +#define kfifo_size(fifo) ((fifo)->kfifo.mask + 1) + +/** + * kfifo_reset - removes the entire fifo content + * @fifo: address of the fifo to be used + * + * Note: usage of kfifo_reset() is dangerous. It should be only called when the + * fifo is exclusived locked or when it is secured that no other thread is + * accessing the fifo. + */ +#define kfifo_reset(fifo) \ +(void)({ \ + typeof((fifo) + 1) __tmp = (fifo); \ + __tmp->kfifo.in = __tmp->kfifo.out = 0; \ +}) + +/** + * kfifo_reset_out - skip fifo content + * @fifo: address of the fifo to be used + * + * Note: The usage of kfifo_reset_out() is safe until it will be only called + * from the reader thread and there is only one concurrent reader. Otherwise + * it is dangerous and must be handled in the same way as kfifo_reset(). + */ +#define kfifo_reset_out(fifo) \ +(void)({ \ + typeof((fifo) + 1) __tmp = (fifo); \ + __tmp->kfifo.out = __tmp->kfifo.in; \ +}) + +/** + * kfifo_len - returns the number of used elements in the fifo + * @fifo: address of the fifo to be used + */ +#define kfifo_len(fifo) \ +({ \ + typeof((fifo) + 1) __tmpl = (fifo); \ + __tmpl->kfifo.in - __tmpl->kfifo.out; \ +}) + +/** + * kfifo_is_empty - returns true if the fifo is empty + * @fifo: address of the fifo to be used + */ +#define kfifo_is_empty(fifo) \ +({ \ + typeof((fifo) + 1) __tmpq = (fifo); \ + __tmpq->kfifo.in == __tmpq->kfifo.out; \ +}) + +/** + * kfifo_is_full - returns true if the fifo is full + * @fifo: address of the fifo to be used + */ +#define kfifo_is_full(fifo) \ +({ \ + typeof((fifo) + 1) __tmpq = (fifo); \ + kfifo_len(__tmpq) > __tmpq->kfifo.mask; \ +}) + +/** + * kfifo_avail - returns the number of unused elements in the fifo + * @fifo: address of the fifo to be used + */ +#define kfifo_avail(fifo) \ +__kfifo_uint_must_check_helper( \ +({ \ + typeof((fifo) + 1) __tmpq = (fifo); \ + const size_t __recsize = sizeof(*__tmpq->rectype); \ + unsigned int __avail = kfifo_size(__tmpq) - kfifo_len(__tmpq); \ + (__recsize) ? ((__avail <= __recsize) ? 0 : \ + __kfifo_max_r(__avail - __recsize, __recsize)) : \ + __avail; \ +}) \ +) + +/** + * kfifo_skip - skip output data + * @fifo: address of the fifo to be used + */ +#define kfifo_skip(fifo) \ +(void)({ \ + typeof((fifo) + 1) __tmp = (fifo); \ + const size_t __recsize = sizeof(*__tmp->rectype); \ + struct __kfifo *__kfifo = &__tmp->kfifo; \ + if (__recsize) \ + __kfifo_skip_r(__kfifo, __recsize); \ + else \ + __kfifo->out++; \ +}) + +/** + * kfifo_peek_len - gets the size of the next fifo record + * @fifo: address of the fifo to be used + * + * This function returns the size of the next fifo record in number of bytes. + */ +#define kfifo_peek_len(fifo) \ +__kfifo_uint_must_check_helper( \ +({ \ + typeof((fifo) + 1) __tmp = (fifo); \ + const size_t __recsize = sizeof(*__tmp->rectype); \ + struct __kfifo *__kfifo = &__tmp->kfifo; \ + (!__recsize) ? kfifo_len(__tmp) * sizeof(*__tmp->type) : \ + __kfifo_len_r(__kfifo, __recsize); \ +}) \ +) + +/** + * kfifo_alloc - dynamically allocates a new fifo buffer + * @fifo: pointer to the fifo + * @size: the number of elements in the fifo, this must be a power of 2 + * @gfp_mask: get_free_pages mask, passed to kmalloc() + * + * This macro dynamically allocates a new fifo buffer. + * + * The numer of elements will be rounded-up to a power of 2. + * The fifo will be release with kfifo_free(). + * Return 0 if no error, otherwise an error code. + */ +#define kfifo_alloc(fifo, size, gfp_mask) \ +__kfifo_int_must_check_helper( \ +({ \ + typeof((fifo) + 1) __tmp = (fifo); \ + struct __kfifo *__kfifo = &__tmp->kfifo; \ + __is_kfifo_ptr(__tmp) ? \ + __kfifo_alloc(__kfifo, size, sizeof(*__tmp->type), gfp_mask) : \ + -EINVAL; \ +}) \ +) + +/** + * kfifo_free - frees the fifo + * @fifo: the fifo to be freed + */ +#define kfifo_free(fifo) \ +({ \ + typeof((fifo) + 1) __tmp = (fifo); \ + struct __kfifo *__kfifo = &__tmp->kfifo; \ + if (__is_kfifo_ptr(__tmp)) \ + __kfifo_free(__kfifo); \ +}) + +/** + * kfifo_init - initialize a fifo using a preallocated buffer + * @fifo: the fifo to assign the buffer + * @buffer: the preallocated buffer to be used + * @size: the size of the internal buffer, this have to be a power of 2 + * + * This macro initialize a fifo using a preallocated buffer. + * + * The numer of elements will be rounded-up to a power of 2. + * Return 0 if no error, otherwise an error code. + */ +#define kfifo_init(fifo, buffer, size) \ +({ \ + typeof((fifo) + 1) __tmp = (fifo); \ + struct __kfifo *__kfifo = &__tmp->kfifo; \ + __is_kfifo_ptr(__tmp) ? \ + __kfifo_init(__kfifo, buffer, size, sizeof(*__tmp->type)) : \ + -EINVAL; \ +}) + +/** + * kfifo_put - put data into the fifo + * @fifo: address of the fifo to be used + * @val: the data to be added + * + * This macro copies the given value into the fifo. + * It returns 0 if the fifo was full. Otherwise it returns the number + * processed elements. + * + * Note that with only one concurrent reader and one concurrent + * writer, you don't need extra locking to use these macro. + */ +#define kfifo_put(fifo, val) \ +({ \ + typeof((fifo) + 1) __tmp = (fifo); \ + typeof((val) + 1) __val = (val); \ + unsigned int __ret; \ + const size_t __recsize = sizeof(*__tmp->rectype); \ + struct __kfifo *__kfifo = &__tmp->kfifo; \ + if (0) { \ + typeof(__tmp->ptr_const) __dummy __attribute__ ((unused)); \ + __dummy = (typeof(__val))NULL; \ + } \ + if (__recsize) \ + __ret = __kfifo_in_r(__kfifo, __val, sizeof(*__val), \ + __recsize); \ + else { \ + __ret = !kfifo_is_full(__tmp); \ + if (__ret) { \ + (__is_kfifo_ptr(__tmp) ? \ + ((typeof(__tmp->type))__kfifo->data) : \ + (__tmp->buf) \ + )[__kfifo->in & __tmp->kfifo.mask] = \ + *(typeof(__tmp->type))__val; \ + smp_wmb(); \ + __kfifo->in++; \ + } \ + } \ + __ret; \ +}) + +/** + * kfifo_get - get data from the fifo + * @fifo: address of the fifo to be used + * @val: the var where to store the data to be added + * + * This macro reads the data from the fifo. + * It returns 0 if the fifo was empty. Otherwise it returns the number + * processed elements. + * + * Note that with only one concurrent reader and one concurrent + * writer, you don't need extra locking to use these macro. + */ +#define kfifo_get(fifo, val) \ +__kfifo_uint_must_check_helper( \ +({ \ + typeof((fifo) + 1) __tmp = (fifo); \ + typeof((val) + 1) __val = (val); \ + unsigned int __ret; \ + const size_t __recsize = sizeof(*__tmp->rectype); \ + struct __kfifo *__kfifo = &__tmp->kfifo; \ + if (0) \ + __val = (typeof(__tmp->ptr))0; \ + if (__recsize) \ + __ret = __kfifo_out_r(__kfifo, __val, sizeof(*__val), \ + __recsize); \ + else { \ + __ret = !kfifo_is_empty(__tmp); \ + if (__ret) { \ + *(typeof(__tmp->type))__val = \ + (__is_kfifo_ptr(__tmp) ? \ + ((typeof(__tmp->type))__kfifo->data) : \ + (__tmp->buf) \ + )[__kfifo->out & __tmp->kfifo.mask]; \ + smp_wmb(); \ + __kfifo->out++; \ + } \ + } \ + __ret; \ +}) \ +) + +/** + * kfifo_peek - get data from the fifo without removing + * @fifo: address of the fifo to be used + * @val: the var where to store the data to be added + * + * This reads the data from the fifo without removing it from the fifo. + * It returns 0 if the fifo was empty. Otherwise it returns the number + * processed elements. + * + * Note that with only one concurrent reader and one concurrent + * writer, you don't need extra locking to use these macro. + */ +#define kfifo_peek(fifo, val) \ +__kfifo_uint_must_check_helper( \ +({ \ + typeof((fifo) + 1) __tmp = (fifo); \ + typeof((val) + 1) __val = (val); \ + unsigned int __ret; \ + const size_t __recsize = sizeof(*__tmp->rectype); \ + struct __kfifo *__kfifo = &__tmp->kfifo; \ + if (0) \ + __val = (typeof(__tmp->ptr))NULL; \ + if (__recsize) \ + __ret = __kfifo_out_peek_r(__kfifo, __val, sizeof(*__val), \ + __recsize); \ + else { \ + __ret = !kfifo_is_empty(__tmp); \ + if (__ret) { \ + *(typeof(__tmp->type))__val = \ + (__is_kfifo_ptr(__tmp) ? \ + ((typeof(__tmp->type))__kfifo->data) : \ + (__tmp->buf) \ + )[__kfifo->out & __tmp->kfifo.mask]; \ + smp_wmb(); \ + } \ + } \ + __ret; \ +}) \ +) + +/** + * kfifo_in - put data into the fifo + * @fifo: address of the fifo to be used + * @buf: the data to be added + * @n: number of elements to be added + * + * This macro copies the given buffer into the fifo and returns the + * number of copied elements. + * + * Note that with only one concurrent reader and one concurrent + * writer, you don't need extra locking to use these macro. + */ +#define kfifo_in(fifo, buf, n) \ +({ \ + typeof((fifo) + 1) __tmp = (fifo); \ + typeof((buf) + 1) __buf = (buf); \ + unsigned long __n = (n); \ + const size_t __recsize = sizeof(*__tmp->rectype); \ + struct __kfifo *__kfifo = &__tmp->kfifo; \ + if (0) { \ + typeof(__tmp->ptr_const) __dummy __attribute__ ((unused)); \ + __dummy = (typeof(__buf))NULL; \ + } \ + (__recsize) ?\ + __kfifo_in_r(__kfifo, __buf, __n, __recsize) : \ + __kfifo_in(__kfifo, __buf, __n); \ +}) + +/** + * kfifo_in_spinlocked - put data into the fifo using a spinlock for locking + * @fifo: address of the fifo to be used + * @buf: the data to be added + * @n: number of elements to be added + * @lock: pointer to the spinlock to use for locking + * + * This macro copies the given values buffer into the fifo and returns the + * number of copied elements. + */ +#define kfifo_in_spinlocked(fifo, buf, n, lock) \ +({ \ + unsigned long __flags; \ + unsigned int __ret; \ + spin_lock_irqsave(lock, __flags); \ + __ret = kfifo_in(fifo, buf, n); \ + spin_unlock_irqrestore(lock, __flags); \ + __ret; \ +}) + +/* alias for kfifo_in_spinlocked, will be removed in a future release */ +#define kfifo_in_locked(fifo, buf, n, lock) \ + kfifo_in_spinlocked(fifo, buf, n, lock) + +/** + * kfifo_out - get data from the fifo + * @fifo: address of the fifo to be used + * @buf: pointer to the storage buffer + * @n: max. number of elements to get + * + * This macro get some data from the fifo and return the numbers of elements + * copied. + * + * Note that with only one concurrent reader and one concurrent + * writer, you don't need extra locking to use these macro. + */ +#define kfifo_out(fifo, buf, n) \ +__kfifo_uint_must_check_helper( \ +({ \ + typeof((fifo) + 1) __tmp = (fifo); \ + typeof((buf) + 1) __buf = (buf); \ + unsigned long __n = (n); \ + const size_t __recsize = sizeof(*__tmp->rectype); \ + struct __kfifo *__kfifo = &__tmp->kfifo; \ + if (0) { \ + typeof(__tmp->ptr) __dummy = NULL; \ + __buf = __dummy; \ + } \ + (__recsize) ?\ + __kfifo_out_r(__kfifo, __buf, __n, __recsize) : \ + __kfifo_out(__kfifo, __buf, __n); \ +}) \ +) + +/** + * kfifo_out_spinlocked - get data from the fifo using a spinlock for locking + * @fifo: address of the fifo to be used + * @buf: pointer to the storage buffer + * @n: max. number of elements to get + * @lock: pointer to the spinlock to use for locking + * + * This macro get the data from the fifo and return the numbers of elements + * copied. + */ +#define kfifo_out_spinlocked(fifo, buf, n, lock) \ +__kfifo_uint_must_check_helper( \ +({ \ + unsigned long __flags; \ + unsigned int __ret; \ + spin_lock_irqsave(lock, __flags); \ + __ret = kfifo_out(fifo, buf, n); \ + spin_unlock_irqrestore(lock, __flags); \ + __ret; \ +}) \ +) + +/* alias for kfifo_out_spinlocked, will be removed in a future release */ +#define kfifo_out_locked(fifo, buf, n, lock) \ + kfifo_out_spinlocked(fifo, buf, n, lock) + +/** + * kfifo_from_user - puts some data from user space into the fifo + * @fifo: address of the fifo to be used + * @from: pointer to the data to be added + * @len: the length of the data to be added + * @copied: pointer to output variable to store the number of copied bytes + * + * This macro copies at most @len bytes from the @from into the + * fifo, depending of the available space and returns -EFAULT/0. + * + * Note that with only one concurrent reader and one concurrent + * writer, you don't need extra locking to use these macro. + */ +#define kfifo_from_user(fifo, from, len, copied) \ +__kfifo_uint_must_check_helper( \ +({ \ + typeof((fifo) + 1) __tmp = (fifo); \ + const void __user *__from = (from); \ + unsigned int __len = (len); \ + unsigned int *__copied = (copied); \ + const size_t __recsize = sizeof(*__tmp->rectype); \ + struct __kfifo *__kfifo = &__tmp->kfifo; \ + (__recsize) ? \ + __kfifo_from_user_r(__kfifo, __from, __len, __copied, __recsize) : \ + __kfifo_from_user(__kfifo, __from, __len, __copied); \ +}) \ +) + +/** + * kfifo_to_user - copies data from the fifo into user space + * @fifo: address of the fifo to be used + * @to: where the data must be copied + * @len: the size of the destination buffer + * @copied: pointer to output variable to store the number of copied bytes + * + * This macro copies at most @len bytes from the fifo into the + * @to buffer and returns -EFAULT/0. + * + * Note that with only one concurrent reader and one concurrent + * writer, you don't need extra locking to use these macro. + */ +#define kfifo_to_user(fifo, to, len, copied) \ +__kfifo_uint_must_check_helper( \ +({ \ + typeof((fifo) + 1) __tmp = (fifo); \ + void __user *__to = (to); \ + unsigned int __len = (len); \ + unsigned int *__copied = (copied); \ + const size_t __recsize = sizeof(*__tmp->rectype); \ + struct __kfifo *__kfifo = &__tmp->kfifo; \ + (__recsize) ? \ + __kfifo_to_user_r(__kfifo, __to, __len, __copied, __recsize) : \ + __kfifo_to_user(__kfifo, __to, __len, __copied); \ +}) \ +) + +/** + * kfifo_dma_in_prepare - setup a scatterlist for DMA input + * @fifo: address of the fifo to be used + * @sgl: pointer to the scatterlist array + * @nents: number of entries in the scatterlist array + * @len: number of elements to transfer + * + * This macro fills a scatterlist for DMA input. + * It returns the number entries in the scatterlist array. + * + * Note that with only one concurrent reader and one concurrent + * writer, you don't need extra locking to use these macros. + */ +#define kfifo_dma_in_prepare(fifo, sgl, nents, len) \ +({ \ + typeof((fifo) + 1) __tmp = (fifo); \ + struct scatterlist *__sgl = (sgl); \ + int __nents = (nents); \ + unsigned int __len = (len); \ + const size_t __recsize = sizeof(*__tmp->rectype); \ + struct __kfifo *__kfifo = &__tmp->kfifo; \ + (__recsize) ? \ + __kfifo_dma_in_prepare_r(__kfifo, __sgl, __nents, __len, __recsize) : \ + __kfifo_dma_in_prepare(__kfifo, __sgl, __nents, __len); \ +}) + +/** + * kfifo_dma_in_finish - finish a DMA IN operation + * @fifo: address of the fifo to be used + * @len: number of bytes to received + * + * This macro finish a DMA IN operation. The in counter will be updated by + * the len parameter. No error checking will be done. + * + * Note that with only one concurrent reader and one concurrent + * writer, you don't need extra locking to use these macros. + */ +#define kfifo_dma_in_finish(fifo, len) \ +(void)({ \ + typeof((fifo) + 1) __tmp = (fifo); \ + unsigned int __len = (len); \ + const size_t __recsize = sizeof(*__tmp->rectype); \ + struct __kfifo *__kfifo = &__tmp->kfifo; \ + if (__recsize) \ + __kfifo_dma_in_finish_r(__kfifo, __len, __recsize); \ + else \ + __kfifo->in += __len / sizeof(*__tmp->type); \ +}) + +/** + * kfifo_dma_out_prepare - setup a scatterlist for DMA output + * @fifo: address of the fifo to be used + * @sgl: pointer to the scatterlist array + * @nents: number of entries in the scatterlist array + * @len: number of elements to transfer + * + * This macro fills a scatterlist for DMA output which at most @len bytes + * to transfer. + * It returns the number entries in the scatterlist array. + * A zero means there is no space available and the scatterlist is not filled. + * + * Note that with only one concurrent reader and one concurrent + * writer, you don't need extra locking to use these macros. + */ +#define kfifo_dma_out_prepare(fifo, sgl, nents, len) \ +({ \ + typeof((fifo) + 1) __tmp = (fifo); \ + struct scatterlist *__sgl = (sgl); \ + int __nents = (nents); \ + unsigned int __len = (len); \ + const size_t __recsize = sizeof(*__tmp->rectype); \ + struct __kfifo *__kfifo = &__tmp->kfifo; \ + (__recsize) ? \ + __kfifo_dma_out_prepare_r(__kfifo, __sgl, __nents, __len, __recsize) : \ + __kfifo_dma_out_prepare(__kfifo, __sgl, __nents, __len); \ +}) + +/** + * kfifo_dma_out_finish - finish a DMA OUT operation + * @fifo: address of the fifo to be used + * @len: number of bytes transferd + * + * This macro finish a DMA OUT operation. The out counter will be updated by + * the len parameter. No error checking will be done. + * + * Note that with only one concurrent reader and one concurrent + * writer, you don't need extra locking to use these macros. + */ +#define kfifo_dma_out_finish(fifo, len) \ +(void)({ \ + typeof((fifo) + 1) __tmp = (fifo); \ + unsigned int __len = (len); \ + const size_t __recsize = sizeof(*__tmp->rectype); \ + struct __kfifo *__kfifo = &__tmp->kfifo; \ + if (__recsize) \ + __kfifo_dma_out_finish_r(__kfifo, __recsize); \ + else \ + __kfifo->out += __len / sizeof(*__tmp->type); \ +}) + +/** + * kfifo_out_peek - gets some data from the fifo + * @fifo: address of the fifo to be used + * @buf: pointer to the storage buffer + * @n: max. number of elements to get + * + * This macro get the data from the fifo and return the numbers of elements + * copied. The data is not removed from the fifo. + * + * Note that with only one concurrent reader and one concurrent + * writer, you don't need extra locking to use these macro. + */ +#define kfifo_out_peek(fifo, buf, n) \ +__kfifo_uint_must_check_helper( \ +({ \ + typeof((fifo) + 1) __tmp = (fifo); \ + typeof((buf) + 1) __buf = (buf); \ + unsigned long __n = (n); \ + const size_t __recsize = sizeof(*__tmp->rectype); \ + struct __kfifo *__kfifo = &__tmp->kfifo; \ + if (0) { \ + typeof(__tmp->ptr) __dummy __attribute__ ((unused)) = NULL; \ + __buf = __dummy; \ + } \ + (__recsize) ? \ + __kfifo_out_peek_r(__kfifo, __buf, __n, __recsize) : \ + __kfifo_out_peek(__kfifo, __buf, __n); \ +}) \ +) +#endif +#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36)) */ diff --git a/backport/backport-include/linux/kmemleak.h b/backport/backport-include/linux/kmemleak.h new file mode 100644 index 000000000000..83bd199c2934 --- /dev/null +++ b/backport/backport-include/linux/kmemleak.h @@ -0,0 +1,5 @@ +#include + +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,30)) +#include_next +#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,25)) */ diff --git a/backport/backport-include/linux/math64.h b/backport/backport-include/linux/math64.h new file mode 100644 index 000000000000..eb9e8e15225c --- /dev/null +++ b/backport/backport-include/linux/math64.h @@ -0,0 +1,10 @@ +#ifndef _COMPAT_LINUX_MATH64_H +#define _COMPAT_LINUX_MATH64_H 1 + +#include + +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,25)) +#include_next +#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,25)) */ + +#endif /* _COMPAT_LINUX_MATH64_H */ diff --git a/backport/backport-include/linux/of.h b/backport/backport-include/linux/of.h new file mode 100644 index 000000000000..c5dc87c2ef64 --- /dev/null +++ b/backport/backport-include/linux/of.h @@ -0,0 +1,16 @@ +#ifndef _COMPAT_LINUX_OF_H +#define _COMPAT_LINUX_OF_H 1 + +#include + +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34)) +#include_next +#else + +#ifdef CONFIG_OF +#include_next +#endif /* CONFIG_OF */ + +#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34)) */ + +#endif /* _COMPAT_LINUX_OF_H */ diff --git a/backport/backport-include/linux/olpc-ec.h b/backport/backport-include/linux/olpc-ec.h new file mode 100644 index 000000000000..a5b932a75a29 --- /dev/null +++ b/backport/backport-include/linux/olpc-ec.h @@ -0,0 +1,10 @@ +#ifndef _COMPAT_LINUX_OLPC_EC_H +#define _COMPAT_LINUX_OLPC_EC_H + +#include + +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0)) +#include_next +#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(3,6,0)) */ + +#endif /* _COMPAT_LINUX_OLPC_EC_H */ diff --git a/backport/backport-include/linux/pci-aspm.h b/backport/backport-include/linux/pci-aspm.h new file mode 100644 index 000000000000..2bc6efb33300 --- /dev/null +++ b/backport/backport-include/linux/pci-aspm.h @@ -0,0 +1,5 @@ +#include + +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,25)) +#include_next +#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,25)) */ diff --git a/backport/backport-include/linux/pm_qos.h b/backport/backport-include/linux/pm_qos.h new file mode 100644 index 000000000000..c58c1c1f0161 --- /dev/null +++ b/backport/backport-include/linux/pm_qos.h @@ -0,0 +1,12 @@ +#ifndef _COMPAT_LINUX_PM_QOS_H +#define _COMPAT_LINUX_PM_QOS_H 1 + +#include + +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0)) +#include_next +#else +#include +#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0)) */ + +#endif /* _COMPAT_LINUX_PM_QOS_H */ diff --git a/backport/backport-include/linux/pm_qos_params.h b/backport/backport-include/linux/pm_qos_params.h new file mode 100644 index 000000000000..4c8c89eff15c --- /dev/null +++ b/backport/backport-include/linux/pm_qos_params.h @@ -0,0 +1,42 @@ +#include + +#ifndef __COMPAT_LINUX_PM_QOS_PARAMS_H +#define __COMPAT_LINUX_PM_QOS_PARAMS_H + +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)) +#include_next +#else +/* interface for the pm_qos_power infrastructure of the linux kernel. + * + * Mark Gross + */ +#include +#include +#include + +#define PM_QOS_RESERVED 0 +#define PM_QOS_CPU_DMA_LATENCY 1 +#define PM_QOS_NETWORK_LATENCY 2 +#define PM_QOS_NETWORK_THROUGHPUT 3 +#define PM_QOS_SYSTEM_BUS_FREQ 4 + +#define PM_QOS_NUM_CLASSES 5 +#define PM_QOS_DEFAULT_VALUE -1 + +#define pm_qos_add_requirement LINUX_BACKPORT(pm_qos_add_requirement) +int pm_qos_add_requirement(int qos, char *name, s32 value); +#define pm_qos_update_requirement LINUX_BACKPORT(pm_qos_update_requirement) +int pm_qos_update_requirement(int qos, char *name, s32 new_value); +#define pm_qos_remove_requirement LINUX_BACKPORT(pm_qos_remove_requirement) +void pm_qos_remove_requirement(int qos, char *name); + +#define pm_qos_requirement LINUX_BACKPORT(pm_qos_requirement) +int pm_qos_requirement(int qos); + +#define pm_qos_add_notifier LINUX_BACKPORT(pm_qos_add_notifier) +int pm_qos_add_notifier(int qos, struct notifier_block *notifier); +#define pm_qos_remove_notifier LINUX_BACKPORT(pm_qos_remove_notifier) +int pm_qos_remove_notifier(int qos, struct notifier_block *notifier); +#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)) */ + +#endif diff --git a/backport/backport-include/linux/pm_runtime.h b/backport/backport-include/linux/pm_runtime.h new file mode 100644 index 000000000000..eec965ba0d73 --- /dev/null +++ b/backport/backport-include/linux/pm_runtime.h @@ -0,0 +1,14 @@ +#include + +#ifndef __COMPAT_LINUX_PM_RUNTIME_H +#define __COMPAT_LINUX_PM_RUNTIME_H + +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)) +#include_next +#else + +static inline void pm_runtime_enable(struct device *dev) {} + +#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)) */ + +#endif diff --git a/backport/backport-include/linux/printk.h b/backport/backport-include/linux/printk.h new file mode 100644 index 000000000000..c0822ac488ca --- /dev/null +++ b/backport/backport-include/linux/printk.h @@ -0,0 +1,12 @@ +#ifndef _COMPAT_LINUX_PRINTK_H +#define _COMPAT_LINUX_PRINTK_H 1 + +#include + +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,36)) +#include_next +#else +#include +#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,35)) */ + +#endif /* _COMPAT_LINUX_PRINTK_H */ diff --git a/backport/backport-include/linux/rfkill.h b/backport/backport-include/linux/rfkill.h new file mode 100644 index 000000000000..da236b26e668 --- /dev/null +++ b/backport/backport-include/linux/rfkill.h @@ -0,0 +1,10 @@ +#ifndef __COMPAT_RFKILL_H +#define __COMPAT_RFKILL_H + +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33)) +#include_next +#else +#include +#endif + +#endif diff --git a/backport/backport-include/linux/semaphore.h b/backport/backport-include/linux/semaphore.h new file mode 100644 index 000000000000..78af4db376fd --- /dev/null +++ b/backport/backport-include/linux/semaphore.h @@ -0,0 +1,12 @@ +#ifndef _COMPAT_LINUX_SEMAPHORE_H +#define _COMPAT_LINUX_SEMAPHORE_H 1 + +#include + +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,25)) +#include_next +#else +#include +#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,25)) */ + +#endif /* _COMPAT_LINUX_SEMAPHORE_H */ diff --git a/backport/backport-include/linux/tracepoint.h b/backport/backport-include/linux/tracepoint.h new file mode 100644 index 000000000000..f67d8d396fe4 --- /dev/null +++ b/backport/backport-include/linux/tracepoint.h @@ -0,0 +1,46 @@ +#ifndef _COMPAT_LINUX_TRACEPOINT_H +#define _COMPAT_LINUX_TRACEPOINT_H 1 + +#include + +#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,32)) +/* + * Disable all tracing for older kernels + * < 2.6.27 had no tracing + * 2.6.27 had broken tracing + * 2.6.28-2.6.32 didn't have anything like DECLARE_EVENT_CLASS + * and faking it would be extremely difficult + */ +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28)) +/* + * For 2.6.28+ include the original tracepoint.h (for kernel header + * files that require it to work) but override the defines the code + * uses to disable tracing completely. + */ +#include_next +#endif + +#undef CREATE_TRACE_POINTS + +#undef TRACE_EVENT +#define TRACE_EVENT(name, proto, ...) \ +static inline void trace_ ## name(proto) {} +#undef DECLARE_EVENT_CLASS +#define DECLARE_EVENT_CLASS(...) +#undef DEFINE_EVENT +#define DEFINE_EVENT(evt_class, name, proto, ...) \ +static inline void trace_ ## name(proto) {} +#undef EXPORT_TRACEPOINT_SYMBOL +#define EXPORT_TRACEPOINT_SYMBOL(...) + +#define TP_PROTO(args...) args +#define TP_ARGS(args...) args +#define TP_CONDITION(args...) args + +#else +/* since 2.6.33, tracing hasn't changed, so just include the kernel's file */ +#include_next + +#endif /* (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,32)) */ + +#endif /* _COMPAT_LINUX_TRACEPOINT_H */ diff --git a/backport/backport-include/linux/u64_stats_sync.h b/backport/backport-include/linux/u64_stats_sync.h new file mode 100644 index 000000000000..f15116c28279 --- /dev/null +++ b/backport/backport-include/linux/u64_stats_sync.h @@ -0,0 +1,144 @@ +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0)) +#include_next +#else +#ifndef _LINUX_U64_STATS_SYNC_H +#define _LINUX_U64_STATS_SYNC_H + +/* + * To properly implement 64bits network statistics on 32bit and 64bit hosts, + * we provide a synchronization point, that is a noop on 64bit or UP kernels. + * + * Key points : + * 1) Use a seqcount on SMP 32bits, with low overhead. + * 2) Whole thing is a noop on 64bit arches or UP kernels. + * 3) Write side must ensure mutual exclusion or one seqcount update could + * be lost, thus blocking readers forever. + * If this synchronization point is not a mutex, but a spinlock or + * spinlock_bh() or disable_bh() : + * 3.1) Write side should not sleep. + * 3.2) Write side should not allow preemption. + * 3.3) If applicable, interrupts should be disabled. + * + * 4) If reader fetches several counters, there is no guarantee the whole values + * are consistent (remember point 1) : this is a noop on 64bit arches anyway) + * + * 5) readers are allowed to sleep or be preempted/interrupted : They perform + * pure reads. But if they have to fetch many values, it's better to not allow + * preemptions/interruptions to avoid many retries. + * + * 6) If counter might be written by an interrupt, readers should block interrupts. + * (On UP, there is no seqcount_t protection, a reader allowing interrupts could + * read partial values) + * + * 7) For softirq uses, readers can use u64_stats_fetch_begin_bh() and + * u64_stats_fetch_retry_bh() helpers + * + * Usage : + * + * Stats producer (writer) should use following template granted it already got + * an exclusive access to counters (a lock is already taken, or per cpu + * data is used [in a non preemptable context]) + * + * spin_lock_bh(...) or other synchronization to get exclusive access + * ... + * u64_stats_update_begin(&stats->syncp); + * stats->bytes64 += len; // non atomic operation + * stats->packets64++; // non atomic operation + * u64_stats_update_end(&stats->syncp); + * + * While a consumer (reader) should use following template to get consistent + * snapshot for each variable (but no guarantee on several ones) + * + * u64 tbytes, tpackets; + * unsigned int start; + * + * do { + * start = u64_stats_fetch_begin(&stats->syncp); + * tbytes = stats->bytes64; // non atomic operation + * tpackets = stats->packets64; // non atomic operation + * } while (u64_stats_fetch_retry(&stats->syncp, start)); + * + * + * Example of use in drivers/net/loopback.c, using per_cpu containers, + * in BH disabled context. + */ +#include + +struct u64_stats_sync { +#if BITS_PER_LONG==32 && defined(CONFIG_SMP) + seqcount_t seq; +#endif +}; + +static inline void u64_stats_update_begin(struct u64_stats_sync *syncp) +{ +#if BITS_PER_LONG==32 && defined(CONFIG_SMP) + write_seqcount_begin(&syncp->seq); +#endif +} + +static inline void u64_stats_update_end(struct u64_stats_sync *syncp) +{ +#if BITS_PER_LONG==32 && defined(CONFIG_SMP) + write_seqcount_end(&syncp->seq); +#endif +} + +static inline unsigned int u64_stats_fetch_begin(const struct u64_stats_sync *syncp) +{ +#if BITS_PER_LONG==32 && defined(CONFIG_SMP) + return read_seqcount_begin(&syncp->seq); +#else +#if BITS_PER_LONG==32 + preempt_disable(); +#endif + return 0; +#endif +} + +static inline bool u64_stats_fetch_retry(const struct u64_stats_sync *syncp, + unsigned int start) +{ +#if BITS_PER_LONG==32 && defined(CONFIG_SMP) + return read_seqcount_retry(&syncp->seq, start); +#else +#if BITS_PER_LONG==32 + preempt_enable(); +#endif + return false; +#endif +} + +/* + * In case softirq handlers can update u64 counters, readers can use following helpers + * - SMP 32bit arches use seqcount protection, irq safe. + * - UP 32bit must disable BH. + * - 64bit have no problem atomically reading u64 values, irq safe. + */ +static inline unsigned int u64_stats_fetch_begin_bh(const struct u64_stats_sync *syncp) +{ +#if BITS_PER_LONG==32 && defined(CONFIG_SMP) + return read_seqcount_begin(&syncp->seq); +#else +#if BITS_PER_LONG==32 + local_bh_disable(); +#endif + return 0; +#endif +} + +static inline bool u64_stats_fetch_retry_bh(const struct u64_stats_sync *syncp, + unsigned int start) +{ +#if BITS_PER_LONG==32 && defined(CONFIG_SMP) + return read_seqcount_retry(&syncp->seq, start); +#else +#if BITS_PER_LONG==32 + local_bh_enable(); +#endif + return false; +#endif +} + +#endif /* _LINUX_U64_STATS_SYNC_H */ +#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0)) */ diff --git a/backport/backport-include/linux/uidgid.h b/backport/backport-include/linux/uidgid.h new file mode 100644 index 000000000000..ae1ed808cfd6 --- /dev/null +++ b/backport/backport-include/linux/uidgid.h @@ -0,0 +1,221 @@ +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,5,0)) +#include_next +#else + +#ifndef _LINUX_UIDGID_H +#define _LINUX_UIDGID_H + +/* + * A set of types for the internal kernel types representing uids and gids. + * + * The types defined in this header allow distinguishing which uids and gids in + * the kernel are values used by userspace and which uid and gid values are + * the internal kernel values. With the addition of user namespaces the values + * can be different. Using the type system makes it possible for the compiler + * to detect when we overlook these differences. + * + */ +#include +#include + +struct user_namespace; +extern struct user_namespace init_user_ns; + +#ifdef CONFIG_UIDGID_STRICT_TYPE_CHECKS + +typedef struct { + uid_t val; +} kuid_t; + + +typedef struct { + gid_t val; +} kgid_t; + +#define KUIDT_INIT(value) (kuid_t){ value } +#define KGIDT_INIT(value) (kgid_t){ value } + +static inline uid_t __kuid_val(kuid_t uid) +{ + return uid.val; +} + +static inline gid_t __kgid_val(kgid_t gid) +{ + return gid.val; +} + +#else + +typedef uid_t kuid_t; +typedef gid_t kgid_t; + +static inline uid_t __kuid_val(kuid_t uid) +{ + return uid; +} + +static inline gid_t __kgid_val(kgid_t gid) +{ + return gid; +} + +#define KUIDT_INIT(value) ((kuid_t) value ) +#define KGIDT_INIT(value) ((kgid_t) value ) + +#endif + +#define GLOBAL_ROOT_UID KUIDT_INIT(0) +#define GLOBAL_ROOT_GID KGIDT_INIT(0) + +#define INVALID_UID KUIDT_INIT(-1) +#define INVALID_GID KGIDT_INIT(-1) + +static inline bool uid_eq(kuid_t left, kuid_t right) +{ + return __kuid_val(left) == __kuid_val(right); +} + +static inline bool gid_eq(kgid_t left, kgid_t right) +{ + return __kgid_val(left) == __kgid_val(right); +} + +static inline bool uid_gt(kuid_t left, kuid_t right) +{ + return __kuid_val(left) > __kuid_val(right); +} + +static inline bool gid_gt(kgid_t left, kgid_t right) +{ + return __kgid_val(left) > __kgid_val(right); +} + +static inline bool uid_gte(kuid_t left, kuid_t right) +{ + return __kuid_val(left) >= __kuid_val(right); +} + +static inline bool gid_gte(kgid_t left, kgid_t right) +{ + return __kgid_val(left) >= __kgid_val(right); +} + +static inline bool uid_lt(kuid_t left, kuid_t right) +{ + return __kuid_val(left) < __kuid_val(right); +} + +static inline bool gid_lt(kgid_t left, kgid_t right) +{ + return __kgid_val(left) < __kgid_val(right); +} + +static inline bool uid_lte(kuid_t left, kuid_t right) +{ + return __kuid_val(left) <= __kuid_val(right); +} + +static inline bool gid_lte(kgid_t left, kgid_t right) +{ + return __kgid_val(left) <= __kgid_val(right); +} + +static inline bool uid_valid(kuid_t uid) +{ + return !uid_eq(uid, INVALID_UID); +} + +static inline bool gid_valid(kgid_t gid) +{ + return !gid_eq(gid, INVALID_GID); +} + +#ifdef CONFIG_USER_NS + +#define make_kuid LINUX_BACKPORT(make_kuid) +extern kuid_t make_kuid(struct user_namespace *from, uid_t uid); +#define make_kgid LINUX_BACKPORT(make_kgid) +extern kgid_t make_kgid(struct user_namespace *from, gid_t gid); + +#define from_kuid LINUX_BACKPORT(from_kuid) +extern uid_t from_kuid(struct user_namespace *to, kuid_t uid); +#define from_kgid LINUX_BACKPORT(from_kgid) +extern gid_t from_kgid(struct user_namespace *to, kgid_t gid); +#define from_kuid_munged LINUX_BACKPORT(from_kuid_munged) +extern uid_t from_kuid_munged(struct user_namespace *to, kuid_t uid); +#define from_kgid_munged LINUX_BACKPORT(from_kgid_munged) +extern gid_t from_kgid_munged(struct user_namespace *to, kgid_t gid); + +#define kuid_has_mapping LINUX_BACKPORT(kuid_has_mapping) +static inline bool kuid_has_mapping(struct user_namespace *ns, kuid_t uid) +{ + return from_kuid(ns, uid) != (uid_t) -1; +} + +#define kgid_has_mapping LINUX_BACKPORT(kgid_has_mapping) +static inline bool kgid_has_mapping(struct user_namespace *ns, kgid_t gid) +{ + return from_kgid(ns, gid) != (gid_t) -1; +} + +#else + +#define make_kuid LINUX_BACKPORT(make_kuid) +static inline kuid_t make_kuid(struct user_namespace *from, uid_t uid) +{ + return KUIDT_INIT(uid); +} + +#define make_kgid LINUX_BACKPORT(make_kgid) +static inline kgid_t make_kgid(struct user_namespace *from, gid_t gid) +{ + return KGIDT_INIT(gid); +} + +#define from_kuid LINUX_BACKPORT(from_kuid) +static inline uid_t from_kuid(struct user_namespace *to, kuid_t kuid) +{ + return __kuid_val(kuid); +} + +#define from_kgid LINUX_BACKPORT(from_kgid) +static inline gid_t from_kgid(struct user_namespace *to, kgid_t kgid) +{ + return __kgid_val(kgid); +} + +#define from_kuid_munged LINUX_BACKPORT(from_kuid_munged) +static inline uid_t from_kuid_munged(struct user_namespace *to, kuid_t kuid) +{ + uid_t uid = from_kuid(to, kuid); + if (uid == (uid_t)-1) + uid = overflowuid; + return uid; +} + +#define from_kgid_munged LINUX_BACKPORT(from_kgid_munged) +static inline gid_t from_kgid_munged(struct user_namespace *to, kgid_t kgid) +{ + gid_t gid = from_kgid(to, kgid); + if (gid == (gid_t)-1) + gid = overflowgid; + return gid; +} + +#define kuid_has_mapping LINUX_BACKPORT(kuid_has_mapping) +static inline bool kuid_has_mapping(struct user_namespace *ns, kuid_t uid) +{ + return true; +} + +#define kgid_has_mapping LINUX_BACKPORT(kgid_has_mapping) +static inline bool kgid_has_mapping(struct user_namespace *ns, kgid_t gid) +{ + return true; +} + +#endif /* CONFIG_USER_NS */ + +#endif /* _LINUX_UIDGID_H */ +#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(3,5,0) */ diff --git a/backport/backport-include/linux/unaligned/access_ok.h b/backport/backport-include/linux/unaligned/access_ok.h new file mode 100644 index 000000000000..99c1b4d20b0f --- /dev/null +++ b/backport/backport-include/linux/unaligned/access_ok.h @@ -0,0 +1,67 @@ +#ifndef _LINUX_UNALIGNED_ACCESS_OK_H +#define _LINUX_UNALIGNED_ACCESS_OK_H + +#include +#include + +static inline u16 get_unaligned_le16(const void *p) +{ + return le16_to_cpup((__le16 *)p); +} + +static inline u32 get_unaligned_le32(const void *p) +{ + return le32_to_cpup((__le32 *)p); +} + +static inline u64 get_unaligned_le64(const void *p) +{ + return le64_to_cpup((__le64 *)p); +} + +static inline u16 get_unaligned_be16(const void *p) +{ + return be16_to_cpup((__be16 *)p); +} + +static inline u32 get_unaligned_be32(const void *p) +{ + return be32_to_cpup((__be32 *)p); +} + +static inline u64 get_unaligned_be64(const void *p) +{ + return be64_to_cpup((__be64 *)p); +} + +static inline void put_unaligned_le16(u16 val, void *p) +{ + *((__le16 *)p) = cpu_to_le16(val); +} + +static inline void put_unaligned_le32(u32 val, void *p) +{ + *((__le32 *)p) = cpu_to_le32(val); +} + +static inline void put_unaligned_le64(u64 val, void *p) +{ + *((__le64 *)p) = cpu_to_le64(val); +} + +static inline void put_unaligned_be16(u16 val, void *p) +{ + *((__be16 *)p) = cpu_to_be16(val); +} + +static inline void put_unaligned_be32(u32 val, void *p) +{ + *((__be32 *)p) = cpu_to_be32(val); +} + +static inline void put_unaligned_be64(u64 val, void *p) +{ + *((__be64 *)p) = cpu_to_be64(val); +} + +#endif /* _LINUX_UNALIGNED_ACCESS_OK_H */ diff --git a/backport/backport-include/linux/unaligned/be_byteshift.h b/backport/backport-include/linux/unaligned/be_byteshift.h new file mode 100644 index 000000000000..9356b24223ac --- /dev/null +++ b/backport/backport-include/linux/unaligned/be_byteshift.h @@ -0,0 +1,70 @@ +#ifndef _LINUX_UNALIGNED_BE_BYTESHIFT_H +#define _LINUX_UNALIGNED_BE_BYTESHIFT_H + +#include + +static inline u16 __get_unaligned_be16(const u8 *p) +{ + return p[0] << 8 | p[1]; +} + +static inline u32 __get_unaligned_be32(const u8 *p) +{ + return p[0] << 24 | p[1] << 16 | p[2] << 8 | p[3]; +} + +static inline u64 __get_unaligned_be64(const u8 *p) +{ + return (u64)__get_unaligned_be32(p) << 32 | + __get_unaligned_be32(p + 4); +} + +static inline void __put_unaligned_be16(u16 val, u8 *p) +{ + *p++ = val >> 8; + *p++ = val; +} + +static inline void __put_unaligned_be32(u32 val, u8 *p) +{ + __put_unaligned_be16(val >> 16, p); + __put_unaligned_be16(val, p + 2); +} + +static inline void __put_unaligned_be64(u64 val, u8 *p) +{ + __put_unaligned_be32(val >> 32, p); + __put_unaligned_be32(val, p + 4); +} + +static inline u16 get_unaligned_be16(const void *p) +{ + return __get_unaligned_be16((const u8 *)p); +} + +static inline u32 get_unaligned_be32(const void *p) +{ + return __get_unaligned_be32((const u8 *)p); +} + +static inline u64 get_unaligned_be64(const void *p) +{ + return __get_unaligned_be64((const u8 *)p); +} + +static inline void put_unaligned_be16(u16 val, void *p) +{ + __put_unaligned_be16(val, p); +} + +static inline void put_unaligned_be32(u32 val, void *p) +{ + __put_unaligned_be32(val, p); +} + +static inline void put_unaligned_be64(u64 val, void *p) +{ + __put_unaligned_be64(val, p); +} + +#endif /* _LINUX_UNALIGNED_BE_BYTESHIFT_H */ diff --git a/backport/backport-include/linux/unaligned/be_memmove.h b/backport/backport-include/linux/unaligned/be_memmove.h new file mode 100644 index 000000000000..c2a76c5c9ed0 --- /dev/null +++ b/backport/backport-include/linux/unaligned/be_memmove.h @@ -0,0 +1,36 @@ +#ifndef _LINUX_UNALIGNED_BE_MEMMOVE_H +#define _LINUX_UNALIGNED_BE_MEMMOVE_H + +#include + +static inline u16 get_unaligned_be16(const void *p) +{ + return __get_unaligned_memmove16((const u8 *)p); +} + +static inline u32 get_unaligned_be32(const void *p) +{ + return __get_unaligned_memmove32((const u8 *)p); +} + +static inline u64 get_unaligned_be64(const void *p) +{ + return __get_unaligned_memmove64((const u8 *)p); +} + +static inline void put_unaligned_be16(u16 val, void *p) +{ + __put_unaligned_memmove16(val, p); +} + +static inline void put_unaligned_be32(u32 val, void *p) +{ + __put_unaligned_memmove32(val, p); +} + +static inline void put_unaligned_be64(u64 val, void *p) +{ + __put_unaligned_memmove64(val, p); +} + +#endif /* _LINUX_UNALIGNED_LE_MEMMOVE_H */ diff --git a/backport/backport-include/linux/unaligned/be_struct.h b/backport/backport-include/linux/unaligned/be_struct.h new file mode 100644 index 000000000000..132415836c50 --- /dev/null +++ b/backport/backport-include/linux/unaligned/be_struct.h @@ -0,0 +1,36 @@ +#ifndef _LINUX_UNALIGNED_BE_STRUCT_H +#define _LINUX_UNALIGNED_BE_STRUCT_H + +#include + +static inline u16 get_unaligned_be16(const void *p) +{ + return __get_unaligned_cpu16((const u8 *)p); +} + +static inline u32 get_unaligned_be32(const void *p) +{ + return __get_unaligned_cpu32((const u8 *)p); +} + +static inline u64 get_unaligned_be64(const void *p) +{ + return __get_unaligned_cpu64((const u8 *)p); +} + +static inline void put_unaligned_be16(u16 val, void *p) +{ + __put_unaligned_cpu16(val, p); +} + +static inline void put_unaligned_be32(u32 val, void *p) +{ + __put_unaligned_cpu32(val, p); +} + +static inline void put_unaligned_be64(u64 val, void *p) +{ + __put_unaligned_cpu64(val, p); +} + +#endif /* _LINUX_UNALIGNED_BE_STRUCT_H */ diff --git a/backport/backport-include/linux/unaligned/generic.h b/backport/backport-include/linux/unaligned/generic.h new file mode 100644 index 000000000000..02d97ff3df70 --- /dev/null +++ b/backport/backport-include/linux/unaligned/generic.h @@ -0,0 +1,68 @@ +#ifndef _LINUX_UNALIGNED_GENERIC_H +#define _LINUX_UNALIGNED_GENERIC_H + +/* + * Cause a link-time error if we try an unaligned access other than + * 1,2,4 or 8 bytes long + */ +extern void __bad_unaligned_access_size(void); + +#define __get_unaligned_le(ptr) ((__force typeof(*(ptr)))({ \ + __builtin_choose_expr(sizeof(*(ptr)) == 1, *(ptr), \ + __builtin_choose_expr(sizeof(*(ptr)) == 2, get_unaligned_le16((ptr)), \ + __builtin_choose_expr(sizeof(*(ptr)) == 4, get_unaligned_le32((ptr)), \ + __builtin_choose_expr(sizeof(*(ptr)) == 8, get_unaligned_le64((ptr)), \ + __bad_unaligned_access_size())))); \ + })) + +#define __get_unaligned_be(ptr) ((__force typeof(*(ptr)))({ \ + __builtin_choose_expr(sizeof(*(ptr)) == 1, *(ptr), \ + __builtin_choose_expr(sizeof(*(ptr)) == 2, get_unaligned_be16((ptr)), \ + __builtin_choose_expr(sizeof(*(ptr)) == 4, get_unaligned_be32((ptr)), \ + __builtin_choose_expr(sizeof(*(ptr)) == 8, get_unaligned_be64((ptr)), \ + __bad_unaligned_access_size())))); \ + })) + +#define __put_unaligned_le(val, ptr) ({ \ + void *__gu_p = (ptr); \ + switch (sizeof(*(ptr))) { \ + case 1: \ + *(u8 *)__gu_p = (__force u8)(val); \ + break; \ + case 2: \ + put_unaligned_le16((__force u16)(val), __gu_p); \ + break; \ + case 4: \ + put_unaligned_le32((__force u32)(val), __gu_p); \ + break; \ + case 8: \ + put_unaligned_le64((__force u64)(val), __gu_p); \ + break; \ + default: \ + __bad_unaligned_access_size(); \ + break; \ + } \ + (void)0; }) + +#define __put_unaligned_be(val, ptr) ({ \ + void *__gu_p = (ptr); \ + switch (sizeof(*(ptr))) { \ + case 1: \ + *(u8 *)__gu_p = (__force u8)(val); \ + break; \ + case 2: \ + put_unaligned_be16((__force u16)(val), __gu_p); \ + break; \ + case 4: \ + put_unaligned_be32((__force u32)(val), __gu_p); \ + break; \ + case 8: \ + put_unaligned_be64((__force u64)(val), __gu_p); \ + break; \ + default: \ + __bad_unaligned_access_size(); \ + break; \ + } \ + (void)0; }) + +#endif /* _LINUX_UNALIGNED_GENERIC_H */ diff --git a/backport/backport-include/linux/unaligned/le_byteshift.h b/backport/backport-include/linux/unaligned/le_byteshift.h new file mode 100644 index 000000000000..be376fb79b64 --- /dev/null +++ b/backport/backport-include/linux/unaligned/le_byteshift.h @@ -0,0 +1,70 @@ +#ifndef _LINUX_UNALIGNED_LE_BYTESHIFT_H +#define _LINUX_UNALIGNED_LE_BYTESHIFT_H + +#include + +static inline u16 __get_unaligned_le16(const u8 *p) +{ + return p[0] | p[1] << 8; +} + +static inline u32 __get_unaligned_le32(const u8 *p) +{ + return p[0] | p[1] << 8 | p[2] << 16 | p[3] << 24; +} + +static inline u64 __get_unaligned_le64(const u8 *p) +{ + return (u64)__get_unaligned_le32(p + 4) << 32 | + __get_unaligned_le32(p); +} + +static inline void __put_unaligned_le16(u16 val, u8 *p) +{ + *p++ = val; + *p++ = val >> 8; +} + +static inline void __put_unaligned_le32(u32 val, u8 *p) +{ + __put_unaligned_le16(val >> 16, p + 2); + __put_unaligned_le16(val, p); +} + +static inline void __put_unaligned_le64(u64 val, u8 *p) +{ + __put_unaligned_le32(val >> 32, p + 4); + __put_unaligned_le32(val, p); +} + +static inline u16 get_unaligned_le16(const void *p) +{ + return __get_unaligned_le16((const u8 *)p); +} + +static inline u32 get_unaligned_le32(const void *p) +{ + return __get_unaligned_le32((const u8 *)p); +} + +static inline u64 get_unaligned_le64(const void *p) +{ + return __get_unaligned_le64((const u8 *)p); +} + +static inline void put_unaligned_le16(u16 val, void *p) +{ + __put_unaligned_le16(val, p); +} + +static inline void put_unaligned_le32(u32 val, void *p) +{ + __put_unaligned_le32(val, p); +} + +static inline void put_unaligned_le64(u64 val, void *p) +{ + __put_unaligned_le64(val, p); +} + +#endif /* _LINUX_UNALIGNED_LE_BYTESHIFT_H */ diff --git a/backport/backport-include/linux/unaligned/le_memmove.h b/backport/backport-include/linux/unaligned/le_memmove.h new file mode 100644 index 000000000000..269849bee4ec --- /dev/null +++ b/backport/backport-include/linux/unaligned/le_memmove.h @@ -0,0 +1,36 @@ +#ifndef _LINUX_UNALIGNED_LE_MEMMOVE_H +#define _LINUX_UNALIGNED_LE_MEMMOVE_H + +#include + +static inline u16 get_unaligned_le16(const void *p) +{ + return __get_unaligned_memmove16((const u8 *)p); +} + +static inline u32 get_unaligned_le32(const void *p) +{ + return __get_unaligned_memmove32((const u8 *)p); +} + +static inline u64 get_unaligned_le64(const void *p) +{ + return __get_unaligned_memmove64((const u8 *)p); +} + +static inline void put_unaligned_le16(u16 val, void *p) +{ + __put_unaligned_memmove16(val, p); +} + +static inline void put_unaligned_le32(u32 val, void *p) +{ + __put_unaligned_memmove32(val, p); +} + +static inline void put_unaligned_le64(u64 val, void *p) +{ + __put_unaligned_memmove64(val, p); +} + +#endif /* _LINUX_UNALIGNED_LE_MEMMOVE_H */ diff --git a/backport/backport-include/linux/unaligned/le_struct.h b/backport/backport-include/linux/unaligned/le_struct.h new file mode 100644 index 000000000000..088c4572faa8 --- /dev/null +++ b/backport/backport-include/linux/unaligned/le_struct.h @@ -0,0 +1,36 @@ +#ifndef _LINUX_UNALIGNED_LE_STRUCT_H +#define _LINUX_UNALIGNED_LE_STRUCT_H + +#include + +static inline u16 get_unaligned_le16(const void *p) +{ + return __get_unaligned_cpu16((const u8 *)p); +} + +static inline u32 get_unaligned_le32(const void *p) +{ + return __get_unaligned_cpu32((const u8 *)p); +} + +static inline u64 get_unaligned_le64(const void *p) +{ + return __get_unaligned_cpu64((const u8 *)p); +} + +static inline void put_unaligned_le16(u16 val, void *p) +{ + __put_unaligned_cpu16(val, p); +} + +static inline void put_unaligned_le32(u32 val, void *p) +{ + __put_unaligned_cpu32(val, p); +} + +static inline void put_unaligned_le64(u64 val, void *p) +{ + __put_unaligned_cpu64(val, p); +} + +#endif /* _LINUX_UNALIGNED_LE_STRUCT_H */ diff --git a/backport/backport-include/linux/unaligned/memmove.h b/backport/backport-include/linux/unaligned/memmove.h new file mode 100644 index 000000000000..eeb5a779a4fd --- /dev/null +++ b/backport/backport-include/linux/unaligned/memmove.h @@ -0,0 +1,45 @@ +#ifndef _LINUX_UNALIGNED_MEMMOVE_H +#define _LINUX_UNALIGNED_MEMMOVE_H + +#include +#include + +/* Use memmove here, so gcc does not insert a __builtin_memcpy. */ + +static inline u16 __get_unaligned_memmove16(const void *p) +{ + u16 tmp; + memmove(&tmp, p, 2); + return tmp; +} + +static inline u32 __get_unaligned_memmove32(const void *p) +{ + u32 tmp; + memmove(&tmp, p, 4); + return tmp; +} + +static inline u64 __get_unaligned_memmove64(const void *p) +{ + u64 tmp; + memmove(&tmp, p, 8); + return tmp; +} + +static inline void __put_unaligned_memmove16(u16 val, void *p) +{ + memmove(p, &val, 2); +} + +static inline void __put_unaligned_memmove32(u32 val, void *p) +{ + memmove(p, &val, 4); +} + +static inline void __put_unaligned_memmove64(u64 val, void *p) +{ + memmove(p, &val, 8); +} + +#endif /* _LINUX_UNALIGNED_MEMMOVE_H */ diff --git a/backport/backport-include/linux/unaligned/packed_struct.h b/backport/backport-include/linux/unaligned/packed_struct.h new file mode 100644 index 000000000000..2498bb9fe002 --- /dev/null +++ b/backport/backport-include/linux/unaligned/packed_struct.h @@ -0,0 +1,46 @@ +#ifndef _LINUX_UNALIGNED_PACKED_STRUCT_H +#define _LINUX_UNALIGNED_PACKED_STRUCT_H + +#include + +struct __una_u16 { u16 x __attribute__((packed)); }; +struct __una_u32 { u32 x __attribute__((packed)); }; +struct __una_u64 { u64 x __attribute__((packed)); }; + +static inline u16 __get_unaligned_cpu16(const void *p) +{ + const struct __una_u16 *ptr = (const struct __una_u16 *)p; + return ptr->x; +} + +static inline u32 __get_unaligned_cpu32(const void *p) +{ + const struct __una_u32 *ptr = (const struct __una_u32 *)p; + return ptr->x; +} + +static inline u64 __get_unaligned_cpu64(const void *p) +{ + const struct __una_u64 *ptr = (const struct __una_u64 *)p; + return ptr->x; +} + +static inline void __put_unaligned_cpu16(u16 val, void *p) +{ + struct __una_u16 *ptr = (struct __una_u16 *)p; + ptr->x = val; +} + +static inline void __put_unaligned_cpu32(u32 val, void *p) +{ + struct __una_u32 *ptr = (struct __una_u32 *)p; + ptr->x = val; +} + +static inline void __put_unaligned_cpu64(u64 val, void *p) +{ + struct __una_u64 *ptr = (struct __una_u64 *)p; + ptr->x = val; +} + +#endif /* _LINUX_UNALIGNED_PACKED_STRUCT_H */ diff --git a/backport/backport-include/linux/vga_switcheroo.h b/backport/backport-include/linux/vga_switcheroo.h new file mode 100644 index 000000000000..4bda17bf88fa --- /dev/null +++ b/backport/backport-include/linux/vga_switcheroo.h @@ -0,0 +1,12 @@ +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34)) +/* + * XXX: The include guard was sent upstream, drop this + * once the guard is merged. + */ +#ifndef LINUX_VGA_SWITCHEROO_H /* in case this gets upstream */ +#include_next +#ifndef LINUX_VGA_SWITCHEROO_H /* do not redefine once this gets upstream */ +#define LINUX_VGA_SWITCHEROO_H +#endif /* case 1 LINUX_VGA_SWITCHEROO_H */ +#endif /* case 2 LINUX_VGA_SWITCHEROO_H */ +#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34)) */ diff --git a/backport/backport-include/linux/wireless.h b/backport/backport-include/linux/wireless.h new file mode 100644 index 000000000000..4395b28bb86c --- /dev/null +++ b/backport/backport-include/linux/wireless.h @@ -0,0 +1,1162 @@ +/* + * This file define a set of standard wireless extensions + * + * Version : 22 16.3.07 + * + * Authors : Jean Tourrilhes - HPL - + * Copyright (c) 1997-2007 Jean Tourrilhes, All Rights Reserved. + */ + +#ifndef _LINUX_WIRELESS_H +#define _LINUX_WIRELESS_H + +/************************** DOCUMENTATION **************************/ +/* + * Initial APIs (1996 -> onward) : + * ----------------------------- + * Basically, the wireless extensions are for now a set of standard ioctl + * call + /proc/net/wireless + * + * The entry /proc/net/wireless give statistics and information on the + * driver. + * This is better than having each driver having its entry because + * its centralised and we may remove the driver module safely. + * + * Ioctl are used to configure the driver and issue commands. This is + * better than command line options of insmod because we may want to + * change dynamically (while the driver is running) some parameters. + * + * The ioctl mechanimsm are copied from standard devices ioctl. + * We have the list of command plus a structure descibing the + * data exchanged... + * Note that to add these ioctl, I was obliged to modify : + * # net/core/dev.c (two place + add include) + * # net/ipv4/af_inet.c (one place + add include) + * + * /proc/net/wireless is a copy of /proc/net/dev. + * We have a structure for data passed from the driver to /proc/net/wireless + * Too add this, I've modified : + * # net/core/dev.c (two other places) + * # include/linux/netdevice.h (one place) + * # include/linux/proc_fs.h (one place) + * + * New driver API (2002 -> onward) : + * ------------------------------- + * This file is only concerned with the user space API and common definitions. + * The new driver API is defined and documented in : + * # include/net/iw_handler.h + * + * Note as well that /proc/net/wireless implementation has now moved in : + * # net/core/wireless.c + * + * Wireless Events (2002 -> onward) : + * -------------------------------- + * Events are defined at the end of this file, and implemented in : + * # net/core/wireless.c + * + * Other comments : + * -------------- + * Do not add here things that are redundant with other mechanisms + * (drivers init, ifconfig, /proc/net/dev, ...) and with are not + * wireless specific. + * + * These wireless extensions are not magic : each driver has to provide + * support for them... + * + * IMPORTANT NOTE : As everything in the kernel, this is very much a + * work in progress. Contact me if you have ideas of improvements... + */ + +/***************************** INCLUDES *****************************/ + +#include /* for __u* and __s* typedefs */ +#include /* for "struct sockaddr" et al */ +#include /* for IFNAMSIZ and co... */ + +/***************************** VERSION *****************************/ +/* + * This constant is used to know the availability of the wireless + * extensions and to know which version of wireless extensions it is + * (there is some stuff that will be added in the future...) + * I just plan to increment with each new version. + */ +#define WIRELESS_EXT 22 + +/* + * Changes : + * + * V2 to V3 + * -------- + * Alan Cox start some incompatibles changes. I've integrated a bit more. + * - Encryption renamed to Encode to avoid US regulation problems + * - Frequency changed from float to struct to avoid problems on old 386 + * + * V3 to V4 + * -------- + * - Add sensitivity + * + * V4 to V5 + * -------- + * - Missing encoding definitions in range + * - Access points stuff + * + * V5 to V6 + * -------- + * - 802.11 support (ESSID ioctls) + * + * V6 to V7 + * -------- + * - define IW_ESSID_MAX_SIZE and IW_MAX_AP + * + * V7 to V8 + * -------- + * - Changed my e-mail address + * - More 802.11 support (nickname, rate, rts, frag) + * - List index in frequencies + * + * V8 to V9 + * -------- + * - Support for 'mode of operation' (ad-hoc, managed...) + * - Support for unicast and multicast power saving + * - Change encoding to support larger tokens (>64 bits) + * - Updated iw_params (disable, flags) and use it for NWID + * - Extracted iw_point from iwreq for clarity + * + * V9 to V10 + * --------- + * - Add PM capability to range structure + * - Add PM modifier : MAX/MIN/RELATIVE + * - Add encoding option : IW_ENCODE_NOKEY + * - Add TxPower ioctls (work like TxRate) + * + * V10 to V11 + * ---------- + * - Add WE version in range (help backward/forward compatibility) + * - Add retry ioctls (work like PM) + * + * V11 to V12 + * ---------- + * - Add SIOCSIWSTATS to get /proc/net/wireless programatically + * - Add DEV PRIVATE IOCTL to avoid collisions in SIOCDEVPRIVATE space + * - Add new statistics (frag, retry, beacon) + * - Add average quality (for user space calibration) + * + * V12 to V13 + * ---------- + * - Document creation of new driver API. + * - Extract union iwreq_data from struct iwreq (for new driver API). + * - Rename SIOCSIWNAME as SIOCSIWCOMMIT + * + * V13 to V14 + * ---------- + * - Wireless Events support : define struct iw_event + * - Define additional specific event numbers + * - Add "addr" and "param" fields in union iwreq_data + * - AP scanning stuff (SIOCSIWSCAN and friends) + * + * V14 to V15 + * ---------- + * - Add IW_PRIV_TYPE_ADDR for struct sockaddr private arg + * - Make struct iw_freq signed (both m & e), add explicit padding + * - Add IWEVCUSTOM for driver specific event/scanning token + * - Add IW_MAX_GET_SPY for driver returning a lot of addresses + * - Add IW_TXPOW_RANGE for range of Tx Powers + * - Add IWEVREGISTERED & IWEVEXPIRED events for Access Points + * - Add IW_MODE_MONITOR for passive monitor + * + * V15 to V16 + * ---------- + * - Increase the number of bitrates in iw_range to 32 (for 802.11g) + * - Increase the number of frequencies in iw_range to 32 (for 802.11b+a) + * - Reshuffle struct iw_range for increases, add filler + * - Increase IW_MAX_AP to 64 for driver returning a lot of addresses + * - Remove IW_MAX_GET_SPY because conflict with enhanced spy support + * - Add SIOCSIWTHRSPY/SIOCGIWTHRSPY and "struct iw_thrspy" + * - Add IW_ENCODE_TEMP and iw_range->encoding_login_index + * + * V16 to V17 + * ---------- + * - Add flags to frequency -> auto/fixed + * - Document (struct iw_quality *)->updated, add new flags (INVALID) + * - Wireless Event capability in struct iw_range + * - Add support for relative TxPower (yick !) + * + * V17 to V18 (From Jouni Malinen ) + * ---------- + * - Add support for WPA/WPA2 + * - Add extended encoding configuration (SIOCSIWENCODEEXT and + * SIOCGIWENCODEEXT) + * - Add SIOCSIWGENIE/SIOCGIWGENIE + * - Add SIOCSIWMLME + * - Add SIOCSIWPMKSA + * - Add struct iw_range bit field for supported encoding capabilities + * - Add optional scan request parameters for SIOCSIWSCAN + * - Add SIOCSIWAUTH/SIOCGIWAUTH for setting authentication and WPA + * related parameters (extensible up to 4096 parameter values) + * - Add wireless events: IWEVGENIE, IWEVMICHAELMICFAILURE, + * IWEVASSOCREQIE, IWEVASSOCRESPIE, IWEVPMKIDCAND + * + * V18 to V19 + * ---------- + * - Remove (struct iw_point *)->pointer from events and streams + * - Remove header includes to help user space + * - Increase IW_ENCODING_TOKEN_MAX from 32 to 64 + * - Add IW_QUAL_ALL_UPDATED and IW_QUAL_ALL_INVALID macros + * - Add explicit flag to tell stats are in dBm : IW_QUAL_DBM + * - Add IW_IOCTL_IDX() and IW_EVENT_IDX() macros + * + * V19 to V20 + * ---------- + * - RtNetlink requests support (SET/GET) + * + * V20 to V21 + * ---------- + * - Remove (struct net_device *)->get_wireless_stats() + * - Change length in ESSID and NICK to strlen() instead of strlen()+1 + * - Add IW_RETRY_SHORT/IW_RETRY_LONG retry modifiers + * - Power/Retry relative values no longer * 100000 + * - Add explicit flag to tell stats are in 802.11k RCPI : IW_QUAL_RCPI + * + * V21 to V22 + * ---------- + * - Prevent leaking of kernel space in stream on 64 bits. + */ + +/**************************** CONSTANTS ****************************/ + +/* -------------------------- IOCTL LIST -------------------------- */ + +/* Wireless Identification */ +#define SIOCSIWCOMMIT 0x8B00 /* Commit pending changes to driver */ +#define SIOCGIWNAME 0x8B01 /* get name == wireless protocol */ +/* SIOCGIWNAME is used to verify the presence of Wireless Extensions. + * Common values : "IEEE 802.11-DS", "IEEE 802.11-FH", "IEEE 802.11b"... + * Don't put the name of your driver there, it's useless. */ + +/* Basic operations */ +#define SIOCSIWNWID 0x8B02 /* set network id (pre-802.11) */ +#define SIOCGIWNWID 0x8B03 /* get network id (the cell) */ +#define SIOCSIWFREQ 0x8B04 /* set channel/frequency (Hz) */ +#define SIOCGIWFREQ 0x8B05 /* get channel/frequency (Hz) */ +#define SIOCSIWMODE 0x8B06 /* set operation mode */ +#define SIOCGIWMODE 0x8B07 /* get operation mode */ +#define SIOCSIWSENS 0x8B08 /* set sensitivity (dBm) */ +#define SIOCGIWSENS 0x8B09 /* get sensitivity (dBm) */ + +/* Informative stuff */ +#define SIOCSIWRANGE 0x8B0A /* Unused */ +#define SIOCGIWRANGE 0x8B0B /* Get range of parameters */ +#define SIOCSIWPRIV 0x8B0C /* Unused */ +#define SIOCGIWPRIV 0x8B0D /* get private ioctl interface info */ +#define SIOCSIWSTATS 0x8B0E /* Unused */ +#define SIOCGIWSTATS 0x8B0F /* Get /proc/net/wireless stats */ +/* SIOCGIWSTATS is strictly used between user space and the kernel, and + * is never passed to the driver (i.e. the driver will never see it). */ + +/* Spy support (statistics per MAC address - used for Mobile IP support) */ +#define SIOCSIWSPY 0x8B10 /* set spy addresses */ +#define SIOCGIWSPY 0x8B11 /* get spy info (quality of link) */ +#define SIOCSIWTHRSPY 0x8B12 /* set spy threshold (spy event) */ +#define SIOCGIWTHRSPY 0x8B13 /* get spy threshold */ + +/* Access Point manipulation */ +#define SIOCSIWAP 0x8B14 /* set access point MAC addresses */ +#define SIOCGIWAP 0x8B15 /* get access point MAC addresses */ +#define SIOCGIWAPLIST 0x8B17 /* Deprecated in favor of scanning */ +#define SIOCSIWSCAN 0x8B18 /* trigger scanning (list cells) */ +#define SIOCGIWSCAN 0x8B19 /* get scanning results */ + +/* 802.11 specific support */ +#define SIOCSIWESSID 0x8B1A /* set ESSID (network name) */ +#define SIOCGIWESSID 0x8B1B /* get ESSID */ +#define SIOCSIWNICKN 0x8B1C /* set node name/nickname */ +#define SIOCGIWNICKN 0x8B1D /* get node name/nickname */ +/* As the ESSID and NICKN are strings up to 32 bytes long, it doesn't fit + * within the 'iwreq' structure, so we need to use the 'data' member to + * point to a string in user space, like it is done for RANGE... */ + +/* Other parameters useful in 802.11 and some other devices */ +#define SIOCSIWRATE 0x8B20 /* set default bit rate (bps) */ +#define SIOCGIWRATE 0x8B21 /* get default bit rate (bps) */ +#define SIOCSIWRTS 0x8B22 /* set RTS/CTS threshold (bytes) */ +#define SIOCGIWRTS 0x8B23 /* get RTS/CTS threshold (bytes) */ +#define SIOCSIWFRAG 0x8B24 /* set fragmentation thr (bytes) */ +#define SIOCGIWFRAG 0x8B25 /* get fragmentation thr (bytes) */ +#define SIOCSIWTXPOW 0x8B26 /* set transmit power (dBm) */ +#define SIOCGIWTXPOW 0x8B27 /* get transmit power (dBm) */ +#define SIOCSIWRETRY 0x8B28 /* set retry limits and lifetime */ +#define SIOCGIWRETRY 0x8B29 /* get retry limits and lifetime */ + +/* Encoding stuff (scrambling, hardware security, WEP...) */ +#define SIOCSIWENCODE 0x8B2A /* set encoding token & mode */ +#define SIOCGIWENCODE 0x8B2B /* get encoding token & mode */ +/* Power saving stuff (power management, unicast and multicast) */ +#define SIOCSIWPOWER 0x8B2C /* set Power Management settings */ +#define SIOCGIWPOWER 0x8B2D /* get Power Management settings */ + +/* WPA : Generic IEEE 802.11 informatiom element (e.g., for WPA/RSN/WMM). + * This ioctl uses struct iw_point and data buffer that includes IE id and len + * fields. More than one IE may be included in the request. Setting the generic + * IE to empty buffer (len=0) removes the generic IE from the driver. Drivers + * are allowed to generate their own WPA/RSN IEs, but in these cases, drivers + * are required to report the used IE as a wireless event, e.g., when + * associating with an AP. */ +#define SIOCSIWGENIE 0x8B30 /* set generic IE */ +#define SIOCGIWGENIE 0x8B31 /* get generic IE */ + +/* WPA : IEEE 802.11 MLME requests */ +#define SIOCSIWMLME 0x8B16 /* request MLME operation; uses + * struct iw_mlme */ +/* WPA : Authentication mode parameters */ +#define SIOCSIWAUTH 0x8B32 /* set authentication mode params */ +#define SIOCGIWAUTH 0x8B33 /* get authentication mode params */ + +/* WPA : Extended version of encoding configuration */ +#define SIOCSIWENCODEEXT 0x8B34 /* set encoding token & mode */ +#define SIOCGIWENCODEEXT 0x8B35 /* get encoding token & mode */ + +/* WPA2 : PMKSA cache management */ +#define SIOCSIWPMKSA 0x8B36 /* PMKSA cache operation */ + +/* -------------------- DEV PRIVATE IOCTL LIST -------------------- */ + +/* These 32 ioctl are wireless device private, for 16 commands. + * Each driver is free to use them for whatever purpose it chooses, + * however the driver *must* export the description of those ioctls + * with SIOCGIWPRIV and *must* use arguments as defined below. + * If you don't follow those rules, DaveM is going to hate you (reason : + * it make mixed 32/64bit operation impossible). + */ +#define SIOCIWFIRSTPRIV 0x8BE0 +#define SIOCIWLASTPRIV 0x8BFF +/* Previously, we were using SIOCDEVPRIVATE, but we now have our + * separate range because of collisions with other tools such as + * 'mii-tool'. + * We now have 32 commands, so a bit more space ;-). + * Also, all 'even' commands are only usable by root and don't return the + * content of ifr/iwr to user (but you are not obliged to use the set/get + * convention, just use every other two command). More details in iwpriv.c. + * And I repeat : you are not forced to use them with iwpriv, but you + * must be compliant with it. + */ + +/* ------------------------- IOCTL STUFF ------------------------- */ + +/* The first and the last (range) */ +#define SIOCIWFIRST 0x8B00 +#define SIOCIWLAST SIOCIWLASTPRIV /* 0x8BFF */ +#define IW_IOCTL_IDX(cmd) ((cmd) - SIOCIWFIRST) +#define IW_HANDLER(id, func) \ + [IW_IOCTL_IDX(id)] = func + +/* Odd : get (world access), even : set (root access) */ +#define IW_IS_SET(cmd) (!((cmd) & 0x1)) +#define IW_IS_GET(cmd) ((cmd) & 0x1) + +/* ----------------------- WIRELESS EVENTS ----------------------- */ +/* Those are *NOT* ioctls, do not issue request on them !!! */ +/* Most events use the same identifier as ioctl requests */ + +#define IWEVTXDROP 0x8C00 /* Packet dropped to excessive retry */ +#define IWEVQUAL 0x8C01 /* Quality part of statistics (scan) */ +#define IWEVCUSTOM 0x8C02 /* Driver specific ascii string */ +#define IWEVREGISTERED 0x8C03 /* Discovered a new node (AP mode) */ +#define IWEVEXPIRED 0x8C04 /* Expired a node (AP mode) */ +#define IWEVGENIE 0x8C05 /* Generic IE (WPA, RSN, WMM, ..) + * (scan results); This includes id and + * length fields. One IWEVGENIE may + * contain more than one IE. Scan + * results may contain one or more + * IWEVGENIE events. */ +#define IWEVMICHAELMICFAILURE 0x8C06 /* Michael MIC failure + * (struct iw_michaelmicfailure) + */ +#define IWEVASSOCREQIE 0x8C07 /* IEs used in (Re)Association Request. + * The data includes id and length + * fields and may contain more than one + * IE. This event is required in + * Managed mode if the driver + * generates its own WPA/RSN IE. This + * should be sent just before + * IWEVREGISTERED event for the + * association. */ +#define IWEVASSOCRESPIE 0x8C08 /* IEs used in (Re)Association + * Response. The data includes id and + * length fields and may contain more + * than one IE. This may be sent + * between IWEVASSOCREQIE and + * IWEVREGISTERED events for the + * association. */ +#define IWEVPMKIDCAND 0x8C09 /* PMKID candidate for RSN + * pre-authentication + * (struct iw_pmkid_cand) */ + +#define IWEVFIRST 0x8C00 +#define IW_EVENT_IDX(cmd) ((cmd) - IWEVFIRST) + +/* ------------------------- PRIVATE INFO ------------------------- */ +/* + * The following is used with SIOCGIWPRIV. It allow a driver to define + * the interface (name, type of data) for its private ioctl. + * Privates ioctl are SIOCIWFIRSTPRIV -> SIOCIWLASTPRIV + */ + +#define IW_PRIV_TYPE_MASK 0x7000 /* Type of arguments */ +#define IW_PRIV_TYPE_NONE 0x0000 +#define IW_PRIV_TYPE_BYTE 0x1000 /* Char as number */ +#define IW_PRIV_TYPE_CHAR 0x2000 /* Char as character */ +#define IW_PRIV_TYPE_INT 0x4000 /* 32 bits int */ +#define IW_PRIV_TYPE_FLOAT 0x5000 /* struct iw_freq */ +#define IW_PRIV_TYPE_ADDR 0x6000 /* struct sockaddr */ + +#define IW_PRIV_SIZE_FIXED 0x0800 /* Variable or fixed number of args */ + +#define IW_PRIV_SIZE_MASK 0x07FF /* Max number of those args */ + +/* + * Note : if the number of args is fixed and the size < 16 octets, + * instead of passing a pointer we will put args in the iwreq struct... + */ + +/* ----------------------- OTHER CONSTANTS ----------------------- */ + +/* Maximum frequencies in the range struct */ +#define IW_MAX_FREQUENCIES 32 +/* Note : if you have something like 80 frequencies, + * don't increase this constant and don't fill the frequency list. + * The user will be able to set by channel anyway... */ + +/* Maximum bit rates in the range struct */ +#define IW_MAX_BITRATES 32 + +/* Maximum tx powers in the range struct */ +#define IW_MAX_TXPOWER 8 +/* Note : if you more than 8 TXPowers, just set the max and min or + * a few of them in the struct iw_range. */ + +/* Maximum of address that you may set with SPY */ +#define IW_MAX_SPY 8 + +/* Maximum of address that you may get in the + list of access points in range */ +#define IW_MAX_AP 64 + +/* Maximum size of the ESSID and NICKN strings */ +#define IW_ESSID_MAX_SIZE 32 + +/* Modes of operation */ +#define IW_MODE_AUTO 0 /* Let the driver decides */ +#define IW_MODE_ADHOC 1 /* Single cell network */ +#define IW_MODE_INFRA 2 /* Multi cell network, roaming, ... */ +#define IW_MODE_MASTER 3 /* Synchronisation master or Access Point */ +#define IW_MODE_REPEAT 4 /* Wireless Repeater (forwarder) */ +#define IW_MODE_SECOND 5 /* Secondary master/repeater (backup) */ +#define IW_MODE_MONITOR 6 /* Passive monitor (listen only) */ +#define IW_MODE_MESH 7 /* Mesh (IEEE 802.11s) network */ + +/* Statistics flags (bitmask in updated) */ +#define IW_QUAL_QUAL_UPDATED 0x01 /* Value was updated since last read */ +#define IW_QUAL_LEVEL_UPDATED 0x02 +#define IW_QUAL_NOISE_UPDATED 0x04 +#define IW_QUAL_ALL_UPDATED 0x07 +#define IW_QUAL_DBM 0x08 /* Level + Noise are dBm */ +#define IW_QUAL_QUAL_INVALID 0x10 /* Driver doesn't provide value */ +#define IW_QUAL_LEVEL_INVALID 0x20 +#define IW_QUAL_NOISE_INVALID 0x40 +#define IW_QUAL_RCPI 0x80 /* Level + Noise are 802.11k RCPI */ +#define IW_QUAL_ALL_INVALID 0x70 + +/* Frequency flags */ +#define IW_FREQ_AUTO 0x00 /* Let the driver decides */ +#define IW_FREQ_FIXED 0x01 /* Force a specific value */ + +/* Maximum number of size of encoding token available + * they are listed in the range structure */ +#define IW_MAX_ENCODING_SIZES 8 + +/* Maximum size of the encoding token in bytes */ +#define IW_ENCODING_TOKEN_MAX 64 /* 512 bits (for now) */ + +/* Flags for encoding (along with the token) */ +#define IW_ENCODE_INDEX 0x00FF /* Token index (if needed) */ +#define IW_ENCODE_FLAGS 0xFF00 /* Flags defined below */ +#define IW_ENCODE_MODE 0xF000 /* Modes defined below */ +#define IW_ENCODE_DISABLED 0x8000 /* Encoding disabled */ +#define IW_ENCODE_ENABLED 0x0000 /* Encoding enabled */ +#define IW_ENCODE_RESTRICTED 0x4000 /* Refuse non-encoded packets */ +#define IW_ENCODE_OPEN 0x2000 /* Accept non-encoded packets */ +#define IW_ENCODE_NOKEY 0x0800 /* Key is write only, so not present */ +#define IW_ENCODE_TEMP 0x0400 /* Temporary key */ + +/* Power management flags available (along with the value, if any) */ +#define IW_POWER_ON 0x0000 /* No details... */ +#define IW_POWER_TYPE 0xF000 /* Type of parameter */ +#define IW_POWER_PERIOD 0x1000 /* Value is a period/duration of */ +#define IW_POWER_TIMEOUT 0x2000 /* Value is a timeout (to go asleep) */ +#define IW_POWER_MODE 0x0F00 /* Power Management mode */ +#define IW_POWER_UNICAST_R 0x0100 /* Receive only unicast messages */ +#define IW_POWER_MULTICAST_R 0x0200 /* Receive only multicast messages */ +#define IW_POWER_ALL_R 0x0300 /* Receive all messages though PM */ +#define IW_POWER_FORCE_S 0x0400 /* Force PM procedure for sending unicast */ +#define IW_POWER_REPEATER 0x0800 /* Repeat broadcast messages in PM period */ +#define IW_POWER_MODIFIER 0x000F /* Modify a parameter */ +#define IW_POWER_MIN 0x0001 /* Value is a minimum */ +#define IW_POWER_MAX 0x0002 /* Value is a maximum */ +#define IW_POWER_RELATIVE 0x0004 /* Value is not in seconds/ms/us */ + +/* Transmit Power flags available */ +#define IW_TXPOW_TYPE 0x00FF /* Type of value */ +#define IW_TXPOW_DBM 0x0000 /* Value is in dBm */ +#define IW_TXPOW_MWATT 0x0001 /* Value is in mW */ +#define IW_TXPOW_RELATIVE 0x0002 /* Value is in arbitrary units */ +#define IW_TXPOW_RANGE 0x1000 /* Range of value between min/max */ + +/* Retry limits and lifetime flags available */ +#define IW_RETRY_ON 0x0000 /* No details... */ +#define IW_RETRY_TYPE 0xF000 /* Type of parameter */ +#define IW_RETRY_LIMIT 0x1000 /* Maximum number of retries*/ +#define IW_RETRY_LIFETIME 0x2000 /* Maximum duration of retries in us */ +#define IW_RETRY_MODIFIER 0x00FF /* Modify a parameter */ +#define IW_RETRY_MIN 0x0001 /* Value is a minimum */ +#define IW_RETRY_MAX 0x0002 /* Value is a maximum */ +#define IW_RETRY_RELATIVE 0x0004 /* Value is not in seconds/ms/us */ +#define IW_RETRY_SHORT 0x0010 /* Value is for short packets */ +#define IW_RETRY_LONG 0x0020 /* Value is for long packets */ + +/* Scanning request flags */ +#define IW_SCAN_DEFAULT 0x0000 /* Default scan of the driver */ +#define IW_SCAN_ALL_ESSID 0x0001 /* Scan all ESSIDs */ +#define IW_SCAN_THIS_ESSID 0x0002 /* Scan only this ESSID */ +#define IW_SCAN_ALL_FREQ 0x0004 /* Scan all Frequencies */ +#define IW_SCAN_THIS_FREQ 0x0008 /* Scan only this Frequency */ +#define IW_SCAN_ALL_MODE 0x0010 /* Scan all Modes */ +#define IW_SCAN_THIS_MODE 0x0020 /* Scan only this Mode */ +#define IW_SCAN_ALL_RATE 0x0040 /* Scan all Bit-Rates */ +#define IW_SCAN_THIS_RATE 0x0080 /* Scan only this Bit-Rate */ +/* struct iw_scan_req scan_type */ +#define IW_SCAN_TYPE_ACTIVE 0 +#define IW_SCAN_TYPE_PASSIVE 1 +/* Maximum size of returned data */ +#define IW_SCAN_MAX_DATA 4096 /* In bytes */ + +/* Scan capability flags - in (struct iw_range *)->scan_capa */ +#define IW_SCAN_CAPA_NONE 0x00 +#define IW_SCAN_CAPA_ESSID 0x01 +#define IW_SCAN_CAPA_BSSID 0x02 +#define IW_SCAN_CAPA_CHANNEL 0x04 +#define IW_SCAN_CAPA_MODE 0x08 +#define IW_SCAN_CAPA_RATE 0x10 +#define IW_SCAN_CAPA_TYPE 0x20 +#define IW_SCAN_CAPA_TIME 0x40 + +/* Max number of char in custom event - use multiple of them if needed */ +#define IW_CUSTOM_MAX 256 /* In bytes */ + +/* Generic information element */ +#define IW_GENERIC_IE_MAX 1024 + +/* MLME requests (SIOCSIWMLME / struct iw_mlme) */ +#define IW_MLME_DEAUTH 0 +#define IW_MLME_DISASSOC 1 +#define IW_MLME_AUTH 2 +#define IW_MLME_ASSOC 3 + +/* SIOCSIWAUTH/SIOCGIWAUTH struct iw_param flags */ +#define IW_AUTH_INDEX 0x0FFF +#define IW_AUTH_FLAGS 0xF000 +/* SIOCSIWAUTH/SIOCGIWAUTH parameters (0 .. 4095) + * (IW_AUTH_INDEX mask in struct iw_param flags; this is the index of the + * parameter that is being set/get to; value will be read/written to + * struct iw_param value field) */ +#define IW_AUTH_WPA_VERSION 0 +#define IW_AUTH_CIPHER_PAIRWISE 1 +#define IW_AUTH_CIPHER_GROUP 2 +#define IW_AUTH_KEY_MGMT 3 +#define IW_AUTH_TKIP_COUNTERMEASURES 4 +#define IW_AUTH_DROP_UNENCRYPTED 5 +#define IW_AUTH_80211_AUTH_ALG 6 +#define IW_AUTH_WPA_ENABLED 7 +#define IW_AUTH_RX_UNENCRYPTED_EAPOL 8 +#define IW_AUTH_ROAMING_CONTROL 9 +#define IW_AUTH_PRIVACY_INVOKED 10 +#define IW_AUTH_CIPHER_GROUP_MGMT 11 +#define IW_AUTH_MFP 12 + +/* IW_AUTH_WPA_VERSION values (bit field) */ +#define IW_AUTH_WPA_VERSION_DISABLED 0x00000001 +#define IW_AUTH_WPA_VERSION_WPA 0x00000002 +#define IW_AUTH_WPA_VERSION_WPA2 0x00000004 + +/* IW_AUTH_PAIRWISE_CIPHER, IW_AUTH_GROUP_CIPHER, and IW_AUTH_CIPHER_GROUP_MGMT + * values (bit field) */ +#define IW_AUTH_CIPHER_NONE 0x00000001 +#define IW_AUTH_CIPHER_WEP40 0x00000002 +#define IW_AUTH_CIPHER_TKIP 0x00000004 +#define IW_AUTH_CIPHER_CCMP 0x00000008 +#define IW_AUTH_CIPHER_WEP104 0x00000010 +#define IW_AUTH_CIPHER_AES_CMAC 0x00000020 + +/* IW_AUTH_KEY_MGMT values (bit field) */ +#define IW_AUTH_KEY_MGMT_802_1X 1 +#define IW_AUTH_KEY_MGMT_PSK 2 + +/* IW_AUTH_80211_AUTH_ALG values (bit field) */ +#define IW_AUTH_ALG_OPEN_SYSTEM 0x00000001 +#define IW_AUTH_ALG_SHARED_KEY 0x00000002 +#define IW_AUTH_ALG_LEAP 0x00000004 + +/* IW_AUTH_ROAMING_CONTROL values */ +#define IW_AUTH_ROAMING_ENABLE 0 /* driver/firmware based roaming */ +#define IW_AUTH_ROAMING_DISABLE 1 /* user space program used for roaming + * control */ + +/* IW_AUTH_MFP (management frame protection) values */ +#define IW_AUTH_MFP_DISABLED 0 /* MFP disabled */ +#define IW_AUTH_MFP_OPTIONAL 1 /* MFP optional */ +#define IW_AUTH_MFP_REQUIRED 2 /* MFP required */ + +/* SIOCSIWENCODEEXT definitions */ +#define IW_ENCODE_SEQ_MAX_SIZE 8 +/* struct iw_encode_ext ->alg */ +#define IW_ENCODE_ALG_NONE 0 +#define IW_ENCODE_ALG_WEP 1 +#define IW_ENCODE_ALG_TKIP 2 +#define IW_ENCODE_ALG_CCMP 3 +#define IW_ENCODE_ALG_PMK 4 +#define IW_ENCODE_ALG_AES_CMAC 5 +/* struct iw_encode_ext ->ext_flags */ +#define IW_ENCODE_EXT_TX_SEQ_VALID 0x00000001 +#define IW_ENCODE_EXT_RX_SEQ_VALID 0x00000002 +#define IW_ENCODE_EXT_GROUP_KEY 0x00000004 +#define IW_ENCODE_EXT_SET_TX_KEY 0x00000008 + +/* IWEVMICHAELMICFAILURE : struct iw_michaelmicfailure ->flags */ +#define IW_MICFAILURE_KEY_ID 0x00000003 /* Key ID 0..3 */ +#define IW_MICFAILURE_GROUP 0x00000004 +#define IW_MICFAILURE_PAIRWISE 0x00000008 +#define IW_MICFAILURE_STAKEY 0x00000010 +#define IW_MICFAILURE_COUNT 0x00000060 /* 1 or 2 (0 = count not supported) + */ + +/* Bit field values for enc_capa in struct iw_range */ +#define IW_ENC_CAPA_WPA 0x00000001 +#define IW_ENC_CAPA_WPA2 0x00000002 +#define IW_ENC_CAPA_CIPHER_TKIP 0x00000004 +#define IW_ENC_CAPA_CIPHER_CCMP 0x00000008 +#define IW_ENC_CAPA_4WAY_HANDSHAKE 0x00000010 + +/* Event capability macros - in (struct iw_range *)->event_capa + * Because we have more than 32 possible events, we use an array of + * 32 bit bitmasks. Note : 32 bits = 0x20 = 2^5. */ +#define IW_EVENT_CAPA_BASE(cmd) ((cmd >= SIOCIWFIRSTPRIV) ? \ + (cmd - SIOCIWFIRSTPRIV + 0x60) : \ + (cmd - SIOCIWFIRST)) +#define IW_EVENT_CAPA_INDEX(cmd) (IW_EVENT_CAPA_BASE(cmd) >> 5) +#define IW_EVENT_CAPA_MASK(cmd) (1 << (IW_EVENT_CAPA_BASE(cmd) & 0x1F)) +/* Event capability constants - event autogenerated by the kernel + * This list is valid for most 802.11 devices, customise as needed... */ +#define IW_EVENT_CAPA_K_0 (IW_EVENT_CAPA_MASK(0x8B04) | \ + IW_EVENT_CAPA_MASK(0x8B06) | \ + IW_EVENT_CAPA_MASK(0x8B1A)) +#define IW_EVENT_CAPA_K_1 (IW_EVENT_CAPA_MASK(0x8B2A)) +/* "Easy" macro to set events in iw_range (less efficient) */ +#define IW_EVENT_CAPA_SET(event_capa, cmd) (event_capa[IW_EVENT_CAPA_INDEX(cmd)] |= IW_EVENT_CAPA_MASK(cmd)) +#define IW_EVENT_CAPA_SET_KERNEL(event_capa) {event_capa[0] |= IW_EVENT_CAPA_K_0; event_capa[1] |= IW_EVENT_CAPA_K_1; } + + +/****************************** TYPES ******************************/ + +/* --------------------------- SUBTYPES --------------------------- */ +/* + * Generic format for most parameters that fit in an int + */ +struct iw_param +{ + __s32 value; /* The value of the parameter itself */ + __u8 fixed; /* Hardware should not use auto select */ + __u8 disabled; /* Disable the feature */ + __u16 flags; /* Various specifc flags (if any) */ +}; + +/* + * For all data larger than 16 octets, we need to use a + * pointer to memory allocated in user space. + */ +struct iw_point +{ + void __user *pointer; /* Pointer to the data (in user space) */ + __u16 length; /* number of fields or size in bytes */ + __u16 flags; /* Optional params */ +}; + +#ifdef __KERNEL__ +#ifdef CONFIG_COMPAT + +#include + +struct compat_iw_point { + compat_caddr_t pointer; + __u16 length; + __u16 flags; +}; +#endif +#endif + +/* + * A frequency + * For numbers lower than 10^9, we encode the number in 'm' and + * set 'e' to 0 + * For number greater than 10^9, we divide it by the lowest power + * of 10 to get 'm' lower than 10^9, with 'm'= f / (10^'e')... + * The power of 10 is in 'e', the result of the division is in 'm'. + */ +struct iw_freq +{ + __s32 m; /* Mantissa */ + __s16 e; /* Exponent */ + __u8 i; /* List index (when in range struct) */ + __u8 flags; /* Flags (fixed/auto) */ +}; + +/* + * Quality of the link + */ +struct iw_quality +{ + __u8 qual; /* link quality (%retries, SNR, + %missed beacons or better...) */ + __u8 level; /* signal level (dBm) */ + __u8 noise; /* noise level (dBm) */ + __u8 updated; /* Flags to know if updated */ +}; + +/* + * Packet discarded in the wireless adapter due to + * "wireless" specific problems... + * Note : the list of counter and statistics in net_device_stats + * is already pretty exhaustive, and you should use that first. + * This is only additional stats... + */ +struct iw_discarded +{ + __u32 nwid; /* Rx : Wrong nwid/essid */ + __u32 code; /* Rx : Unable to code/decode (WEP) */ + __u32 fragment; /* Rx : Can't perform MAC reassembly */ + __u32 retries; /* Tx : Max MAC retries num reached */ + __u32 misc; /* Others cases */ +}; + +/* + * Packet/Time period missed in the wireless adapter due to + * "wireless" specific problems... + */ +struct iw_missed +{ + __u32 beacon; /* Missed beacons/superframe */ +}; + +/* + * Quality range (for spy threshold) + */ +struct iw_thrspy +{ + struct sockaddr addr; /* Source address (hw/mac) */ + struct iw_quality qual; /* Quality of the link */ + struct iw_quality low; /* Low threshold */ + struct iw_quality high; /* High threshold */ +}; + +/* + * Optional data for scan request + * + * Note: these optional parameters are controlling parameters for the + * scanning behavior, these do not apply to getting scan results + * (SIOCGIWSCAN). Drivers are expected to keep a local BSS table and + * provide a merged results with all BSSes even if the previous scan + * request limited scanning to a subset, e.g., by specifying an SSID. + * Especially, scan results are required to include an entry for the + * current BSS if the driver is in Managed mode and associated with an AP. + */ +struct iw_scan_req +{ + __u8 scan_type; /* IW_SCAN_TYPE_{ACTIVE,PASSIVE} */ + __u8 essid_len; + __u8 num_channels; /* num entries in channel_list; + * 0 = scan all allowed channels */ + __u8 flags; /* reserved as padding; use zero, this may + * be used in the future for adding flags + * to request different scan behavior */ + struct sockaddr bssid; /* ff:ff:ff:ff:ff:ff for broadcast BSSID or + * individual address of a specific BSS */ + + /* + * Use this ESSID if IW_SCAN_THIS_ESSID flag is used instead of using + * the current ESSID. This allows scan requests for specific ESSID + * without having to change the current ESSID and potentially breaking + * the current association. + */ + __u8 essid[IW_ESSID_MAX_SIZE]; + + /* + * Optional parameters for changing the default scanning behavior. + * These are based on the MLME-SCAN.request from IEEE Std 802.11. + * TU is 1.024 ms. If these are set to 0, driver is expected to use + * reasonable default values. min_channel_time defines the time that + * will be used to wait for the first reply on each channel. If no + * replies are received, next channel will be scanned after this. If + * replies are received, total time waited on the channel is defined by + * max_channel_time. + */ + __u32 min_channel_time; /* in TU */ + __u32 max_channel_time; /* in TU */ + + struct iw_freq channel_list[IW_MAX_FREQUENCIES]; +}; + +/* ------------------------- WPA SUPPORT ------------------------- */ + +/* + * Extended data structure for get/set encoding (this is used with + * SIOCSIWENCODEEXT/SIOCGIWENCODEEXT. struct iw_point and IW_ENCODE_* + * flags are used in the same way as with SIOCSIWENCODE/SIOCGIWENCODE and + * only the data contents changes (key data -> this structure, including + * key data). + * + * If the new key is the first group key, it will be set as the default + * TX key. Otherwise, default TX key index is only changed if + * IW_ENCODE_EXT_SET_TX_KEY flag is set. + * + * Key will be changed with SIOCSIWENCODEEXT in all cases except for + * special "change TX key index" operation which is indicated by setting + * key_len = 0 and ext_flags |= IW_ENCODE_EXT_SET_TX_KEY. + * + * tx_seq/rx_seq are only used when respective + * IW_ENCODE_EXT_{TX,RX}_SEQ_VALID flag is set in ext_flags. Normal + * TKIP/CCMP operation is to set RX seq with SIOCSIWENCODEEXT and start + * TX seq from zero whenever key is changed. SIOCGIWENCODEEXT is normally + * used only by an Authenticator (AP or an IBSS station) to get the + * current TX sequence number. Using TX_SEQ_VALID for SIOCSIWENCODEEXT and + * RX_SEQ_VALID for SIOCGIWENCODEEXT are optional, but can be useful for + * debugging/testing. + */ +struct iw_encode_ext +{ + __u32 ext_flags; /* IW_ENCODE_EXT_* */ + __u8 tx_seq[IW_ENCODE_SEQ_MAX_SIZE]; /* LSB first */ + __u8 rx_seq[IW_ENCODE_SEQ_MAX_SIZE]; /* LSB first */ + struct sockaddr addr; /* ff:ff:ff:ff:ff:ff for broadcast/multicast + * (group) keys or unicast address for + * individual keys */ + __u16 alg; /* IW_ENCODE_ALG_* */ + __u16 key_len; + __u8 key[0]; +}; + +/* SIOCSIWMLME data */ +struct iw_mlme +{ + __u16 cmd; /* IW_MLME_* */ + __u16 reason_code; + struct sockaddr addr; +}; + +/* SIOCSIWPMKSA data */ +#define IW_PMKSA_ADD 1 +#define IW_PMKSA_REMOVE 2 +#define IW_PMKSA_FLUSH 3 + +#define IW_PMKID_LEN 16 + +struct iw_pmksa +{ + __u32 cmd; /* IW_PMKSA_* */ + struct sockaddr bssid; + __u8 pmkid[IW_PMKID_LEN]; +}; + +/* IWEVMICHAELMICFAILURE data */ +struct iw_michaelmicfailure +{ + __u32 flags; + struct sockaddr src_addr; + __u8 tsc[IW_ENCODE_SEQ_MAX_SIZE]; /* LSB first */ +}; + +/* IWEVPMKIDCAND data */ +#define IW_PMKID_CAND_PREAUTH 0x00000001 /* RNS pre-authentication enabled */ +struct iw_pmkid_cand +{ + __u32 flags; /* IW_PMKID_CAND_* */ + __u32 index; /* the smaller the index, the higher the + * priority */ + struct sockaddr bssid; +}; + +/* ------------------------ WIRELESS STATS ------------------------ */ +/* + * Wireless statistics (used for /proc/net/wireless) + */ +struct iw_statistics +{ + __u16 status; /* Status + * - device dependent for now */ + + struct iw_quality qual; /* Quality of the link + * (instant/mean/max) */ + struct iw_discarded discard; /* Packet discarded counts */ + struct iw_missed miss; /* Packet missed counts */ +}; + +/* ------------------------ IOCTL REQUEST ------------------------ */ +/* + * This structure defines the payload of an ioctl, and is used + * below. + * + * Note that this structure should fit on the memory footprint + * of iwreq (which is the same as ifreq), which mean a max size of + * 16 octets = 128 bits. Warning, pointers might be 64 bits wide... + * You should check this when increasing the structures defined + * above in this file... + */ +union iwreq_data +{ + /* Config - generic */ + char name[IFNAMSIZ]; + /* Name : used to verify the presence of wireless extensions. + * Name of the protocol/provider... */ + + struct iw_point essid; /* Extended network name */ + struct iw_param nwid; /* network id (or domain - the cell) */ + struct iw_freq freq; /* frequency or channel : + * 0-1000 = channel + * > 1000 = frequency in Hz */ + + struct iw_param sens; /* signal level threshold */ + struct iw_param bitrate; /* default bit rate */ + struct iw_param txpower; /* default transmit power */ + struct iw_param rts; /* RTS threshold threshold */ + struct iw_param frag; /* Fragmentation threshold */ + __u32 mode; /* Operation mode */ + struct iw_param retry; /* Retry limits & lifetime */ + + struct iw_point encoding; /* Encoding stuff : tokens */ + struct iw_param power; /* PM duration/timeout */ + struct iw_quality qual; /* Quality part of statistics */ + + struct sockaddr ap_addr; /* Access point address */ + struct sockaddr addr; /* Destination address (hw/mac) */ + + struct iw_param param; /* Other small parameters */ + struct iw_point data; /* Other large parameters */ +}; + +/* + * The structure to exchange data for ioctl. + * This structure is the same as 'struct ifreq', but (re)defined for + * convenience... + * Do I need to remind you about structure size (32 octets) ? + */ +struct iwreq +{ + union + { + char ifrn_name[IFNAMSIZ]; /* if name, e.g. "eth0" */ + } ifr_ifrn; + + /* Data part (defined just above) */ + union iwreq_data u; +}; + +/* -------------------------- IOCTL DATA -------------------------- */ +/* + * For those ioctl which want to exchange mode data that what could + * fit in the above structure... + */ + +/* + * Range of parameters + */ + +struct iw_range +{ + /* Informative stuff (to choose between different interface) */ + __u32 throughput; /* To give an idea... */ + /* In theory this value should be the maximum benchmarked + * TCP/IP throughput, because with most of these devices the + * bit rate is meaningless (overhead an co) to estimate how + * fast the connection will go and pick the fastest one. + * I suggest people to play with Netperf or any benchmark... + */ + + /* NWID (or domain id) */ + __u32 min_nwid; /* Minimal NWID we are able to set */ + __u32 max_nwid; /* Maximal NWID we are able to set */ + + /* Old Frequency (backward compat - moved lower ) */ + __u16 old_num_channels; + __u8 old_num_frequency; + + /* Scan capabilities */ + __u8 scan_capa; /* IW_SCAN_CAPA_* bit field */ + + /* Wireless event capability bitmasks */ + __u32 event_capa[6]; + + /* signal level threshold range */ + __s32 sensitivity; + + /* Quality of link & SNR stuff */ + /* Quality range (link, level, noise) + * If the quality is absolute, it will be in the range [0 ; max_qual], + * if the quality is dBm, it will be in the range [max_qual ; 0]. + * Don't forget that we use 8 bit arithmetics... */ + struct iw_quality max_qual; /* Quality of the link */ + /* This should contain the average/typical values of the quality + * indicator. This should be the threshold between a "good" and + * a "bad" link (example : monitor going from green to orange). + * Currently, user space apps like quality monitors don't have any + * way to calibrate the measurement. With this, they can split + * the range between 0 and max_qual in different quality level + * (using a geometric subdivision centered on the average). + * I expect that people doing the user space apps will feedback + * us on which value we need to put in each driver... */ + struct iw_quality avg_qual; /* Quality of the link */ + + /* Rates */ + __u8 num_bitrates; /* Number of entries in the list */ + __s32 bitrate[IW_MAX_BITRATES]; /* list, in bps */ + + /* RTS threshold */ + __s32 min_rts; /* Minimal RTS threshold */ + __s32 max_rts; /* Maximal RTS threshold */ + + /* Frag threshold */ + __s32 min_frag; /* Minimal frag threshold */ + __s32 max_frag; /* Maximal frag threshold */ + + /* Power Management duration & timeout */ + __s32 min_pmp; /* Minimal PM period */ + __s32 max_pmp; /* Maximal PM period */ + __s32 min_pmt; /* Minimal PM timeout */ + __s32 max_pmt; /* Maximal PM timeout */ + __u16 pmp_flags; /* How to decode max/min PM period */ + __u16 pmt_flags; /* How to decode max/min PM timeout */ + __u16 pm_capa; /* What PM options are supported */ + + /* Encoder stuff */ + __u16 encoding_size[IW_MAX_ENCODING_SIZES]; /* Different token sizes */ + __u8 num_encoding_sizes; /* Number of entry in the list */ + __u8 max_encoding_tokens; /* Max number of tokens */ + /* For drivers that need a "login/passwd" form */ + __u8 encoding_login_index; /* token index for login token */ + + /* Transmit power */ + __u16 txpower_capa; /* What options are supported */ + __u8 num_txpower; /* Number of entries in the list */ + __s32 txpower[IW_MAX_TXPOWER]; /* list, in bps */ + + /* Wireless Extension version info */ + __u8 we_version_compiled; /* Must be WIRELESS_EXT */ + __u8 we_version_source; /* Last update of source */ + + /* Retry limits and lifetime */ + __u16 retry_capa; /* What retry options are supported */ + __u16 retry_flags; /* How to decode max/min retry limit */ + __u16 r_time_flags; /* How to decode max/min retry life */ + __s32 min_retry; /* Minimal number of retries */ + __s32 max_retry; /* Maximal number of retries */ + __s32 min_r_time; /* Minimal retry lifetime */ + __s32 max_r_time; /* Maximal retry lifetime */ + + /* Frequency */ + __u16 num_channels; /* Number of channels [0; num - 1] */ + __u8 num_frequency; /* Number of entry in the list */ + struct iw_freq freq[IW_MAX_FREQUENCIES]; /* list */ + /* Note : this frequency list doesn't need to fit channel numbers, + * because each entry contain its channel index */ + + __u32 enc_capa; /* IW_ENC_CAPA_* bit field */ +}; + +/* + * Private ioctl interface information + */ + +struct iw_priv_args +{ + __u32 cmd; /* Number of the ioctl to issue */ + __u16 set_args; /* Type and number of args */ + __u16 get_args; /* Type and number of args */ + char name[IFNAMSIZ]; /* Name of the extension */ +}; + +/* ----------------------- WIRELESS EVENTS ----------------------- */ +/* + * Wireless events are carried through the rtnetlink socket to user + * space. They are encapsulated in the IFLA_WIRELESS field of + * a RTM_NEWLINK message. + */ + +/* + * A Wireless Event. Contains basically the same data as the ioctl... + */ +struct iw_event +{ + __u16 len; /* Real length of this stuff */ + __u16 cmd; /* Wireless IOCTL */ + union iwreq_data u; /* IOCTL fixed payload */ +}; + +/* Size of the Event prefix (including padding and alignement junk) */ +#define IW_EV_LCP_LEN (sizeof(struct iw_event) - sizeof(union iwreq_data)) +/* Size of the various events */ +#define IW_EV_CHAR_LEN (IW_EV_LCP_LEN + IFNAMSIZ) +#define IW_EV_UINT_LEN (IW_EV_LCP_LEN + sizeof(__u32)) +#define IW_EV_FREQ_LEN (IW_EV_LCP_LEN + sizeof(struct iw_freq)) +#define IW_EV_PARAM_LEN (IW_EV_LCP_LEN + sizeof(struct iw_param)) +#define IW_EV_ADDR_LEN (IW_EV_LCP_LEN + sizeof(struct sockaddr)) +#define IW_EV_QUAL_LEN (IW_EV_LCP_LEN + sizeof(struct iw_quality)) + +/* iw_point events are special. First, the payload (extra data) come at + * the end of the event, so they are bigger than IW_EV_POINT_LEN. Second, + * we omit the pointer, so start at an offset. */ +#define IW_EV_POINT_OFF (((char *) &(((struct iw_point *) NULL)->length)) - \ + (char *) NULL) +#define IW_EV_POINT_LEN (IW_EV_LCP_LEN + sizeof(struct iw_point) - \ + IW_EV_POINT_OFF) + +#ifdef __KERNEL__ +#ifdef CONFIG_COMPAT +struct __compat_iw_event { + __u16 len; /* Real length of this stuff */ + __u16 cmd; /* Wireless IOCTL */ + compat_caddr_t pointer; +}; +#define IW_EV_COMPAT_LCP_LEN offsetof(struct __compat_iw_event, pointer) +#define IW_EV_COMPAT_POINT_OFF offsetof(struct compat_iw_point, length) + +/* Size of the various events for compat */ +#define IW_EV_COMPAT_CHAR_LEN (IW_EV_COMPAT_LCP_LEN + IFNAMSIZ) +#define IW_EV_COMPAT_UINT_LEN (IW_EV_COMPAT_LCP_LEN + sizeof(__u32)) +#define IW_EV_COMPAT_FREQ_LEN (IW_EV_COMPAT_LCP_LEN + sizeof(struct iw_freq)) +#define IW_EV_COMPAT_PARAM_LEN (IW_EV_COMPAT_LCP_LEN + sizeof(struct iw_param)) +#define IW_EV_COMPAT_ADDR_LEN (IW_EV_COMPAT_LCP_LEN + sizeof(struct sockaddr)) +#define IW_EV_COMPAT_QUAL_LEN (IW_EV_COMPAT_LCP_LEN + sizeof(struct iw_quality)) +#define IW_EV_COMPAT_POINT_LEN \ + (IW_EV_COMPAT_LCP_LEN + sizeof(struct compat_iw_point) - \ + IW_EV_COMPAT_POINT_OFF) +#endif +#endif + +/* Size of the Event prefix when packed in stream */ +#define IW_EV_LCP_PK_LEN (4) +/* Size of the various events when packed in stream */ +#define IW_EV_CHAR_PK_LEN (IW_EV_LCP_PK_LEN + IFNAMSIZ) +#define IW_EV_UINT_PK_LEN (IW_EV_LCP_PK_LEN + sizeof(__u32)) +#define IW_EV_FREQ_PK_LEN (IW_EV_LCP_PK_LEN + sizeof(struct iw_freq)) +#define IW_EV_PARAM_PK_LEN (IW_EV_LCP_PK_LEN + sizeof(struct iw_param)) +#define IW_EV_ADDR_PK_LEN (IW_EV_LCP_PK_LEN + sizeof(struct sockaddr)) +#define IW_EV_QUAL_PK_LEN (IW_EV_LCP_PK_LEN + sizeof(struct iw_quality)) +#define IW_EV_POINT_PK_LEN (IW_EV_LCP_PK_LEN + 4) + +#endif /* _LINUX_WIRELESS_H */ diff --git a/backport/backport-include/net/codel.h b/backport/backport-include/net/codel.h new file mode 100644 index 000000000000..eee0359cd6e5 --- /dev/null +++ b/backport/backport-include/net/codel.h @@ -0,0 +1,363 @@ +#include +#include + +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,5,0)) || (defined(TCA_CODEL_MAX) && !defined(COMPAT_CODEL_BACKPORT)) +#include_next +#else + +#ifndef __NET_SCHED_CODEL_H +#define __NET_SCHED_CODEL_H + +/* + * Codel - The Controlled-Delay Active Queue Management algorithm + * + * Copyright (C) 2011-2012 Kathleen Nichols + * Copyright (C) 2011-2012 Van Jacobson + * Copyright (C) 2012 Michael D. Taht + * Copyright (C) 2012 Eric Dumazet + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions, and the following disclaimer, + * without modification. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The names of the authors may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * Alternatively, provided that this notice is retained in full, this + * software may be distributed under the terms of the GNU General + * Public License ("GPL") version 2, in which case the provisions of the + * GPL apply INSTEAD OF those given above. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + */ + +#include +#include +#include +#include +#include +#include + +/* Controlling Queue Delay (CoDel) algorithm + * ========================================= + * Source : Kathleen Nichols and Van Jacobson + * http://queue.acm.org/detail.cfm?id=2209336 + * + * Implemented on linux by Dave Taht and Eric Dumazet + */ + + +/* CoDel uses a 1024 nsec clock, encoded in u32 + * This gives a range of 2199 seconds, because of signed compares + */ +typedef u32 codel_time_t; +typedef s32 codel_tdiff_t; +#define CODEL_SHIFT 10 +#define MS2TIME(a) ((a * NSEC_PER_MSEC) >> CODEL_SHIFT) + +static inline codel_time_t codel_get_time(void) +{ + u64 ns = ktime_to_ns(ktime_get()); + + return ns >> CODEL_SHIFT; +} + +#define codel_time_after(a, b) ((s32)(a) - (s32)(b) > 0) +#define codel_time_after_eq(a, b) ((s32)(a) - (s32)(b) >= 0) +#define codel_time_before(a, b) ((s32)(a) - (s32)(b) < 0) +#define codel_time_before_eq(a, b) ((s32)(a) - (s32)(b) <= 0) + +/* Qdiscs using codel plugin must use codel_skb_cb in their own cb[] */ +struct codel_skb_cb { + codel_time_t enqueue_time; +}; + +static struct codel_skb_cb *get_codel_cb(const struct sk_buff *skb) +{ + qdisc_cb_private_validate(skb, sizeof(struct codel_skb_cb)); +#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,37)) + return (struct codel_skb_cb *)qdisc_skb_cb((struct sk_buff *) skb)->data; +#else + return (struct codel_skb_cb *)qdisc_skb_cb(skb)->data; +#endif +} + +static codel_time_t codel_get_enqueue_time(const struct sk_buff *skb) +{ + return get_codel_cb(skb)->enqueue_time; +} + +static void codel_set_enqueue_time(struct sk_buff *skb) +{ + get_codel_cb(skb)->enqueue_time = codel_get_time(); +} + +static inline u32 codel_time_to_us(codel_time_t val) +{ + u64 valns = ((u64)val << CODEL_SHIFT); + + do_div(valns, NSEC_PER_USEC); + return (u32)valns; +} + +/** + * struct codel_params - contains codel parameters + * @target: target queue size (in time units) + * @interval: width of moving time window + * @ecn: is Explicit Congestion Notification enabled + */ +struct codel_params { + codel_time_t target; + codel_time_t interval; + bool ecn; +}; + +/** + * struct codel_vars - contains codel variables + * @count: how many drops we've done since the last time we + * entered dropping state + * @lastcount: count at entry to dropping state + * @dropping: set to true if in dropping state + * @rec_inv_sqrt: reciprocal value of sqrt(count) >> 1 + * @first_above_time: when we went (or will go) continuously above target + * for interval + * @drop_next: time to drop next packet, or when we dropped last + * @ldelay: sojourn time of last dequeued packet + */ +struct codel_vars { + u32 count; + u32 lastcount; + bool dropping; + u16 rec_inv_sqrt; + codel_time_t first_above_time; + codel_time_t drop_next; + codel_time_t ldelay; +}; + +#define REC_INV_SQRT_BITS (8 * sizeof(u16)) /* or sizeof_in_bits(rec_inv_sqrt) */ +/* needed shift to get a Q0.32 number from rec_inv_sqrt */ +#define REC_INV_SQRT_SHIFT (32 - REC_INV_SQRT_BITS) + +/** + * struct codel_stats - contains codel shared variables and stats + * @maxpacket: largest packet we've seen so far + * @drop_count: temp count of dropped packets in dequeue() + * ecn_mark: number of packets we ECN marked instead of dropping + */ +struct codel_stats { + u32 maxpacket; + u32 drop_count; + u32 ecn_mark; +}; + +static void codel_params_init(struct codel_params *params) +{ + params->interval = MS2TIME(100); + params->target = MS2TIME(5); + params->ecn = false; +} + +static void codel_vars_init(struct codel_vars *vars) +{ + memset(vars, 0, sizeof(*vars)); +} + +static void codel_stats_init(struct codel_stats *stats) +{ + stats->maxpacket = 256; +} + +/* + * http://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Iterative_methods_for_reciprocal_square_roots + * new_invsqrt = (invsqrt / 2) * (3 - count * invsqrt^2) + * + * Here, invsqrt is a fixed point number (< 1.0), 32bit mantissa, aka Q0.32 + */ +static void codel_Newton_step(struct codel_vars *vars) +{ + u32 invsqrt = ((u32)vars->rec_inv_sqrt) << REC_INV_SQRT_SHIFT; + u32 invsqrt2 = ((u64)invsqrt * invsqrt) >> 32; + u64 val = (3LL << 32) - ((u64)vars->count * invsqrt2); + + val >>= 2; /* avoid overflow in following multiply */ + val = (val * invsqrt) >> (32 - 2 + 1); + + vars->rec_inv_sqrt = val >> REC_INV_SQRT_SHIFT; +} + +/* + * CoDel control_law is t + interval/sqrt(count) + * We maintain in rec_inv_sqrt the reciprocal value of sqrt(count) to avoid + * both sqrt() and divide operation. + */ +static codel_time_t codel_control_law(codel_time_t t, + codel_time_t interval, + u32 rec_inv_sqrt) +{ + return t + reciprocal_divide(interval, rec_inv_sqrt << REC_INV_SQRT_SHIFT); +} + + +static bool codel_should_drop(const struct sk_buff *skb, + struct Qdisc *sch, + struct codel_vars *vars, + struct codel_params *params, + struct codel_stats *stats, + codel_time_t now) +{ + bool ok_to_drop; + + if (!skb) { + vars->first_above_time = 0; + return false; + } + + vars->ldelay = now - codel_get_enqueue_time(skb); +#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,37)) + sch->qstats.backlog -= qdisc_pkt_len((struct sk_buff *)skb); +#else + sch->qstats.backlog -= qdisc_pkt_len(skb); +#endif + +#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,37)) + if (unlikely(qdisc_pkt_len((struct sk_buff *)skb) > stats->maxpacket)) + stats->maxpacket = qdisc_pkt_len((struct sk_buff *)skb); +#else + if (unlikely(qdisc_pkt_len(skb) > stats->maxpacket)) + stats->maxpacket = qdisc_pkt_len(skb); +#endif + + if (codel_time_before(vars->ldelay, params->target) || + sch->qstats.backlog <= stats->maxpacket) { + /* went below - stay below for at least interval */ + vars->first_above_time = 0; + return false; + } + ok_to_drop = false; + if (vars->first_above_time == 0) { + /* just went above from below. If we stay above + * for at least interval we'll say it's ok to drop + */ + vars->first_above_time = now + params->interval; + } else if (codel_time_after(now, vars->first_above_time)) { + ok_to_drop = true; + } + return ok_to_drop; +} + +typedef struct sk_buff * (*codel_skb_dequeue_t)(struct codel_vars *vars, + struct Qdisc *sch); + +static struct sk_buff *codel_dequeue(struct Qdisc *sch, + struct codel_params *params, + struct codel_vars *vars, + struct codel_stats *stats, + codel_skb_dequeue_t dequeue_func) +{ + struct sk_buff *skb = dequeue_func(vars, sch); + codel_time_t now; + bool drop; + + if (!skb) { + vars->dropping = false; + return skb; + } + now = codel_get_time(); + drop = codel_should_drop(skb, sch, vars, params, stats, now); + if (vars->dropping) { + if (!drop) { + /* sojourn time below target - leave dropping state */ + vars->dropping = false; + } else if (codel_time_after_eq(now, vars->drop_next)) { + /* It's time for the next drop. Drop the current + * packet and dequeue the next. The dequeue might + * take us out of dropping state. + * If not, schedule the next drop. + * A large backlog might result in drop rates so high + * that the next drop should happen now, + * hence the while loop. + */ + while (vars->dropping && + codel_time_after_eq(now, vars->drop_next)) { + vars->count++; /* dont care of possible wrap + * since there is no more divide + */ + codel_Newton_step(vars); + if (params->ecn && INET_ECN_set_ce(skb)) { + stats->ecn_mark++; + vars->drop_next = + codel_control_law(vars->drop_next, + params->interval, + vars->rec_inv_sqrt); + goto end; + } + qdisc_drop(skb, sch); + stats->drop_count++; + skb = dequeue_func(vars, sch); + if (!codel_should_drop(skb, sch, + vars, params, stats, now)) { + /* leave dropping state */ + vars->dropping = false; + } else { + /* and schedule the next drop */ + vars->drop_next = + codel_control_law(vars->drop_next, + params->interval, + vars->rec_inv_sqrt); + } + } + } + } else if (drop) { + if (params->ecn && INET_ECN_set_ce(skb)) { + stats->ecn_mark++; + } else { + qdisc_drop(skb, sch); + stats->drop_count++; + + skb = dequeue_func(vars, sch); + drop = codel_should_drop(skb, sch, vars, params, + stats, now); + } + vars->dropping = true; + /* if min went above target close to when we last went below it + * assume that the drop rate that controlled the queue on the + * last cycle is a good starting point to control it now. + */ + if (codel_time_before(now - vars->drop_next, + 16 * params->interval)) { + vars->count = (vars->count - vars->lastcount) | 1; + /* we dont care if rec_inv_sqrt approximation + * is not very precise : + * Next Newton steps will correct it quadratically. + */ + codel_Newton_step(vars); + } else { + vars->count = 1; + vars->rec_inv_sqrt = ~0U >> REC_INV_SQRT_SHIFT; + } + vars->lastcount = vars->count; + vars->drop_next = codel_control_law(now, params->interval, + vars->rec_inv_sqrt); + } +end: + return skb; +} +#endif +#endif diff --git a/backport/backport-include/net/flow_keys.h b/backport/backport-include/net/flow_keys.h new file mode 100644 index 000000000000..a875ee6eeb3b --- /dev/null +++ b/backport/backport-include/net/flow_keys.h @@ -0,0 +1,21 @@ +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0)) +#include_next +#else + +#ifndef _NET_FLOW_KEYS_H +#define _NET_FLOW_KEYS_H + +struct flow_keys { + /* (src,dst) must be grouped, in the same way than in IP header */ + __be32 src; + __be32 dst; + union { + __be32 ports; + __be16 port16[2]; + }; + u8 ip_proto; +}; + +extern bool skb_flow_dissect(const struct sk_buff *skb, struct flow_keys *flow); +#endif +#endif diff --git a/backport/backport-include/net/net_namespace.h b/backport/backport-include/net/net_namespace.h new file mode 100644 index 000000000000..0f74944b3823 --- /dev/null +++ b/backport/backport-include/net/net_namespace.h @@ -0,0 +1,10 @@ +#ifndef _COMPAT_NET_NET_NAMESPACE_H +#define _COMPAT_NET_NET_NAMESPACE_H 1 + +#include + +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)) +#include_next +#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)) */ + +#endif /* _COMPAT_NET_NET_NAMESPACE_H */ diff --git a/backport/backport-include/pcmcia/cistpl.h b/backport/backport-include/pcmcia/cistpl.h new file mode 100644 index 000000000000..789dc59db726 --- /dev/null +++ b/backport/backport-include/pcmcia/cistpl.h @@ -0,0 +1,10 @@ +#include + +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36) +#include +#endif +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,37) +#include +#endif + +#include_next diff --git a/backport/backport-include/trace/define_trace.h b/backport/backport-include/trace/define_trace.h new file mode 100644 index 000000000000..0b4072786d49 --- /dev/null +++ b/backport/backport-include/trace/define_trace.h @@ -0,0 +1,5 @@ +#include + +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,32)) +#include_next +#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,32)) */ diff --git a/backport/include/crypto/aes.h b/backport/include/crypto/aes.h deleted file mode 100644 index 8031a54d4a45..000000000000 --- a/backport/include/crypto/aes.h +++ /dev/null @@ -1,21 +0,0 @@ -#ifndef _COMPAT_CRYPTO_AES_H -#define _COMPAT_CRYPTO_AES_H - -#include - -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,24)) -#include_next -#else - -#define AES_MIN_KEY_SIZE 16 -#define AES_MAX_KEY_SIZE 32 -#define AES_KEYSIZE_128 16 -#define AES_KEYSIZE_192 24 -#define AES_KEYSIZE_256 32 -#define AES_BLOCK_SIZE 16 -#define AES_MAX_KEYLENGTH (15 * 16) -#define AES_MAX_KEYLENGTH_U32 (AES_MAX_KEYLENGTH / sizeof(u32)) - -#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,24)) */ - -#endif diff --git a/backport/include/linux/atomic.h b/backport/include/linux/atomic.h deleted file mode 100644 index 378b748fb207..000000000000 --- a/backport/include/linux/atomic.h +++ /dev/null @@ -1,46 +0,0 @@ -#ifndef _COMPAT_LINUX_ATOMIC_H -#define _COMPAT_LINUX_ATOMIC_H 1 - -#include - -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,36)) -#include_next -#else - -#include - -/** - * atomic_inc_not_zero_hint - increment if not null - * @v: pointer of type atomic_t - * @hint: probable value of the atomic before the increment - * - * This version of atomic_inc_not_zero() gives a hint of probable - * value of the atomic. This helps processor to not read the memory - * before doing the atomic read/modify/write cycle, lowering - * number of bus transactions on some arches. - * - * Returns: 0 if increment was not done, 1 otherwise. - */ -#ifndef atomic_inc_not_zero_hint -static inline int atomic_inc_not_zero_hint(atomic_t *v, int hint) -{ - int val, c = hint; - - /* sanity test, should be removed by compiler if hint is a constant */ - if (!hint) - return atomic_inc_not_zero(v); - - do { - val = atomic_cmpxchg(v, c, c + 1); - if (val == c) - return 1; - c = val; - } while (c); - - return 0; -} -#endif - -#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,36)) */ - -#endif /* _COMPAT_LINUX_ATOMIC_H */ diff --git a/backport/include/linux/average.h b/backport/include/linux/average.h deleted file mode 100644 index 2d6210e53105..000000000000 --- a/backport/include/linux/average.h +++ /dev/null @@ -1,34 +0,0 @@ -#include - -#ifndef CPTCFG_BACKPORT_BUILD_AVERAGE -#include_next -#else -/* Exponentially weighted moving average (EWMA) */ - -/* For more documentation see lib/average.c */ - -struct ewma { - unsigned long internal; - unsigned long factor; - unsigned long weight; -}; - -#define ewma_init LINUX_BACKPORT(ewma_init) -extern void ewma_init(struct ewma *avg, unsigned long factor, - unsigned long weight); - -#define ewma_add LINUX_BACKPORT(ewma_add) -extern struct ewma *ewma_add(struct ewma *avg, unsigned long val); - -#define ewma_read LINUX_BACKPORT(ewma_read) -/** - * ewma_read() - Get average value - * @avg: Average structure - * - * Returns the average value held in @avg. - */ -static inline unsigned long ewma_read(const struct ewma *avg) -{ - return avg->internal >> avg->factor; -} -#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,37)) */ diff --git a/backport/include/linux/backport_checks.h b/backport/include/linux/backport_checks.h deleted file mode 100644 index 6244559a5cef..000000000000 --- a/backport/include/linux/backport_checks.h +++ /dev/null @@ -1,16 +0,0 @@ -#ifndef __BACKPORT_CHECKS -#define __BACKPORT_CHECKS - -#if defined(CPTCFG_BACKPORT_KERNEL_2_6_28) && defined(CONFIG_DYNAMIC_FTRACE) -#error "You can't build on a 2.6.27 or older kernel with dynamic ftrace, it's broken" -#endif - -#if defined(CONFIG_MAC80211) && defined(CPTCFG_MAC80211) -#error "You must not have mac80211 built into your kernel if you want to enable it" -#endif - -#if defined(CONFIG_CFG80211) && defined(CPTCFG_CFG80211) -#error "You must not have cfg80211 built into your kernel if you want to enable it" -#endif - -#endif /* __BACKPORT_CHECKS */ diff --git a/backport/include/linux/bitops.h b/backport/include/linux/bitops.h deleted file mode 100644 index aa76af184344..000000000000 --- a/backport/include/linux/bitops.h +++ /dev/null @@ -1,211 +0,0 @@ -#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 -#ifndef BITS_TO_LONGS /* Older kernels define this already */ -#define BITS_TO_LONGS(nr) DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long)) -#endif -#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__ -#ifdef CONFIG_GENERIC_FIND_FIRST_BIT - -/** - * find_first_bit - find the first 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. - */ -extern unsigned long find_first_bit(const unsigned long *addr, - unsigned long size); - -/** - * find_first_zero_bit - find the first cleared 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 cleared bit. - */ -extern unsigned long find_first_zero_bit(const unsigned long *addr, - unsigned long size); -#endif /* CONFIG_GENERIC_FIND_FIRST_BIT */ - -#ifdef CONFIG_GENERIC_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 /* CONFIG_GENERIC_FIND_LAST_BIT */ - -#ifdef CONFIG_GENERIC_FIND_NEXT_BIT - -/** - * find_next_bit - find the next set bit in a memory region - * @addr: The address to base the search on - * @offset: The bitnumber to start searching at - * @size: The bitmap size in bits - */ -extern unsigned long find_next_bit(const unsigned long *addr, - unsigned long size, unsigned long offset); - -/** - * find_next_zero_bit - find the next cleared bit in a memory region - * @addr: The address to base the search on - * @offset: The bitnumber to start searching at - * @size: The bitmap size in bits - */ - -extern unsigned long find_next_zero_bit(const unsigned long *addr, - unsigned long size, - unsigned long offset); - -#endif /* CONFIG_GENERIC_FIND_NEXT_BIT */ -#endif /* __KERNEL__ */ -#endif diff --git a/backport/include/linux/compat-2.6.14.h b/backport/include/linux/compat-2.6.14.h deleted file mode 100644 index 1f19f7fee562..000000000000 --- a/backport/include/linux/compat-2.6.14.h +++ /dev/null @@ -1,13 +0,0 @@ -#ifndef LINUX_26_14_COMPAT_H -#define LINUX_26_14_COMPAT_H - -#include - -/* Compat work for 2.6.14 */ -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14)) - -typedef unsigned int gfp_t; - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14)) */ - -#endif /* LINUX_26_14_COMPAT_H */ diff --git a/backport/include/linux/compat-2.6.18.h b/backport/include/linux/compat-2.6.18.h deleted file mode 100644 index 5e0182b18a16..000000000000 --- a/backport/include/linux/compat-2.6.18.h +++ /dev/null @@ -1,13 +0,0 @@ -#ifndef LINUX_26_18_COMPAT_H -#define LINUX_26_18_COMPAT_H - -#include - -/* Compat work for 2.6.18 */ -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)) - -#define roundup(x, y) ((((x) + ((y) - 1)) / (y)) * (y)) - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)) */ - -#endif /* LINUX_26_18_COMPAT_H */ diff --git a/backport/include/linux/compat-2.6.19.h b/backport/include/linux/compat-2.6.19.h deleted file mode 100644 index 1e648c0aeba6..000000000000 --- a/backport/include/linux/compat-2.6.19.h +++ /dev/null @@ -1,24 +0,0 @@ -#ifndef LINUX_26_19_COMPAT_H -#define LINUX_26_19_COMPAT_H - -#include - -/* Compat work for 2.6.19 */ -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19)) - -#include - -static inline int -compat_kmem_cache_destroy(struct kmem_cache *cachep) -{ -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)) - return kmem_cache_destroy(cachep); -#else - kmem_cache_destroy(cachep); - return 0; -#endif -} - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)) */ - -#endif /* LINUX_26_19_COMPAT_H */ diff --git a/backport/include/linux/compat-2.6.20.h b/backport/include/linux/compat-2.6.20.h deleted file mode 100644 index 14579e29cf8e..000000000000 --- a/backport/include/linux/compat-2.6.20.h +++ /dev/null @@ -1,21 +0,0 @@ -#ifndef LINUX_26_20_COMPAT_H -#define LINUX_26_20_COMPAT_H - -#include - -/* Compat work for 2.6.20 */ -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)) - -#include - -typedef void (*work_func_t)(struct work_struct *work); -typedef void (*compat_work_func_t)(void *work); -static inline void (INIT_WORK)(struct work_struct *work, work_func_t func) -{ - INIT_WORK(work, (compat_work_func_t)func, work); -} -#undef INIT_WORK - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)) */ - -#endif /* LINUX_26_20_COMPAT_H */ diff --git a/backport/include/linux/compat-2.6.21.h b/backport/include/linux/compat-2.6.21.h deleted file mode 100644 index 89ed6d9a4358..000000000000 --- a/backport/include/linux/compat-2.6.21.h +++ /dev/null @@ -1,18 +0,0 @@ -#ifndef LINUX_26_21_COMPAT_H -#define LINUX_26_21_COMPAT_H - -#include - -/* Compat work for 2.6.21 */ -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)) - -#include - -#define register_sysctl_table(table) \ - ({ \ - register_sysctl_table((table), 0); \ - }) - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)) */ - -#endif /* LINUX_26_21_COMPAT_H */ diff --git a/backport/include/linux/compat-2.6.22.h b/backport/include/linux/compat-2.6.22.h deleted file mode 100644 index 7ca1b18ea0f3..000000000000 --- a/backport/include/linux/compat-2.6.22.h +++ /dev/null @@ -1,104 +0,0 @@ -#ifndef LINUX_26_22_COMPAT_H -#define LINUX_26_22_COMPAT_H - -#include - -/* Compat work for 2.6.21 */ -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)) - -#include -#include - -/* reuse ax25_ptr */ -#define ieee80211_ptr ax25_ptr - -#ifdef CONFIG_AX25 -#error Compat reuses the AX.25 pointer so that may not be enabled! -#endif - -static inline unsigned char *skb_mac_header(const struct sk_buff *skb) -{ - return skb->mac.raw; -} - -static inline void skb_set_mac_header(struct sk_buff *skb, int offset) -{ - skb->mac.raw = skb->data + offset; -} - -static inline void skb_reset_mac_header(struct sk_buff *skb) -{ - skb->mac.raw = skb->data; -} - -static inline void skb_reset_network_header(struct sk_buff *skb) -{ - skb->nh.raw = skb->data; -} - -static inline void skb_set_network_header(struct sk_buff *skb, int offset) -{ - skb->nh.raw = skb->data + offset; -} - -static inline void skb_set_transport_header(struct sk_buff *skb, int offset) -{ - skb->h.raw = skb->data + offset; -} - -static inline unsigned char *skb_transport_header(struct sk_buff *skb) -{ - return skb->h.raw; -} - -static inline unsigned char *skb_network_header(const struct sk_buff *skb) -{ - return skb->nh.raw; -} - -static inline unsigned char *skb_tail_pointer(const struct sk_buff *skb) -{ - return skb->tail; -} - -static inline struct iphdr *ip_hdr(const struct sk_buff *skb) -{ - return (struct iphdr *)skb_network_header(skb); -} - -static inline void skb_copy_from_linear_data(const struct sk_buff *skb, - void *to, - const unsigned int len) -{ - memcpy(to, skb->data, len); -} - -static inline void skb_copy_from_linear_data_offset(const struct sk_buff *skb, - const int offset, void *to, - const unsigned int len) -{ - memcpy(to, skb->data + offset, len); -} - -#define __maybe_unused __attribute__((unused)) - -#define uninitialized_var(x) x = x - -/* This will lead to very weird behaviour... */ -#define NLA_BINARY NLA_STRING - -static inline int pci_set_mwi(struct pci_dev *dev) -{ - return -ENOSYS; -} - -static inline void pci_clear_mwi(struct pci_dev *dev) -{ -} - -#define list_first_entry(ptr, type, member) \ - list_entry((ptr)->next, type, member) - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)) */ - -#endif /* LINUX_26_22_COMPAT_H */ diff --git a/backport/include/linux/compat-2.6.23.h b/backport/include/linux/compat-2.6.23.h deleted file mode 100644 index 37cbc22a6670..000000000000 --- a/backport/include/linux/compat-2.6.23.h +++ /dev/null @@ -1,139 +0,0 @@ -#ifndef LINUX_26_23_COMPAT_H -#define LINUX_26_23_COMPAT_H - -#include - -/* Compat work for < 2.6.23 */ -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)) - -#include -#include -#include -#include -#include - -/* - * Tell gcc if a function is cold. The compiler will assume any path - * directly leading to the call is unlikely. - */ - -#if !(__GNUC__ == 4 && __GNUC_MINOR__ < 3) -/* Mark functions as cold. gcc will assume any path leading to a call - * to them will be unlikely. This means a lot of manual unlikely()s - * are unnecessary now for any paths leading to the usual suspects - * like BUG(), printk(), panic() etc. [but let's keep them for now for - * older compilers] - * - * Early snapshots of gcc 4.3 don't support this and we can't detect this - * in the preprocessor, but we can live with this because they're unreleased. - * Maketime probing would be overkill here. - * - * gcc also has a __attribute__((__hot__)) to move hot functions into - * a special section, but I don't see any sense in this right now in - * the kernel context */ -#define __cold __attribute__((__cold__)) -#endif /* gcc 4.3 check */ - -#ifndef __cold -#define __cold -#endif - -/* Added as of 2.6.23 in include/linux/netdevice.h */ -#define alloc_netdev_mq(sizeof_priv, name, setup, queue) \ - alloc_netdev(sizeof_priv, name, setup) -#define NETIF_F_MULTI_QUEUE 16384 - -/* Added as of 2.6.23 on include/linux/netdevice.h */ -static inline int netif_is_multiqueue(const struct net_device *dev) -{ - return (!!(NETIF_F_MULTI_QUEUE & dev->features)); -} - -/* 2.6.23 fixed a bug in tcf_destroy_chain and the parameter changed */ -static inline void tcf_destroy_chain_compat(struct tcf_proto **fl) -{ - struct tcf_proto *tp; - - while ((tp = *fl) != NULL) { - *fl = tp->next; - tp->ops->destroy(tp); - module_put(tp->ops->owner); - kfree(tp); - } -} - -/* dev_mc_list was replaced with dev_addr_list as of 2.6.23, - * only new member added is da_synced. */ -#define dev_addr_list dev_mc_list -#define da_addr dmi_addr -#define da_addrlen dmi_addrlen -#define da_users dmi_users -#define da_gusers dmi_gusers - -/* dev_set_promiscuity() was moved to __dev_set_promiscuity() on 2.6.23 and - * dev_set_promiscuity() became a wrapper. */ -#define __dev_set_promiscuity dev_set_promiscuity - -/* Our own 2.6.22 port on compat.c */ -#define dev_mc_unsync LINUX_BACKPORT(dev_mc_unsync) -#define dev_mc_sync LINUX_BACKPORT(dev_mc_sync) -extern void dev_mc_unsync(struct net_device *to, struct net_device *from); -extern int dev_mc_sync(struct net_device *to, struct net_device *from); - -/* Our own 2.6.22 port on compat.c */ -extern void __dev_set_rx_mode(struct net_device *dev); - -/* Simple to add this */ -extern int cancel_delayed_work_sync(struct delayed_work *work); - -#define cancel_delayed_work_sync cancel_rearming_delayed_work - -#define debugfs_rename(a, b, c, d) 1 - -/* nl80211 requires multicast group support which is new and added on - * 2.6.23. We can't add support for it for older kernels to support it - * genl_family structure was changed. Lets just let through the - * genl_register_mc_group call. This means no multicast group suppport */ - -#define genl_register_mc_group(a, b) 0 - -/** - * struct genl_multicast_group - generic netlink multicast group - * @name: name of the multicast group, names are per-family - * @id: multicast group ID, assigned by the core, to use with - * genlmsg_multicast(). - * @list: list entry for linking - * @family: pointer to family, need not be set before registering - */ -struct genl_multicast_group -{ - struct genl_family *family; /* private */ - struct list_head list; /* private */ - char name[GENL_NAMSIZ]; - u32 id; -}; - - -/* Added as of 2.6.23 */ -#define pci_try_set_mwi LINUX_BACKPORT(pci_try_set_mwi) -int pci_try_set_mwi(struct pci_dev *dev); - -/* Added as of 2.6.23 */ -#ifdef CONFIG_PM_SLEEP -/* - * Tell the freezer that the current task should be frozen by it - */ -static inline void set_freezable(void) -{ - current->flags &= ~PF_NOFREEZE; -} - -#else -static inline void set_freezable(void) {} -#endif /* CONFIG_PM_SLEEP */ - -#else -#define tcf_destroy_chain_compat tcf_destroy_chain -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)) */ - -#endif /* LINUX_26_23_COMPAT_H */ diff --git a/backport/include/linux/compat-2.6.24.h b/backport/include/linux/compat-2.6.24.h deleted file mode 100644 index 5448604cdbb2..000000000000 --- a/backport/include/linux/compat-2.6.24.h +++ /dev/null @@ -1,252 +0,0 @@ -#ifndef LINUX_26_24_COMPAT_H -#define LINUX_26_24_COMPAT_H - -#include - -/* Compat work for 2.6.21, 2.6.22 and 2.6.23 */ -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)) - -#include -#include -#include -#include -#include -#include -#include - -#define KEY_BLUETOOTH 237 -#define KEY_WLAN 238 -#define KEY_UWB 239 - -#define DMA_BIT_MASK(n) (((n) == 64) ? ~0ULL : ((1ULL<<(n))-1)) - -struct proc_dir_entry; -struct net_device; -struct net { - atomic_t count; /* To decided when the network - * namespace should be freed. - */ - atomic_t use_count; /* To track references we - * destroy on demand - */ - struct list_head list; /* list of network namespaces */ - struct work_struct work; /* work struct for freeing */ - - struct proc_dir_entry *proc_net; - struct proc_dir_entry *proc_net_stat; - struct proc_dir_entry *proc_net_root; - - struct net_device *loopback_dev; /* The loopback */ - - struct list_head dev_base_head; - struct hlist_head *dev_name_head; - struct hlist_head *dev_index_head; -}; - -#ifdef CONFIG_NET -/* Init's network namespace */ -#define init_net LINUX_BACKPORT(init_net) -extern struct net init_net; -#define INIT_NET_NS(net_ns) .net_ns = &init_net, -#else -#define INIT_NET_NS(net_ns) -#endif - -/* Added on 2.6.24 in include/linux/types.h by Al viro on commit 142956af */ -typedef unsigned long uintptr_t; - -/* From include/linux/net.h */ -enum sock_shutdown_cmd { - SHUT_RD = 0, - SHUT_WR = 1, - SHUT_RDWR = 2, -}; - -#if (LINUX_VERSION_CODE == KERNEL_VERSION(2,6,23)) /* Local check */ -/* Added as of 2.6.24 in include/linux/skbuff.h. - * - * Although 2.6.23 does support for CONFIG_NETDEVICES_MULTIQUEUE - * this helper was not added until 2.6.24. This implementation - * is exactly as it is on newer kernels. - * - * For older kernels we use the an internal mac80211 hack. - * For details see changes to include/net/mac80211.h through - * compat.diff and compat/mq_compat.h */ -static inline u16 skb_get_queue_mapping(struct sk_buff *skb) -{ -#ifdef CONFIG_NETDEVICES_MULTIQUEUE - return skb->queue_mapping; -#else - return 0; -#endif -} -#endif /* Local 2.6.23 check */ - -/* On older kernels we handle this a bit differently, so we yield to that - * code for its implementation in mq_compat.h as we want to make - * use of the internal mac80211 __ieee80211_queue_stopped() which itself - * uses internal mac80211 data structure hacks. */ -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23)) /* Local check */ -/** - * netif_subqueue_stopped - test status of subqueue - * @dev: network device - * @queue_index: sub queue index - * - * Check individual transmit queue of a device with multiple transmit queues. - */ -static inline int __netif_subqueue_stopped(const struct net_device *dev, - u16 queue_index) -{ -#ifdef CONFIG_NETDEVICES_MULTIQUEUE - return test_bit(__LINK_STATE_XOFF, - &dev->egress_subqueue[queue_index].state); -#else - return 0; -#endif -} - -/* Note: although the backport implementation for netif_subqueue_stopped - * on older kernels is identical to upstream __netif_subqueue_stopped() - * (except for a const qualifier) we implement netif_subqueue_stopped() - * as part of mac80211 as it relies on internal mac80211 structures we - * use for MQ support. We this implement it in mq_compat.h */ - -#endif /* Local 2.6.23 check */ - -/* - * Force link bug if constructor is used, can't be done compatibly - * because constructor arguments were swapped since then! - */ -extern void __incompatible_kmem_cache_create(void); - -/* 2.6.21 and 2.6.22 kmem_cache_create() takes 6 arguments */ -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)) -#define kmem_cache_create(name, objsize, align, flags, ctor) \ - ({ \ - if (ctor) __incompatible_kmem_cache_create(); \ - kmem_cache_create((name), (objsize), (align), \ - (flags), NULL, NULL); \ - }) -#endif - -/* 2.6.23 kmem_cache_create() takes 5 arguments */ -#if (LINUX_VERSION_CODE == KERNEL_VERSION(2,6,23)) -#define kmem_cache_create(name, objsize, align, flags, ctor) \ - ({ \ - if (ctor) __incompatible_kmem_cache_create(); \ - kmem_cache_create((name), (objsize), (align), \ - (flags), NULL); \ - }) -#endif - -/* From include/linux/mod_devicetable.h */ - -/* SSB core, see drivers/ssb/ */ -#ifndef SSB_DEVICE -struct ssb_device_id { - __u16 vendor; - __u16 coreid; - __u8 revision; -}; -#define SSB_DEVICE(_vendor, _coreid, _revision) \ - { .vendor = _vendor, .coreid = _coreid, .revision = _revision, } -#define SSB_DEVTABLE_END \ - { 0, }, - -#define SSB_ANY_VENDOR 0xFFFF -#define SSB_ANY_ID 0xFFFF -#define SSB_ANY_REV 0xFF -#endif - - -/* Namespace stuff, introduced on 2.6.24 */ -#define dev_get_by_index(a, b) dev_get_by_index(b) -#define __dev_get_by_index(a, b) __dev_get_by_index(b) - -#define eth_header LINUX_BACKPORT(eth_header) -extern int eth_header(struct sk_buff *skb, struct net_device *dev, - unsigned short type, void *daddr, - void *saddr, unsigned len); -#define eth_rebuild_header LINUX_BACKPORT(eth_rebuild_header) -extern int eth_rebuild_header(struct sk_buff *skb); -#define eth_header_cache_update LINUX_BACKPORT(eth_header_cache_update) -extern void eth_header_cache_update(struct hh_cache *hh, struct net_device *dev, - unsigned char * haddr); -#define eth_header_cache LINUX_BACKPORT(eth_header_cache) -extern int eth_header_cache(struct neighbour *neigh, - struct hh_cache *hh); - -/* This structure is simply not present on 2.6.22 and 2.6.23 */ -struct header_ops { - int (*create) (struct sk_buff *skb, struct net_device *dev, - unsigned short type, void *daddr, - void *saddr, unsigned len); - int (*parse)(const struct sk_buff *skb, unsigned char *haddr); - int (*rebuild)(struct sk_buff *skb); - #define HAVE_HEADER_CACHE - int (*cache)(struct neighbour *neigh, struct hh_cache *hh); - void (*cache_update)(struct hh_cache *hh, - struct net_device *dev, - unsigned char *haddr); -}; - -/* net/ieee80211/ieee80211_crypt_tkip uses sg_init_table. This was added on - * 2.6.24. CONFIG_DEBUG_SG was added in 2.6.24 as well, so lets just ignore - * the debug stuff. Note that adding this required changes to the struct - * scatterlist on include/asm/scatterlist*, so the right way to port this - * is to simply ignore the new structure changes and zero the scatterlist - * array. We lave the kdoc intact for reference. - */ - -/** - * sg_mark_end - Mark the end of the scatterlist - * @sg: SG entryScatterlist - * - * Description: - * Marks the passed in sg entry as the termination point for the sg - * table. A call to sg_next() on this entry will return NULL. - * - **/ -static inline void sg_mark_end(struct scatterlist *sg) -{ -#ifdef CONFIG_DEBUG_SG - BUG_ON(sg->sg_magic != SG_MAGIC); -#endif -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)) - /* - * Set termination bit, clear potential chain bit - */ - sg->page_link |= 0x02; - sg->page_link &= ~0x01; -#endif -} - -/** - * sg_init_table - Initialize SG table - * @sgl: The SG table - * @nents: Number of entries in table - * - * Notes: - * If this is part of a chained sg table, sg_mark_end() should be - * used only on the last table part. - * - **/ -static inline void sg_init_table(struct scatterlist *sgl, unsigned int nents) -{ - memset(sgl, 0, sizeof(*sgl) * nents); -} - -/** - * usb_endpoint_num - get the endpoint's number - * @epd: endpoint to be checked - * - * Returns @epd's number: 0 to 15. - */ -static inline int usb_endpoint_num(const struct usb_endpoint_descriptor *epd) -{ - return epd->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK; -} - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)) */ - -#endif /* LINUX_26_24_COMPAT_H */ diff --git a/backport/include/linux/compat-2.6.25.h b/backport/include/linux/compat-2.6.25.h deleted file mode 100644 index dd986f5c6013..000000000000 --- a/backport/include/linux/compat-2.6.25.h +++ /dev/null @@ -1,361 +0,0 @@ -#ifndef LINUX_26_25_COMPAT_H -#define LINUX_26_25_COMPAT_H - -#include - -/* Compat work for 2.6.24 */ -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)) - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#define __inet_lookup_established __inet_lookup_established_old -#include -#undef __inet_lookup_established -#include - -struct sg_table { - struct scatterlist *sgl; /* the list */ - unsigned int nents; /* number of mapped entries */ - unsigned int orig_nents; /* original size of list */ -}; - -#define sg_alloc_fn LINUX_BACKPORT(sg_alloc_fn) -typedef struct scatterlist *(sg_alloc_fn)(unsigned int, gfp_t); - -#define sg_free_fn LINUX_BACKPORT(sg_free_fn) -typedef void (sg_free_fn)(struct scatterlist *, unsigned int); - -#define __sg_free_table LINUX_BACKPORT(__sg_free_table) -void __sg_free_table(struct sg_table *table, unsigned int max_ents, - sg_free_fn *free_fn); -#define sg_free_table LINUX_BACKPORT(sg_free_table) -void sg_free_table(struct sg_table *); -#define __sg_alloc_table LINUX_BACKPORT(__sg_alloc_table) -int __sg_alloc_table(struct sg_table *table, unsigned int nents, - unsigned int max_ents, gfp_t gfp_mask, - sg_alloc_fn *alloc_fn); -#define sg_alloc_table LINUX_BACKPORT(sg_alloc_table) -int sg_alloc_table(struct sg_table *table, unsigned int nents, gfp_t gfp_mask); - -/* - * Maximum number of entries that will be allocated in one piece, if - * a list larger than this is required then chaining will be utilized. - */ -#define SG_MAX_SINGLE_ALLOC (PAGE_SIZE / sizeof(struct scatterlist)) - - -/* - * Sockets in TCP_CLOSE state are _always_ taken out of the hash, so we need - * not check it for lookups anymore, thanks Alexey. -DaveM - * - * Local BH must be disabled here. - */ -static inline struct sock * - __inet_lookup_established(struct inet_hashinfo *hashinfo, - const __be32 saddr, const __be16 sport, - const __be32 daddr, const u16 hnum, - const int dif) -{ - INET_ADDR_COOKIE(acookie, saddr, daddr) - const __portpair ports = INET_COMBINED_PORTS(sport, hnum); - struct sock *sk; - /* Optimize here for direct hit, only listening connections can - * have wildcards anyways. - */ - unsigned int hash = inet_ehashfn(daddr, hnum, saddr, sport); - struct inet_ehash_bucket *head = inet_ehash_bucket(hashinfo, hash); - rwlock_t *lock = inet_ehash_lockp(hashinfo, hash); - - prefetch(head->chain.first); - read_lock(lock); - sk_for_each(sk, &head->chain) { - if (INET_MATCH(sk, hash, acookie, saddr, daddr, ports, dif)) - goto hit; /* You sunk my battleship! */ - } - - /* Must check for a TIME_WAIT'er before going to listener hash. */ - sk_for_each(sk, &head->twchain) { - if (INET_TW_MATCH(sk, hash, acookie, saddr, daddr, ports, dif)) - goto hit; - } - sk = NULL; -out: - read_unlock(lock); - return sk; -hit: - sock_hold(sk); - goto out; -} - -/* Backports b718989da7 */ -#define pci_enable_device_mem LINUX_BACKPORT(pci_enable_device_mem) -int __must_check pci_enable_device_mem(struct pci_dev *dev); - -/* - * Backports 312b1485fb509c9bc32eda28ad29537896658cb8 - * Author: Sam Ravnborg - * Date: Mon Jan 28 20:21:15 2008 +0100 - * - * Introduce new section reference annotations tags: __ref, __refdata, __refconst - */ -#define __ref __init_refok -#define __refdata __initdata_refok - -/* - * backports 2658fa803111dae1353602e7f586de8e537803e2 - */ - -static inline bool ipv4_is_loopback(__be32 addr) -{ - return (addr & htonl(0xff000000)) == htonl(0x7f000000); -} - -static inline bool ipv4_is_multicast(__be32 addr) -{ - return (addr & htonl(0xf0000000)) == htonl(0xe0000000); -} - -static inline bool ipv4_is_local_multicast(__be32 addr) -{ - return (addr & htonl(0xffffff00)) == htonl(0xe0000000); -} - -static inline bool ipv4_is_lbcast(__be32 addr) -{ - /* limited broadcast */ - return addr == htonl(INADDR_BROADCAST); -} - -static inline bool ipv4_is_zeronet(__be32 addr) -{ - return (addr & htonl(0xff000000)) == htonl(0x00000000); -} - -/* Special-Use IPv4 Addresses (RFC3330) */ - -static inline bool ipv4_is_private_10(__be32 addr) -{ - return (addr & htonl(0xff000000)) == htonl(0x0a000000); -} - -static inline bool ipv4_is_private_172(__be32 addr) -{ - return (addr & htonl(0xfff00000)) == htonl(0xac100000); -} - -static inline bool ipv4_is_private_192(__be32 addr) -{ - return (addr & htonl(0xffff0000)) == htonl(0xc0a80000); -} - -static inline bool ipv4_is_linklocal_169(__be32 addr) -{ - return (addr & htonl(0xffff0000)) == htonl(0xa9fe0000); -} - -static inline bool ipv4_is_anycast_6to4(__be32 addr) -{ - return (addr & htonl(0xffffff00)) == htonl(0xc0586300); -} - -static inline bool ipv4_is_test_192(__be32 addr) -{ - return (addr & htonl(0xffffff00)) == htonl(0xc0000200); -} - -static inline bool ipv4_is_test_198(__be32 addr) -{ - return (addr & htonl(0xfffe0000)) == htonl(0xc6120000); -} - -/* - * phys_addr_t was added as a generic arch typedef on 2.6.28, - * that backport is dealt with in compat-2.6.28.h - */ -#if defined(CONFIG_X86) || defined(CONFIG_X86_64) - -#if defined(CONFIG_64BIT) || defined(CONFIG_X86_PAE) || defined(CONFIG_PHYS_64BIT) -typedef u64 phys_addr_t; -#else -typedef u32 phys_addr_t; -#endif - -#endif /* x86 */ - -/* The macro below uses a const upstream, this differs */ - -/** - * DEFINE_PCI_DEVICE_TABLE - macro used to describe a pci device table - * @_table: device table name - * - * This macro is used to create a struct pci_device_id array (a device table) - * in a generic manner. - */ -#define DEFINE_PCI_DEVICE_TABLE(_table) \ - const struct pci_device_id _table[] __devinitdata - -/* - * Backport work for QoS dependencies (kernel/pm_qos_params.c) - * pm-qos stuff written by mark gross mgross@linux.intel.com. - * - * ipw2100 now makes use of: - * - * pm_qos_add_requirement(), - * pm_qos_update_requirement() and - * pm_qos_remove_requirement() from it - * - * mac80211 uses the network latency to determine if to enable or not - * dynamic PS. mac80211 also and registers a notifier for when - * the latency changes. Since older kernels do no thave pm-qos stuff - * we just implement it completley here and register it upon cfg80211 - * init. I haven't tested ipw2100 on 2.6.24 though. - * - * This pm-qos implementation is copied verbatim from the kernel - * written by mark gross mgross@linux.intel.com. You don't have - * to do anythinig to use pm-qos except use the same exported - * routines as used in newer kernels. The backport_pm_qos_power_init() - * defned below is used by the compat module to initialize pm-qos. - */ -int backport_pm_qos_power_init(void); -int backport_pm_qos_power_deinit(void); - -/* - * 2.6.25 adds PM_EVENT_HIBERNATE as well here but - * we don't have this on <= 2.6.23) - */ -#ifndef PM_EVENT_SLEEP /* some distribution have mucked with their own headers to add this.. */ -#define PM_EVENT_SLEEP (PM_EVENT_SUSPEND) -#endif - -/* Although we don't care about wimax this is needed for rfkill input stuff */ -#define KEY_WIMAX 246 - -/* Although pm_qos stuff is not implemented on <= 2.6.24 lets keep the define */ -#define PM_QOS_DEFAULT_VALUE -1 - -#define __WARN(foo) dump_stack() - -#define dev_emerg(dev, format, arg...) \ - dev_printk(KERN_EMERG , dev , format , ## arg) -#define dev_alert(dev, format, arg...) \ - dev_printk(KERN_ALERT , dev , format , ## arg) -#define dev_crit(dev, format, arg...) \ - dev_printk(KERN_CRIT , dev , format , ## arg) - -#define __dev_addr_sync LINUX_BACKPORT(__dev_addr_sync) -extern int __dev_addr_sync(struct dev_addr_list **to, int *to_count, struct dev_addr_list **from, int *from_count); -#define __dev_addr_unsync LINUX_BACKPORT(__dev_addr_unsync) -extern void __dev_addr_unsync(struct dev_addr_list **to, int *to_count, struct dev_addr_list **from, int *from_count); - -#define seq_file_net &init_net; - -enum nf_inet_hooks { - NF_INET_PRE_ROUTING = 0, - NF_INET_LOCAL_IN = 1, - NF_INET_FORWARD = 2, - NF_INET_LOCAL_OUT = 3, - NF_INET_POST_ROUTING = 4, - NF_INET_NUMHOOKS = 5 -}; - -/* The patch: - * commit 8b5f6883683c91ad7e1af32b7ceeb604d68e2865 - * Author: Marcin Slusarz - * Date: Fri Feb 8 04:20:12 2008 -0800 - * - * byteorder: move le32_add_cpu & friends from OCFS2 to core - * - * moves le*_add_cpu and be*_add_cpu functions from OCFS2 to core - * header (1st) and converted some existing code to it. We port - * it here as later kernels will most likely use it. - */ -static inline void le16_add_cpu(__le16 *var, u16 val) -{ - *var = cpu_to_le16(le16_to_cpu(*var) + val); -} - -static inline void le32_add_cpu(__le32 *var, u32 val) -{ - *var = cpu_to_le32(le32_to_cpu(*var) + val); -} - -static inline void le64_add_cpu(__le64 *var, u64 val) -{ - *var = cpu_to_le64(le64_to_cpu(*var) + val); -} - -static inline void be16_add_cpu(__be16 *var, u16 val) -{ - u16 v = be16_to_cpu(*var); - *var = cpu_to_be16(v + val); -} - -static inline void be32_add_cpu(__be32 *var, u32 val) -{ - u32 v = be32_to_cpu(*var); - *var = cpu_to_be32(v + val); -} - -static inline void be64_add_cpu(__be64 *var, u64 val) -{ - u64 v = be64_to_cpu(*var); - *var = cpu_to_be64(v + val); -} - -/* 2.6.25 changes hwrng_unregister()'s behaviour by supporting - * suspend of its parent device (the misc device, which is itself the - * hardware random number generator). It does this by passing a parameter to - * unregister_miscdev() which is not supported in older kernels. The suspend - * parameter allows us to enable access to the device's hardware - * number generator during suspend. As far as wireless is concerned this means - * if a driver goes to suspend it you won't have the HNR available in - * older kernels. */ -static inline void __hwrng_unregister(struct hwrng *rng, bool suspended) -{ - hwrng_unregister(rng); -} - -static inline void led_classdev_unregister_suspended(struct led_classdev *lcd) -{ - led_classdev_unregister(lcd); -} - -/** - * The following things are out of ./include/linux/kernel.h - * The new iwlwifi driver is using them. - */ -#define strict_strtoul LINUX_BACKPORT(strict_strtoul) -extern int strict_strtoul(const char *, unsigned int, unsigned long *); -#define strict_strtol LINUX_BACKPORT(strict_strtol) -extern int strict_strtol(const char *, unsigned int, long *); - -#else -/* - * Kernels >= 2.6.25 have pm-qos and its initialized as part of - * the bootup process - */ -static inline int backport_pm_qos_power_init(void) -{ - return 0; -} - -static inline int backport_pm_qos_power_deinit(void) -{ - return 0; -} -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)) */ - -#endif /* LINUX_26_25_COMPAT_H */ diff --git a/backport/include/linux/compat-2.6.26.h b/backport/include/linux/compat-2.6.26.h deleted file mode 100644 index b8d9dc645377..000000000000 --- a/backport/include/linux/compat-2.6.26.h +++ /dev/null @@ -1,456 +0,0 @@ -#ifndef LINUX_26_26_COMPAT_H -#define LINUX_26_26_COMPAT_H - -#include - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26)) - -#include -#include -#include -#include -#include -#include -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)) -#include -#endif -#include -#include -#include - -/* These jiffie helpers added as of 2.6.26 */ - -/* - * These four macros compare jiffies and 'a' for convenience. - */ - -/* time_is_before_jiffies(a) return true if a is before jiffies */ -#define time_is_before_jiffies(a) time_after(jiffies, a) - -/* time_is_after_jiffies(a) return true if a is after jiffies */ -#define time_is_after_jiffies(a) time_before(jiffies, a) - -/* time_is_before_eq_jiffies(a) return true if a is before or equal to jiffies*/ -#define time_is_before_eq_jiffies(a) time_after_eq(jiffies, a) - -/* time_is_after_eq_jiffies(a) return true if a is after or equal to jiffies*/ -#define time_is_after_eq_jiffies(a) time_before_eq(jiffies, a) - -/* This comes from include/linux/input.h */ -#define SW_RFKILL_ALL 0x03 /* rfkill master switch, type "any" - set = radio enabled */ - -/* From kernel.h */ -#define USHORT_MAX ((u16)(~0U)) -#define SHORT_MAX ((s16)(USHORT_MAX>>1)) -#define SHORT_MIN (-SHORT_MAX - 1) - -#define dev_set_name LINUX_BACKPORT(dev_set_name) -extern int dev_set_name(struct device *dev, const char *name, ...) - __attribute__((format(printf, 2, 3))); - -/** - * clamp - return a value clamped to a given range with strict typechecking - * @val: current value - * @min: minimum allowable value - * @max: maximum allowable value - * - * This macro does strict typechecking of min/max to make sure they are of the - * same type as val. See the unnecessary pointer comparisons. - */ -#define clamp(val, min, max) ({ \ - typeof(val) __val = (val); \ - typeof(min) __min = (min); \ - typeof(max) __max = (max); \ - (void) (&__val == &__min); \ - (void) (&__val == &__max); \ - __val = __val < __min ? __min: __val; \ - __val > __max ? __max: __val; }) - -/** - * clamp_t - return a value clamped to a given range using a given type - * @type: the type of variable to use - * @val: current value - * @min: minimum allowable value - * @max: maximum allowable value - * - * This macro does no typechecking and uses temporary variables of type - * 'type' to make all the comparisons. - */ -#define clamp_t(type, val, min, max) ({ \ - type __val = (val); \ - type __min = (min); \ - type __max = (max); \ - __val = __val < __min ? __min: __val; \ - __val > __max ? __max: __val; }) - - -/* from include/linux/device.h */ -/* device_create_drvdata() is new */ -extern struct device *device_create_drvdata(struct class *cls, - struct device *parent, - dev_t devt, - void *drvdata, - const char *fmt, ...) -__attribute__((format(printf, 5, 6))); - -/* This is from include/linux/list.h */ - -/** - * list_is_singular - tests whether a list has just one entry. - * @head: the list to test. - */ -static inline int list_is_singular(const struct list_head *head) -{ - return !list_empty(head) && (head->next == head->prev); -} - -/* This is from include/linux/device.h, which was added as of 2.6.26 */ -static inline const char *dev_name(struct device *dev) -{ - /* will be changed into kobject_name(&dev->kobj) in the near future */ - return dev->bus_id; -} - -/* This is from include/linux/kernel.h, which was added as of 2.6.26 */ - -/** - * clamp_val - return a value clamped to a given range using val's type - * @val: current value - * @min: minimum allowable value - * @max: maximum allowable value - * - * This macro does no typechecking and uses temporary variables of whatever - * type the input argument 'val' is. This is useful when val is an unsigned - * type and min and max are literals that will otherwise be assigned a signed - * integer type. - */ - -#define clamp_val(val, min, max) ({ \ - typeof(val) __val = (val); \ - typeof(val) __min = (min); \ - typeof(val) __max = (max); \ - __val = __val < __min ? __min: __val; \ - __val > __max ? __max: __val; }) - -/* This comes from include/net/net_namespace.h */ - -#ifdef CONFIG_NET_NS -static inline -int net_eq(const struct net *net1, const struct net *net2) -{ - return net1 == net2; -} -#else -static inline -int net_eq(const struct net *net1, const struct net *net2) -{ - return 1; -} -#endif - -static inline -void dev_net_set(struct net_device *dev, struct net *net) -{ -#ifdef CONFIG_NET_NS - release_net(dev->nd_net); - dev->nd_net = hold_net(net); -#endif -} - -static inline -struct net *sock_net(const struct sock *sk) -{ -#ifdef CONFIG_NET_NS - return sk->sk_net; -#else - return &init_net; -#endif -} - -/* This comes from include/linux/netdevice.h */ - -/* - * Net namespace inlines - */ -static inline -struct net *dev_net(const struct net_device *dev) -{ -#ifdef CONFIG_NET_NS - /* - * compat-wirelss backport note: - * For older kernels we may just need to always return init_net, - * not sure when we added dev->nd_net. - */ - return dev->nd_net; -#else - return &init_net; -#endif -} - - -/* - * 2.6.26 added its own unaligned API which the - * new drivers can use. Lets port it here by including it in older - * kernels and also deal with the architecture handling here. - */ - -#ifdef CONFIG_ALPHA - -#include -#include -#include - -#endif /* alpha */ -#ifdef CONFIG_ARM - -/* arm */ -#include -#include -#include - -#endif /* arm */ -#ifdef CONFIG_AVR32 - -/* - * AVR32 can handle some unaligned accesses, depending on the - * implementation. The AVR32 AP implementation can handle unaligned - * words, but halfwords must be halfword-aligned, and doublewords must - * be word-aligned. - * - * However, swapped word loads must be word-aligned so we can't - * optimize word loads in general. - */ - -#include -#include -#include - -#endif -#ifdef CONFIG_BLACKFIN - -#include -#include -#include - -#endif /* blackfin */ -#ifdef CONFIG_CRIS - -/* - * CRIS can do unaligned accesses itself. - */ -#include -#include - -#endif /* cris */ -#ifdef CONFIG_FRV - -#include -#include -#include - -#endif /* frv */ -#ifdef CONFIG_H8300 - -#include -#include -#include - -#endif /* h8300 */ -#ifdef CONFIG_IA64 - -#include -#include -#include - -#endif /* ia64 */ -#ifdef CONFIG_M32R - -#if defined(__LITTLE_ENDIAN__) -# include -# include -# include -#else -# include -# include -# include -#endif - -#endif /* m32r */ -#ifdef CONFIG_M68K /* this handles both m68k and m68knommu */ - -#ifdef CONFIG_COLDFIRE -#include -#include -#include -#else - -/* - * The m68k can do unaligned accesses itself. - */ -#include -#include -#endif - -#endif /* m68k and m68knommu */ -#ifdef CONFIG_MIPS - -#if defined(__MIPSEB__) -# include -# include -# include -# define get_unaligned __get_unaligned_be -# define put_unaligned __put_unaligned_be -#elif defined(__MIPSEL__) -# include -# include -# include -#endif - -#endif /* mips */ -#ifdef CONFIG_MN10300 - -#include -#include - -#endif /* mn10300 */ -#ifdef CONFIG_PARISC - -#include -#include -#include - -#endif /* parisc */ -#ifdef CONFIG_PPC -/* - * The PowerPC can do unaligned accesses itself in big endian mode. - */ -#include -#include - -#endif /* ppc */ -#ifdef CONFIG_S390 - -/* - * The S390 can do unaligned accesses itself. - */ -#include -#include - -#endif /* s390 */ -#ifdef CONFIG_SUPERH - -/* SH can't handle unaligned accesses. */ -#ifdef __LITTLE_ENDIAN__ -# include -# include -# include -#else -# include -# include -# include -#endif - -#endif /* sh - SUPERH */ -#ifdef CONFIG_SPARC - -/* sparc and sparc64 */ -#include -#include -#include - -#endif /* sparc */ -#ifdef CONFIG_UML - -#include "asm/arch/unaligned.h" - -#endif /* um - uml */ -#ifdef CONFIG_V850 - -#include -#include -#include - -#endif /* v850 */ -#ifdef CONFIG_X86 -/* - * The x86 can do unaligned accesses itself. - */ -#include -#include - -#endif /* x86 */ -#ifdef CONFIG_XTENSA - -#ifdef __XTENSA_EL__ -# include -# include -# include -#elif defined(__XTENSA_EB__) -# include -# include -# include -#else -# error processor byte order undefined! -#endif - -#endif /* xtensa */ - -#define PCIE_LINK_STATE_L0S 1 -#define PCIE_LINK_STATE_L1 2 -#define PCIE_LINK_STATE_CLKPM 4 - -static inline void pci_disable_link_state(struct pci_dev *pdev, int state) -{ -} -/* source: include/linux/pci-aspm.h */ - - -#if BITS_PER_LONG == 64 - -/** - * div_u64_rem - unsigned 64bit divide with 32bit divisor with remainder - * - * This is commonly provided by 32bit archs to provide an optimized 64bit - * divide. - */ -static inline u64 div_u64_rem(u64 dividend, u32 divisor, u32 *remainder) -{ - *remainder = dividend % divisor; - return dividend / divisor; -} - -#elif BITS_PER_LONG == 32 - -#ifndef div_u64_rem -static inline u64 div_u64_rem(u64 dividend, u32 divisor, u32 *remainder) -{ - *remainder = do_div(dividend, divisor); - return dividend; -} -#endif - -#endif /* BITS_PER_LONG */ - -/** - * div_u64 - unsigned 64bit divide with 32bit divisor - * - * This is the most common 64bit divide and should be used if possible, - * as many 32bit archs can optimize this variant better than a full 64bit - * divide. - */ -#ifndef div_u64 -static inline u64 div_u64(u64 dividend, u32 divisor) -{ - u32 remainder; - return div_u64_rem(dividend, divisor, &remainder); -} -#endif -/* source: include/math64.h */ - -#define hex_asc_lo(x) hex_asc((x) & 0x0f) -#define hex_asc_hi(x) hex_asc(((x) & 0xf0) >> 4) - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26)) */ - -#endif /* LINUX_26_26_COMPAT_H */ diff --git a/backport/include/linux/compat-2.6.27.h b/backport/include/linux/compat-2.6.27.h deleted file mode 100644 index b71a3b57a202..000000000000 --- a/backport/include/linux/compat-2.6.27.h +++ /dev/null @@ -1,317 +0,0 @@ -#ifndef LINUX_26_27_COMPAT_H -#define LINUX_26_27_COMPAT_H - -#include - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27)) - -#include -#include -#include -#include -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)) -#include -#include -#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24) */ -#include -#include -#include -#include -#include -#include -#include -#include - -static inline struct net_device *qdisc_dev(const struct Qdisc *qdisc) -{ - return qdisc->dev; -} - -/* - * Backports 378a2f09 and c27f339a - * This may need a bit more work. - */ -enum net_xmit_qdisc_t { - __NET_XMIT_STOLEN = 0x00010000, - __NET_XMIT_BYPASS = 0x00020000, -}; - -struct qdisc_skb_cb { - unsigned int pkt_len; - char data[]; -}; - -static inline struct qdisc_skb_cb *qdisc_skb_cb(struct sk_buff *skb) -{ - return (struct qdisc_skb_cb *)skb->cb; -} - -static inline unsigned int qdisc_pkt_len(struct sk_buff *skb) -{ - return qdisc_skb_cb(skb)->pkt_len; -} - -#define PCI_PM_CAP_PME_SHIFT 11 - -/* I can't find a more suitable replacement... */ -#define flush_work(work) cancel_work_sync(work) - -struct builtin_fw { - char *name; - void *data; - unsigned long size; -}; - -/* - * On older kernels we do not have net_device Multi Queue support, but - * since we no longer use MQ on mac80211 we can simply use the 0 queue. - * Note that if other fullmac drivers make use of this they then need - * to be backported somehow or deal with just 1 queueue from MQ. - */ -static inline void netif_tx_wake_all_queues(struct net_device *dev) -{ - netif_wake_queue(dev); -} -static inline void netif_tx_start_all_queues(struct net_device *dev) -{ - netif_start_queue(dev); -} -static inline void netif_tx_stop_all_queues(struct net_device *dev) -{ - netif_stop_queue(dev); -} - -/* Are all TX queues of the device empty? */ -static inline bool qdisc_all_tx_empty(const struct net_device *dev) -{ - return skb_queue_empty(&dev->qdisc->q); -} - -#define pci_pme_capable LINUX_BACKPORT(pci_pme_capable) -bool pci_pme_capable(struct pci_dev *dev, pci_power_t state); - -/* - * The net_device has a spin_lock on newer kernels, on older kernels we're out of luck - */ -#define netif_addr_lock_bh(dev) -#define netif_addr_unlock_bh(dev) - -/* - * To port this properly we'd have to port warn_slowpath_null(), - * which I'm lazy to do so just do a regular print for now. If you - * want to port this read kernel/panic.c - */ -#define __WARN_printf(arg...) do { printk(arg); __WARN(); } while (0) - -/* This is ported directly as-is on newer kernels */ -#ifndef WARN -#define WARN(condition, format...) ({ \ - int __ret_warn_on = !!(condition); \ - if (unlikely(__ret_warn_on)) \ - __WARN_printf(format); \ - unlikely(__ret_warn_on); \ -}) -#endif - -/* On 2.6.27 a second argument was added, on older kernels we ignore it */ -#define dma_mapping_error(pdev, dma_addr) dma_mapping_error(dma_addr) -#define pci_dma_mapping_error(pdev, dma_addr) dma_mapping_error(pdev, dma_addr) - -/* This is from include/linux/ieee80211.h */ -#define IEEE80211_HT_CAP_DSSSCCK40 0x1000 - -/* New link list changes added as of 2.6.27, needed for ath9k */ - -static inline void __list_cut_position(struct list_head *list, - struct list_head *head, struct list_head *entry) -{ - struct list_head *new_first = entry->next; - list->next = head->next; - list->next->prev = list; - list->prev = entry; - entry->next = list; - head->next = new_first; - new_first->prev = head; -} - -/** - * list_cut_position - cut a list into two - * @list: a new list to add all removed entries - * @head: a list with entries - * @entry: an entry within head, could be the head itself - * and if so we won't cut the list - * - * This helper moves the initial part of @head, up to and - * including @entry, from @head to @list. You should - * pass on @entry an element you know is on @head. @list - * should be an empty list or a list you do not care about - * losing its data. - * - */ -static inline void list_cut_position(struct list_head *list, - struct list_head *head, struct list_head *entry) -{ - if (list_empty(head)) - return; - if (list_is_singular(head) && - (head->next != entry && head != entry)) - return; - if (entry == head) - INIT_LIST_HEAD(list); - else - __list_cut_position(list, head, entry); -} - - -/* __list_splice as re-implemented on 2.6.27, we backport it */ -static inline void __compat_list_splice_new_27(const struct list_head *list, - struct list_head *prev, - struct list_head *next) -{ - struct list_head *first = list->next; - struct list_head *last = list->prev; - - first->prev = prev; - prev->next = first; - - last->next = next; - next->prev = last; -} - -/** - * list_splice_tail - join two lists, each list being a queue - * @list: the new list to add. - * @head: the place to add it in the first list. - */ -static inline void list_splice_tail(struct list_head *list, - struct list_head *head) -{ - if (!list_empty(list)) - __compat_list_splice_new_27(list, head->prev, head); -} - -/** - * list_splice_tail_init - join two lists and reinitialise the emptied list - * @list: the new list to add. - * @head: the place to add it in the first list. - * - * Each of the lists is a queue. - * The list at @list is reinitialised - */ -static inline void list_splice_tail_init(struct list_head *list, - struct list_head *head) -{ - if (!list_empty(list)) { - __compat_list_splice_new_27(list, head->prev, head); - INIT_LIST_HEAD(list); - } -} - -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)) -#define mmc_align_data_size LINUX_BACKPORT(mmc_align_data_size) -extern unsigned int mmc_align_data_size(struct mmc_card *, unsigned int); -#define sdio_align_size LINUX_BACKPORT(sdio_align_size) -extern unsigned int sdio_align_size(struct sdio_func *func, unsigned int sz); -#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24) */ - -#define iwe_stream_add_value(info, event, value, ends, iwe, event_len) iwe_stream_add_value(event, value, ends, iwe, event_len) -#define iwe_stream_add_point(info, stream, ends, iwe, extra) iwe_stream_add_point(stream, ends, iwe, extra) -#define iwe_stream_add_event(info, stream, ends, iwe, event_len) iwe_stream_add_event(stream, ends, iwe, event_len) - -/* Flags available in struct iw_request_info */ -#define IW_REQUEST_FLAG_COMPAT 0x0001 /* Compat ioctl call */ - -static inline int iwe_stream_lcp_len(struct iw_request_info *info) -{ -#ifdef CONFIG_COMPAT - if (info->flags & IW_REQUEST_FLAG_COMPAT) - return IW_EV_COMPAT_LCP_LEN; -#endif - return IW_EV_LCP_LEN; -} - -#ifdef CONFIG_ARM - -/* - * The caller asks to handle a range between offset and offset + size, - * but we process a larger range from 0 to offset + size due to lack of - * offset support. - */ - -static inline void dma_sync_single_range_for_cpu(struct device *dev, - dma_addr_t handle, unsigned long offset, size_t size, - enum dma_data_direction dir) -{ - dma_sync_single_for_cpu(dev, handle, offset + size, dir); -} - -static inline void dma_sync_single_range_for_device(struct device *dev, - dma_addr_t handle, unsigned long offset, size_t size, - enum dma_data_direction dir) -{ - dma_sync_single_for_device(dev, handle, offset + size, dir); -} - -#endif /* arm */ - -#define debugfs_remove_recursive LINUX_BACKPORT(debugfs_remove_recursive) - -#if defined(CONFIG_DEBUG_FS) -void debugfs_remove_recursive(struct dentry *dentry); -#else -static inline void debugfs_remove_recursive(struct dentry *dentry) -{ } -#endif - -#define device_create(cls, parent, devt, drvdata, fmt, ...) \ -({ \ - struct device *_dev; \ - _dev = (device_create)(cls, parent, devt, fmt, __VA_ARGS__); \ - dev_set_drvdata(_dev, drvdata); \ - _dev; \ -}) - -#define dev_name(dev) dev_name((struct device *)dev) - -static inline void ethtool_cmd_speed_set(struct ethtool_cmd *ep, - __u32 speed) -{ - ep->speed = (__u16)speed; -} - -static inline __u32 ethtool_cmd_speed(const struct ethtool_cmd *ep) -{ - return ep->speed; -} - -/** - * lower_32_bits - return bits 0-31 of a number - * @n: the number we're accessing - */ -#define lower_32_bits(n) ((u32)(n)) - -#define netif_wake_subqueue netif_start_subqueue - -/* Backport of: - * - * commit 3295f0ef9ff048a4619ede597ad9ec9cab725654 - * Author: Ingo Molnar - * Date: Mon Aug 11 10:30:30 2008 +0200 - * - * lockdep: rename map_[acquire|release]() => lock_map_[acquire|release]() - */ -#ifdef CONFIG_DEBUG_LOCK_ALLOC -# ifdef CONFIG_PROVE_LOCKING -# define lock_map_acquire(l) lock_acquire(l, 0, 0, 0, 2, NULL, _THIS_IP_) -# else -# define lock_map_acquire(l) lock_acquire(l, 0, 0, 0, 1, NULL, _THIS_IP_) -# endif -# define lock_map_release(l) lock_release(l, 1, _THIS_IP_) -#else -# define lock_map_acquire(l) do { } while (0) -# define lock_map_release(l) do { } while (0) -#endif - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27)) */ - -#endif /* LINUX_26_27_COMPAT_H */ diff --git a/backport/include/linux/compat-2.6.28.h b/backport/include/linux/compat-2.6.28.h deleted file mode 100644 index 3b5f3ea7141c..000000000000 --- a/backport/include/linux/compat-2.6.28.h +++ /dev/null @@ -1,305 +0,0 @@ -#ifndef LINUX_26_28_COMPAT_H -#define LINUX_26_28_COMPAT_H - -#include - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)) - -#include -#include -#include -#include -#include -#include -#include -#include - -#define HID_ANY_ID (~0) - -#define HID_USB_DEVICE(ven, prod) \ - .bus = BUS_USB, .vendor = (ven), .product = (prod) -#define HID_BLUETOOTH_DEVICE(ven, prod) \ - .bus = BUS_BLUETOOTH, .vendor = (ven), .product = (prod) - - -struct hid_device_id { - __u16 bus; - __u32 vendor; - __u32 product; - kernel_ulong_t driver_data - __attribute__((aligned(sizeof(kernel_ulong_t)))); -}; - -#ifndef ETH_P_PAE -#define ETH_P_PAE 0x888E /* Port Access Entity (IEEE 802.1X) */ -#endif - -#include -#include -#include - -#define platform_device_register_data LINUX_BACKPORT(platform_device_register_data) -extern struct platform_device *platform_device_register_data(struct device *, - const char *, int, const void *, size_t); - -typedef struct cpumask { DECLARE_BITMAP(bits, NR_CPUS); } compat_cpumask_t; - -#if defined(CONFIG_X86) || defined(CONFIG_X86_64) || defined(CONFIG_PPC) -/* - * CONFIG_PHYS_ADDR_T_64BIT was added as new to all architectures - * as of 2.6.28 but x86 and ppc had it already. x86 only got phys_addr_t - * as of 2.6.25 but then is backported in compat-2.6.25.h - */ -#else -#if defined(CONFIG_64BIT) || defined(CONFIG_X86_PAE) || defned(CONFIG_PPC64) || defined(CONFIG_PHYS_64BIT) -#define CONFIG_PHYS_ADDR_T_64BIT 1 -typedef u64 phys_addr_t; -#else -typedef u32 phys_addr_t; -#endif - -#endif /* non x86 and ppc */ - -#ifndef WARN_ONCE -#define WARN_ONCE(condition, format...) ({ \ - static int __warned; \ - int __ret_warn_once = !!(condition); \ - \ - if (unlikely(__ret_warn_once)) \ - if (WARN(!__warned, format)) \ - __warned = 1; \ - unlikely(__ret_warn_once); \ -}) -#endif /* From include/asm-generic/bug.h */ - -#if defined(CONFIG_PCMCIA) || defined(CONFIG_PCMCIA_MODULE) - -#include -#include -#include -#ifdef pcmcia_parse_tuple -#undef pcmcia_parse_tuple -#define pcmcia_parse_tuple(tuple, parse) pccard_parse_tuple(tuple, parse) -#endif - -/* From : include/pcmcia/ds.h */ -/* loop CIS entries for valid configuration */ -#define pcmcia_loop_config LINUX_BACKPORT(pcmcia_loop_config) -int pcmcia_loop_config(struct pcmcia_device *p_dev, - int (*conf_check) (struct pcmcia_device *p_dev, - cistpl_cftable_entry_t *cfg, - cistpl_cftable_entry_t *dflt, - unsigned int vcc, - void *priv_data), - void *priv_data); - -#endif /* CONFIG_PCMCIA */ - -/* USB anchors were added as of 2.6.23 */ -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23)) - -#if defined(CONFIG_USB) || defined(CONFIG_USB_MODULE) -#if 0 -#define usb_poison_urb LINUX_BACKPORT(usb_poison_urb) -extern void usb_poison_urb(struct urb *urb); -#endif -#define usb_unpoison_urb LINUX_BACKPORT(usb_unpoison_urb) -extern void usb_unpoison_urb(struct urb *urb); - -#if 0 -#define usb_poison_anchored_urbs LINUX_BACKPORT(usb_poison_anchored_urbs) -extern void usb_poison_anchored_urbs(struct usb_anchor *anchor); -#endif - -#define usb_anchor_empty LINUX_BACKPORT(usb_anchor_empty) -extern int usb_anchor_empty(struct usb_anchor *anchor); -#endif /* CONFIG_USB */ -#endif - - -#define pci_ioremap_bar LINUX_BACKPORT(pci_ioremap_bar) -void __iomem *pci_ioremap_bar(struct pci_dev *pdev, int bar); - -/** - * skb_queue_is_last - check if skb is the last entry in the queue - * @list: queue head - * @skb: buffer - * - * Returns true if @skb is the last buffer on the list. - */ -static inline bool skb_queue_is_last(const struct sk_buff_head *list, - const struct sk_buff *skb) -{ - return (skb->next == (struct sk_buff *) list); -} - -/** - * skb_queue_next - return the next packet in the queue - * @list: queue head - * @skb: current buffer - * - * Return the next packet in @list after @skb. It is only valid to - * call this if skb_queue_is_last() evaluates to false. - */ -static inline struct sk_buff *skb_queue_next(const struct sk_buff_head *list, - const struct sk_buff *skb) -{ - /* This BUG_ON may seem severe, but if we just return then we - * are going to dereference garbage. - */ - BUG_ON(skb_queue_is_last(list, skb)); - return skb->next; -} - -/** - * __skb_queue_head_init - initialize non-spinlock portions of sk_buff_head - * @list: queue to initialize - * - * This initializes only the list and queue length aspects of - * an sk_buff_head object. This allows to initialize the list - * aspects of an sk_buff_head without reinitializing things like - * the spinlock. It can also be used for on-stack sk_buff_head - * objects where the spinlock is known to not be used. - */ -static inline void __skb_queue_head_init(struct sk_buff_head *list) -{ - list->prev = list->next = (struct sk_buff *)list; - list->qlen = 0; -} - -static inline void __skb_queue_splice(const struct sk_buff_head *list, - struct sk_buff *prev, - struct sk_buff *next) -{ - struct sk_buff *first = list->next; - struct sk_buff *last = list->prev; - - first->prev = prev; - prev->next = first; - - last->next = next; - next->prev = last; -} - -/** - * skb_queue_splice - join two skb lists, this is designed for stacks - * @list: the new list to add - * @head: the place to add it in the first list - */ -static inline void skb_queue_splice(const struct sk_buff_head *list, - struct sk_buff_head *head) -{ - if (!skb_queue_empty(list)) { - __skb_queue_splice(list, (struct sk_buff *) head, head->next); - head->qlen += list->qlen; - } -} - -/** - * skb_queue_splice - join two skb lists and reinitialise the emptied list - * @list: the new list to add - * @head: the place to add it in the first list - * - * The list at @list is reinitialised - */ -static inline void skb_queue_splice_init(struct sk_buff_head *list, - struct sk_buff_head *head) -{ - if (!skb_queue_empty(list)) { - __skb_queue_splice(list, (struct sk_buff *) head, head->next); - head->qlen += list->qlen; - __skb_queue_head_init(list); - } -} - -/** - * skb_queue_splice_tail - join two skb lists and reinitialise the emptied list - * @list: the new list to add - * @head: the place to add it in the first list - * - * Each of the lists is a queue. - * The list at @list is reinitialised - */ -static inline void skb_queue_splice_tail_init(struct sk_buff_head *list, - struct sk_buff_head *head) -{ - if (!skb_queue_empty(list)) { - __skb_queue_splice(list, head->prev, (struct sk_buff *) head); - head->qlen += list->qlen; - __skb_queue_head_init(list); - } -} /* From include/linux/skbuff.h */ - -/** - * skb_queue_splice_tail - join two skb lists, each list being a queue - * @list: the new list to add - * @head: the place to add it in the first list - */ -static inline void skb_queue_splice_tail(const struct sk_buff_head *list, - struct sk_buff_head *head) -{ - if (!skb_queue_empty(list)) { - __skb_queue_splice(list, head->prev, (struct sk_buff *) head); - head->qlen += list->qlen; - } -} - -#define skb_queue_walk_from(queue, skb) \ - for (; skb != (struct sk_buff *)(queue); \ - skb = skb->next) - -#ifndef DECLARE_TRACE - -#define TP_PROTO(args...) args -#define TP_ARGS(args...) args - -#define DECLARE_TRACE(name, proto, args) \ - static inline void _do_trace_##name(struct tracepoint *tp, proto) \ - { } \ - static inline void trace_##name(proto) \ - { } \ - static inline int register_trace_##name(void (*probe)(proto)) \ - { \ - return -ENOSYS; \ - } \ - static inline int unregister_trace_##name(void (*probe)(proto)) \ - { \ - return -ENOSYS; \ - } - -#define EXPORT_TRACEPOINT_SYMBOL_GPL(name) -#define EXPORT_TRACEPOINT_SYMBOL(name) - - -#endif - -#define round_jiffies_up LINUX_BACKPORT(round_jiffies_up) -unsigned long round_jiffies_up(unsigned long j); - -extern void v2_6_28_skb_add_rx_frag(struct sk_buff *skb, int i, struct page *page, - int off, int size); - -#define wake_up_interruptible_poll(x, m) \ - __wake_up(x, TASK_INTERRUPTIBLE, 1, (void *) (m)) - -#define n_tty_ioctl_helper LINUX_BACKPORT(n_tty_ioctl_helper) -extern int n_tty_ioctl_helper(struct tty_struct *tty, struct file *file, - unsigned int cmd, unsigned long arg); - -#define pci_wake_from_d3 LINUX_BACKPORT(pci_wake_from_d3) -int pci_wake_from_d3(struct pci_dev *dev, bool enable); - -#define alloc_workqueue(name, flags, max_active) __create_workqueue(name, flags, max_active) - -#ifndef pr_fmt -#define pr_fmt(fmt) fmt -#endif - -#define PCI_EXP_DEVCAP2 36 /* Device Capabilities 2 */ -#define PCI_EXP_DEVCAP2_ARI 0x20 /* Alternative Routing-ID */ -#define PCI_EXP_DEVCTL2 40 /* Device Control 2 */ -#define PCI_EXP_DEVCTL2_ARI 0x20 /* Alternative Routing-ID */ - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)) */ - -#endif /* LINUX_26_28_COMPAT_H */ diff --git a/backport/include/linux/compat-2.6.29.h b/backport/include/linux/compat-2.6.29.h deleted file mode 100644 index c8cf89873ab5..000000000000 --- a/backport/include/linux/compat-2.6.29.h +++ /dev/null @@ -1,430 +0,0 @@ -#ifndef LINUX_26_29_COMPAT_H -#define LINUX_26_29_COMPAT_H - -#include -#include -#include - -/* - * I kow this looks odd.. but 2.6.32 added the netdev_tx_t - * and we backport that there so inlcude that header first - * as we need it for the netdev ops. - */ -#include - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29)) - -#include -#include -#include -#include - -#define napi_gro_receive(napi, skb) netif_receive_skb(skb) - -/* backports */ -static inline void usb_autopm_put_interface_async(struct usb_interface *intf) -{ } -static inline int usb_autopm_get_interface_async(struct usb_interface *intf) -{ return 0; } - -#if \ - defined(CONFIG_ALPHA) || defined(CONFIG_AVR32) || \ - defined(CONFIG_BLACKFIN) || defined(CONFIG_CRIS) || \ - defined(CONFIG_H8300) || defined(CONFIG_IA64) || \ - defined(CONFIG_M68K) || defined(CONFIG_MIPS) || \ - defined(CONFIG_PARISC) || defined(CONFIG_S390) || \ - defined(CONFIG_PPC64) || defined(CONFIG_PPC32) || \ - defined(CONFIG_SUPERH) || defined(CONFIG_SPARC) || \ - defined(CONFIG_FRV) || defined(CONFIG_X86) || \ - defined(CONFIG_M32R) || defined(CONFIG_M68K) || \ - defined(CONFIG_MN10300) || defined(CONFIG_XTENSA) || \ - defined(CONFIG_ARM) -#include -#else -typedef struct { - volatile int counter; -} atomic_t; - -#ifdef CONFIG_64BIT -typedef struct { - volatile long counter; -} atomic64_t; -#endif /* CONFIG_64BIT */ - -#endif - -#define PCI_EXP_LNKCTL_ES 0x0080 /* Extended Synch */ - -/* - * Older kernels do not have struct net_device_ops but what we can - * do is just define the data structure and use a caller to let us - * set the data structure's routines onto the old netdev, essentially - * doing it the old way. This avoids huge deltas on our backports. - */ - -/* - * This structure defines the management hooks for network devices. - * The following hooks can be defined; unless noted otherwise, they are - * optional and can be filled with a null pointer. - * - * int (*ndo_init)(struct net_device *dev); - * This function is called once when network device is registered. - * The network device can use this to any late stage initializaton - * or semantic validattion. It can fail with an error code which will - * be propogated back to register_netdev - * - * void (*ndo_uninit)(struct net_device *dev); - * This function is called when device is unregistered or when registration - * fails. It is not called if init fails. - * - * int (*ndo_open)(struct net_device *dev); - * This function is called when network device transistions to the up - * state. - * - * int (*ndo_stop)(struct net_device *dev); - * This function is called when network device transistions to the down - * state. - * - * netdev_tx_t (*ndo_start_xmit)(struct sk_buff *skb, - * struct net_device *dev); - * Called when a packet needs to be transmitted. - * Must return NETDEV_TX_OK , NETDEV_TX_BUSY. - * (can also return NETDEV_TX_LOCKED iff NETIF_F_LLTX) - * Required can not be NULL. - * - * u16 (*ndo_select_queue)(struct net_device *dev, struct sk_buff *skb); - * Called to decide which queue to when device supports multiple - * transmit queues. - * - * void (*ndo_change_rx_flags)(struct net_device *dev, int flags); - * This function is called to allow device receiver to make - * changes to configuration when multicast or promiscious is enabled. - * - * void (*ndo_set_rx_mode)(struct net_device *dev); - * This function is called device changes address list filtering. - * - * void (*ndo_set_multicast_list)(struct net_device *dev); - * This function is called when the multicast address list changes. - * - * int (*ndo_set_mac_address)(struct net_device *dev, void *addr); - * This function is called when the Media Access Control address - * needs to be changed. If this interface is not defined, the - * mac address can not be changed. - * - * int (*ndo_validate_addr)(struct net_device *dev); - * Test if Media Access Control address is valid for the device. - * - * int (*ndo_do_ioctl)(struct net_device *dev, struct ifreq *ifr, int cmd); - * Called when a user request an ioctl which can't be handled by - * the generic interface code. If not defined ioctl's return - * not supported error code. - * - * int (*ndo_set_config)(struct net_device *dev, struct ifmap *map); - * Used to set network devices bus interface parameters. This interface - * is retained for legacy reason, new devices should use the bus - * interface (PCI) for low level management. - * - * int (*ndo_change_mtu)(struct net_device *dev, int new_mtu); - * Called when a user wants to change the Maximum Transfer Unit - * of a device. If not defined, any request to change MTU will - * will return an error. - * - * void (*ndo_tx_timeout)(struct net_device *dev); - * Callback uses when the transmitter has not made any progress - * for dev->watchdog ticks. - * - * struct net_device_stats* (*ndo_get_stats)(struct net_device *dev); - * Called when a user wants to get the network device usage - * statistics. If not defined, the counters in dev->stats will - * be used. - * - * void (*ndo_vlan_rx_register)(struct net_device *dev, struct vlan_group *grp); - * If device support VLAN receive accleration - * (ie. dev->features & NETIF_F_HW_VLAN_RX), then this function is called - * when vlan groups for the device changes. Note: grp is NULL - * if no vlan's groups are being used. - * - * void (*ndo_vlan_rx_add_vid)(struct net_device *dev, unsigned short vid); - * If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER) - * this function is called when a VLAN id is registered. - * - * void (*ndo_vlan_rx_kill_vid)(struct net_device *dev, unsigned short vid); - * If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER) - * this function is called when a VLAN id is unregistered. - * - * void (*ndo_poll_controller)(struct net_device *dev); - * - * SR-IOV management functions. - * int (*ndo_set_vf_mac)(struct net_device *dev, int vf, u8* mac); - * int (*ndo_set_vf_vlan)(struct net_device *dev, int vf, u16 vlan, u8 qos); - * int (*ndo_set_vf_tx_rate)(struct net_device *dev, int vf, int rate); - * int (*ndo_get_vf_config)(struct net_device *dev, - * int vf, struct ifla_vf_info *ivf); - */ -#define HAVE_NET_DEVICE_OPS -struct net_device_ops { - int (*ndo_init)(struct net_device *dev); - void (*ndo_uninit)(struct net_device *dev); - int (*ndo_open)(struct net_device *dev); - int (*ndo_stop)(struct net_device *dev); - netdev_tx_t (*ndo_start_xmit) (struct sk_buff *skb, - struct net_device *dev); - u16 (*ndo_select_queue)(struct net_device *dev, - struct sk_buff *skb); - void (*ndo_change_rx_flags)(struct net_device *dev, - int flags); - void (*ndo_set_rx_mode)(struct net_device *dev); - void (*ndo_set_multicast_list)(struct net_device *dev); - int (*ndo_set_mac_address)(struct net_device *dev, - void *addr); - int (*ndo_validate_addr)(struct net_device *dev); - int (*ndo_do_ioctl)(struct net_device *dev, - struct ifreq *ifr, int cmd); - int (*ndo_set_config)(struct net_device *dev, - struct ifmap *map); - int (*ndo_change_mtu)(struct net_device *dev, - int new_mtu); - int (*ndo_neigh_setup)(struct net_device *dev, - struct neigh_parms *); - void (*ndo_tx_timeout) (struct net_device *dev); - -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36)) - struct rtnl_link_stats64* (*ndo_get_stats64)(struct net_device *dev, - struct rtnl_link_stats64 *storage); -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36)) */ - - struct net_device_stats* (*ndo_get_stats)(struct net_device *dev); - - void (*ndo_vlan_rx_register)(struct net_device *dev, - struct vlan_group *grp); - void (*ndo_vlan_rx_add_vid)(struct net_device *dev, - unsigned short vid); - void (*ndo_vlan_rx_kill_vid)(struct net_device *dev, - unsigned short vid); -#ifdef CONFIG_NET_POLL_CONTROLLER - void (*ndo_poll_controller)(struct net_device *dev); -#endif - int (*ndo_set_vf_mac)(struct net_device *dev, - int queue, u8 *mac); - int (*ndo_set_vf_vlan)(struct net_device *dev, - int queue, u16 vlan, u8 qos); - int (*ndo_set_vf_tx_rate)(struct net_device *dev, - int vf, int rate); -/* - * The struct ifla_vf_info was added via b280da8d54b8d82b52f368a8703b7ada6c1744d5 - * on the v2.6.34-rc1~233^2~338 release - */ -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34)) - int (*ndo_get_vf_config)(struct net_device *dev, - int vf, - struct ifla_vf_info *ivf); -#endif -#if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE) - int (*ndo_fcoe_enable)(struct net_device *dev); - int (*ndo_fcoe_disable)(struct net_device *dev); - int (*ndo_fcoe_ddp_setup)(struct net_device *dev, - u16 xid, - struct scatterlist *sgl, - unsigned int sgc); - int (*ndo_fcoe_ddp_done)(struct net_device *dev, - u16 xid); -#define NETDEV_FCOE_WWNN 0 -#define NETDEV_FCOE_WWPN 1 - int (*ndo_fcoe_get_wwn)(struct net_device *dev, - u64 *wwn, int type); -#endif -}; - -static inline int ndo_do_ioctl(struct net_device *dev, - struct ifreq *ifr, - int cmd) -{ - if (dev->do_ioctl) - return dev->do_ioctl(dev, ifr, cmd); - return -EOPNOTSUPP; -} - - -#define netdev_attach_ops LINUX_BACKPORT(netdev_attach_ops) -void netdev_attach_ops(struct net_device *dev, - const struct net_device_ops *ops); - -/** - * skb_queue_is_first - check if skb is the first entry in the queue - * @list: queue head - * @skb: buffer - * - * Returns true if @skb is the first buffer on the list. - */ -static inline bool skb_queue_is_first(const struct sk_buff_head *list, - const struct sk_buff *skb) -{ - return (skb->prev == (struct sk_buff *) list); -} - -/** - * skb_queue_prev - return the prev packet in the queue - * @list: queue head - * @skb: current buffer - * - * Return the prev packet in @list before @skb. It is only valid to - * call this if skb_queue_is_first() evaluates to false. - */ -static inline struct sk_buff *skb_queue_prev(const struct sk_buff_head *list, - const struct sk_buff *skb) -{ - /* This BUG_ON may seem severe, but if we just return then we - * are going to dereference garbage. - */ - BUG_ON(skb_queue_is_first(list, skb)); - return skb->prev; -} - - -static inline struct net_device_stats *dev_get_stats(struct net_device *dev) -{ - return dev->get_stats(dev); -} - -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23)) -#if defined(CONFIG_USB) || defined(CONFIG_USB_MODULE) -#define usb_unpoison_anchored_urbs LINUX_BACKPORT(usb_unpoison_anchored_urbs) -extern void usb_unpoison_anchored_urbs(struct usb_anchor *anchor); -#endif /* CONFIG_USB */ -#endif - -#define DIV_ROUND_CLOSEST(x, divisor)( \ -{ \ - typeof(divisor) __divisor = divisor; \ - (((x) + ((__divisor) / 2)) / (__divisor)); \ -} \ -) - -#define eth_mac_addr LINUX_BACKPORT(eth_mac_addr) -extern int eth_mac_addr(struct net_device *dev, void *p); -#define eth_change_mtu LINUX_BACKPORT(eth_change_mtu) -extern int eth_change_mtu(struct net_device *dev, int new_mtu); -#define eth_validate_addr LINUX_BACKPORT(eth_validate_addr) -extern int eth_validate_addr(struct net_device *dev); - -#ifdef CONFIG_NET_NS - -static inline void write_pnet(struct net **pnet, struct net *net) -{ - *pnet = net; -} - -static inline struct net *read_pnet(struct net * const *pnet) -{ - return *pnet; -} - -#else - -#define write_pnet(pnet, net) do { (void)(net);} while (0) -#define read_pnet(pnet) (&init_net) - -/* - * swap - swap value of @a and @b - */ -#define swap(a, b) \ - do { typeof(a) __tmp = (a); (a) = (b); (b) = __tmp; } while (0) - -#endif - -#define init_dummy_netdev LINUX_BACKPORT(init_dummy_netdev) -extern int init_dummy_netdev(struct net_device *dev); - -#else /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29)) */ - -/* Kernels >= 2.6.29 follows */ - -/* XXX: this can probably just go upstream ! */ -static inline void netdev_attach_ops(struct net_device *dev, - const struct net_device_ops *ops) -{ - dev->netdev_ops = ops; -} - -/* XXX: this can probably just go upstream! */ -static inline int ndo_do_ioctl(struct net_device *dev, - struct ifreq *ifr, - int cmd) -{ - if (dev->netdev_ops && dev->netdev_ops->ndo_do_ioctl) - return dev->netdev_ops->ndo_do_ioctl(dev, ifr, cmd); - return -EOPNOTSUPP; -} - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29)) */ - -#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29) -#define compat_pci_suspend(fn) \ - int fn##_compat(struct pci_dev *pdev, pm_message_t state) \ - { \ - int r; \ - \ - r = fn(&pdev->dev); \ - if (r) \ - return r; \ - \ - pci_save_state(pdev); \ - pci_disable_device(pdev); \ - pci_set_power_state(pdev, PCI_D3hot); \ - \ - return 0; \ - } - -#define compat_pci_resume(fn) \ - int fn##_compat(struct pci_dev *pdev) \ - { \ - int r; \ - \ - pci_set_power_state(pdev, PCI_D0); \ - r = pci_enable_device(pdev); \ - if (r) \ - return r; \ - pci_restore_state(pdev); \ - \ - return fn(&pdev->dev); \ - } -#elif LINUX_VERSION_CODE == KERNEL_VERSION(2,6,29) -#define compat_pci_suspend(fn) \ - int fn##_compat(struct device *dev) \ - { \ - struct pci_dev *pdev = to_pci_dev(dev); \ - int r; \ - \ - r = fn(&pdev->dev); \ - if (r) \ - return r; \ - \ - pci_save_state(pdev); \ - pci_disable_device(pdev); \ - pci_set_power_state(pdev, PCI_D3hot); \ - \ - return 0; \ - } - -#define compat_pci_resume(fn) \ - int fn##_compat(struct device *dev) \ - { \ - struct pci_dev *pdev = to_pci_dev(dev); \ - int r; \ - \ - pci_set_power_state(pdev, PCI_D0); \ - r = pci_enable_device(pdev); \ - if (r) \ - return r; \ - pci_restore_state(pdev); \ - \ - return fn(&pdev->dev); \ - } -#else -#define compat_pci_suspend(fn) -#define compat_pci_resume(fn) -#endif - -#define PCI_EXP_SLTSTA_PDS 0x0040 /* Presence Detect State */ - -#endif /* LINUX_26_29_COMPAT_H */ diff --git a/backport/include/linux/compat-2.6.30.h b/backport/include/linux/compat-2.6.30.h deleted file mode 100644 index 5841b6c8e348..000000000000 --- a/backport/include/linux/compat-2.6.30.h +++ /dev/null @@ -1,53 +0,0 @@ -#ifndef LINUX_26_30_COMPAT_H -#define LINUX_26_30_COMPAT_H - -#include - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,30)) - -#include -#include - -#define HID_QUIRK_IGNORE 0x00000004 - -#ifndef TP_PROTO -#define TP_PROTO(args...) TPPROTO(args) -#endif -#ifndef TP_ARGS -#define TP_ARGS(args...) TPARGS(args) -#endif - -#define IRQ_WAKE_THREAD (2) - -/* From : include/linux/pm.h */ -/* How to reorder dpm_list after device_move() */ -enum dpm_order { - DPM_ORDER_NONE, - DPM_ORDER_DEV_AFTER_PARENT, - DPM_ORDER_PARENT_BEFORE_DEV, - DPM_ORDER_DEV_LAST, -}; - -static inline void dev_set_uevent_suppress(struct device *dev, int val) -{ - dev->uevent_suppress = val; -} - -/* - * Print a one-time message (analogous to WARN_ONCE() et al): - */ -#define printk_once(x...) ({ \ - static bool __print_once; \ - \ - if (!__print_once) { \ - __print_once = true; \ - printk(x); \ - } \ -}) - -#define PCI_EXP_LNKCTL2 48 /* Link Control 2 */ -#define PCI_EXP_SLTCTL2 56 /* Slot Control 2 */ - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,30)) */ - -#endif /* LINUX_26_30_COMPAT_H */ diff --git a/backport/include/linux/compat-2.6.31.h b/backport/include/linux/compat-2.6.31.h deleted file mode 100644 index 096c13183470..000000000000 --- a/backport/include/linux/compat-2.6.31.h +++ /dev/null @@ -1,273 +0,0 @@ -#ifndef LINUX_26_31_COMPAT_H -#define LINUX_26_31_COMPAT_H - -#include - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,31)) - -#include -#include -#include -#include -#include -#include -#include - -#define SUPPORTED_Backplane (1 << 16) -#define SUPPORTED_1000baseKX_Full (1 << 17) -#define SUPPORTED_10000baseKX4_Full (1 << 18) -#define SUPPORTED_10000baseKR_Full (1 << 19) -#define SUPPORTED_10000baseR_FEC (1 << 20) - -#define ADVERTISED_Backplane (1 << 16) -#define ADVERTISED_1000baseKX_Full (1 << 17) -#define ADVERTISED_10000baseKX4_Full (1 << 18) -#define ADVERTISED_10000baseKR_Full (1 << 19) -#define ADVERTISED_10000baseR_FEC (1 << 20) - -#define rfkill_get_led_trigger_name LINUX_BACKPORT(rfkill_get_led_trigger_name) -#define rfkill_set_led_trigger_name LINUX_BACKPORT(rfkill_set_led_trigger_name) -#define rfkill_set_hw_state LINUX_BACKPORT(rfkill_set_hw_state) -#define rfkill_set_sw_state LINUX_BACKPORT(rfkill_set_sw_state) -#define rfkill_init_sw_state LINUX_BACKPORT(rfkill_init_sw_state) -#define rfkill_set_states LINUX_BACKPORT(rfkill_set_states) -#define rfkill_pause_polling LINUX_BACKPORT(rfkill_pause_polling) -#define rfkill_resume_polling LINUX_BACKPORT(rfkill_resume_polling) -#define rfkill_blocked LINUX_BACKPORT(rfkill_blocked) -#define rfkill_alloc LINUX_BACKPORT(rfkill_alloc) -#define rfkill_register LINUX_BACKPORT(rfkill_register) -#define rfkill_unregister LINUX_BACKPORT(rfkill_unregister) -#define rfkill_destroy LINUX_BACKPORT(rfkill_destroy) - -#ifndef ERFKILL -#if !defined(CONFIG_ALPHA) && !defined(CONFIG_MIPS) && !defined(CONFIG_PARISC) && !defined(CONFIG_SPARC) -#define ERFKILL 132 /* Operation not possible due to RF-kill */ -#endif -#ifdef CONFIG_ALPHA -#define ERFKILL 138 /* Operation not possible due to RF-kill */ -#endif -#ifdef CONFIG_MIPS -#define ERFKILL 167 /* Operation not possible due to RF-kill */ -#endif -#ifdef CONFIG_PARISC -#define ERFKILL 256 /* Operation not possible due to RF-kill */ -#endif -#ifdef CONFIG_SPARC -#define ERFKILL 134 /* Operation not possible due to RF-kill */ -#endif -#endif - -#define mdio45_probe LINUX_BACKPORT(mdio45_probe) -#define mdio_set_flag LINUX_BACKPORT(mdio_set_flag) -#define mdio45_links_ok LINUX_BACKPORT(mdio45_links_ok) -#define mdio45_nway_restart LINUX_BACKPORT(mdio45_nway_restart) - -#define mdio45_ethtool_gset_npage LINUX_BACKPORT(mdio45_ethtool_gset_npage) -#define mdio45_ethtool_spauseparam_an LINUX_BACKPORT(mdio45_ethtool_spauseparam_an) -#define mdio_mii_ioctl LINUX_BACKPORT(mdio_mii_ioctl) - -#ifndef NETDEV_PRE_UP -#define NETDEV_PRE_UP 0x000D -#endif - -#ifndef SDIO_DEVICE_ID_MARVELL_8688WLAN -#define SDIO_DEVICE_ID_MARVELL_8688WLAN 0x9104 -#endif - -struct compat_threaded_irq { - unsigned int irq; - irq_handler_t handler; - irq_handler_t thread_fn; - void *dev_id; - char wq_name[64]; - struct workqueue_struct *wq; - struct work_struct work; -}; - -/* - * kmemleak was introduced on 2.6.31, since older kernels do not have - * we simply ignore its tuning. - */ -static inline void kmemleak_ignore(const void *ptr) -{ - return; -} - -static inline void kmemleak_not_leak(const void *ptr) -{ - return; -} - -static inline void kmemleak_no_scan(const void *ptr) -{ - return; -} - -/* - * Added via adf30907d63893e4208dfe3f5c88ae12bc2f25d5 - * - * There is no _sk_dst on older kernels, so just set the - * old dst to NULL and release it directly. - */ -static inline void skb_dst_drop(struct sk_buff *skb) -{ - dst_release(skb->dst); - skb->dst = NULL; -} - -static inline struct dst_entry *skb_dst(const struct sk_buff *skb) -{ - return (struct dst_entry *)skb->dst; -} - -static inline void skb_dst_set(struct sk_buff *skb, struct dst_entry *dst) -{ - skb->dst = dst; -} - -static inline struct rtable *skb_rtable(const struct sk_buff *skb) -{ - return (struct rtable *)skb_dst(skb); -} - -/* Backport threaded IRQ support */ - -static inline -void compat_irq_work(struct work_struct *work) -{ - struct compat_threaded_irq *comp = container_of(work, struct compat_threaded_irq, work); - comp->thread_fn(comp->irq, comp->dev_id); -} - -static inline -irqreturn_t compat_irq_dispatcher(int irq, void *dev_id) -{ - struct compat_threaded_irq *comp = dev_id; - irqreturn_t res; - - res = comp->handler(irq, comp->dev_id); - if (res == IRQ_WAKE_THREAD) { - queue_work(comp->wq, &comp->work); - res = IRQ_HANDLED; - } - - return res; -} - -static inline -int compat_request_threaded_irq(struct compat_threaded_irq *comp, - unsigned int irq, - irq_handler_t handler, - irq_handler_t thread_fn, - unsigned long flags, - const char *name, - void *dev_id) -{ - comp->irq = irq; - comp->handler = handler; - comp->thread_fn = thread_fn; - comp->dev_id = dev_id; - INIT_WORK(&comp->work, compat_irq_work); - - if (!comp->wq) { - snprintf(comp->wq_name, sizeof(comp->wq_name), - "compirq/%u-%s", irq, name); - comp->wq = create_singlethread_workqueue(comp->wq_name); - if (!comp->wq) { - printk(KERN_ERR "Failed to create compat-threaded-IRQ workqueue %s\n", - comp->wq_name); - return -ENOMEM; - } - } - return request_irq(irq, compat_irq_dispatcher, flags, name, comp); -} - -static inline -void compat_free_threaded_irq(struct compat_threaded_irq *comp) -{ - free_irq(comp->irq, comp); -} - -static inline -void compat_destroy_threaded_irq(struct compat_threaded_irq *comp) -{ - if (comp->wq) - destroy_workqueue(comp->wq); - comp->wq = NULL; -} - -static inline -void compat_synchronize_threaded_irq(struct compat_threaded_irq *comp) -{ - synchronize_irq(comp->irq); - cancel_work_sync(&comp->work); -} - -/** - * list_entry_rcu - get the struct for this entry - * @ptr: the &struct list_head pointer. - * @type: the type of the struct this is embedded in. - * @member: the name of the list_struct within the struct. - * - * This primitive may safely run concurrently with the _rcu list-mutation - * primitives such as list_add_rcu() as long as it's guarded by rcu_read_lock(). - */ -#define list_entry_rcu(ptr, type, member) \ - container_of(rcu_dereference(ptr), type, member) - -#define skb_walk_frags(skb, iter) \ - for (iter = skb_shinfo(skb)->frag_list; iter; iter = iter->next) - -#ifndef CONFIG_64BIT - -typedef struct { - long long counter; -} atomic64_t; - -#define atomic64_read LINUX_BACKPORT(atomic64_read) -extern long long atomic64_read(const atomic64_t *v); -#define atomic64_add_return LINUX_BACKPORT(atomic64_add_return) -extern long long atomic64_add_return(long long a, atomic64_t *v); - -#define atomic64_inc_return(v) atomic64_add_return(1LL, (v)) - -#endif - -/** - * sk_rmem_alloc_get - returns read allocations - * @sk: socket - * - * Returns sk_rmem_alloc - */ -static inline int sk_rmem_alloc_get(const struct sock *sk) -{ - return atomic_read(&sk->sk_rmem_alloc); -} - -/** - * sk_wmem_alloc_get - returns write allocations - * @sk: socket - * - * Returns sk_wmem_alloc minus initial offset of one - */ -static inline int sk_wmem_alloc_get(const struct sock *sk) -{ - return atomic_read(&sk->sk_wmem_alloc) - 1; -} - -/** - * sk_has_allocations - check if allocations are outstanding - * @sk: socket - * - * Returns true if socket has write or read allocations - */ -static inline bool sk_has_allocations(const struct sock *sk) -{ - return sk_wmem_alloc_get(sk) || sk_rmem_alloc_get(sk); -} - -#define USB_SUBCLASS_VENDOR_SPEC 0xff - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,31)) */ - -#endif /* LINUX_26_31_COMPAT_H */ diff --git a/backport/include/linux/compat-2.6.32.h b/backport/include/linux/compat-2.6.32.h deleted file mode 100644 index d5b5df87a17b..000000000000 --- a/backport/include/linux/compat-2.6.32.h +++ /dev/null @@ -1,198 +0,0 @@ -#ifndef LINUX_26_32_COMPAT_H -#define LINUX_26_32_COMPAT_H - -#include - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,32)) - -#include -#include -#include -#include -#include -#include - -#define TCQ_F_CAN_BYPASS 4 - -static inline int qdisc_qlen(const struct Qdisc *q) -{ - return q->q.qlen; -} - -#define SDIO_VENDOR_ID_INTEL 0x0089 -#define SDIO_DEVICE_ID_INTEL_IWMC3200WIMAX 0x1402 -#define SDIO_DEVICE_ID_INTEL_IWMC3200WIFI 0x1403 -#define SDIO_DEVICE_ID_INTEL_IWMC3200TOP 0x1404 -#define SDIO_DEVICE_ID_INTEL_IWMC3200GPS 0x1405 -#define SDIO_DEVICE_ID_INTEL_IWMC3200BT 0x1406 - -/* - * Backports 5e928f77a09a07f9dd595bb8a489965d69a83458 - * run-time power management cannot really be backported - * given that the implementation added bus specific - * callbacks that we won't have on older kernels. If - * you really want run-time power management or good - * power management upgrade your kernel. We'll just - * compile this out as if run-time power management was - * disabled just as the kernel disables run-time power management - * when CONFIG_PM_RUNTIME is disabled. - */ -static inline void pm_runtime_init(struct device *dev) {} -static inline void pm_runtime_remove(struct device *dev) {} -static inline int pm_runtime_get(struct device *dev) -{ - return 0; -} - -static inline int pm_runtime_get_sync(struct device *dev) -{ - return 0; -} - -static inline int pm_runtime_put(struct device *dev) -{ - return 0; -} - -static inline int pm_runtime_put_sync(struct device *dev) -{ - return 0; -} - -static inline int pm_runtime_set_active(struct device *dev) -{ - return 0; -} - -static inline void pm_runtime_set_suspended(struct device *dev) -{ -} - -static inline void pm_runtime_disable(struct device *dev) -{ -} - -static inline void pm_runtime_put_noidle(struct device *dev) {} -static inline void pm_runtime_get_noresume(struct device *dev) {} - -static inline void flush_delayed_work(struct delayed_work *dwork) -{ - if (del_timer_sync(&dwork->timer)) { - /* - * This is what would happen on 2.6.32 but since we don't have - * access to the singlethread_cpu we can't really backport this, - * so avoid really *flush*ing the work... Oh well. Any better ideas? - - struct cpu_workqueue_struct *cwq; - cwq = wq_per_cpu(keventd_wq, get_cpu()); - __queue_work(cwq, &dwork->work); - put_cpu(); - - */ - } - flush_work(&dwork->work); -} - -/* - * struct genl_multicast_group was made netns aware through - * patch "genetlink: make netns aware" by johannes, we just - * force this to always use the default init_net - */ -#define genl_info_net(x) &init_net -/* Just use init_net for older kernels */ -#define get_net_ns_by_pid(x) &init_net - -/* net namespace is lost */ -#define genlmsg_multicast_netns(a, b, c, d, e) genlmsg_multicast(b, c, d, e) -#define genlmsg_multicast_allns(a, b, c, d) genlmsg_multicast(a, b, c, d) -#define genlmsg_unicast(net, skb, pid) genlmsg_unicast(skb, pid) - -#define dev_change_net_namespace(a, b, c) (-EOPNOTSUPP) - -#define SET_NETDEV_DEVTYPE(netdev, type) - -#ifdef __KERNEL__ -/* Driver transmit return codes */ -enum netdev_tx { - BACKPORT_NETDEV_TX_OK = NETDEV_TX_OK, /* driver took care of packet */ - BACKPORT_NETDEV_TX_BUSY = NETDEV_TX_BUSY, /* driver tx path was busy*/ - BACKPORT_NETDEV_TX_LOCKED = NETDEV_TX_LOCKED, /* driver tx lock was already taken */ -}; -typedef enum netdev_tx netdev_tx_t; -#endif /* __KERNEL__ */ - -/* - * dev_pm_ops is only available on kernels >= 2.6.29, for - * older kernels we rely on reverting the work to old - * power management style stuff. On 2.6.29 the pci calls - * weren't included yet though, so include them here. - */ -#if (LINUX_VERSION_CODE == KERNEL_VERSION(2,6,29)) -#define SIMPLE_DEV_PM_OPS(name, suspend_fn, resume_fn) \ -struct dev_pm_ops name = { \ - .suspend = suspend_fn ## _compat, \ - .resume = resume_fn ## _compat, \ - .freeze = suspend_fn ## _compat, \ - .thaw = resume_fn ## _compat, \ - .poweroff = suspend_fn ## _compat, \ - .restore = resume_fn ## _compat, \ -} -#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,30)) -/* - * Use this if you want to use the same suspend and resume callbacks for suspend - * to RAM and hibernation. - */ -#define SIMPLE_DEV_PM_OPS(name, suspend_fn, resume_fn) \ -struct dev_pm_ops name = { \ - .suspend = suspend_fn, \ - .resume = resume_fn, \ - .freeze = suspend_fn, \ - .thaw = resume_fn, \ - .poweroff = suspend_fn, \ - .restore = resume_fn, \ -} -#else -#define SIMPLE_DEV_PM_OPS(name, suspend_fn, resume_fn) -#endif /* >= 2.6.29 */ - -#define wireless_send_event(a, b, c, d) wireless_send_event(a, b, c, (char * ) d) - -/* The export symbol in changed in compat/patches/15-symbol-export-conflicts.patch */ -#define ieee80211_rx(hw, skb) mac80211_ieee80211_rx(hw, skb) - -#define dev_to_sdio_func(d) container_of(d, struct sdio_func, dev) - -#define lockdep_assert_held(l) do { } while (0) - -/* - * Similar to the struct tm in userspace , but it needs to be here so - * that the kernel source is self contained. - */ -struct tm { - /* - * the number of seconds after the minute, normally in the range - * 0 to 59, but can be up to 60 to allow for leap seconds - */ - int tm_sec; - /* the number of minutes after the hour, in the range 0 to 59*/ - int tm_min; - /* the number of hours past midnight, in the range 0 to 23 */ - int tm_hour; - /* the day of the month, in the range 1 to 31 */ - int tm_mday; - /* the number of months since January, in the range 0 to 11 */ - int tm_mon; - /* the number of years since 1900 */ - long tm_year; - /* the number of days since Sunday, in the range 0 to 6 */ - int tm_wday; - /* the number of days since January 1, in the range 0 to 365 */ - int tm_yday; -}; - -#define time_to_tm LINUX_BACKPORT(time_to_tm) -void time_to_tm(time_t totalsecs, int offset, struct tm *result); - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,32)) */ - -#endif /* LINUX_26_32_COMPAT_H */ diff --git a/backport/include/linux/compat-2.6.33.h b/backport/include/linux/compat-2.6.33.h deleted file mode 100644 index b03fe401cc80..000000000000 --- a/backport/include/linux/compat-2.6.33.h +++ /dev/null @@ -1,190 +0,0 @@ -#ifndef LINUX_26_33_COMPAT_H -#define LINUX_26_33_COMPAT_H - -#include - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,33)) - -#include -#include -#include -#if defined(CONFIG_PCCARD) || defined(CONFIG_PCCARD_MODULE) -#include -#include -#include -#endif -#include -#include - -#define usb_autopm_get_interface_no_resume LINUX_BACKPORT(usb_autopm_get_interface_no_resume) -#define usb_autopm_put_interface_no_suspend LINUX_BACKPORT(usb_autopm_put_interface_no_suspend) -#ifdef CONFIG_USB_SUSPEND -extern void usb_autopm_get_interface_no_resume(struct usb_interface *intf); -extern void usb_autopm_put_interface_no_suspend(struct usb_interface *intf); -#else -static inline void usb_autopm_get_interface_no_resume(struct usb_interface *intf) -{ - atomic_inc(&intf->pm_usage_cnt); -} -static inline void usb_autopm_put_interface_no_suspend(struct usb_interface *intf) -{ - atomic_dec(&intf->pm_usage_cnt); -} -#endif /* CONFIG_USB_SUSPEND */ - -#if defined(CPTCFG_BACKPORT_BUILD_FW_LOADER_MODULE) -#define request_firmware_nowait LINUX_BACKPORT(request_firmware_nowait) -#define request_firmware LINUX_BACKPORT(request_firmware) -#define release_firmware LINUX_BACKPORT(release_firmware) - -int request_firmware(const struct firmware **fw, const char *name, - struct device *device); -int request_firmware_nowait( - struct module *module, int uevent, - const char *name, struct device *device, gfp_t gfp, void *context, - void (*cont)(const struct firmware *fw, void *context)); - -void release_firmware(const struct firmware *fw); -#endif - -/* mask KEY_RFKILL as RHEL6 backports this */ -#if !defined(KEY_RFKILL) -#define KEY_RFKILL 247 /* Key that controls all radios */ -#endif - -/* mask IFF_DONT_BRIDGE as RHEL6 backports this */ -#if !defined(IFF_DONT_BRIDGE) -#define IFF_DONT_BRIDGE 0x800 /* disallow bridging this ether dev */ -/* source: include/linux/if.h */ -#endif - -/* mask NETDEV_POST_INIT as RHEL6 backports this */ -/* this will never happen on older kernels */ -#if !defined(NETDEV_POST_INIT) -#define NETDEV_POST_INIT 0xffff -#endif - -/* mask netdev_alloc_skb_ip_align as debian squeeze also backports this */ -#define netdev_alloc_skb_ip_align(a, b) compat_netdev_alloc_skb_ip_align(a, b) - -static inline struct sk_buff *netdev_alloc_skb_ip_align(struct net_device *dev, - unsigned int length) -{ - struct sk_buff *skb = netdev_alloc_skb(dev, length + NET_IP_ALIGN); - - if (NET_IP_ALIGN && skb) - skb_reserve(skb, NET_IP_ALIGN); - return skb; -} - -#if defined(CONFIG_PCCARD) || defined(CONFIG_PCCARD_MODULE) - -#if defined(CONFIG_PCMCIA) || defined(CONFIG_PCMCIA_MODULE) - -#define pcmcia_request_window(a, b, c) pcmcia_request_window(&a, b, c) - -#define pcmcia_map_mem_page(a, b, c) pcmcia_map_mem_page(b, c) - -/* loop over CIS entries */ -#define pcmcia_loop_tuple LINUX_BACKPORT(pcmcia_loop_tuple) -int pcmcia_loop_tuple(struct pcmcia_device *p_dev, cisdata_t code, - int (*loop_tuple) (struct pcmcia_device *p_dev, - tuple_t *tuple, - void *priv_data), - void *priv_data); - -#endif /* CONFIG_PCMCIA */ - -/* loop over CIS entries */ -#define pccard_loop_tuple LINUX_BACKPORT(pccard_loop_tuple) -int pccard_loop_tuple(struct pcmcia_socket *s, unsigned int function, - cisdata_t code, cisparse_t *parse, void *priv_data, - int (*loop_tuple) (tuple_t *tuple, - cisparse_t *parse, - void *priv_data)); - -#endif /* CONFIG_PCCARD */ - -/** - * list_for_each_entry_continue_rcu - continue iteration over list of given type - * @pos: the type * to use as a loop cursor. - * @head: the head for your list. - * @member: the name of the list_struct within the struct. - * - * Continue to iterate over list of given type, continuing after - * the current position. - */ -#define list_for_each_entry_continue_rcu(pos, head, member) \ - for (pos = list_entry_rcu(pos->member.next, typeof(*pos), member); \ - prefetch(pos->member.next), &pos->member != (head); \ - pos = list_entry_rcu(pos->member.next, typeof(*pos), member)) - -#define sock_recv_ts_and_drops(msg, sk, skb) sock_recv_timestamp(msg, sk, skb) - -/* mask pci_pcie_cap as debian squeeze also backports this */ -#define pci_pcie_cap(a) compat_pci_pcie_cap(a) - -/** - * pci_pcie_cap - get the saved PCIe capability offset - * @dev: PCI device - * - * PCIe capability offset is calculated at PCI device initialization - * time and saved in the data structure. This function returns saved - * PCIe capability offset. Using this instead of pci_find_capability() - * reduces unnecessary search in the PCI configuration space. If you - * need to calculate PCIe capability offset from raw device for some - * reasons, please use pci_find_capability() instead. - */ -static inline int pci_pcie_cap(struct pci_dev *dev) -{ - return pci_find_capability(dev, PCI_CAP_ID_EXP); -} - -/* mask pci_is_pcie as RHEL6 backports this */ -#define pci_is_pcie(a) compat_pci_is_pcie(a) - -/** - * pci_is_pcie - check if the PCI device is PCI Express capable - * @dev: PCI device - * - * Retrun true if the PCI device is PCI Express capable, false otherwise. - */ -static inline bool pci_is_pcie(struct pci_dev *dev) -{ -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)) - return dev->is_pcie; -#else - return !!pci_pcie_cap(dev); -#endif -} - -#ifdef __GNUC__ -#define __always_unused __attribute__((unused)) -#else -#define __always_unused /* unimplemented */ -#endif - -/* mask IS_ERR_OR_NULL as debian squeeze also backports this */ -#define IS_ERR_OR_NULL(a) compat_IS_ERR_OR_NULL(a) - -static inline long __must_check IS_ERR_OR_NULL(const void *ptr) -{ - return !ptr || IS_ERR_VALUE((unsigned long)ptr); -} - -#if (LINUX_VERSION_CODE == KERNEL_VERSION(2,6,32)) -#undef SIMPLE_DEV_PM_OPS -#define SIMPLE_DEV_PM_OPS(name, suspend_fn, resume_fn) \ -const struct dev_pm_ops name = { \ - .suspend = suspend_fn, \ - .resume = resume_fn, \ - .freeze = suspend_fn, \ - .thaw = resume_fn, \ - .poweroff = suspend_fn, \ - .restore = resume_fn, \ -} -#endif /* (LINUX_VERSION_CODE == KERNEL_VERSION(2,6,32)) */ - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,33)) */ - -#endif /* LINUX_26_33_COMPAT_H */ diff --git a/backport/include/linux/compat-2.6.34.h b/backport/include/linux/compat-2.6.34.h deleted file mode 100644 index d444853a4f66..000000000000 --- a/backport/include/linux/compat-2.6.34.h +++ /dev/null @@ -1,347 +0,0 @@ -#ifndef LINUX_26_34_COMPAT_H -#define LINUX_26_34_COMPAT_H - -#include - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,34)) - -#include -#include -#include -#include - -/* - * Backports da68c4eb25 - * sdio: introduce API for special power management features - * - * We wimply carry around the data structures and flags, and - * make the host return no flags set by the driver. - */ -typedef unsigned int mmc_pm_flag_t; - -#define MMC_PM_KEEP_POWER (1 << 0) /* preserve card power during suspend */ -#define MMC_PM_WAKE_SDIO_IRQ (1 << 1) /* wake up host system on SDIO IRQ assertion */ - -extern mmc_pm_flag_t sdio_get_host_pm_caps(struct sdio_func *func); -extern int sdio_set_host_pm_flags(struct sdio_func *func, mmc_pm_flag_t flags); - -#define netdev_mc_count(dev) ((dev)->mc_count) -#define netdev_mc_empty(dev) (netdev_mc_count(dev) == 0) - -/* mask netdev_for_each_mc_addr as RHEL6 backports this */ -#if !defined(netdev_for_each_mc_addr) -#define netdev_for_each_mc_addr(mclist, dev) \ - for (mclist = dev->mc_list; mclist; mclist = mclist->next) -#endif -/* source: include/linux/netdevice.h */ - - -/* Logging, debugging and troubleshooting/diagnostic helpers. */ - -/* netdev_printk helpers, similar to dev_printk */ - -#ifndef netdev_name -#define netdev_name(__dev) \ - ((__dev->reg_state != NETREG_REGISTERED) ? \ - "(unregistered net_device)" : __dev->name) -#endif - -#define netdev_printk(level, netdev, format, args...) \ - dev_printk(level, (netdev)->dev.parent, \ - "%s: " format, \ - netdev_name(netdev), ##args) - -#define netdev_emerg(dev, format, args...) \ - netdev_printk(KERN_EMERG, dev, format, ##args) -#define netdev_alert(dev, format, args...) \ - netdev_printk(KERN_ALERT, dev, format, ##args) -#define netdev_crit(dev, format, args...) \ - netdev_printk(KERN_CRIT, dev, format, ##args) -#define netdev_err(dev, format, args...) \ - netdev_printk(KERN_ERR, dev, format, ##args) -#define netdev_warn(dev, format, args...) \ - netdev_printk(KERN_WARNING, dev, format, ##args) -#define netdev_notice(dev, format, args...) \ - netdev_printk(KERN_NOTICE, dev, format, ##args) -#define netdev_info(dev, format, args...) \ - netdev_printk(KERN_INFO, dev, format, ##args) - -/* mask netdev_dbg as RHEL6 backports this */ -#if !defined(netdev_dbg) - -#if defined(DEBUG) -#define netdev_dbg(__dev, format, args...) \ - netdev_printk(KERN_DEBUG, __dev, format, ##args) -#elif defined(CONFIG_DYNAMIC_DEBUG) -#define netdev_dbg(__dev, format, args...) \ -do { \ - dynamic_dev_dbg((__dev)->dev.parent, "%s: " format, \ - netdev_name(__dev), ##args); \ -} while (0) -#else -#define netdev_dbg(__dev, format, args...) \ -({ \ - if (0) \ - netdev_printk(KERN_DEBUG, __dev, format, ##args); \ - 0; \ -}) -#endif - -#endif - -/* mask netdev_vdbg as RHEL6 backports this */ -#if !defined(netdev_dbg) - -#if defined(VERBOSE_DEBUG) -#define netdev_vdbg netdev_dbg -#else - -#define netdev_vdbg(dev, format, args...) \ -({ \ - if (0) \ - netdev_printk(KERN_DEBUG, dev, format, ##args); \ - 0; \ -}) -#endif - -#endif - -/* - * netdev_WARN() acts like dev_printk(), but with the key difference - * of using a WARN/WARN_ON to get the message out, including the - * file/line information and a backtrace. - */ -#define netdev_WARN(dev, format, args...) \ - WARN(1, "netdevice: %s\n" format, netdev_name(dev), ##args); - -/* netif printk helpers, similar to netdev_printk */ - -#define netif_printk(priv, type, level, dev, fmt, args...) \ -do { \ - if (netif_msg_##type(priv)) \ - netdev_printk(level, (dev), fmt, ##args); \ -} while (0) - -#define netif_emerg(priv, type, dev, fmt, args...) \ - netif_printk(priv, type, KERN_EMERG, dev, fmt, ##args) -#define netif_alert(priv, type, dev, fmt, args...) \ - netif_printk(priv, type, KERN_ALERT, dev, fmt, ##args) -#define netif_crit(priv, type, dev, fmt, args...) \ - netif_printk(priv, type, KERN_CRIT, dev, fmt, ##args) -#define netif_err(priv, type, dev, fmt, args...) \ - netif_printk(priv, type, KERN_ERR, dev, fmt, ##args) -#define netif_warn(priv, type, dev, fmt, args...) \ - netif_printk(priv, type, KERN_WARNING, dev, fmt, ##args) -#define netif_notice(priv, type, dev, fmt, args...) \ - netif_printk(priv, type, KERN_NOTICE, dev, fmt, ##args) -#define netif_info(priv, type, dev, fmt, args...) \ - netif_printk(priv, type, KERN_INFO, (dev), fmt, ##args) - -/* mask netif_dbg as RHEL6 backports this */ -#if !defined(netif_dbg) - -#if defined(DEBUG) -#define netif_dbg(priv, type, dev, format, args...) \ - netif_printk(priv, type, KERN_DEBUG, dev, format, ##args) -#elif defined(CONFIG_DYNAMIC_DEBUG) -#define netif_dbg(priv, type, netdev, format, args...) \ -do { \ - if (netif_msg_##type(priv)) \ - dynamic_dev_dbg((netdev)->dev.parent, \ - "%s: " format, \ - netdev_name(netdev), ##args); \ -} while (0) -#else -#define netif_dbg(priv, type, dev, format, args...) \ -({ \ - if (0) \ - netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \ - 0; \ -}) -#endif - -#endif - -/* mask netif_vdbg as RHEL6 backports this */ -#if !defined(netif_vdbg) - -#if defined(VERBOSE_DEBUG) -#define netif_vdbg netdev_dbg -#else -#define netif_vdbg(priv, type, dev, format, args...) \ -({ \ - if (0) \ - netif_printk(KERN_DEBUG, dev, format, ##args); \ - 0; \ -}) -#endif -#endif -/* source: include/linux/netdevice.h */ - - -static inline void device_lock(struct device *dev) -{ -#if defined(CONFIG_PREEMPT_RT) || defined(CONFIG_PREEMPT_DESKTOP) - mutex_lock(&dev->mutex); -#else - down(&dev->sem); -#endif -} - -static inline int device_trylock(struct device *dev) -{ -#if defined(CONFIG_PREEMPT_RT) || defined(CONFIG_PREEMPT_DESKTOP) - return mutex_trylock(&dev->mutex); -#else - return down_trylock(&dev->sem); -#endif -} - -static inline void device_unlock(struct device *dev) -{ -#if defined(CONFIG_PREEMPT_RT) || defined(CONFIG_PREEMPT_DESKTOP) - mutex_unlock(&dev->mutex); -#else - up(&dev->sem); -#endif -} - -#if defined(CONFIG_PCMCIA) || defined(CONFIG_PCMCIA_MODULE) -#define PCMCIA_DEVICE_PROD_ID3(v3, vh3) { \ - .match_flags = PCMCIA_DEV_ID_MATCH_PROD_ID3, \ - .prod_id = { NULL, NULL, (v3), NULL }, \ - .prod_id_hash = { 0, 0, (vh3), 0 }, } -#endif - -#define rcu_dereference_check(p, c) rcu_dereference(p) - -/** - * sysfs_attr_init - initialize a dynamically allocated sysfs attribute - * @attr: struct attribute to initialize - * - * Initialize a dynamically allocated struct attribute so we can - * make lockdep happy. This is a new requirement for attributes - * and initially this is only needed when lockdep is enabled. - * Lockdep gives a nice error when your attribute is added to - * sysfs if you don't have this. - */ -#ifdef CONFIG_DEBUG_LOCK_ALLOC -#define sysfs_attr_init(attr) \ -do { \ - static struct lock_class_key __key; \ - \ - (attr)->key = &__key; \ -} while(0) -#else -#define sysfs_attr_init(attr) do {} while(0) -#endif - -/* mask sysfs_bin_attr_init as RHEL6 backports this */ -#if !defined(sysfs_bin_attr_init) -/** - * sysfs_bin_attr_init - initialize a dynamically allocated bin_attribute - * @attr: struct bin_attribute to initialize - * - * Initialize a dynamically allocated struct bin_attribute so we - * can make lockdep happy. This is a new requirement for - * attributes and initially this is only needed when lockdep is - * enabled. Lockdep gives a nice error when your attribute is - * added to sysfs if you don't have this. - */ -#define sysfs_bin_attr_init(bin_attr) sysfs_attr_init(&(bin_attr)->attr) -#endif - -#define usb_alloc_coherent(dev, size, mem_flags, dma) usb_buffer_alloc(dev, size, mem_flags, dma) -#define usb_free_coherent(dev, size, addr, dma) usb_buffer_free(dev, size, addr, dma) - -/* only include this if DEFINE_DMA_UNMAP_ADDR is not set as debian squeeze also backports this */ -#ifndef DEFINE_DMA_UNMAP_ADDR -#ifdef CONFIG_NEED_DMA_MAP_STATE -#define DEFINE_DMA_UNMAP_ADDR(ADDR_NAME) dma_addr_t ADDR_NAME -#define DEFINE_DMA_UNMAP_LEN(LEN_NAME) __u32 LEN_NAME -#define dma_unmap_addr(PTR, ADDR_NAME) ((PTR)->ADDR_NAME) -#define dma_unmap_addr_set(PTR, ADDR_NAME, VAL) (((PTR)->ADDR_NAME) = (VAL)) -#define dma_unmap_len(PTR, LEN_NAME) ((PTR)->LEN_NAME) -#define dma_unmap_len_set(PTR, LEN_NAME, VAL) (((PTR)->LEN_NAME) = (VAL)) -#else -#define DEFINE_DMA_UNMAP_ADDR(ADDR_NAME) -#define DEFINE_DMA_UNMAP_LEN(LEN_NAME) -#define dma_unmap_addr(PTR, ADDR_NAME) (0) -#define dma_unmap_addr_set(PTR, ADDR_NAME, VAL) do { } while (0) -#define dma_unmap_len(PTR, LEN_NAME) (0) -#define dma_unmap_len_set(PTR, LEN_NAME, VAL) do { } while (0) -#endif -#endif - -/* mask dma_set_coherent_mask as debian squeeze also backports this */ -#define dma_set_coherent_mask(a, b) compat_dma_set_coherent_mask(a, b) - -static inline int dma_set_coherent_mask(struct device *dev, u64 mask) -{ - if (!dma_supported(dev, mask)) - return -EIO; - dev->coherent_dma_mask = mask; - return 0; -} - -/* USB autosuspend and autoresume */ -static inline int usb_enable_autosuspend(struct usb_device *udev) -{ return 0; } -static inline int usb_disable_autosuspend(struct usb_device *udev) -{ return 0; } - -#if !defined(rcu_dereference_protected) -#define rcu_dereference_protected(p, c) (p) -#endif -#define rcu_access_pointer(p) ACCESS_ONCE(p) - -#define rcu_dereference_raw(p) rcu_dereference(p) - -#define KEY_WPS_BUTTON 0x211 /* WiFi Protected Setup key */ - -/* - * This looks more complex than it should be. But we need to - * get the type for the ~ right in round_down (it needs to be - * as wide as the result!), and we want to evaluate the macro - * arguments just once each. - */ -#define __round_mask(x, y) ((__typeof__(x))((y)-1)) -#define round_up(x, y) ((((x)-1) | __round_mask(x, y))+1) -#define round_down(x, y) ((x) & ~__round_mask(x, y)) - -static inline int rcu_read_lock_held(void) -{ - return 1; -} - -#ifdef CONFIG_PROVE_LOCKING -/* - * Obviously, this is wrong. But the base kernel will have rtnl_mutex - * declared static, with no way to access it. I think this is the best - * we can do... - */ -static inline int lockdep_rtnl_is_held(void) -{ - return 1; -} -#endif /* #ifdef CONFIG_PROVE_LOCKING */ - -#define seq_hlist_start_head LINUX_BACKPORT(seq_hlist_start_head) -extern struct hlist_node *seq_hlist_start_head(struct hlist_head *head, - loff_t pos); - -#define seq_hlist_next LINUX_BACKPORT(seq_hlist_next) -extern struct hlist_node *seq_hlist_next(void *v, struct hlist_head *head, - loff_t *ppos); - -static inline struct sock *sk_entry(const struct hlist_node *node) -{ - return hlist_entry(node, struct sock, sk_node); -} - -#else /* Kernels >= 2.6.34 */ - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,34)) */ - - -#endif /* LINUX_26_34_COMPAT_H */ diff --git a/backport/include/linux/compat-2.6.35.h b/backport/include/linux/compat-2.6.35.h deleted file mode 100644 index cb434728ec05..000000000000 --- a/backport/include/linux/compat-2.6.35.h +++ /dev/null @@ -1,100 +0,0 @@ -#ifndef LINUX_26_35_COMPAT_H -#define LINUX_26_35_COMPAT_H - -#include - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35)) -#include -#include -#include -#include -#include -#include - -#define HID_QUIRK_NO_IGNORE 0x40000000 -#define HID_QUIRK_HIDDEV_FORCE 0x00000010 - -/* added on linux/kernel.h */ -#define USHRT_MAX ((u16)(~0U)) -#define SHRT_MAX ((s16)(USHRT_MAX>>1)) -#define SHRT_MIN ((s16)(-SHRT_MAX - 1)) - -#define SDIO_BUS_ECSI 0x20 /* Enable continuous SPI interrupt */ -#define SDIO_BUS_SCSI 0x40 /* Support continuous SPI interrupt */ - -#define netdev_hw_addr dev_mc_list - -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)) - -#define qdisc_reset_all_tx_gt LINUX_BACKPORT(qdisc_reset_all_tx_gt) - -/* Reset all TX qdiscs greater then index of a device. */ -static inline void qdisc_reset_all_tx_gt(struct net_device *dev, unsigned int i) -{ - struct Qdisc *qdisc; - - for (; i < dev->num_tx_queues; i++) { - qdisc = netdev_get_tx_queue(dev, i)->qdisc; - if (qdisc) { - spin_lock_bh(qdisc_lock(qdisc)); - qdisc_reset(qdisc); - spin_unlock_bh(qdisc_lock(qdisc)); - } - } -} -#else -static inline void qdisc_reset_all_tx_gt(struct net_device *dev, unsigned int i) -{ -} -#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)) */ - -#define netif_set_real_num_tx_queues LINUX_BACKPORT(netif_set_real_num_tx_queues) -extern int netif_set_real_num_tx_queues(struct net_device *dev, - unsigned int txq); - -/* mask irq_set_affinity_hint as RHEL6 backports this */ -#define irq_set_affinity_hint(a,b) compat_irq_set_affinity_hint(a,b) -/* - * We cannot backport this guy as the IRQ data structure - * was modified in the kernel itself to support this. We - * treat the system as uni-processor in this case. - */ -static inline int irq_set_affinity_hint(unsigned int irq, - const struct cpumask *m) -{ - return -EINVAL; -} - -static inline wait_queue_head_t *sk_sleep(struct sock *sk) -{ - return sk->sk_sleep; -} - -#define sdio_writeb_readb(func, write_byte, addr, err_ret) sdio_readb(func, addr, err_ret) - -#define hex_to_bin LINUX_BACKPORT(hex_to_bin) -int hex_to_bin(char ch); - -#define noop_llseek LINUX_BACKPORT(noop_llseek) -extern loff_t noop_llseek(struct file *file, loff_t offset, int origin); - -#define pm_qos_request(_qos) pm_qos_requirement(_qos) - -/* mask usb_pipe_endpoint as RHEL6 backports this */ -#define usb_pipe_endpoint(a,b) compat_usb_pipe_endpoint(a,b) - -static inline struct usb_host_endpoint * -usb_pipe_endpoint(struct usb_device *dev, unsigned int pipe) -{ - struct usb_host_endpoint **eps; - eps = usb_pipein(pipe) ? dev->ep_in : dev->ep_out; - return eps[usb_pipeendpoint(pipe)]; -} - -#define simple_write_to_buffer LINUX_BACKPORT(simple_write_to_buffer) -extern ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos, - const void __user *from, size_t count); - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35)) */ - -#endif /* LINUX_26_35_COMPAT_H */ diff --git a/backport/include/linux/compat-2.6.36.h b/backport/include/linux/compat-2.6.36.h deleted file mode 100644 index ff6a53f191db..000000000000 --- a/backport/include/linux/compat-2.6.36.h +++ /dev/null @@ -1,217 +0,0 @@ -#ifndef LINUX_26_36_COMPAT_H -#define LINUX_26_36_COMPAT_H - -#include - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36)) - -#include -#include -#include -#include -#include - -#define kparam_block_sysfs_write(a) -#define kparam_unblock_sysfs_write(a) - -/* mask va_format as RHEL6 backports this */ -#define va_format compat_va_format - -struct va_format { - const char *fmt; - va_list *va; -}; - -#define device_rename(dev, new_name) device_rename(dev, (char *)new_name) - -#ifdef CPTCFG_BACKPORT_OPTION_USB_URB_THREAD_FIX -#define usb_scuttle_anchored_urbs LINUX_BACKPORT(usb_scuttle_anchored_urbs) -#define usb_get_from_anchor LINUX_BACKPORT(usb_get_from_anchor) -#define usb_unlink_anchored_urbs LINUX_BACKPORT(usb_unlink_anchored_urbs) - -extern void usb_unlink_anchored_urbs(struct usb_anchor *anchor); -extern struct urb *usb_get_from_anchor(struct usb_anchor *anchor); -extern void usb_scuttle_anchored_urbs(struct usb_anchor *anchor); -#endif - -/** - * pcmcia_read_config_byte() - read a byte from a card configuration register - * - * pcmcia_read_config_byte() reads a byte from a configuration register in - * attribute memory. - */ -static inline int pcmcia_read_config_byte(struct pcmcia_device *p_dev, off_t where, u8 *val) -{ - int ret; - conf_reg_t reg = { 0, CS_READ, where, 0 }; - ret = pcmcia_access_configuration_register(p_dev, ®); - *val = reg.Value; - return ret; -} - -/** - * pcmcia_write_config_byte() - write a byte to a card configuration register - * - * pcmcia_write_config_byte() writes a byte to a configuration register in - * attribute memory. - */ -static inline int pcmcia_write_config_byte(struct pcmcia_device *p_dev, off_t where, u8 val) -{ - conf_reg_t reg = { 0, CS_WRITE, where, val }; - return pcmcia_access_configuration_register(p_dev, ®); -} - -struct pm_qos_request_list { - u32 qos; - void *request; -}; - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35)) - -#define pm_qos_add_request(_req, _class, _value) do { \ - (_req)->request = #_req; \ - (_req)->qos = _class; \ - pm_qos_add_requirement((_class), (_req)->request, (_value)); \ - } while(0) - -#define pm_qos_update_request(_req, _value) \ - pm_qos_update_requirement((_req)->qos, (_req)->request, (_value)) - -#define pm_qos_remove_request(_req) \ - pm_qos_remove_requirement((_req)->qos, (_req)->request) - -#else - -#define pm_qos_add_request(_req, _class, _value) do { \ - (_req)->request = pm_qos_add_request((_class), (_value)); \ - } while (0) - -#define pm_qos_update_request(_req, _value) \ - pm_qos_update_request((_req)->request, (_value)) - -#define pm_qos_remove_request(_req) \ - pm_qos_remove_request((_req)->request) - -#endif - -/* - * Dummy printk for disabled debugging statements to use whilst maintaining - * gcc's format and side-effect checking. - */ -/* mask no_printk as RHEL6 backports this */ -#define no_printk(a, ...) compat_no_printk(a, ##__VA_ARGS__) -static inline __attribute__ ((format (printf, 1, 2))) -int no_printk(const char *s, ...) { return 0; } - -#ifndef alloc_workqueue -#define alloc_workqueue(name, flags, max_active) __create_workqueue(name, flags, max_active, 0) -#endif - -#define EXTPROC 0200000 -#define TIOCPKT_IOCTL 64 - -static inline void tty_lock(void) __acquires(kernel_lock) -{ -#ifdef CONFIG_LOCK_KERNEL - /* kernel_locked is 1 for !CONFIG_LOCK_KERNEL */ - WARN_ON(kernel_locked()); -#endif - lock_kernel(); -} -static inline void tty_unlock(void) __releases(kernel_lock) -{ - unlock_kernel(); -} -#define tty_locked() (kernel_locked()) - -#define usleep_range(_min, _max) msleep((_max) / 1000) - -#define __rcu - -static inline void pm_wakeup_event(struct device *dev, unsigned int msec) {} - -static inline bool skb_defer_rx_timestamp(struct sk_buff *skb) -{ - return false; -} - -static inline void skb_tx_timestamp(struct sk_buff *skb) -{ -} - -/* - * System-wide workqueues which are always present. - * - * system_wq is the one used by schedule[_delayed]_work[_on](). - * Multi-CPU multi-threaded. There are users which expect relatively - * short queue flush time. Don't queue works which can run for too - * long. - * - * system_long_wq is similar to system_wq but may host long running - * works. Queue flushing might take relatively long. - * - * system_nrt_wq is non-reentrant and guarantees that any given work - * item is never executed in parallel by multiple CPUs. Queue - * flushing might take relatively long. - */ -#define system_wq LINUX_BACKPORT(system_wq) -extern struct workqueue_struct *system_wq; -#define system_long_wq LINUX_BACKPORT(system_long_wq) -extern struct workqueue_struct *system_long_wq; -#define system_nrt_wq LINUX_BACKPORT(system_nrt_wq) -extern struct workqueue_struct *system_nrt_wq; - -void backport_system_workqueue_create(void); -void backport_system_workqueue_destroy(void); - -#define schedule_work LINUX_BACKPORT(schedule_work) -int schedule_work(struct work_struct *work); -#define schedule_work_on LINUX_BACKPORT(schedule_work_on) -int schedule_work_on(int cpu, struct work_struct *work); -#define schedule_delayed_work LINUX_BACKPORT(schedule_delayed_work) -int schedule_delayed_work(struct delayed_work *dwork, - unsigned long delay); -#define schedule_delayed_work_on LINUX_BACKPORT(schedule_delayed_work_on) -int schedule_delayed_work_on(int cpu, - struct delayed_work *dwork, - unsigned long delay); -#define flush_scheduled_work LINUX_BACKPORT(flush_scheduled_work) -void flush_scheduled_work(void); - -enum { - /* bit mask for work_busy() return values */ - WORK_BUSY_PENDING = 1 << 0, - WORK_BUSY_RUNNING = 1 << 1, -}; - -#define work_busy LINUX_BACKPORT(work_busy) -extern unsigned int work_busy(struct work_struct *work); - -#define br_port_exists(dev) (dev->br_port) - -#else - -static inline void backport_system_workqueue_create(void) -{ -} - -static inline void backport_system_workqueue_destroy(void) -{ -} - -/* - * This is not part of The 2.6.37 kernel yet but we - * we use it to optimize the backport code we - * need to implement. Instead of using ifdefs - * to check what version of the check we use - * we just replace all checks on current code - * with this. I'll submit this upstream too, that - * way all we'd have to do is to implement this - * for older kernels, then we would not have to - * edit the upstrema code for backport efforts. - */ -#define br_port_exists(dev) (dev->priv_flags & IFF_BRIDGE_PORT) - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36)) */ - -#endif /* LINUX_26_36_COMPAT_H */ diff --git a/backport/include/linux/compat-2.6.37.h b/backport/include/linux/compat-2.6.37.h deleted file mode 100644 index 317ae6fe88d4..000000000000 --- a/backport/include/linux/compat-2.6.37.h +++ /dev/null @@ -1,182 +0,0 @@ -#ifndef LINUX_26_37_COMPAT_H -#define LINUX_26_37_COMPAT_H - -#include - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,37)) - -#include -#include -#include -#include -#include - -#ifdef CONFIG_RPS -extern int netif_set_real_num_rx_queues(struct net_device *dev, - unsigned int rxq); -#else -static inline int netif_set_real_num_rx_queues(struct net_device *dev, - unsigned int rxq) -{ - return 0; -} -#endif - -static inline int proto_ports_offset(int proto) -{ - switch (proto) { - case IPPROTO_TCP: - case IPPROTO_UDP: - case IPPROTO_DCCP: - case IPPROTO_ESP: /* SPI */ - case IPPROTO_SCTP: - case IPPROTO_UDPLITE: - return 0; - case IPPROTO_AH: /* SPI */ - return 4; - default: - return -EINVAL; - } -} - -#define SDIO_CLASS_BT_AMP 0x09 /* Type-A Bluetooth AMP interface */ - -#define net_ns_type_operations LINUX_BACKPORT(net_ns_type_operations) -extern struct kobj_ns_type_operations net_ns_type_operations; - -/* mask skb_checksum_none_assert as RHEL6 backports this */ -#define skb_checksum_none_assert(a) compat_skb_checksum_none_assert(a) - -/** - * skb_checksum_none_assert - make sure skb ip_summed is CHECKSUM_NONE - * @skb: skb to check - * - * fresh skbs have their ip_summed set to CHECKSUM_NONE. - * Instead of forcing ip_summed to CHECKSUM_NONE, we can - * use this helper, to document places where we make this assertion. - */ -static inline void skb_checksum_none_assert(struct sk_buff *skb) -{ -#ifdef DEBUG - BUG_ON(skb->ip_summed != CHECKSUM_NONE); -#endif -} - -#define pcmcia_enable_device(link) pcmcia_request_configuration(link, &link->conf) - -#include - -struct compat_genl_info { - struct genl_info *info; - - u32 snd_seq; - u32 snd_pid; - struct genlmsghdr *genlhdr; - struct nlattr **attrs; - void *user_ptr[2]; -}; -#define genl_info compat_genl_info - -struct compat_genl_ops { - struct genl_ops ops; - - u8 cmd; - u8 internal_flags; - unsigned int flags; - const struct nla_policy *policy; - - int (*doit)(struct sk_buff *skb, struct genl_info *info); - int (*dumpit)(struct sk_buff *skb, struct netlink_callback *cb); - int (*done)(struct netlink_callback *cb); -}; -#define genl_ops compat_genl_ops - -struct compat_genl_family { - struct genl_family family; - - struct list_head list; - - unsigned int id, hdrsize, version, maxattr; - const char *name; - bool netnsok; - - struct nlattr **attrbuf; - - int (*pre_doit)(struct genl_ops *ops, struct sk_buff *skb, - struct genl_info *info); - - void (*post_doit)(struct genl_ops *ops, struct sk_buff *skb, - struct genl_info *info); -}; - -#define genl_family compat_genl_family - -#define genl_register_family_with_ops compat_genl_register_family_with_ops - -int genl_register_family_with_ops(struct genl_family *family, - struct genl_ops *ops, size_t n_ops); - -#define genl_unregister_family compat_genl_unregister_family - -int genl_unregister_family(struct genl_family *family); - -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)) -#define genl_info_net(_info) genl_info_net((_info)->info) -#endif - -#define genlmsg_reply(_msg, _info) genlmsg_reply(_msg, (_info)->info) -#define genlmsg_put(_skb, _pid, _seq, _fam, _flags, _cmd) genlmsg_put(_skb, _pid, _seq, &(_fam)->family, _flags, _cmd) -#define genl_register_mc_group(_fam, _grp) genl_register_mc_group(&(_fam)->family, _grp) -#define genl_unregister_mc_group(_fam, _grp) genl_unregister_mc_group(&(_fam)->family, _grp) - - -extern void led_blink_set(struct led_classdev *led_cdev, - unsigned long *delay_on, - unsigned long *delay_off); - -#define led_classdev_unregister compat_led_classdev_unregister -extern void compat_led_classdev_unregister(struct led_classdev *led_cdev); - -#define led_brightness_set compat_led_brightness_set -extern void compat_led_brightness_set(struct led_classdev *led_cdev, - enum led_brightness brightness); - -#define alloc_ordered_workqueue(name, flags) create_singlethread_workqueue(name) - -#define netdev_refcnt_read(a) atomic_read(&a->refcnt) - -#define vzalloc LINUX_BACKPORT(vzalloc) -extern void *vzalloc(unsigned long size); - -#define rtnl_dereference(p) \ - rcu_dereference_protected(p, lockdep_rtnl_is_held()) - -/** - * RCU_INIT_POINTER() - initialize an RCU protected pointer - * - * Initialize an RCU-protected pointer in such a way to avoid RCU-lockdep - * splats. - */ -#define RCU_INIT_POINTER(p, v) \ - p = (typeof(*v) __force __rcu *)(v) - -static inline bool skb_has_frag_list(const struct sk_buff *skb) -{ - return skb_shinfo(skb)->frag_list != NULL; -} - -/** - * backport: - * - * commit 67bdbffd696f29a0b68aa8daa285783a06651583 - * Author: Arnd Bergmann - * Date: Thu Feb 25 16:55:13 2010 +0100 - * - * rculist: avoid __rcu annotations - */ -#define hlist_first_rcu(head) (*((struct hlist_node __rcu **)(&(head)->first))) -#define hlist_next_rcu(node) (*((struct hlist_node __rcu **)(&(node)->next))) - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,37)) */ - -#endif /* LINUX_26_37_COMPAT_H */ diff --git a/backport/include/linux/compat-2.6.38.h b/backport/include/linux/compat-2.6.38.h deleted file mode 100644 index 4a823108c4d6..000000000000 --- a/backport/include/linux/compat-2.6.38.h +++ /dev/null @@ -1,165 +0,0 @@ -#ifndef LINUX_26_38_COMPAT_H -#define LINUX_26_38_COMPAT_H - -#include - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,38)) - -#include -#include -#include -#include - -#define PCI_MSIX_ENTRY_CTRL_MASKBIT 1 - -#define alloc_etherdev_mqs(sizeof_priv, tx_q, rx_q) alloc_etherdev_mq(sizeof_priv, tx_q) - -/* MSI-X entry's format */ -#define PCI_MSIX_ENTRY_SIZE 16 -#define PCI_MSIX_ENTRY_LOWER_ADDR 0 -#define PCI_MSIX_ENTRY_UPPER_ADDR 4 -#define PCI_MSIX_ENTRY_DATA 8 -#define PCI_MSIX_ENTRY_VECTOR_CTRL 12 - -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,30)) -static inline void bstats_update(struct gnet_stats_basic_packed *bstats, - const struct sk_buff *skb) -{ - bstats->bytes += qdisc_pkt_len((struct sk_buff *) skb); - bstats->packets += skb_is_gso(skb) ? skb_shinfo(skb)->gso_segs : 1; -} -static inline void qdisc_bstats_update(struct Qdisc *sch, - const struct sk_buff *skb) -{ - bstats_update(&sch->bstats, skb); -} -#else -/* - * kernels <= 2.6.30 do not pass a const skb to qdisc_pkt_len, and - * gnet_stats_basic_packed did not exist (see c1a8f1f1c8) - */ -static inline void bstats_update(struct gnet_stats_basic *bstats, - struct sk_buff *skb) -{ - bstats->bytes += qdisc_pkt_len(skb); - bstats->packets += skb_is_gso(skb) ? skb_shinfo(skb)->gso_segs : 1; -} -static inline void qdisc_bstats_update(struct Qdisc *sch, - struct sk_buff *skb) -{ - bstats_update(&sch->bstats, skb); -} -#endif - - -/* rename member in struct mmc_host in include/linux/mmc/host.h */ -#define max_segs max_hw_segs - - -#define pr_warn pr_warning -#define create_freezable_workqueue create_freezeable_workqueue - -static inline int skb_checksum_start_offset(const struct sk_buff *skb) -{ - return skb->csum_start - skb_headroom(skb); -} - -/* from include/linux/printk.h */ -#define pr_emerg_once(fmt, ...) \ - printk_once(KERN_EMERG pr_fmt(fmt), ##__VA_ARGS__) -#define pr_alert_once(fmt, ...) \ - printk_once(KERN_ALERT pr_fmt(fmt), ##__VA_ARGS__) -#define pr_crit_once(fmt, ...) \ - printk_once(KERN_CRIT pr_fmt(fmt), ##__VA_ARGS__) -#define pr_err_once(fmt, ...) \ - printk_once(KERN_ERR pr_fmt(fmt), ##__VA_ARGS__) -#define pr_warn_once(fmt, ...) \ - printk_once(KERN_WARNING pr_fmt(fmt), ##__VA_ARGS__) -#define pr_notice_once(fmt, ...) \ - printk_once(KERN_NOTICE pr_fmt(fmt), ##__VA_ARGS__) -#define pr_info_once(fmt, ...) \ - printk_once(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__) -#define pr_cont_once(fmt, ...) \ - printk_once(KERN_CONT pr_fmt(fmt), ##__VA_ARGS__) -#if defined(DEBUG) -#define pr_debug_once(fmt, ...) \ - printk_once(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__) -#else -#define pr_debug_once(fmt, ...) \ - no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__) -#endif - -/* include/linux/netdevice.h */ -#define alloc_netdev_mqs(sizeof_priv, name, setup, txqs, rxqs) \ - alloc_netdev_mq(sizeof_priv, name, setup, \ - max_t(unsigned int, txqs, rxqs)) - -#define ETH_P_LINK_CTL 0x886c /* HPNA, wlan link local tunnel */ - -/** - * is_unicast_ether_addr - Determine if the Ethernet address is unicast - * @addr: Pointer to a six-byte array containing the Ethernet address - * - * Return true if the address is a unicast address. - */ -static inline int is_unicast_ether_addr(const u8 *addr) -{ - return !is_multicast_ether_addr(addr); -} - -/* Backport of: - * - * commit 7ef88ad561457c0346355dfd1f53e503ddfde719 - * Author: Rusty Russell - * Date: Mon Jan 24 14:45:10 2011 -0600 - * - * BUILD_BUG_ON: make it handle more cases - */ -#undef BUILD_BUG_ON -/** - * BUILD_BUG_ON - break compile if a condition is true. - * @condition: the condition which the compiler should know is false. - * - * If you have some code which relies on certain constants being equal, or - * other compile-time-evaluated condition, you should use BUILD_BUG_ON to - * detect if someone changes it. - * - * The implementation uses gcc's reluctance to create a negative array, but - * gcc (as of 4.4) only emits that error for obvious cases (eg. not arguments - * to inline functions). So as a fallback we use the optimizer; if it can't - * prove the condition is false, it will cause a link error on the undefined - * "__build_bug_on_failed". This error message can be harder to track down - * though, hence the two different methods. - */ -#ifndef __OPTIMIZE__ -#define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)])) -#else -extern int __build_bug_on_failed; -#define BUILD_BUG_ON(condition) \ - do { \ - ((void)sizeof(char[1 - 2*!!(condition)])); \ - if (condition) __build_bug_on_failed = 1; \ - } while(0) -#endif - -/* Backport of: - * - * commit e159489baa717dbae70f9903770a6a4990865887 - * Author: Tejun Heo - * Date: Sun Jan 9 23:32:15 2011 +0100 - * - * workqueue: relax lockdep annotation on flush_work() - */ -#ifdef CONFIG_DEBUG_LOCK_ALLOC -# ifdef CONFIG_PROVE_LOCKING -# define lock_map_acquire_read(l) lock_acquire(l, 0, 0, 2, 2, NULL, _THIS_IP_) -# else -# define lock_map_acquire_read(l) lock_acquire(l, 0, 0, 2, 1, NULL, _THIS_IP_) -# endif -#else -# define lock_map_acquire_read(l) do { } while (0) -#endif - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,38)) */ - -#endif /* LINUX_26_38_COMPAT_H */ diff --git a/backport/include/linux/compat-2.6.39.h b/backport/include/linux/compat-2.6.39.h deleted file mode 100644 index 863afa4e9833..000000000000 --- a/backport/include/linux/compat-2.6.39.h +++ /dev/null @@ -1,183 +0,0 @@ -#ifndef LINUX_26_39_COMPAT_H -#define LINUX_26_39_COMPAT_H - -#include - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39)) - -#include -#include -#include -#include - -static inline int __must_check PTR_RET(const void *ptr) -{ - if (IS_ERR(ptr)) - return PTR_ERR(ptr); - else - return 0; -} - -#if !defined(NETIF_F_RXCSUM) -#define NETIF_F_RXCSUM 0 -#endif - -#define tiocmget(tty) tiocmget(tty, NULL) -#define tiocmset(tty, set, clear) tiocmset(tty, NULL, set, clear) - -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)) -#define tty_set_termios LINUX_BACKPORT(tty_set_termios) -extern int tty_set_termios(struct tty_struct *tty, struct ktermios *kt); -#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)) */ - -static inline int irq_set_irq_wake(unsigned int irq, unsigned int on) -{ - return set_irq_wake(irq, on); -} -static inline int irq_set_chip(unsigned int irq, struct irq_chip *chip) -{ - return set_irq_chip(irq, chip); -} -static inline int irq_set_handler_data(unsigned int irq, void *data) -{ - return set_irq_data(irq, data); -} -static inline int irq_set_chip_data(unsigned int irq, void *data) -{ - return set_irq_chip_data(irq, data); -} -static inline int irq_set_irq_type(unsigned int irq, unsigned int type) -{ - return set_irq_type(irq, type); -} -static inline int irq_set_msi_desc(unsigned int irq, struct msi_desc *entry) -{ - return set_irq_msi(irq, entry); -} -static inline struct irq_chip *irq_get_chip(unsigned int irq) -{ - return get_irq_chip(irq); -} -static inline void *irq_get_chip_data(unsigned int irq) -{ - return get_irq_chip_data(irq); -} -static inline void *irq_get_handler_data(unsigned int irq) -{ - return get_irq_data(irq); -} - -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37)) -static inline void *irq_data_get_irq_handler_data(struct irq_data *d) -{ - return irq_data_get_irq_data(d); -} -#endif - -static inline struct msi_desc *irq_get_msi_desc(unsigned int irq) -{ - return get_irq_msi(irq); -} - -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)) -static inline void irq_set_noprobe(unsigned int irq) -{ - set_irq_noprobe(irq); -} -static inline void irq_set_probe(unsigned int irq) -{ - set_irq_probe(irq); -} -#endif - -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29)) -static inline struct irq_chip *irq_desc_get_chip(struct irq_desc *desc) -{ - return get_irq_desc_chip(desc); -} -static inline void *irq_desc_get_handler_data(struct irq_desc *desc) -{ - return get_irq_desc_data(desc); -} - -static inline void *irq_desc_get_chip_data(struct irq_desc *desc) -{ - return get_irq_desc_chip_data(desc); -} - -static inline struct msi_desc *irq_desc_get_msi_desc(struct irq_desc *desc) -{ - return get_irq_desc_msi(desc); -} -#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29)) */ - -/* - * kstrto* was included in kernel 2.6.38.4 and causes conflicts with the - * version included in compat-drivers. We use strict_strtol to check if - * kstrto* is already available. - */ -#ifndef strict_strtoull -/* Internal, do not use. */ -int __must_check _kstrtoul(const char *s, unsigned int base, unsigned long *res); -int __must_check _kstrtol(const char *s, unsigned int base, long *res); - -int __must_check kstrtoull(const char *s, unsigned int base, unsigned long long *res); -int __must_check kstrtoll(const char *s, unsigned int base, long long *res); -static inline int __must_check kstrtoul(const char *s, unsigned int base, unsigned long *res) -{ - /* - * We want to shortcut function call, but - * __builtin_types_compatible_p(unsigned long, unsigned long long) = 0. - */ - if (sizeof(unsigned long) == sizeof(unsigned long long) && - __alignof__(unsigned long) == __alignof__(unsigned long long)) - return kstrtoull(s, base, (unsigned long long *)res); - else - return _kstrtoul(s, base, res); -} - -static inline int __must_check kstrtol(const char *s, unsigned int base, long *res) -{ - /* - * We want to shortcut function call, but - * __builtin_types_compatible_p(long, long long) = 0. - */ - if (sizeof(long) == sizeof(long long) && - __alignof__(long) == __alignof__(long long)) - return kstrtoll(s, base, (long long *)res); - else - return _kstrtol(s, base, res); -} - -int __must_check kstrtouint(const char *s, unsigned int base, unsigned int *res); -int __must_check kstrtoint(const char *s, unsigned int base, int *res); - -static inline int __must_check kstrtou64(const char *s, unsigned int base, u64 *res) -{ - return kstrtoull(s, base, res); -} - -static inline int __must_check kstrtos64(const char *s, unsigned int base, s64 *res) -{ - return kstrtoll(s, base, res); -} - -static inline int __must_check kstrtou32(const char *s, unsigned int base, u32 *res) -{ - return kstrtouint(s, base, res); -} - -static inline int __must_check kstrtos32(const char *s, unsigned int base, s32 *res) -{ - return kstrtoint(s, base, res); -} - -int __must_check kstrtou16(const char *s, unsigned int base, u16 *res); -int __must_check kstrtos16(const char *s, unsigned int base, s16 *res); -int __must_check kstrtou8(const char *s, unsigned int base, u8 *res); -int __must_check kstrtos8(const char *s, unsigned int base, s8 *res); -#endif /* ifndef strict_strtol */ - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39)) */ - -#endif /* LINUX_26_39_COMPAT_H */ diff --git a/backport/include/linux/compat-2.6.h b/backport/include/linux/compat-2.6.h deleted file mode 100644 index f9e0e74a6db6..000000000000 --- a/backport/include/linux/compat-2.6.h +++ /dev/null @@ -1,91 +0,0 @@ -#ifndef LINUX_26_COMPAT_H -#define LINUX_26_COMPAT_H - -#ifndef __ASSEMBLY__ - -#define LINUX_BACKPORT(__sym) backport_ ##__sym -#include - -#include -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0)) -#include -#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33)) -#include -#else -#include -#endif -#include -#include -#include -#include - -/* - * The define overwriting module_init is based on the original module_init - * which looks like this: - * #define module_init(initfn) \ - * static inline initcall_t __inittest(void) \ - * { return initfn; } \ - * int init_module(void) __attribute__((alias(#initfn))); - * - * To the call to the initfn we added the symbol dependency on compat - * to make sure that compat.ko gets loaded for any compat modules. - */ -void backport_dependency_symbol(void); - -#ifdef BACKPORTS_GIT_TRACKED -#define BACKPORT_MOD_VERSIONS MODULE_VERSION(BACKPORTS_GIT_TRACKED); -#else -#define BACKPORT_MOD_VERSIONS \ - MODULE_VERSION("backported from " BACKPORTED_KERNEL_NAME \ - " (" BACKPORTED_KERNEL_VERSION ")" \ - " using backports " BACKPORTS_VERSION); -#endif - -#undef module_init -#define module_init(initfn) \ - static int __init __init_backport(void) \ - { \ - backport_dependency_symbol(); \ - return initfn(); \ - } \ - int init_module(void) __attribute__((alias("__init_backport")));\ - BACKPORT_MOD_VERSIONS - -/* - * Each compat file represents compatibility code for new kernel - * code introduced for *that* kernel revision. - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#endif /* __ASSEMBLY__ */ - -#endif /* LINUX_26_COMPAT_H */ diff --git a/backport/include/linux/compat-3.0.h b/backport/include/linux/compat-3.0.h deleted file mode 100644 index 0bf179dd0218..000000000000 --- a/backport/include/linux/compat-3.0.h +++ /dev/null @@ -1,163 +0,0 @@ -#ifndef LINUX_3_0_COMPAT_H -#define LINUX_3_0_COMPAT_H - -#include - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,0,0)) - -#include - -/* This pulls-in a lot of non-exported symbol backports - * on kernels older than 2.6.32. There's no harm for not - * making this available on kernels < 2.6.32. */ -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)) -#include - -/* This backports the 2nd part of: - * - * commit d9d90e5eb70e09903dadff42099b6c948f814050 - * Author: Hugh Dickins - * Date: Mon Jun 27 16:18:04 2011 -0700 - * - * tmpfs: add shmem_read_mapping_page_gfp - * - * First part is in compat-3.0.c. - */ -#define shmem_read_mapping_page_gfp LINUX_BACKPORT(shmem_read_mapping_page_gfp) -extern struct page *shmem_read_mapping_page_gfp(struct address_space *mapping, - pgoff_t index, gfp_t gfp); - - -#define shmem_read_mapping_page LINUX_BACKPORT(shmem_read_mapping_page) -static inline struct page *shmem_read_mapping_page( - struct address_space *mapping, pgoff_t index) -{ - return shmem_read_mapping_page_gfp(mapping, index, - mapping_gfp_mask(mapping)); -} -#endif - - -/* - * since commit 1c5cae815d19ffe02bdfda1260949ef2b1806171 - * "net: call dev_alloc_name from register_netdevice" dev_alloc_name is - * called automatically. This is not implemented in older kernel - * versions so it will result in device wrong names. - */ -static inline int register_netdevice_name(struct net_device *dev) -{ - int err; - - if (strchr(dev->name, '%')) { - err = dev_alloc_name(dev, dev->name); - if (err < 0) - return err; - } - - return register_netdevice(dev); -} - -#define register_netdevice(dev) register_netdevice_name(dev) - -/* BCMA core, see drivers/bcma/ */ -#ifndef BCMA_CORE -/* Broadcom's specific AMBA core, see drivers/bcma/ */ -struct bcma_device_id { - __u16 manuf; - __u16 id; - __u8 rev; - __u8 class; -}; -#define BCMA_CORE(_manuf, _id, _rev, _class) \ - { .manuf = _manuf, .id = _id, .rev = _rev, .class = _class, } -#define BCMA_CORETABLE_END \ - { 0, }, - -#define BCMA_ANY_MANUF 0xFFFF -#define BCMA_ANY_ID 0xFFFF -#define BCMA_ANY_REV 0xFF -#define BCMA_ANY_CLASS 0xFF -#endif /* BCMA_CORE */ - -#define mac_pton LINUX_BACKPORT(mac_pton) -int mac_pton(const char *s, u8 *mac); - -int __must_check kstrtoull_from_user(const char __user *s, size_t count, unsigned int base, unsigned long long *res); -int __must_check kstrtoll_from_user(const char __user *s, size_t count, unsigned int base, long long *res); -int __must_check kstrtoul_from_user(const char __user *s, size_t count, unsigned int base, unsigned long *res); -int __must_check kstrtol_from_user(const char __user *s, size_t count, unsigned int base, long *res); -int __must_check kstrtouint_from_user(const char __user *s, size_t count, unsigned int base, unsigned int *res); -int __must_check kstrtoint_from_user(const char __user *s, size_t count, unsigned int base, int *res); -int __must_check kstrtou16_from_user(const char __user *s, size_t count, unsigned int base, u16 *res); -int __must_check kstrtos16_from_user(const char __user *s, size_t count, unsigned int base, s16 *res); -int __must_check kstrtou8_from_user(const char __user *s, size_t count, unsigned int base, u8 *res); -int __must_check kstrtos8_from_user(const char __user *s, size_t count, unsigned int base, s8 *res); - -static inline int __must_check kstrtou64_from_user(const char __user *s, size_t count, unsigned int base, u64 *res) -{ - return kstrtoull_from_user(s, count, base, res); -} - -static inline int __must_check kstrtos64_from_user(const char __user *s, size_t count, unsigned int base, s64 *res) -{ - return kstrtoll_from_user(s, count, base, res); -} - -static inline int __must_check kstrtou32_from_user(const char __user *s, size_t count, unsigned int base, u32 *res) -{ - return kstrtouint_from_user(s, count, base, res); -} - -static inline int __must_check kstrtos32_from_user(const char __user *s, size_t count, unsigned int base, s32 *res) -{ - return kstrtoint_from_user(s, count, base, res); -} - -/* - * This adds a nested function everywhere kfree_rcu() was called. This - * function frees the memory and is given as a function to call_rcu(). - * The rcu callback could happen every time also after the module was - * unloaded and this will cause problems. - */ -#if !defined(kfree_rcu) -#define kfree_rcu(data, rcuhead) do { \ - void __kfree_rcu_fn(struct rcu_head *rcu_head) \ - { \ - void *___ptr; \ - ___ptr = container_of(rcu_head, typeof(*(data)), rcuhead);\ - kfree(___ptr); \ - } \ - call_rcu(&(data)->rcuhead, __kfree_rcu_fn); \ - } while (0) -#endif -#ifdef MODULE - -/* - * The define overwriting module_exit is based on the original module_exit - * which looks like this: - * #define module_exit(exitfn) \ - * static inline exitcall_t __exittest(void) \ - * { return exitfn; } \ - * void cleanup_module(void) __attribute__((alias(#exitfn))); - * - * We replaced the call to the actual function exitfn() with a call to our - * function which calls the original exitfn() and then rcu_barrier() - * - * As a module will not be unloaded that ofter it should not have a big - * performance impact when rcu_barrier() is called on every module exit, - * also when no kfree_rcu() backport is used in that module. - */ -#undef module_exit -#define module_exit(exitfn) \ - static void __exit __exit_compat(void) \ - { \ - exitfn(); \ - rcu_barrier(); \ - } \ - void cleanup_module(void) __attribute__((alias("__exit_compat"))); - -#endif - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(3,0,0)) */ - -#endif /* LINUX_3_0_COMPAT_H */ diff --git a/backport/include/linux/compat-3.1.h b/backport/include/linux/compat-3.1.h deleted file mode 100644 index d2ac0db2ec7d..000000000000 --- a/backport/include/linux/compat-3.1.h +++ /dev/null @@ -1,100 +0,0 @@ -#ifndef LINUX_3_1_COMPAT_H -#define LINUX_3_1_COMPAT_H - -#include - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0)) - -#include -#include -#include -#include -#include - -#define HID_TYPE_USBNONE 2 - -/* This backports: - * - * commit 36a26c69b4c70396ef569c3452690fba0c1dec08 - * Author: Nicholas Bellinger - * Date: Tue Jul 26 00:35:26 2011 -0700 - * - * kernel.h: Add DIV_ROUND_UP_ULL and DIV_ROUND_UP_SECTOR_T macro usage - */ - -#define DIV_ROUND_UP_ULL(ll,d) \ - ({ unsigned long long _tmp = (ll)+(d)-1; do_div(_tmp, d); _tmp; }) - -/* Backports 56f8a75c */ -static inline bool ip_is_fragment(const struct iphdr *iph) -{ - return (iph->frag_off & htons(IP_MF | IP_OFFSET)) != 0; -} - -/* mask __netdev_alloc_skb_ip_align as RHEL6 backports this */ -#define __netdev_alloc_skb_ip_align(a,b,c) compat__netdev_alloc_skb_ip_align(a,b,c) -static inline struct sk_buff *__netdev_alloc_skb_ip_align(struct net_device *dev, - unsigned int length, gfp_t gfp) -{ - struct sk_buff *skb = __netdev_alloc_skb(dev, length + NET_IP_ALIGN, gfp); - - if (NET_IP_ALIGN && skb) - skb_reserve(skb, NET_IP_ALIGN); - return skb; -} - -#define genl_dump_check_consistent(cb, user_hdr, family) - -#define IFF_TX_SKB_SHARING 0x10000 /* The interface supports sharing - * skbs on transmit */ - -#define PCMCIA_DEVICE_MANF_CARD_PROD_ID3(manf, card, v3, vh3) { \ - .match_flags = PCMCIA_DEV_ID_MATCH_MANF_ID| \ - PCMCIA_DEV_ID_MATCH_CARD_ID| \ - PCMCIA_DEV_ID_MATCH_PROD_ID3, \ - .manf_id = (manf), \ - .card_id = (card), \ - .prod_id = { NULL, NULL, (v3), NULL }, \ - .prod_id_hash = { 0, 0, (vh3), 0 }, } - -/* - * This has been defined in include/linux/security.h for some time, but was - * only given an EXPORT_SYMBOL for 3.1. Add a compat_* definition to avoid - * breaking the compile. - */ -#define security_sk_clone(a, b) compat_security_sk_clone(a, b) - -static inline void security_sk_clone(const struct sock *sk, struct sock *newsk) -{ -} - -/* - * In many versions, several architectures do not seem to include an - * atomic64_t implementation, and do not include the software emulation from - * asm-generic/atomic64_t. - * Detect and handle this here. - */ -#include - -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,31)) && !defined(ATOMIC64_INIT) && !defined(CONFIG_X86) && !((LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33)) && defined(CONFIG_ARM) && !defined(CONFIG_GENERIC_ATOMIC64)) -#include -#endif - -#define ida_simple_get LINUX_BACKPORT(ida_simple_get) -int ida_simple_get(struct ida *ida, unsigned int start, unsigned int end, - gfp_t gfp_mask); - -#define ida_simple_remove LINUX_BACKPORT(ida_simple_remove) -void ida_simple_remove(struct ida *ida, unsigned int id); - -#ifdef CONFIG_CPU_FREQ -#define cpufreq_quick_get_max LINUX_BACKPORT(cpufreq_quick_get_max) -unsigned int cpufreq_quick_get_max(unsigned int cpu); -#endif - -struct watchdog_device { -}; - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0)) */ - -#endif /* LINUX_3_1_COMPAT_H */ diff --git a/backport/include/linux/compat-3.10.h b/backport/include/linux/compat-3.10.h deleted file mode 100644 index b4d8bc5affb6..000000000000 --- a/backport/include/linux/compat-3.10.h +++ /dev/null @@ -1,145 +0,0 @@ -#ifndef LINUX_3_10_COMPAT_H -#define LINUX_3_10_COMPAT_H - -#include - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)) - -#include -#include -#include -#include -#include - -#define sg_page_iter_page LINUX_BACKPORT(sg_page_iter_page) -/** - * sg_page_iter_page - get the current page held by the page iterator - * @piter: page iterator holding the page - */ -static inline struct page *sg_page_iter_page(struct sg_page_iter *piter) -{ - return nth_page(sg_page(piter->sg), piter->sg_pgoffset); -} - -#define sg_page_iter_dma_address LINUX_BACKPORT(sg_page_iter_dma_address) -/** - * sg_page_iter_dma_address - get the dma address of the current page held by - * the page iterator. - * @piter: page iterator holding the page - */ -static inline dma_addr_t sg_page_iter_dma_address(struct sg_page_iter *piter) -{ - return sg_dma_address(piter->sg) + (piter->sg_pgoffset << PAGE_SHIFT); -} - -/* - * This is a linux-next data structure element collateral evolution, - * we use a wrapper to avoid #ifdef hell to backport it. This allows - * us to use a simple fb_info_skip_vt_switch() replacement for when - * the new data structure element is used. If coccinelle SmPL grammar - * could be used to express the transformation for us on compat-drivers - * it means we'd need to express it only once. If the structure element - * collateral evolution were to be used *at development* time and we'd - * have a way to express the inverse through SmPL we'd be able to - * backport this collateral evolution automatically for any new driver - * that used it. We'd use coccinelle to look for it and do the - * transformations for us based on the original commit (maybe SmPL - * would be listed on the commit log. - * - * We may need the LINUX_BACKPORT() call that adds the backport_ - * prefix for older kernels than 3.10 if distros decide to - * add this same static inline themselves (although unlikely). - */ -#define fb_enable_skip_vt_switch LINUX_BACKPORT(fb_enable_skip_vt_switch) -static inline void fb_enable_skip_vt_switch(struct fb_info *info) -{ -} - -/** - * backport of: - * - * commit 6ed7ffddcf61f668114edb676417e5fb33773b59 - * Author: H Hartley Sweeten - * Date: Wed Mar 6 11:24:44 2013 -0700 - * - * pcmcia/ds.h: introduce helper for pcmcia_driver module boilerplate - */ - -/** - * module_pcmcia_driver() - Helper macro for registering a pcmcia driver - * @__pcmcia_driver: pcmcia_driver struct - * - * Helper macro for pcmcia drivers which do not do anything special in module - * init/exit. This eliminates a lot of boilerplate. Each module may only use - * this macro once, and calling it replaces module_init() and module_exit(). - */ -#define module_pcmcia_driver(__pcmcia_driver) \ - module_driver(__pcmcia_driver, pcmcia_register_driver, \ - pcmcia_unregister_driver) - -/* - * backport of: - * commit e5c5d22e8dcf7c2d430336cbf8e180bd38e8daf1 - * Author: Simon Horman - * Date: Thu Mar 28 13:38:25 2013 +0900 - * - * net: add ETH_P_802_3_MIN - */ -#ifndef ETH_P_802_3_MIN -#define ETH_P_802_3_MIN 0x0600 -#endif - -/* - * backport of: - * procfs: new helper - PDE_DATA(inode) - */ -static inline void *PDE_DATA(const struct inode *inode) -{ - return PROC_I(inode)->pde->data; -} - -/* - * backport SOCK_SELECT_ERR_QUEUE -- see commit - * "net: add option to enable error queue packets waking select" - * - * Adding 14 to SOCK_QUEUE_SHRUNK will reach a bet that can't be - * set on older kernels, so sock_flag() will always return false. - */ -#define SOCK_SELECT_ERR_QUEUE (SOCK_QUEUE_SHRUNK + 14) - -/* - * DRM requires this, but we can't really backport it well - */ -static inline void __iomem *pci_platform_rom(struct pci_dev *pdev, size_t *size) -{ - printk(KERN_WARNING "compat: not providing pci_platform_rom!\n"); - return NULL; -} - -/* - * backport SOL_NFC -- see commit: - * NFC: llcp: Implement socket options - */ -#define SOL_NFC 280 - -#else /* kernel is >= 3.10 */ -/* - * We'd delete this upstream ever got this, we use our - * backport_ prefix with LINUX_BACKPORT() so that if this - * does get upstream we would not have to add another ifdef - * here for the kernels in between v3.10.. up to the point - * the routine would have gotten added, we'd just delete this - * #else condition completely. If we didn't have this and - * say 3.12 added the static inline upstream, we'd have a - * clash on the backport for 3.12 as the routine would - * already be defined *but* we'd need it for 3.11. - */ -#define fb_enable_skip_vt_switch LINUX_BACKPORT(fb_enable_skip_vt_switch) -static inline void fb_enable_skip_vt_switch(struct fb_info *info) -{ - info->skip_vt_switch = true; -} - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0)) */ - -#endif /* LINUX_3_10_COMPAT_H */ diff --git a/backport/include/linux/compat-3.2.h b/backport/include/linux/compat-3.2.h deleted file mode 100644 index 982b9898d9ce..000000000000 --- a/backport/include/linux/compat-3.2.h +++ /dev/null @@ -1,111 +0,0 @@ -#ifndef LINUX_3_2_COMPAT_H -#define LINUX_3_2_COMPAT_H - -#include - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,2,0)) - -#include -#include -#include - -/* backports 07613b0b */ -#if defined(CONFIG_DYNAMIC_DEBUG) -#define DEFINE_DYNAMIC_DEBUG_METADATA(name, fmt) \ - static struct _ddebug __used __aligned(8) \ - __attribute__((section("__verbose"))) name = { \ - .modname = KBUILD_MODNAME, \ - .function = __func__, \ - .filename = __FILE__, \ - .format = (fmt), \ - .lineno = __LINE__, \ - .flags = _DPRINTK_FLAGS_DEFAULT, \ - .enabled = false, \ - } -#endif /* defined(CONFIG_DYNAMIC_DEBUG) */ - -/* backports b4625dab */ -#define SDIO_CCCR_REV_3_00 3 /* CCCR/FBR Version 3.00 */ -#define SDIO_SDIO_REV_3_00 4 /* SDIO Spec Version 3.00 */ - -#define PMSG_IS_AUTO(msg) (((msg).event & PM_EVENT_AUTO) != 0) - -/* mask skb_frag_page as RHEL6 backports this */ -#define skb_frag_page(a) compat_skb_frag_page(a) - -/** - * skb_frag_page - retrieve the page refered to by a paged fragment - * @frag: the paged fragment - * - * Returns the &struct page associated with @frag. - */ -static inline struct page *skb_frag_page(const skb_frag_t *frag) -{ - return frag->page; -} - -/* mask skb_frag_dma_map as RHEL6 backports this */ -#define skb_frag_dma_map(a,b,c,d,e) compat_skb_frag_dma_map(a,b,c,d,e) - -/** - * skb_frag_dma_map - maps a paged fragment via the DMA API - * @device: the device to map the fragment to - * @frag: the paged fragment to map - * @offset: the offset within the fragment (starting at the - * fragment's own offset) - * @size: the number of bytes to map - * @direction: the direction of the mapping (%PCI_DMA_*) - * - * Maps the page associated with @frag to @device. - */ -static inline dma_addr_t skb_frag_dma_map(struct device *dev, - const skb_frag_t *frag, - size_t offset, size_t size, - enum dma_data_direction dir) -{ - return dma_map_page(dev, skb_frag_page(frag), - frag->page_offset + offset, size, dir); -} - -#define ETH_P_TDLS 0x890D /* TDLS */ - -/* mask skb_frag_size as RHEL6 backports this */ -#define skb_frag_size(a) compat_skb_frag_size(a) - -static inline unsigned int skb_frag_size(const skb_frag_t *frag) -{ - return frag->size; -} - -static inline char *hex_byte_pack(char *buf, u8 byte) -{ - *buf++ = hex_asc_hi(byte); - *buf++ = hex_asc_lo(byte); - return buf; -} - -/* module_platform_driver() - Helper macro for drivers that don't do - * anything special in module init/exit. This eliminates a lot of - * boilerplate. Each module may only use this macro once, and - * calling it replaces module_init() and module_exit() - */ -#define module_platform_driver(__platform_driver) \ - module_driver(__platform_driver, platform_driver_register, \ - platform_driver_unregister) - -static inline void *dma_zalloc_coherent(struct device *dev, size_t size, - dma_addr_t *dma_handle, gfp_t flag) -{ - void *ret = dma_alloc_coherent(dev, size, dma_handle, flag); - if (ret) - memset(ret, 0, size); - return ret; -} - -#define __netdev_printk LINUX_BACKPORT(__netdev_printk) -extern int __netdev_printk(const char *level, const struct net_device *dev, - struct va_format *vaf); - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(3,2,0)) */ - -#endif /* LINUX_3_2_COMPAT_H */ diff --git a/backport/include/linux/compat-3.3.h b/backport/include/linux/compat-3.3.h deleted file mode 100644 index ce7e776bf390..000000000000 --- a/backport/include/linux/compat-3.3.h +++ /dev/null @@ -1,397 +0,0 @@ -#ifndef LINUX_3_3_COMPAT_H -#define LINUX_3_3_COMPAT_H - -#include - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0)) - -#include - -/* include to override NL80211_FEATURE_SK_TX_STATUS */ -#include -#include -#include -#include -#include - -/* - * BQL was added as of v3.3 but some Linux distributions - * have backported BQL to their v3.2 kernels or older. To - * address this we assume that they also enabled CONFIG_BQL - * and test for that here and simply avoid adding the static - * inlines if it was defined - */ -#ifndef CONFIG_BQL -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26)) -static inline void netdev_tx_sent_queue(struct netdev_queue *dev_queue, - unsigned int bytes) -{ -} -#endif - -static inline void netdev_sent_queue(struct net_device *dev, unsigned int bytes) -{ -} - -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26)) -static inline void netdev_tx_completed_queue(struct netdev_queue *dev_queue, - unsigned pkts, unsigned bytes) -{ -} -#endif - -static inline void netdev_completed_queue(struct net_device *dev, - unsigned pkts, unsigned bytes) -{ -} - -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26)) -static inline void netdev_tx_reset_queue(struct netdev_queue *q) -{ -} -#endif - -static inline void netdev_reset_queue(struct net_device *dev_queue) -{ -} -#endif /* CONFIG_BQL */ - - -#define ethtool_adv_to_mii_adv_t LINUX_BACKPORT(ethtool_adv_to_mii_adv_t) - -/** - * ethtool_adv_to_mii_adv_t - * @ethadv: the ethtool advertisement settings - * - * A small helper function that translates ethtool advertisement - * settings to phy autonegotiation advertisements for the - * MII_ADVERTISE register. - */ -static inline u32 ethtool_adv_to_mii_adv_t(u32 ethadv) -{ - u32 result = 0; - - if (ethadv & ADVERTISED_10baseT_Half) - result |= ADVERTISE_10HALF; - if (ethadv & ADVERTISED_10baseT_Full) - result |= ADVERTISE_10FULL; - if (ethadv & ADVERTISED_100baseT_Half) - result |= ADVERTISE_100HALF; - if (ethadv & ADVERTISED_100baseT_Full) - result |= ADVERTISE_100FULL; - if (ethadv & ADVERTISED_Pause) - result |= ADVERTISE_PAUSE_CAP; - if (ethadv & ADVERTISED_Asym_Pause) - result |= ADVERTISE_PAUSE_ASYM; - - return result; -} - -#define mii_adv_to_ethtool_adv_t LINUX_BACKPORT(mii_adv_to_ethtool_adv_t) - -/** - * mii_adv_to_ethtool_adv_t - * @adv: value of the MII_ADVERTISE register - * - * A small helper function that translates MII_ADVERTISE bits - * to ethtool advertisement settings. - */ -static inline u32 mii_adv_to_ethtool_adv_t(u32 adv) -{ - u32 result = 0; - - if (adv & ADVERTISE_10HALF) - result |= ADVERTISED_10baseT_Half; - if (adv & ADVERTISE_10FULL) - result |= ADVERTISED_10baseT_Full; - if (adv & ADVERTISE_100HALF) - result |= ADVERTISED_100baseT_Half; - if (adv & ADVERTISE_100FULL) - result |= ADVERTISED_100baseT_Full; - if (adv & ADVERTISE_PAUSE_CAP) - result |= ADVERTISED_Pause; - if (adv & ADVERTISE_PAUSE_ASYM) - result |= ADVERTISED_Asym_Pause; - - return result; -} - -#define ethtool_adv_to_mii_ctrl1000_t LINUX_BACKPORT(ethtool_adv_to_mii_ctrl1000_t) - -/** - * ethtool_adv_to_mii_ctrl1000_t - * @ethadv: the ethtool advertisement settings - * - * A small helper function that translates ethtool advertisement - * settings to phy autonegotiation advertisements for the - * MII_CTRL1000 register when in 1000T mode. - */ -static inline u32 ethtool_adv_to_mii_ctrl1000_t(u32 ethadv) -{ - u32 result = 0; - - if (ethadv & ADVERTISED_1000baseT_Half) - result |= ADVERTISE_1000HALF; - if (ethadv & ADVERTISED_1000baseT_Full) - result |= ADVERTISE_1000FULL; - - return result; -} - -#define mii_ctrl1000_to_ethtool_adv_t LINUX_BACKPORT(mii_ctrl1000_to_ethtool_adv_t) - -/** - * mii_ctrl1000_to_ethtool_adv_t - * @adv: value of the MII_CTRL1000 register - * - * A small helper function that translates MII_CTRL1000 - * bits, when in 1000Base-T mode, to ethtool - * advertisement settings. - */ -static inline u32 mii_ctrl1000_to_ethtool_adv_t(u32 adv) -{ - u32 result = 0; - - if (adv & ADVERTISE_1000HALF) - result |= ADVERTISED_1000baseT_Half; - if (adv & ADVERTISE_1000FULL) - result |= ADVERTISED_1000baseT_Full; - - return result; -} - -#define mii_lpa_to_ethtool_lpa_t LINUX_BACKPORT(mii_lpa_to_ethtool_lpa_t) - -/** - * mii_lpa_to_ethtool_lpa_t - * @adv: value of the MII_LPA register - * - * A small helper function that translates MII_LPA - * bits, when in 1000Base-T mode, to ethtool - * LP advertisement settings. - */ -static inline u32 mii_lpa_to_ethtool_lpa_t(u32 lpa) -{ - u32 result = 0; - - if (lpa & LPA_LPACK) - result |= ADVERTISED_Autoneg; - - return result | mii_adv_to_ethtool_adv_t(lpa); -} - -#define mii_stat1000_to_ethtool_lpa_t LINUX_BACKPORT(mii_stat1000_to_ethtool_lpa_t) - -/** - * mii_stat1000_to_ethtool_lpa_t - * @adv: value of the MII_STAT1000 register - * - * A small helper function that translates MII_STAT1000 - * bits, when in 1000Base-T mode, to ethtool - * advertisement settings. - */ -static inline u32 mii_stat1000_to_ethtool_lpa_t(u32 lpa) -{ - u32 result = 0; - - if (lpa & LPA_1000HALF) - result |= ADVERTISED_1000baseT_Half; - if (lpa & LPA_1000FULL) - result |= ADVERTISED_1000baseT_Full; - - return result; -} - -#define ethtool_adv_to_mii_adv_x LINUX_BACKPORT(ethtool_adv_to_mii_adv_x) -/** - * ethtool_adv_to_mii_adv_x - * @ethadv: the ethtool advertisement settings - * - * A small helper function that translates ethtool advertisement - * settings to phy autonegotiation advertisements for the - * MII_CTRL1000 register when in 1000Base-X mode. - */ -static inline u32 ethtool_adv_to_mii_adv_x(u32 ethadv) -{ - u32 result = 0; - - if (ethadv & ADVERTISED_1000baseT_Half) - result |= ADVERTISE_1000XHALF; - if (ethadv & ADVERTISED_1000baseT_Full) - result |= ADVERTISE_1000XFULL; - if (ethadv & ADVERTISED_Pause) - result |= ADVERTISE_1000XPAUSE; - if (ethadv & ADVERTISED_Asym_Pause) - result |= ADVERTISE_1000XPSE_ASYM; - - return result; -} - -#define mii_adv_to_ethtool_adv_x LINUX_BACKPORT(mii_adv_to_ethtool_adv_x) - -/** - * mii_adv_to_ethtool_adv_x - * @adv: value of the MII_CTRL1000 register - * - * A small helper function that translates MII_CTRL1000 - * bits, when in 1000Base-X mode, to ethtool - * advertisement settings. - */ -static inline u32 mii_adv_to_ethtool_adv_x(u32 adv) -{ - u32 result = 0; - - if (adv & ADVERTISE_1000XHALF) - result |= ADVERTISED_1000baseT_Half; - if (adv & ADVERTISE_1000XFULL) - result |= ADVERTISED_1000baseT_Full; - if (adv & ADVERTISE_1000XPAUSE) - result |= ADVERTISED_Pause; - if (adv & ADVERTISE_1000XPSE_ASYM) - result |= ADVERTISED_Asym_Pause; - - return result; -} - -#define mii_lpa_to_ethtool_lpa_x LINUX_BACKPORT(mii_lpa_to_ethtool_lpa_x) - -/** - * mii_lpa_to_ethtool_lpa_x - * @adv: value of the MII_LPA register - * - * A small helper function that translates MII_LPA - * bits, when in 1000Base-X mode, to ethtool - * LP advertisement settings. - */ -static inline u32 mii_lpa_to_ethtool_lpa_x(u32 lpa) -{ - u32 result = 0; - - if (lpa & LPA_LPACK) - result |= ADVERTISED_Autoneg; - - return result | mii_adv_to_ethtool_adv_x(lpa); -} - -/** - * ethtool_rxfh_indir_default - get default value for RX flow hash indirection - * @index: Index in RX flow hash indirection table - * @n_rx_rings: Number of RX rings to use - * - * This function provides the default policy for RX flow hash indirection. - */ -static inline u32 ethtool_rxfh_indir_default(u32 index, u32 n_rx_rings) -{ - return index % n_rx_rings; -} - -#define ETHTOOL_FWVERS_LEN 32 - -#if !((LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,9) && LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0)) || (LINUX_VERSION_CODE >= KERNEL_VERSION(3,0,23) && LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0))) -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,37)) -/* mask qdisc_cb_private_validate as RHEL6 backports this */ -#define qdisc_cb_private_validate(a,b) compat_qdisc_cb_private_validate(a,b) -static inline void qdisc_cb_private_validate(const struct sk_buff *skb, int sz) -{ - BUILD_BUG_ON(sizeof(skb->cb) < sizeof(struct qdisc_skb_cb) + sz); -} -#else -/* mask qdisc_cb_private_validate as RHEL6 backports this */ -#define qdisc_cb_private_validate(a,b) compat_qdisc_cb_private_validate(a,b) -static inline void qdisc_cb_private_validate(const struct sk_buff *skb, int sz) -{ - /* XXX ? */ -} -#endif -#endif - -#define __pskb_copy LINUX_BACKPORT(__pskb_copy) -extern struct sk_buff *__pskb_copy(struct sk_buff *skb, - int headroom, gfp_t gfp_mask); - -static inline void skb_complete_wifi_ack(struct sk_buff *skb, bool acked) -{ - WARN_ON(1); -} -#define NL80211_FEATURE_SK_TX_STATUS 0 - -typedef u32 netdev_features_t; - -/* source include/linux/device.h */ -/** - * module_driver() - Helper macro for drivers that don't do anything - * special in module init/exit. This eliminates a lot of boilerplate. - * Each module may only use this macro once, and calling it replaces - * module_init() and module_exit(). - * - * Use this macro to construct bus specific macros for registering - * drivers, and do not use it on its own. - */ -#define module_driver(__driver, __register, __unregister) \ -static int __init __driver##_init(void) \ -{ \ - return __register(&(__driver)); \ -} \ -module_init(__driver##_init); \ -static void __exit __driver##_exit(void) \ -{ \ - __unregister(&(__driver)); \ -} \ -module_exit(__driver##_exit); - -/* source include/linux/usb.h */ -/** - * module_usb_driver() - Helper macro for registering a USB driver - * @__usb_driver: usb_driver struct - * - * Helper macro for USB drivers which do not do anything special in module - * init/exit. This eliminates a lot of boilerplate. Each module may only - * use this macro once, and calling it replaces module_init() and module_exit() - */ -#define module_usb_driver(__usb_driver) \ - module_driver(__usb_driver, usb_register, \ - usb_deregister) - - -/* - * PCI_EXP_TYPE_RC_EC was added via 1b6b8ce2 on v2.6.30-rc4~20 : - * - * mcgrof@frijol ~/linux-next (git::master)$ git describe --contains 1b6b8ce2 - * v2.6.30-rc4~20^2 - * - * but the fix for its definition was merged on v3.3-rc1~101^2~67 - * - * mcgrof@frijol ~/linux-next (git::master)$ git describe --contains 1830ea91 - * v3.3-rc1~101^2~67 - * - * while we can assume it got merged and backported on v3.2.28 (which it did - * see c1c3cd9) we cannot assume every kernel has it fixed so lets just undef - * it here and redefine it. - */ -#undef PCI_EXP_TYPE_RC_EC -#define PCI_EXP_TYPE_RC_EC 0xa /* Root Complex Event Collector */ - - -/* This backports: - * - * commit 7c92784a546d2945b6d6973a30f7134be78eb7a4 - * Author: Lars-Peter Clausen - * Date: Wed Nov 16 10:13:36 2011 +0100 - * - * I2C: Add helper macro for i2c_driver boilerplate - */ -/** - * module_i2c_driver() - Helper macro for registering a I2C driver - * @__i2c_driver: i2c_driver struct - * - * Helper macro for I2C drivers which do not do anything special in module - * init/exit. This eliminates a lot of boilerplate. Each module may only - * use this macro once, and calling it replaces module_init() and module_exit() - */ -#define module_i2c_driver(__i2c_driver) \ - module_driver(__i2c_driver, i2c_add_driver, \ - i2c_del_driver) - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0)) */ - -#endif /* LINUX_3_3_COMPAT_H */ diff --git a/backport/include/linux/compat-3.4.h b/backport/include/linux/compat-3.4.h deleted file mode 100644 index a152d517a824..000000000000 --- a/backport/include/linux/compat-3.4.h +++ /dev/null @@ -1,225 +0,0 @@ -#ifndef LINUX_3_4_COMPAT_H -#define LINUX_3_4_COMPAT_H - -#include - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,4,0)) - -#include -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0)) -/* need to import it, but it only exists since kernel 3.1 */ -#include -#endif - -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0)) -#if defined(CONFIG_REGMAP) -#include -#define devm_regmap_init LINUX_BACKPORT(devm_regmap_init) -struct regmap *devm_regmap_init(struct device *dev, - const struct regmap_bus *bus, - const struct regmap_config *config); -#if defined(CONFIG_REGMAP_I2C) -#define devm_regmap_init_i2c LINUX_BACKPORT(devm_regmap_init_i2c) -struct regmap *devm_regmap_init_i2c(struct i2c_client *i2c, - const struct regmap_config *config); -#endif /* defined(CONFIG_REGMAP_I2C) */ -#if defined(CONFIG_REGMAP_SPI) -#define devm_regmap_init_spi LINUX_BACKPORT(devm_regmap_init_spi) -struct regmap *devm_regmap_init_spi(struct spi_device *dev, - const struct regmap_config *config); -#endif /* defined(CONFIG_REGMAP_SPI) */ - -/* - * We can't backport these unless we try to backport - * the full regmap into core so warn if used. - * No drivers are using this yet anyway. - */ -#define regmap_raw_write_async LINUX_BACKPORT(regmap_raw_write_async) -static inline int regmap_raw_write_async(struct regmap *map, unsigned int reg, - const void *val, size_t val_len) -{ - WARN_ONCE(1, "regmap API is disabled"); - return -EINVAL; -} - -#define regmap_async_complete LINUX_BACKPORT(regmap_async_complete) -static inline void regmap_async_complete(struct regmap *map) -{ - WARN_ONCE(1, "regmap API is disabled"); -} - -#endif /* defined(CONFIG_REGMAP) */ -#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0)) */ - -/* - * defined here to allow things to compile but technically - * using this for memory regions will yield in a no-op on newer - * kernels but on older kernels (v3.3 and older) this bit was used - * for VM_ALWAYSDUMP. The goal was to remove this bit moving forward - * and since we can't skip the core dump on old kernels we just make - * this bit name now a no-op. - * - * For details see commits: 909af7 accb61fe cdaaa7003 - */ -#define VM_NODUMP 0x0 - -/* This backports: - * - * commit 63b2001169e75cd71e917ec953fdab572e3f944a - * Author: Thomas Gleixner - * Date: Thu Dec 1 00:04:00 2011 +0100 - - * sched/wait: Add __wake_up_all_locked() API - */ -#include -extern void compat_wake_up_locked(wait_queue_head_t *q, unsigned int mode, int nr); -#define wake_up_all_locked(x) compat_wake_up_locked((x), TASK_NORMAL, 0) - -/* This backports: - * - * commit a8203725dfded5c1f79dca3368a4a273e24b59bb - * Author: Xi Wang - * Date: Mon Mar 5 15:14:41 2012 -0800 - * - * slab: introduce kmalloc_array() - */ - -/* SIZE_MAX is backported in compat-3.5.h so include it */ -#include -#define kmalloc_array LINUX_BACKPORT(kmalloc_array) -static inline void *kmalloc_array(size_t n, size_t size, gfp_t flags) -{ - if (size != 0 && n > SIZE_MAX / size) - return NULL; - return __kmalloc(n * size, flags); -} - -#include -#include - -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34)) -#define i2c_bit_algo LINUX_BACKPORT(i2c_bit_algo) -extern const struct i2c_algorithm i2c_bit_algo; -#endif - -#define simple_open LINUX_BACKPORT(simple_open) -extern int simple_open(struct inode *inode, struct file *file); - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28)) -#define skb_add_rx_frag(skb, i, page, off, size, truesize) \ - v2_6_28_skb_add_rx_frag(skb, i, page, off, size) -#else -#define skb_add_rx_frag(skb, i, page, off, size, truesize) \ - skb_add_rx_frag(skb, i, page, off, size) -#endif - -#ifdef CONFIG_X86_X32_ABI -#define COMPAT_USE_64BIT_TIME \ - (!!(task_pt_regs(current)->orig_ax & __X32_SYSCALL_BIT)) -#else -#define COMPAT_USE_64BIT_TIME 0 -#endif - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,12)) -#define eth_hw_addr_random LINUX_BACKPORT(eth_hw_addr_random) -static inline void eth_hw_addr_random(struct net_device *dev) -{ -#error eth_hw_addr_random() needs to be implemented for < 2.6.12 -} -#else /* kernels >= 2.6.12 */ - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,31)) -#define eth_hw_addr_random LINUX_BACKPORT(eth_hw_addr_random) -static inline void eth_hw_addr_random(struct net_device *dev) -{ - get_random_bytes(dev->dev_addr, ETH_ALEN); - dev->dev_addr[0] &= 0xfe; /* clear multicast bit */ - dev->dev_addr[0] |= 0x02; /* set local assignment bit (IEEE802) */ -} -#else /* kernels >= 2.6.31 */ - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36)) -/* So this is 2.6.31..2.6.35 */ - -/* Just have the flags present, they won't really mean anything though */ -#define NET_ADDR_PERM 0 /* address is permanent (default) */ -#define NET_ADDR_RANDOM 1 /* address is generated randomly */ -#define NET_ADDR_STOLEN 2 /* address is stolen from other device */ - -#define eth_hw_addr_random LINUX_BACKPORT(eth_hw_addr_random) -static inline void eth_hw_addr_random(struct net_device *dev) -{ - random_ether_addr(dev->dev_addr); -} - -#else /* 2.6.36 and on */ -#define eth_hw_addr_random LINUX_BACKPORT(eth_hw_addr_random) -static inline void eth_hw_addr_random(struct net_device *dev) -{ - dev_hw_addr_random(dev, dev->dev_addr); -} -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,31)) */ - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,31)) */ -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,12)) */ - -/* source include/linux/pci.h */ -/** - * module_pci_driver() - Helper macro for registering a PCI driver - * @__pci_driver: pci_driver struct - * - * Helper macro for PCI drivers which do not do anything special in module - * init/exit. This eliminates a lot of boilerplate. Each module may only - * use this macro once, and calling it replaces module_init() and module_exit() - */ -#define module_pci_driver(__pci_driver) \ - module_driver(__pci_driver, pci_register_driver, \ - pci_unregister_driver) - -/* - * Getting something that works in C and CPP for an arg that may or may - * not be defined is tricky. Here, if we have "#define CONFIG_BOOGER 1" - * we match on the placeholder define, insert the "0," for arg1 and generate - * the triplet (0, 1, 0). Then the last step cherry picks the 2nd arg (a one). - * When CONFIG_BOOGER is not defined, we generate a (... 1, 0) pair, and when - * the last step cherry picks the 2nd arg, we get a zero. - */ -#define __ARG_PLACEHOLDER_1 0, -#define config_enabled(cfg) _config_enabled(cfg) -#define _config_enabled(value) __config_enabled(__ARG_PLACEHOLDER_##value) -#define __config_enabled(arg1_or_junk) ___config_enabled(arg1_or_junk 1, 0) -#define ___config_enabled(__ignored, val, ...) val - -/* 3.1 - 3.3 had a broken version of this, so undef */ -#undef IS_ENABLED -#define IS_ENABLED(option) \ - (config_enabled(option) || config_enabled(option##_MODULE)) - -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,31)) -/* - * Return true if it is guaranteed that poll will not wait. This is the case - * if the poll() of another file descriptor in the set got an event, so there - * is no need for waiting. - */ -#define poll_does_not_wait LINUX_BACKPORT(poll_does_not_wait) -static inline bool poll_does_not_wait(const poll_table *p) -{ - return p == NULL || p->qproc == NULL; -} - -/* - * Return the set of events that the application wants to poll for. - * This is useful for drivers that need to know whether a DMA transfer has - * to be started implicitly on poll(). You typically only want to do that - * if the application is actually polling for POLLIN and/or POLLOUT. - */ -#define poll_requested_events LINUX_BACKPORT(poll_requested_events) -static inline unsigned long poll_requested_events(const poll_table *p) -{ - return p ? p->key : ~0UL; -} -#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,31)) */ - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(3,4,0)) */ - -#endif /* LINUX_5_4_COMPAT_H */ diff --git a/backport/include/linux/compat-3.5.h b/backport/include/linux/compat-3.5.h deleted file mode 100644 index e21048dd3fd1..000000000000 --- a/backport/include/linux/compat-3.5.h +++ /dev/null @@ -1,378 +0,0 @@ -#ifndef LINUX_3_5_COMPAT_H -#define LINUX_3_5_COMPAT_H - -#include -#include -#include -#include - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0)) - -#include - -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0)) -#include - -#define dev_get_regmap LINUX_BACKPORT(dev_get_regmap) -static inline -struct regmap *dev_get_regmap(struct device *dev, const char *name) -{ - return NULL; -} - -#define devres_release LINUX_BACKPORT(devres_release) -extern int devres_release(struct device *dev, dr_release_t release, - dr_match_t match, void *match_data); -#endif - -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)) -#include -#define dev_level_ratelimited(dev_level, dev, fmt, ...) \ -do { \ - static DEFINE_RATELIMIT_STATE(_rs, \ - DEFAULT_RATELIMIT_INTERVAL, \ - DEFAULT_RATELIMIT_BURST); \ - if (__ratelimit(&_rs)) \ - dev_level(dev, fmt, ##__VA_ARGS__); \ -} while (0) - -#define dev_emerg_ratelimited(dev, fmt, ...) \ - dev_level_ratelimited(dev_emerg, dev, fmt, ##__VA_ARGS__) -#define dev_alert_ratelimited(dev, fmt, ...) \ - dev_level_ratelimited(dev_alert, dev, fmt, ##__VA_ARGS__) - - -#if defined(CONFIG_DYNAMIC_DEBUG) || defined(DEBUG) -#define dev_dbg_ratelimited(dev, fmt, ...) \ -do { \ - static DEFINE_RATELIMIT_STATE(_rs, \ - DEFAULT_RATELIMIT_INTERVAL, \ - DEFAULT_RATELIMIT_BURST); \ - DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt); \ - if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT) && \ - __ratelimit(&_rs)) \ - __dynamic_pr_debug(&descriptor, pr_fmt(fmt), \ - ##__VA_ARGS__); \ -} while (0) -#else -#define dev_dbg_ratelimited(dev, fmt, ...) \ - no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__) -#endif - -#endif - -/* - * This backports: - * commit 569a8fc38367dfafd87454f27ac646c8e6b54bca - * Author: David S. Miller - * Date: Thu Mar 29 23:18:53 2012 -0400 - * - * netlink: Add nla_put_be{16,32,64}() helpers. - */ - -static inline int nla_put_be16(struct sk_buff *skb, int attrtype, __be16 value) -{ - return nla_put(skb, attrtype, sizeof(__be16), &value); -} - -static inline int nla_put_be32(struct sk_buff *skb, int attrtype, __be32 value) -{ - return nla_put(skb, attrtype, sizeof(__be32), &value); -} - -static inline int nla_put_be64(struct sk_buff *skb, int attrtype, __be64 value) -{ - return nla_put(skb, attrtype, sizeof(__be64), &value); -} - -/* - * This backports: - * - * commit f56f821feb7b36223f309e0ec05986bb137ce418 - * Author: Daniel Vetter - * Date: Sun Mar 25 19:47:41 2012 +0200 - * - * mm: extend prefault helpers to fault in more than PAGE_SIZE - * - * The new functions are used by drm/i915 driver. - * - */ - -static inline int fault_in_multipages_writeable(char __user *uaddr, int size) -{ - int ret = 0; - char __user *end = uaddr + size - 1; - - if (unlikely(size == 0)) - return ret; - - /* - * Writing zeroes into userspace here is OK, because we know that if - * the zero gets there, we'll be overwriting it. - */ - while (uaddr <= end) { - ret = __put_user(0, uaddr); - if (ret != 0) - return ret; - uaddr += PAGE_SIZE; - } - - /* Check whether the range spilled into the next page. */ - if (((unsigned long)uaddr & PAGE_MASK) == - ((unsigned long)end & PAGE_MASK)) - ret = __put_user(0, end); - - return ret; -} - -static inline int fault_in_multipages_readable(const char __user *uaddr, - int size) -{ - volatile char c; - int ret = 0; - const char __user *end = uaddr + size - 1; - - if (unlikely(size == 0)) - return ret; - - while (uaddr <= end) { - ret = __get_user(c, uaddr); - if (ret != 0) - return ret; - uaddr += PAGE_SIZE; - } - - /* Check whether the range spilled into the next page. */ - if (((unsigned long)uaddr & PAGE_MASK) == - ((unsigned long)end & PAGE_MASK)) { - ret = __get_user(c, end); - (void)c; - } - - return ret; -} - -/* switcheroo is available on >= 2.6.34 */ -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34)) -#include -/* - * This backports: - * - * From 26ec685ff9d9c16525d8ec4c97e52fcdb187b302 Mon Sep 17 00:00:00 2001 - * From: Takashi Iwai - * Date: Fri, 11 May 2012 07:51:17 +0200 - * Subject: [PATCH] vga_switcheroo: Introduce struct vga_switcheroo_client_ops - * - */ - -struct vga_switcheroo_client_ops { - void (*set_gpu_state)(struct pci_dev *dev, enum vga_switcheroo_state); - void (*reprobe)(struct pci_dev *dev); - bool (*can_switch)(struct pci_dev *dev); -}; - -/* Wrap around the old code and redefine vga_switcheroo_register_client() - * for older kernels < 3.5.0. - */ -static inline int compat_vga_switcheroo_register_client(struct pci_dev *dev, - const struct vga_switcheroo_client_ops *ops) { - - return vga_switcheroo_register_client(dev, - ops->set_gpu_state, -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,38)) - ops->reprobe, -#endif - ops->can_switch); -} - -#define vga_switcheroo_register_client(_dev, _ops) \ - compat_vga_switcheroo_register_client(_dev, _ops) - -#endif - -/* This backports - * - * commit 14674e70119ea01549ce593d8901a797f8a90f74 - * Author: Mark Brown - * Date: Wed May 30 10:55:34 2012 +0200 - * - * i2c: Split I2C_M_NOSTART support out of I2C_FUNC_PROTOCOL_MANGLING - */ - -#define I2C_FUNC_NOSTART 0x00000010 /* I2C_M_NOSTART */ - -/* - * This backports: - * - * From a3860c1c5dd1137db23d7786d284939c5761d517 Mon Sep 17 00:00:00 2001 - * From: Xi Wang - * Date: Thu, 31 May 2012 16:26:04 -0700 - * Subject: [PATCH] introduce SIZE_MAX - */ - -#define SIZE_MAX (~(size_t)0) - - -#include - -/* - * This backports: - * - * From 76e3cc126bb223013a6b9a0e2a51238d1ef2e409 Mon Sep 17 00:00:00 2001 - * From: Eric Dumazet - * Date: Thu, 10 May 2012 07:51:25 +0000 - * Subject: [PATCH] codel: Controlled Delay AQM - */ - -#ifndef TCA_CODEL_MAX -/* CODEL */ - -#define COMPAT_CODEL_BACKPORT - -enum { - TCA_CODEL_UNSPEC, - TCA_CODEL_TARGET, - TCA_CODEL_LIMIT, - TCA_CODEL_INTERVAL, - TCA_CODEL_ECN, - __TCA_CODEL_MAX -}; - -#define TCA_CODEL_MAX (__TCA_CODEL_MAX - 1) - -struct tc_codel_xstats { - __u32 maxpacket; /* largest packet we've seen so far */ - __u32 count; /* how many drops we've done since the last time we - * entered dropping state - */ - __u32 lastcount; /* count at entry to dropping state */ - __u32 ldelay; /* in-queue delay seen by most recently dequeued packet */ - __s32 drop_next; /* time to drop next packet */ - __u32 drop_overlimit; /* number of time max qdisc packet limit was hit */ - __u32 ecn_mark; /* number of packets we ECN marked instead of dropped */ - __u32 dropping; /* are we in dropping state ? */ -}; - -/* This backports: - * - * commit 4b549a2ef4bef9965d97cbd992ba67930cd3e0fe - * Author: Eric Dumazet - * Date: Fri May 11 09:30:50 2012 +0000 - * fq_codel: Fair Queue Codel AQM - */ - -/* FQ_CODEL */ - -enum { - TCA_FQ_CODEL_UNSPEC, - TCA_FQ_CODEL_TARGET, - TCA_FQ_CODEL_LIMIT, - TCA_FQ_CODEL_INTERVAL, - TCA_FQ_CODEL_ECN, - TCA_FQ_CODEL_FLOWS, - TCA_FQ_CODEL_QUANTUM, - __TCA_FQ_CODEL_MAX -}; - -#define TCA_FQ_CODEL_MAX (__TCA_FQ_CODEL_MAX - 1) - -enum { - TCA_FQ_CODEL_XSTATS_QDISC, - TCA_FQ_CODEL_XSTATS_CLASS, -}; - -struct tc_fq_codel_qd_stats { - __u32 maxpacket; /* largest packet we've seen so far */ - __u32 drop_overlimit; /* number of time max qdisc - * packet limit was hit - */ - __u32 ecn_mark; /* number of packets we ECN marked - * instead of being dropped - */ - __u32 new_flow_count; /* number of time packets - * created a 'new flow' - */ - __u32 new_flows_len; /* count of flows in new list */ - __u32 old_flows_len; /* count of flows in old list */ -}; - -struct tc_fq_codel_cl_stats { - __s32 deficit; - __u32 ldelay; /* in-queue delay seen by most recently - * dequeued packet - */ - __u32 count; - __u32 lastcount; - __u32 dropping; - __s32 drop_next; -}; - -struct tc_fq_codel_xstats { - __u32 type; - union { - struct tc_fq_codel_qd_stats qdisc_stats; - struct tc_fq_codel_cl_stats class_stats; - }; -}; -#endif /* TCA_CODEL_MAX */ - -/* Backport ether_addr_equal */ -static inline bool ether_addr_equal(const u8 *addr1, const u8 *addr2) -{ - return !compare_ether_addr(addr1, addr2); -} - -#define net_ratelimited_function(function, ...) \ -do { \ - if (net_ratelimit()) \ - function(__VA_ARGS__); \ -} while (0) - -#define net_emerg_ratelimited(fmt, ...) \ - net_ratelimited_function(pr_emerg, fmt, ##__VA_ARGS__) -#define net_alert_ratelimited(fmt, ...) \ - net_ratelimited_function(pr_alert, fmt, ##__VA_ARGS__) -#define net_crit_ratelimited(fmt, ...) \ - net_ratelimited_function(pr_crit, fmt, ##__VA_ARGS__) -#define net_err_ratelimited(fmt, ...) \ - net_ratelimited_function(pr_err, fmt, ##__VA_ARGS__) -#define net_notice_ratelimited(fmt, ...) \ - net_ratelimited_function(pr_notice, fmt, ##__VA_ARGS__) -#define net_warn_ratelimited(fmt, ...) \ - net_ratelimited_function(pr_warn, fmt, ##__VA_ARGS__) -#define net_info_ratelimited(fmt, ...) \ - net_ratelimited_function(pr_info, fmt, ##__VA_ARGS__) -#define net_dbg_ratelimited(fmt, ...) \ - net_ratelimited_function(pr_debug, fmt, ##__VA_ARGS__) - -#define ktime_get_monotonic_offset LINUX_BACKPORT(ktime_get_monotonic_offset) -extern ktime_t ktime_get_monotonic_offset(void); - -/* This backports: - * - * commit 2033e9bf06f07e049bbc77e9452856df846714cc - * Author: Neil Horman - * Date: Tue May 29 09:30:40 2012 +0000 - * - * net: add MODULE_ALIAS_NET_PF_PROTO_NAME - */ - -#define MODULE_ALIAS_NET_PF_PROTO_NAME(pf, proto, name) \ - MODULE_ALIAS("net-pf-" __stringify(pf) "-proto-" __stringify(proto) \ - name) - -/* This backports: - * - * commit e9412c37082b5c932e83364aaed0c38c2ce33acb - * Author: Neil Horman - * Date: Tue May 29 09:30:41 2012 +0000 - * - * genetlink: Build a generic netlink family module alias - */ - -#define MODULE_ALIAS_GENL_FAMILY(family)\ - MODULE_ALIAS_NET_PF_PROTO_NAME(PF_NETLINK, NETLINK_GENERIC, "-family-" family) - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0)) */ - -#endif /* LINUX_3_5_COMPAT_H */ diff --git a/backport/include/linux/compat-3.6.h b/backport/include/linux/compat-3.6.h deleted file mode 100644 index f2c1a9098e82..000000000000 --- a/backport/include/linux/compat-3.6.h +++ /dev/null @@ -1,138 +0,0 @@ -#ifndef LINUX_3_6_COMPAT_H -#define LINUX_3_6_COMPAT_H - -#include - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0)) - -#include - -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0)) -#include -#include -/* Unlocked flavor */ -#define __i2c_transfer LINUX_BACKPORT(__i2c_transfer) -extern int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, - int num); -#endif - - -#define memweight LINUX_BACKPORT(memweight) -extern size_t memweight(const void *ptr, size_t bytes); - -/* backports efc42bc9 */ -#define sg_alloc_table_from_pages LINUX_BACKPORT(sg_alloc_table_from_pages) -int sg_alloc_table_from_pages(struct sg_table *sgt, - struct page **pages, unsigned int n_pages, - unsigned long offset, unsigned long size, - gfp_t gfp_mask); - -#define dma_common_get_sgtable LINUX_BACKPORT(dma_common_get_sgtable) -int -dma_common_get_sgtable(struct device *dev, struct sg_table *sgt, - void *cpu_addr, dma_addr_t dma_addr, size_t size); - -#define dma_get_sgtable_attrs LINUX_BACKPORT(dma_get_sgtable_attrs) -static inline int -dma_get_sgtable_attrs(struct device *dev, struct sg_table *sgt, void *cpu_addr, - dma_addr_t dma_addr, size_t size, struct dma_attrs *attrs) -{ - return dma_common_get_sgtable(dev, sgt, cpu_addr, dma_addr, size); -} - -#define dma_get_sgtable(d, t, v, h, s) dma_get_sgtable_attrs(d, t, v, h, s, NULL) - - -/** - * Backports - * - * commit d81a5d1956731c453b85c141458d4ff5d6cc5366 - * Author: Gustavo Padovan - * Date: Tue Jul 10 19:10:06 2012 -0300 - * - * USB: add USB_VENDOR_AND_INTERFACE_INFO() macro - */ -#include -#define USB_VENDOR_AND_INTERFACE_INFO(vend, cl, sc, pr) \ - .match_flags = USB_DEVICE_ID_MATCH_INT_INFO \ - | USB_DEVICE_ID_MATCH_VENDOR, \ - .idVendor = (vend), \ - .bInterfaceClass = (cl), \ - .bInterfaceSubClass = (sc), \ - .bInterfaceProtocol = (pr) - -/** - * Backports - * - * commit cdcac9cd7741af2c2b9255cbf060f772596907bb - * Author: Dave Airlie - * Date: Wed Jun 27 08:35:52 2012 +0100 - * - * pci_regs: define LNKSTA2 pcie cap + bits. - * - * We need these for detecting the max link speed for drm drivers. - * - * Acked-by: Bjorn Helgaas - * Signed-off-by: Dave Airlie - */ - -#define PCI_EXP_LNKCAP2 44 /* Link Capability 2 */ -#define PCI_EXP_LNKCAP2_SLS_2_5GB 0x01 /* Current Link Speed 2.5GT/s */ -#define PCI_EXP_LNKCAP2_SLS_5_0GB 0x02 /* Current Link Speed 5.0GT/s */ -#define PCI_EXP_LNKCAP2_SLS_8_0GB 0x04 /* Current Link Speed 8.0GT/s */ -#define PCI_EXP_LNKCAP2_CROSSLINK 0x100 /* Crosslink supported */ - -#include -#include - -/** - * eth_broadcast_addr - Assign broadcast address - * @addr: Pointer to a six-byte array containing the Ethernet address - * - * Assign the broadcast address to the given address array. - */ -static inline void eth_broadcast_addr(u8 *addr) -{ - memset(addr, 0xff, ETH_ALEN); -} - -/** - * eth_random_addr - Generate software assigned random Ethernet address - * @addr: Pointer to a six-byte array containing the Ethernet address - * - * Generate a random Ethernet address (MAC) that is not multicast - * and has the local assigned bit set. - */ -static inline void eth_random_addr(u8 *addr) -{ - get_random_bytes(addr, ETH_ALEN); - addr[0] &= 0xfe; /* clear multicast bit */ - addr[0] |= 0x02; /* set local assignment bit (IEEE802) */ -} - -#define GENLMSG_DEFAULT_SIZE (NLMSG_DEFAULT_SIZE - GENL_HDRLEN) - -/* - * Backports - * - * commit 959d62fa865d2e616b61a509e1cc5b88741f065e - * Author: Shuah Khan - * Date: Thu Jun 14 04:34:30 2012 +0800 - * - * leds: Rename led_brightness_set() to led_set_brightness() - * - * Rename leds external interface led_brightness_set() to led_set_brightness(). - * This is the second phase of the change to reduce confusion between the - * leds internal and external interfaces that set brightness. With this change, - * now the external interface is led_set_brightness(). The first phase renamed - * the internal interface led_set_brightness() to __led_set_brightness(). - * There are no changes to the interface implementations. - * - * Signed-off-by: Shuah Khan - * Signed-off-by: Bryan Wu - */ -#define led_set_brightness(_dev, _switch) led_brightness_set(_dev, _switch) - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0)) */ - -#endif /* LINUX_3_6_COMPAT_H */ diff --git a/backport/include/linux/compat-3.7.h b/backport/include/linux/compat-3.7.h deleted file mode 100644 index c7a4ebc2ee1c..000000000000 --- a/backport/include/linux/compat-3.7.h +++ /dev/null @@ -1,218 +0,0 @@ -#ifndef LINUX_3_7_COMPAT_H -#define LINUX_3_7_COMPAT_H - -#include - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,7,0)) - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#define VM_DONTDUMP VM_NODUMP - -#define IORESOURCE_REG 0x00000300 /* Register offsets */ - -#ifdef CONFIG_USER_NS - -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,38)) -static inline struct user_namespace *seq_user_ns(struct seq_file *seq) -{ - struct file *f = container_of((void *) seq, struct file, private_data); - - return f->f_cred->user_ns; -} -#else -static inline struct user_namespace *seq_user_ns(struct seq_file *seq) -{ - return current_user_ns(); -} -#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,38)) */ - -#else -static inline struct user_namespace *seq_user_ns(struct seq_file *seq) -{ - extern struct user_namespace init_user_ns; - return &init_user_ns; -} -#endif /* CONFIG_USER_NS */ - -#define netlink_notify_portid(__notify) (__notify->pid) -#define genl_info_snd_portid(__genl_info) (__genl_info->snd_pid) -#define NETLINK_CB_PORTID(__skb) NETLINK_CB(cb->skb).pid - -#define mod_delayed_work LINUX_BACKPORT(mod_delayed_work) -bool mod_delayed_work(struct workqueue_struct *wq, struct delayed_work *dwork, - unsigned long delay); - -/* Backports tty_lock: Localise the lock */ -#define tty_lock(__tty) tty_lock() -#define tty_unlock(__tty) tty_unlock() - -#define tty_port_register_device(port, driver, index, device) \ - tty_register_device(driver, index, device) - -#define pcie_capability_read_word LINUX_BACKPORT(pcie_capability_read_word) -int pcie_capability_read_word(struct pci_dev *dev, int pos, u16 *val); -#define pcie_capability_read_dword LINUX_BACKPORT(pcie_capability_read_dword) -int pcie_capability_read_dword(struct pci_dev *dev, int pos, u32 *val); -#define pcie_capability_write_word LINUX_BACKPORT(pcie_capability_write_word) -int pcie_capability_write_word(struct pci_dev *dev, int pos, u16 val); -#define pcie_capability_write_dword LINUX_BACKPORT(pcie_capability_write_dword) -int pcie_capability_write_dword(struct pci_dev *dev, int pos, u32 val); -#define pcie_capability_clear_and_set_word LINUX_BACKPORT(pcie_capability_clear_and_set_word) -int pcie_capability_clear_and_set_word(struct pci_dev *dev, int pos, - u16 clear, u16 set); -#define pcie_capability_clear_and_set_dword LINUX_BACKPORT(pcie_capability_clear_and_set_dword) -int pcie_capability_clear_and_set_dword(struct pci_dev *dev, int pos, - u32 clear, u32 set); - -static inline int pcie_capability_set_word(struct pci_dev *dev, int pos, - u16 set) -{ - return pcie_capability_clear_and_set_word(dev, pos, 0, set); -} - -static inline int pcie_capability_set_dword(struct pci_dev *dev, int pos, - u32 set) -{ - return pcie_capability_clear_and_set_dword(dev, pos, 0, set); -} - -static inline int pcie_capability_clear_word(struct pci_dev *dev, int pos, - u16 clear) -{ - return pcie_capability_clear_and_set_word(dev, pos, clear, 0); -} - -static inline int pcie_capability_clear_dword(struct pci_dev *dev, int pos, - u32 clear) -{ - return pcie_capability_clear_and_set_dword(dev, pos, clear, 0); -} - -#define PCI_EXP_LNKSTA2 50 /* Link Status 2 */ - -/* This backports: - * - * commit 6d57e9078e880a3dd232d579f42ac437a8f1ef7b - * Author: Duan Jiong - * Date: Sat Sep 8 16:32:28 2012 +0000 - * - * etherdevice: introduce help function eth_zero_addr() - */ -/** - * eth_zero_addr - Assign zero address - * @addr: Pointer to a six-byte array containing the Ethernet address - * - * Assign the zero address to the given address array. - */ -static inline void eth_zero_addr(u8 *addr) -{ - memset(addr, 0x00, ETH_ALEN); -} - -/** - * nla_put_s8 - Add a s8 netlink attribute to a socket buffer - * @skb: socket buffer to add attribute to - * @attrtype: attribute type - * @value: numeric value - */ -static inline int nla_put_s8(struct sk_buff *skb, int attrtype, s8 value) -{ - return nla_put(skb, attrtype, sizeof(s8), &value); -} - -/** - * nla_put_s16 - Add a s16 netlink attribute to a socket buffer - * @skb: socket buffer to add attribute to - * @attrtype: attribute type - * @value: numeric value - */ -static inline int nla_put_s16(struct sk_buff *skb, int attrtype, s16 value) -{ - return nla_put(skb, attrtype, sizeof(s16), &value); -} - -/** - * nla_put_s32 - Add a s32 netlink attribute to a socket buffer - * @skb: socket buffer to add attribute to - * @attrtype: attribute type - * @value: numeric value - */ -static inline int nla_put_s32(struct sk_buff *skb, int attrtype, s32 value) -{ - return nla_put(skb, attrtype, sizeof(s32), &value); -} - -/** - * nla_put_s64 - Add a s64 netlink attribute to a socket buffer - * @skb: socket buffer to add attribute to - * @attrtype: attribute type - * @value: numeric value - */ -static inline int nla_put_s64(struct sk_buff *skb, int attrtype, s64 value) -{ - return nla_put(skb, attrtype, sizeof(s64), &value); -} - -/** - * nla_get_s32 - return payload of s32 attribute - * @nla: s32 netlink attribute - */ -static inline s32 nla_get_s32(const struct nlattr *nla) -{ - return *(s32 *) nla_data(nla); -} - -/** - * nla_get_s16 - return payload of s16 attribute - * @nla: s16 netlink attribute - */ -static inline s16 nla_get_s16(const struct nlattr *nla) -{ - return *(s16 *) nla_data(nla); -} - -/** - * nla_get_s8 - return payload of s8 attribute - * @nla: s8 netlink attribute - */ -static inline s8 nla_get_s8(const struct nlattr *nla) -{ - return *(s8 *) nla_data(nla); -} - -/** - * nla_get_s64 - return payload of s64 attribute - * @nla: s64 netlink attribute - */ -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29)) -static inline s64 nla_get_s64(const struct nlattr *nla) -#else -static inline s64 nla_get_s64(struct nlattr *nla) -#endif -{ - s64 tmp; - - nla_memcpy(&tmp, nla, sizeof(tmp)); - - return tmp; -} - -#define PLATFORM_DEVID_NONE (-1) -#define PLATFORM_DEVID_AUTO (-1) - -#else /* (LINUX_VERSION_CODE > KERNEL_VERSION(3,7,0)) */ -#define netlink_notify_portid(__notify) (__notify->portid) -#define genl_info_snd_portid(__genl_info) (__genl_info->snd_portid) -#define NETLINK_CB_PORTID(__skb) NETLINK_CB(cb->skb).portid -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(3,7,0)) */ - -#endif /* LINUX_3_7_COMPAT_H */ diff --git a/backport/include/linux/compat-3.8.h b/backport/include/linux/compat-3.8.h deleted file mode 100644 index 55fdc165422f..000000000000 --- a/backport/include/linux/compat-3.8.h +++ /dev/null @@ -1,131 +0,0 @@ -#ifndef LINUX_3_8_COMPAT_H -#define LINUX_3_8_COMPAT_H - -#include - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,8,0)) - -#include -#include -#include -#include - -/* backports 496f2f9 */ -#define prandom_seed(_seed) srandom32(_seed) -#define prandom_u32() random32() -#define prandom_u32_state(_state) prandom32(_state) - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,7,8)) -#define netdev_set_default_ethtool_ops LINUX_BACKPORT(netdev_set_default_ethtool_ops) -extern void netdev_set_default_ethtool_ops(struct net_device *dev, - const struct ethtool_ops *ops); -#endif - -#define HID_BUS_ANY 0xffff -#define HID_GROUP_ANY 0x0000 - -#define PCI_EXP_LNKCTL_ASPM_L0S 0x01 /* L0s Enable */ -#define PCI_EXP_LNKCTL_ASPM_L1 0x02 /* L1 Enable */ - -#define hid_ignore LINUX_BACKPORT(hid_ignore) -extern bool hid_ignore(struct hid_device *); - -/* This backports: - * - * commit 4b20db3de8dab005b07c74161cb041db8c5ff3a7 - * Author: Thomas Hellstrom - * Date: Tue Nov 6 11:31:49 2012 +0000 - * - * kref: Implement kref_get_unless_zero v3 - */ -/** - * kref_get_unless_zero - Increment refcount for object unless it is zero. - * @kref: object. - * - * Return non-zero if the increment succeeded. Otherwise return 0. - * - * This function is intended to simplify locking around refcounting for - * objects that can be looked up from a lookup structure, and which are - * removed from that lookup structure in the object destructor. - * Operations on such objects require at least a read lock around - * lookup + kref_get, and a write lock around kref_put + remove from lookup - * structure. Furthermore, RCU implementations become extremely tricky. - * With a lookup followed by a kref_get_unless_zero *with return value check* - * locking in the kref_put path can be deferred to the actual removal from - * the lookup structure and RCU lookups become trivial. - */ -static inline int __must_check kref_get_unless_zero(struct kref *kref) -{ - return atomic_add_unless(&kref->refcount, 1, 0); -} - -/* This backports: - * - * commit 83e68189745ad931c2afd45d8ee3303929233e7f - * Author: Matt Fleming - * Date: Wed Nov 14 09:42:35 2012 +0000 - * - * efi: Make 'efi_enabled' a function to query EFI facilities - * - */ -/* check first if this was already backported */ -#ifndef EFI_BOOT -/* - * We play games with efi_enabled so that the compiler will, if - * possible, remove EFI-related code altogether. - */ -#define EFI_BOOT 0 /* Were we booted from EFI? */ -#define EFI_SYSTEM_TABLES 1 /* Can we use EFI system tables? */ -#define EFI_CONFIG_TABLES 2 /* Can we use EFI config tables? */ -#define EFI_RUNTIME_SERVICES 3 /* Can we use runtime services? */ -#define EFI_MEMMAP 4 /* Can we use EFI memory map? */ -#define EFI_64BIT 5 /* Is the firmware 64-bit? */ - -#ifdef CONFIG_EFI -# ifdef CONFIG_X86 -static inline int compat_efi_enabled(int facility) -{ - switch (facility) { - case EFI_BOOT: - return efi_enabled; -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0)) - case EFI_64BIT: - return efi_64bit; -#endif - default: - printk(KERN_ERR "can not translate efi_enabled() to old values completly\n"); - return efi_enabled; - } -} -# else -static inline int compat_efi_enabled(int facility) -{ - return 1; -} -# endif -#else -static inline int compat_efi_enabled(int facility) -{ - return 0; -} -#endif -#ifdef efi_enabled -#undef efi_enabled -#endif -#define efi_enabled(facility) compat_efi_enabled(facility) -#endif /* EFI_BOOT */ - -/* This backports: - * - * commit 130f1b8f35f14d27c43da755f3c9226318c17f57 - * Author: Bjorn Helgaas - * Date: Wed Dec 26 10:39:23 2012 -0700 - * - * PCI: Add PCIe Link Capability link speed and width names - */ -#define PCI_EXP_LNKCAP_SLS_2_5GB 0x1 /* LNKCAP2 SLS Vector bit 0 (2.5GT/s) */ -#define PCI_EXP_LNKCAP_SLS_5_0GB 0x2 /* LNKCAP2 SLS Vector bit 1 (5.0GT/s) */ - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(3,8,0)) */ - -#endif /* LINUX_3_8_COMPAT_H */ diff --git a/backport/include/linux/compat-3.9.h b/backport/include/linux/compat-3.9.h deleted file mode 100644 index a939e0b9270e..000000000000 --- a/backport/include/linux/compat-3.9.h +++ /dev/null @@ -1,243 +0,0 @@ -#ifndef LINUX_3_9_COMPAT_H -#define LINUX_3_9_COMPAT_H - -#include - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,9,0)) - -#include -#include -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,25)) -#include -#endif -#include -#include -#include -#include -#include -#include -#include - -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0)) -int vb2_mmap_pfn_range(struct vm_area_struct *vma, unsigned long paddr, - unsigned long size, - const struct vm_operations_struct *vm_ops, - void *priv); -#endif - -/* module_platform_driver_probe() - Helper macro for drivers that don't do - * anything special in module init/exit. This eliminates a lot of - * boilerplate. Each module may only use this macro once, and - * calling it replaces module_init() and module_exit() - */ -#define module_platform_driver_probe(__platform_driver, __platform_probe) \ -static int __init __platform_driver##_init(void) \ -{ \ - return platform_driver_probe(&(__platform_driver), \ - __platform_probe); \ -} \ -module_init(__platform_driver##_init); \ -static void __exit __platform_driver##_exit(void) \ -{ \ - platform_driver_unregister(&(__platform_driver)); \ -} \ -module_exit(__platform_driver##_exit); - - -/* include this before changing hlist_for_each_* to use the old versions. */ -#include - -/* Lets expect distributions might backport this */ - -#ifndef for_each_sg_page -/* - * sg page iterator - * - * Iterates over sg entries page-by-page. On each successful iteration, - * @piter->page points to the current page, @piter->sg to the sg holding this - * page and @piter->sg_pgoffset to the page's page offset within the sg. The - * iteration will stop either when a maximum number of sg entries was reached - * or a terminating sg (sg_last(sg) == true) was reached. - */ -struct sg_page_iter { - struct page *page; /* current page */ - struct scatterlist *sg; /* sg holding the page */ - unsigned int sg_pgoffset; /* page offset within the sg */ - - /* these are internal states, keep away */ - unsigned int __nents; /* remaining sg entries */ - int __pg_advance; /* nr pages to advance at the - * next step */ -}; - -#define __sg_page_iter_next LINUX_BACKPORT(__sg_page_iter_next) -bool __sg_page_iter_next(struct sg_page_iter *piter); -#define __sg_page_iter_start LINUX_BACKPORT(__sg_page_iter_start) -void __sg_page_iter_start(struct sg_page_iter *piter, - struct scatterlist *sglist, unsigned int nents, - unsigned long pgoffset); - -/** - * for_each_sg_page - iterate over the pages of the given sg list - * @sglist: sglist to iterate over - * @piter: page iterator to hold current page, sg, sg_pgoffset - * @nents: maximum number of sg entries to iterate over - * @pgoffset: starting page offset - */ -#define for_each_sg_page(sglist, piter, nents, pgoffset) \ - for (__sg_page_iter_start((piter), (sglist), (nents), (pgoffset)); \ - __sg_page_iter_next(piter);) - -#endif /* for_each_sg_page assumption */ - -/* backports 7a555613 */ -#if defined(CONFIG_DYNAMIC_DEBUG) -#define dynamic_hex_dump(prefix_str, prefix_type, rowsize, \ - groupsize, buf, len, ascii) \ -do { \ - DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, \ - __builtin_constant_p(prefix_str) ? prefix_str : "hexdump");\ - if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT)) \ - print_hex_dump(KERN_DEBUG, prefix_str, \ - prefix_type, rowsize, groupsize, \ - buf, len, ascii); \ -} while (0) -#define print_hex_dump_debug(prefix_str, prefix_type, rowsize, \ - groupsize, buf, len, ascii) \ - dynamic_hex_dump(prefix_str, prefix_type, rowsize, \ - groupsize, buf, len, ascii) -#else -#define print_hex_dump_debug(prefix_str, prefix_type, rowsize, \ - groupsize, buf, len, ascii) \ - print_hex_dump(KERN_DEBUG, prefix_str, prefix_type, rowsize, \ - groupsize, buf, len, ascii) -#endif /* defined(CONFIG_DYNAMIC_DEBUG) */ - - -/** - * backport of idr idr_alloc() usage - * - * This backports a patch series send by Tejun Heo: - * https://lkml.org/lkml/2013/2/2/159 - */ -static inline void compat_idr_destroy(struct idr *idp) -{ - idr_remove_all(idp); - idr_destroy(idp); -} -#define idr_destroy(idp) compat_idr_destroy(idp) - -static inline int idr_alloc(struct idr *idr, void *ptr, int start, int end, - gfp_t gfp_mask) -{ - int id, ret; - - do { - if (!idr_pre_get(idr, gfp_mask)) - return -ENOMEM; - ret = idr_get_new_above(idr, ptr, start, &id); - if (!ret && id > end) { - idr_remove(idr, id); - ret = -ENOSPC; - } - } while (ret == -EAGAIN); - - return ret ? ret : id; -} - -static inline void idr_preload(gfp_t gfp_mask) -{ -} - -static inline void idr_preload_end(void) -{ -} - - -/** - * backport: - * - * commit 0bbacca7c3911451cea923b0ad6389d58e3d9ce9 - * Author: Sasha Levin - * Date: Thu Feb 7 12:32:18 2013 +1100 - * - * hlist: drop the node parameter from iterators - */ - -#define hlist_entry_safe(ptr, type, member) \ - (ptr) ? hlist_entry(ptr, type, member) : NULL - -#undef hlist_for_each_entry -/** - * hlist_for_each_entry - iterate over list of given type - * @pos: the type * to use as a loop cursor. - * @head: the head for your list. - * @member: the name of the hlist_node within the struct. - */ -#define hlist_for_each_entry(pos, head, member) \ - for (pos = hlist_entry_safe((head)->first, typeof(*(pos)), member); \ - pos; \ - pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member)) - -#undef hlist_for_each_entry_safe -/** - * hlist_for_each_entry_safe - iterate over list of given type safe against removal of list entry - * @pos: the type * to use as a loop cursor. - * @n: another &struct hlist_node to use as temporary storage - * @head: the head for your list. - * @member: the name of the hlist_node within the struct. - */ -#define hlist_for_each_entry_safe(pos, n, head, member) \ - for (pos = hlist_entry_safe((head)->first, typeof(*pos), member); \ - pos && ({ n = pos->member.next; 1; }); \ - pos = hlist_entry_safe(n, typeof(*pos), member)) - -#undef hlist_for_each_entry_rcu -/** - * hlist_for_each_entry_rcu - iterate over rcu list of given type - * @pos: the type * to use as a loop cursor. - * @head: the head for your list. - * @member: the name of the hlist_node within the struct. - * - * This list-traversal primitive may safely run concurrently with - * the _rcu list-mutation primitives such as hlist_add_head_rcu() - * as long as the traversal is guarded by rcu_read_lock(). - */ -#define hlist_for_each_entry_rcu(pos, head, member) \ - for (pos = hlist_entry_safe (rcu_dereference_raw(hlist_first_rcu(head)),\ - typeof(*(pos)), member); \ - pos; \ - pos = hlist_entry_safe(rcu_dereference_raw(hlist_next_rcu( \ - &(pos)->member)), typeof(*(pos)), member)) - -#undef sk_for_each -#define sk_for_each(__sk, list) \ - hlist_for_each_entry(__sk, list, sk_node) - -#undef sk_for_each_safe -#define sk_for_each_safe(__sk, tmp, list) \ - hlist_for_each_entry_safe(__sk, tmp, list, sk_node) - -#define tty_flip_buffer_push(port) tty_flip_buffer_push((port)->tty) -#define tty_insert_flip_string(port, chars, size) tty_insert_flip_string((port)->tty, chars, size) - -/** - * backport of: - * - * commit 496ad9aa8ef448058e36ca7a787c61f2e63f0f54 - * Author: Al Viro - * Date: Wed Jan 23 17:07:38 2013 -0500 - * - * new helper: file_inode(file) - */ -static inline struct inode *file_inode(struct file *f) -{ - return f->f_path.dentry->d_inode; -} - -#define devm_ioremap_resource LINUX_BACKPORT(devm_ioremap_resource) -void __iomem *devm_ioremap_resource(struct device *dev, struct resource *res); - -#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(3,9,0)) */ - -#endif /* LINUX_3_9_COMPAT_H */ diff --git a/backport/include/linux/cordic.h b/backport/include/linux/cordic.h deleted file mode 100644 index 7f27b007e650..000000000000 --- a/backport/include/linux/cordic.h +++ /dev/null @@ -1,60 +0,0 @@ -#ifndef _BACKPORT_LINUX_CORDIC_H -#define _BACKPORT_LINUX_CORDIC_H 1 - -#include - -#if (LINUX_VERSION_CODE > KERNEL_VERSION(3,1,0)) -#include_next -#else - -/* - * Copyright (c) 2011 Broadcom Corporation - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY - * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION - * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN - * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ -#ifndef __CORDIC_H_ -#define __CORDIC_H_ - -#include - -/** - * struct cordic_iq - i/q coordinate. - * - * @i: real part of coordinate (in phase). - * @q: imaginary part of coordinate (quadrature). - */ -struct cordic_iq { - s32 i; - s32 q; -}; - -/** - * cordic_calc_iq() - calculates the i/q coordinate for given angle. - * - * @theta: angle in degrees for which i/q coordinate is to be calculated. - * @coord: function output parameter holding the i/q coordinate. - * - * The function calculates the i/q coordinate for a given angle using - * cordic algorithm. The coordinate consists of a real (i) and an - * imaginary (q) part. The real part is essentially the cosine of the - * angle and the imaginary part is the sine of the angle. The returned - * values are scaled by 2^16 for precision. The range for theta is - * for -180 degrees to +180 degrees. Passed values outside this range are - * converted before doing the actual calculation. - */ -#define cordic_calc_iq LINUX_BACKPORT(cordic_calc_iq) -struct cordic_iq cordic_calc_iq(s32 theta); - -#endif /* __CORDIC_H_ */ -#endif /* LINUX_VERSION_CODE > KERNEL_VERSION(3,1,0)) */ -#endif /* _BACKPORT_LINUX_CORDIC_H */ diff --git a/backport/include/linux/crc8.h b/backport/include/linux/crc8.h deleted file mode 100644 index 611ba0d43de0..000000000000 --- a/backport/include/linux/crc8.h +++ /dev/null @@ -1,109 +0,0 @@ -/* - * Copyright (c) 2011 Broadcom Corporation - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY - * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION - * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN - * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ -#ifndef CPTCFG_BACKPORT_BUILD_CRC8_MODULE -#include_next -#else - -#ifndef __CRC8_H_ -#define __CRC8_H_ - -#include - -/* see usage of this value in crc8() description */ -#define CRC8_INIT_VALUE 0xFF - -/* - * Return value of crc8() indicating valid message+crc. This is true - * if a CRC is inverted before transmission. The CRC computed over the - * whole received bitstream is _table[x], where x is the bit pattern - * of the modification (almost always 0xff). - */ -#define CRC8_GOOD_VALUE(_table) (_table[0xFF]) - -/* required table size for crc8 algorithm */ -#define CRC8_TABLE_SIZE 256 - -/* helper macro assuring right table size is used */ -#define DECLARE_CRC8_TABLE(_table) \ - static u8 _table[CRC8_TABLE_SIZE] - -/** - * crc8_populate_lsb - fill crc table for given polynomial in regular bit order. - * - * @table: table to be filled. - * @polynomial: polynomial for which table is to be filled. - * - * This function fills the provided table according the polynomial provided for - * regular bit order (lsb first). Polynomials in CRC algorithms are typically - * represented as shown below. - * - * poly = x^8 + x^7 + x^6 + x^4 + x^2 + 1 - * - * For lsb first direction x^7 maps to the lsb. So the polynomial is as below. - * - * - lsb first: poly = 10101011(1) = 0xAB - */ -#define crc8_populate_lsb LINUX_BACKPORT(crc8_populate_lsb) -void crc8_populate_lsb(u8 table[CRC8_TABLE_SIZE], u8 polynomial); - -/** - * crc8_populate_msb - fill crc table for given polynomial in reverse bit order. - * - * @table: table to be filled. - * @polynomial: polynomial for which table is to be filled. - * - * This function fills the provided table according the polynomial provided for - * reverse bit order (msb first). Polynomials in CRC algorithms are typically - * represented as shown below. - * - * poly = x^8 + x^7 + x^6 + x^4 + x^2 + 1 - * - * For msb first direction x^7 maps to the msb. So the polynomial is as below. - * - * - msb first: poly = (1)11010101 = 0xD5 - */ -#define crc8_populate_msb LINUX_BACKPORT(crc8_populate_msb) -void crc8_populate_msb(u8 table[CRC8_TABLE_SIZE], u8 polynomial); - -/** - * crc8() - calculate a crc8 over the given input data. - * - * @table: crc table used for calculation. - * @pdata: pointer to data buffer. - * @nbytes: number of bytes in data buffer. - * @crc: previous returned crc8 value. - * - * The CRC8 is calculated using the polynomial given in crc8_populate_msb() - * or crc8_populate_lsb(). - * - * The caller provides the initial value (either %CRC8_INIT_VALUE - * or the previous returned value) to allow for processing of - * discontiguous blocks of data. When generating the CRC the - * caller is responsible for complementing the final return value - * and inserting it into the byte stream. When validating a byte - * stream (including CRC8), a final return value of %CRC8_GOOD_VALUE - * indicates the byte stream data can be considered valid. - * - * Reference: - * "A Painless Guide to CRC Error Detection Algorithms", ver 3, Aug 1993 - * Williams, Ross N., rossross.net - * (see URL http://www.ross.net/crc/download/crc_v3.txt). - */ -#define crc8 LINUX_BACKPORT(crc8) -u8 crc8(const u8 table[CRC8_TABLE_SIZE], u8 *pdata, size_t nbytes, u8 crc); - -#endif /* __CRC8_H_ */ -#endif /* BACKPORT_BUILD_CRC8_MODULE */ diff --git a/backport/include/linux/export.h b/backport/include/linux/export.h deleted file mode 100644 index f7842b7a582d..000000000000 --- a/backport/include/linux/export.h +++ /dev/null @@ -1,12 +0,0 @@ -#ifndef _COMPAT_LINUX_EXPORT_H -#define _COMPAT_LINUX_EXPORT_H 1 - -#include - -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0)) -#include_next -#else -#include -#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0)) */ - -#endif /* _COMPAT_LINUX_EXPORT_H */ diff --git a/backport/include/linux/gpio.h b/backport/include/linux/gpio.h deleted file mode 100644 index d31e14ee00ba..000000000000 --- a/backport/include/linux/gpio.h +++ /dev/null @@ -1,10 +0,0 @@ -#ifndef _COMPAT_LINUX_GPIO_H -#define _COMPAT_LINUX_GPIO_H 1 - -#include - -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)) -#include_next -#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)) */ - -#endif /* _COMPAT_LINUX_GPIO_H */ diff --git a/backport/include/linux/kfifo.h b/backport/include/linux/kfifo.h deleted file mode 100644 index 398b00d0196c..000000000000 --- a/backport/include/linux/kfifo.h +++ /dev/null @@ -1,877 +0,0 @@ -#include -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36)) -#include_next -#else -/* - * A generic kernel FIFO implementation - * - * Copyright (C) 2009/2010 Stefani Seibold - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - * - */ - -#ifndef _LINUX_KFIFO_H -#define _LINUX_KFIFO_H - -/* - * How to porting drivers to the new generic FIFO API: - * - * - Modify the declaration of the "struct kfifo *" object into a - * in-place "struct kfifo" object - * - Init the in-place object with kfifo_alloc() or kfifo_init() - * Note: The address of the in-place "struct kfifo" object must be - * passed as the first argument to this functions - * - Replace the use of __kfifo_put into kfifo_in and __kfifo_get - * into kfifo_out - * - Replace the use of kfifo_put into kfifo_in_spinlocked and kfifo_get - * into kfifo_out_spinlocked - * Note: the spinlock pointer formerly passed to kfifo_init/kfifo_alloc - * must be passed now to the kfifo_in_spinlocked and kfifo_out_spinlocked - * as the last parameter - * - The formerly __kfifo_* functions are renamed into kfifo_* - */ - -/* - * Note about locking : There is no locking required until only * one reader - * and one writer is using the fifo and no kfifo_reset() will be * called - * kfifo_reset_out() can be safely used, until it will be only called - * in the reader thread. - * For multiple writer and one reader there is only a need to lock the writer. - * And vice versa for only one writer and multiple reader there is only a need - * to lock the reader. - */ - -#include -#include -#include -#include - -struct __kfifo { - unsigned int in; - unsigned int out; - unsigned int mask; - unsigned int esize; - void *data; -}; - -#define __STRUCT_KFIFO_COMMON(datatype, recsize, ptrtype) \ - union { \ - struct __kfifo kfifo; \ - datatype *type; \ - char (*rectype)[recsize]; \ - ptrtype *ptr; \ - const ptrtype *ptr_const; \ - } - -#define __STRUCT_KFIFO(type, size, recsize, ptrtype) \ -{ \ - __STRUCT_KFIFO_COMMON(type, recsize, ptrtype); \ - type buf[((size < 2) || (size & (size - 1))) ? -1 : size]; \ -} - -#define STRUCT_KFIFO(type, size) \ - struct __STRUCT_KFIFO(type, size, 0, type) - -#define __STRUCT_KFIFO_PTR(type, recsize, ptrtype) \ -{ \ - __STRUCT_KFIFO_COMMON(type, recsize, ptrtype); \ - type buf[0]; \ -} - -#define STRUCT_KFIFO_PTR(type) \ - struct __STRUCT_KFIFO_PTR(type, 0, type) - -/* - * define compatibility "struct kfifo" for dynamic allocated fifos - */ -struct kfifo __STRUCT_KFIFO_PTR(unsigned char, 0, void); - -#define STRUCT_KFIFO_REC_1(size) \ - struct __STRUCT_KFIFO(unsigned char, size, 1, void) - -#define STRUCT_KFIFO_REC_2(size) \ - struct __STRUCT_KFIFO(unsigned char, size, 2, void) - -/* - * define kfifo_rec types - */ -struct kfifo_rec_ptr_1 __STRUCT_KFIFO_PTR(unsigned char, 1, void); -struct kfifo_rec_ptr_2 __STRUCT_KFIFO_PTR(unsigned char, 2, void); - -/* - * helper macro to distinguish between real in place fifo where the fifo - * array is a part of the structure and the fifo type where the array is - * outside of the fifo structure. - */ -#define __is_kfifo_ptr(fifo) (sizeof(*fifo) == sizeof(struct __kfifo)) - -/** - * DECLARE_KFIFO_PTR - macro to declare a fifo pointer object - * @fifo: name of the declared fifo - * @type: type of the fifo elements - */ -#define DECLARE_KFIFO_PTR(fifo, type) STRUCT_KFIFO_PTR(type) fifo - -/** - * DECLARE_KFIFO - macro to declare a fifo object - * @fifo: name of the declared fifo - * @type: type of the fifo elements - * @size: the number of elements in the fifo, this must be a power of 2 - */ -#define DECLARE_KFIFO(fifo, type, size) STRUCT_KFIFO(type, size) fifo - -/** - * INIT_KFIFO - Initialize a fifo declared by DECLARE_KFIFO - * @fifo: name of the declared fifo datatype - */ -#define INIT_KFIFO(fifo) \ -(void)({ \ - typeof(&(fifo)) __tmp = &(fifo); \ - struct __kfifo *__kfifo = &__tmp->kfifo; \ - __kfifo->in = 0; \ - __kfifo->out = 0; \ - __kfifo->mask = __is_kfifo_ptr(__tmp) ? 0 : ARRAY_SIZE(__tmp->buf) - 1;\ - __kfifo->esize = sizeof(*__tmp->buf); \ - __kfifo->data = __is_kfifo_ptr(__tmp) ? NULL : __tmp->buf; \ -}) - -/** - * DEFINE_KFIFO - macro to define and initialize a fifo - * @fifo: name of the declared fifo datatype - * @type: type of the fifo elements - * @size: the number of elements in the fifo, this must be a power of 2 - * - * Note: the macro can be used for global and local fifo data type variables. - */ -#define DEFINE_KFIFO(fifo, type, size) \ - DECLARE_KFIFO(fifo, type, size) = \ - (typeof(fifo)) { \ - { \ - { \ - .in = 0, \ - .out = 0, \ - .mask = __is_kfifo_ptr(&(fifo)) ? \ - 0 : \ - ARRAY_SIZE((fifo).buf) - 1, \ - .esize = sizeof(*(fifo).buf), \ - .data = __is_kfifo_ptr(&(fifo)) ? \ - NULL : \ - (fifo).buf, \ - } \ - } \ - } - - -static inline unsigned int __must_check -__kfifo_uint_must_check_helper(unsigned int val) -{ - return val; -} - -static inline int __must_check -__kfifo_int_must_check_helper(int val) -{ - return val; -} - -#define __kfifo_alloc LINUX_BACKPORT(__kfifo_alloc) -extern int __kfifo_alloc(struct __kfifo *fifo, unsigned int size, - size_t esize, gfp_t gfp_mask); -#define __kfifo_free LINUX_BACKPORT(__kfifo_free) -extern void __kfifo_free(struct __kfifo *fifo); - -#define __kfifo_init LINUX_BACKPORT(__kfifo_init) -extern int __kfifo_init(struct __kfifo *fifo, void *buffer, - unsigned int size, size_t esize); - -#define __kfifo_in LINUX_BACKPORT(__kfifo_in) -extern unsigned int __kfifo_in(struct __kfifo *fifo, - const void *buf, unsigned int len); - -#define __kfifo_out LINUX_BACKPORT(__kfifo_out) -extern unsigned int __kfifo_out(struct __kfifo *fifo, - void *buf, unsigned int len); - -#define __kfifo_from_user LINUX_BACKPORT(__kfifo_from_user) -extern int __kfifo_from_user(struct __kfifo *fifo, - const void __user *from, unsigned long len, unsigned int *copied); - -#define __kfifo_to_user LINUX_BACKPORT(__kfifo_to_user) -extern int __kfifo_to_user(struct __kfifo *fifo, - void __user *to, unsigned long len, unsigned int *copied); - -#define __kfifo_dma_in_prepare LINUX_BACKPORT(__kfifo_dma_in_prepare) -extern unsigned int __kfifo_dma_in_prepare(struct __kfifo *fifo, - struct scatterlist *sgl, int nents, unsigned int len); - -#define __kfifo_dma_out_prepare LINUX_BACKPORT(__kfifo_dma_out_prepare) -extern unsigned int __kfifo_dma_out_prepare(struct __kfifo *fifo, - struct scatterlist *sgl, int nents, unsigned int len); - -#define __kfifo_out_peek LINUX_BACKPORT(__kfifo_out_peek) -extern unsigned int __kfifo_out_peek(struct __kfifo *fifo, - void *buf, unsigned int len); - -#define __kfifo_in_r LINUX_BACKPORT(__kfifo_in_r) -extern unsigned int __kfifo_in_r(struct __kfifo *fifo, - const void *buf, unsigned int len, size_t recsize); - -#define __kfifo_out_r LINUX_BACKPORT(__kfifo_out_r) -extern unsigned int __kfifo_out_r(struct __kfifo *fifo, - void *buf, unsigned int len, size_t recsize); - -#define __kfifo_from_user_r LINUX_BACKPORT(__kfifo_from_user_r) -extern int __kfifo_from_user_r(struct __kfifo *fifo, - const void __user *from, unsigned long len, unsigned int *copied, - size_t recsize); - -#define __kfifo_to_user_r LINUX_BACKPORT(__kfifo_to_user_r) -extern int __kfifo_to_user_r(struct __kfifo *fifo, void __user *to, - unsigned long len, unsigned int *copied, size_t recsize); - -#define __kfifo_dma_in_prepare_r LINUX_BACKPORT(__kfifo_dma_in_prepare_r) -extern unsigned int __kfifo_dma_in_prepare_r(struct __kfifo *fifo, - struct scatterlist *sgl, int nents, unsigned int len, size_t recsize); - -#define __kfifo_dma_in_finish_r LINUX_BACKPORT(__kfifo_dma_in_finish_r) -extern void __kfifo_dma_in_finish_r(struct __kfifo *fifo, - unsigned int len, size_t recsize); - -#define __kfifo_dma_out_prepare_r LINUX_BACKPORT(__kfifo_dma_out_prepare_r) -extern unsigned int __kfifo_dma_out_prepare_r(struct __kfifo *fifo, - struct scatterlist *sgl, int nents, unsigned int len, size_t recsize); - -#define __kfifo_dma_out_finish_r LINUX_BACKPORT(__kfifo_dma_out_finish_r) -extern void __kfifo_dma_out_finish_r(struct __kfifo *fifo, size_t recsize); - -#define __kfifo_len_r LINUX_BACKPORT(__kfifo_len_r) -extern unsigned int __kfifo_len_r(struct __kfifo *fifo, size_t recsize); - -#define __kfifo_skip_r LINUX_BACKPORT(__kfifo_skip_r) -extern void __kfifo_skip_r(struct __kfifo *fifo, size_t recsize); - -#define __kfifo_out_peek_r LINUX_BACKPORT(__kfifo_out_peek_r) -extern unsigned int __kfifo_out_peek_r(struct __kfifo *fifo, - void *buf, unsigned int len, size_t recsize); - -#define __kfifo_max_r LINUX_BACKPORT(__kfifo_max_r) -extern unsigned int __kfifo_max_r(unsigned int len, size_t recsize); - -/** - * kfifo_initialized - Check if the fifo is initialized - * @fifo: address of the fifo to check - * - * Return %true if fifo is initialized, otherwise %false. - * Assumes the fifo was 0 before. - */ -#define kfifo_initialized(fifo) ((fifo)->kfifo.mask) - -/** - * kfifo_esize - returns the size of the element managed by the fifo - * @fifo: address of the fifo to be used - */ -#define kfifo_esize(fifo) ((fifo)->kfifo.esize) - -/** - * kfifo_recsize - returns the size of the record length field - * @fifo: address of the fifo to be used - */ -#define kfifo_recsize(fifo) (sizeof(*(fifo)->rectype)) - -/** - * kfifo_size - returns the size of the fifo in elements - * @fifo: address of the fifo to be used - */ -#define kfifo_size(fifo) ((fifo)->kfifo.mask + 1) - -/** - * kfifo_reset - removes the entire fifo content - * @fifo: address of the fifo to be used - * - * Note: usage of kfifo_reset() is dangerous. It should be only called when the - * fifo is exclusived locked or when it is secured that no other thread is - * accessing the fifo. - */ -#define kfifo_reset(fifo) \ -(void)({ \ - typeof((fifo) + 1) __tmp = (fifo); \ - __tmp->kfifo.in = __tmp->kfifo.out = 0; \ -}) - -/** - * kfifo_reset_out - skip fifo content - * @fifo: address of the fifo to be used - * - * Note: The usage of kfifo_reset_out() is safe until it will be only called - * from the reader thread and there is only one concurrent reader. Otherwise - * it is dangerous and must be handled in the same way as kfifo_reset(). - */ -#define kfifo_reset_out(fifo) \ -(void)({ \ - typeof((fifo) + 1) __tmp = (fifo); \ - __tmp->kfifo.out = __tmp->kfifo.in; \ -}) - -/** - * kfifo_len - returns the number of used elements in the fifo - * @fifo: address of the fifo to be used - */ -#define kfifo_len(fifo) \ -({ \ - typeof((fifo) + 1) __tmpl = (fifo); \ - __tmpl->kfifo.in - __tmpl->kfifo.out; \ -}) - -/** - * kfifo_is_empty - returns true if the fifo is empty - * @fifo: address of the fifo to be used - */ -#define kfifo_is_empty(fifo) \ -({ \ - typeof((fifo) + 1) __tmpq = (fifo); \ - __tmpq->kfifo.in == __tmpq->kfifo.out; \ -}) - -/** - * kfifo_is_full - returns true if the fifo is full - * @fifo: address of the fifo to be used - */ -#define kfifo_is_full(fifo) \ -({ \ - typeof((fifo) + 1) __tmpq = (fifo); \ - kfifo_len(__tmpq) > __tmpq->kfifo.mask; \ -}) - -/** - * kfifo_avail - returns the number of unused elements in the fifo - * @fifo: address of the fifo to be used - */ -#define kfifo_avail(fifo) \ -__kfifo_uint_must_check_helper( \ -({ \ - typeof((fifo) + 1) __tmpq = (fifo); \ - const size_t __recsize = sizeof(*__tmpq->rectype); \ - unsigned int __avail = kfifo_size(__tmpq) - kfifo_len(__tmpq); \ - (__recsize) ? ((__avail <= __recsize) ? 0 : \ - __kfifo_max_r(__avail - __recsize, __recsize)) : \ - __avail; \ -}) \ -) - -/** - * kfifo_skip - skip output data - * @fifo: address of the fifo to be used - */ -#define kfifo_skip(fifo) \ -(void)({ \ - typeof((fifo) + 1) __tmp = (fifo); \ - const size_t __recsize = sizeof(*__tmp->rectype); \ - struct __kfifo *__kfifo = &__tmp->kfifo; \ - if (__recsize) \ - __kfifo_skip_r(__kfifo, __recsize); \ - else \ - __kfifo->out++; \ -}) - -/** - * kfifo_peek_len - gets the size of the next fifo record - * @fifo: address of the fifo to be used - * - * This function returns the size of the next fifo record in number of bytes. - */ -#define kfifo_peek_len(fifo) \ -__kfifo_uint_must_check_helper( \ -({ \ - typeof((fifo) + 1) __tmp = (fifo); \ - const size_t __recsize = sizeof(*__tmp->rectype); \ - struct __kfifo *__kfifo = &__tmp->kfifo; \ - (!__recsize) ? kfifo_len(__tmp) * sizeof(*__tmp->type) : \ - __kfifo_len_r(__kfifo, __recsize); \ -}) \ -) - -/** - * kfifo_alloc - dynamically allocates a new fifo buffer - * @fifo: pointer to the fifo - * @size: the number of elements in the fifo, this must be a power of 2 - * @gfp_mask: get_free_pages mask, passed to kmalloc() - * - * This macro dynamically allocates a new fifo buffer. - * - * The numer of elements will be rounded-up to a power of 2. - * The fifo will be release with kfifo_free(). - * Return 0 if no error, otherwise an error code. - */ -#define kfifo_alloc(fifo, size, gfp_mask) \ -__kfifo_int_must_check_helper( \ -({ \ - typeof((fifo) + 1) __tmp = (fifo); \ - struct __kfifo *__kfifo = &__tmp->kfifo; \ - __is_kfifo_ptr(__tmp) ? \ - __kfifo_alloc(__kfifo, size, sizeof(*__tmp->type), gfp_mask) : \ - -EINVAL; \ -}) \ -) - -/** - * kfifo_free - frees the fifo - * @fifo: the fifo to be freed - */ -#define kfifo_free(fifo) \ -({ \ - typeof((fifo) + 1) __tmp = (fifo); \ - struct __kfifo *__kfifo = &__tmp->kfifo; \ - if (__is_kfifo_ptr(__tmp)) \ - __kfifo_free(__kfifo); \ -}) - -/** - * kfifo_init - initialize a fifo using a preallocated buffer - * @fifo: the fifo to assign the buffer - * @buffer: the preallocated buffer to be used - * @size: the size of the internal buffer, this have to be a power of 2 - * - * This macro initialize a fifo using a preallocated buffer. - * - * The numer of elements will be rounded-up to a power of 2. - * Return 0 if no error, otherwise an error code. - */ -#define kfifo_init(fifo, buffer, size) \ -({ \ - typeof((fifo) + 1) __tmp = (fifo); \ - struct __kfifo *__kfifo = &__tmp->kfifo; \ - __is_kfifo_ptr(__tmp) ? \ - __kfifo_init(__kfifo, buffer, size, sizeof(*__tmp->type)) : \ - -EINVAL; \ -}) - -/** - * kfifo_put - put data into the fifo - * @fifo: address of the fifo to be used - * @val: the data to be added - * - * This macro copies the given value into the fifo. - * It returns 0 if the fifo was full. Otherwise it returns the number - * processed elements. - * - * Note that with only one concurrent reader and one concurrent - * writer, you don't need extra locking to use these macro. - */ -#define kfifo_put(fifo, val) \ -({ \ - typeof((fifo) + 1) __tmp = (fifo); \ - typeof((val) + 1) __val = (val); \ - unsigned int __ret; \ - const size_t __recsize = sizeof(*__tmp->rectype); \ - struct __kfifo *__kfifo = &__tmp->kfifo; \ - if (0) { \ - typeof(__tmp->ptr_const) __dummy __attribute__ ((unused)); \ - __dummy = (typeof(__val))NULL; \ - } \ - if (__recsize) \ - __ret = __kfifo_in_r(__kfifo, __val, sizeof(*__val), \ - __recsize); \ - else { \ - __ret = !kfifo_is_full(__tmp); \ - if (__ret) { \ - (__is_kfifo_ptr(__tmp) ? \ - ((typeof(__tmp->type))__kfifo->data) : \ - (__tmp->buf) \ - )[__kfifo->in & __tmp->kfifo.mask] = \ - *(typeof(__tmp->type))__val; \ - smp_wmb(); \ - __kfifo->in++; \ - } \ - } \ - __ret; \ -}) - -/** - * kfifo_get - get data from the fifo - * @fifo: address of the fifo to be used - * @val: the var where to store the data to be added - * - * This macro reads the data from the fifo. - * It returns 0 if the fifo was empty. Otherwise it returns the number - * processed elements. - * - * Note that with only one concurrent reader and one concurrent - * writer, you don't need extra locking to use these macro. - */ -#define kfifo_get(fifo, val) \ -__kfifo_uint_must_check_helper( \ -({ \ - typeof((fifo) + 1) __tmp = (fifo); \ - typeof((val) + 1) __val = (val); \ - unsigned int __ret; \ - const size_t __recsize = sizeof(*__tmp->rectype); \ - struct __kfifo *__kfifo = &__tmp->kfifo; \ - if (0) \ - __val = (typeof(__tmp->ptr))0; \ - if (__recsize) \ - __ret = __kfifo_out_r(__kfifo, __val, sizeof(*__val), \ - __recsize); \ - else { \ - __ret = !kfifo_is_empty(__tmp); \ - if (__ret) { \ - *(typeof(__tmp->type))__val = \ - (__is_kfifo_ptr(__tmp) ? \ - ((typeof(__tmp->type))__kfifo->data) : \ - (__tmp->buf) \ - )[__kfifo->out & __tmp->kfifo.mask]; \ - smp_wmb(); \ - __kfifo->out++; \ - } \ - } \ - __ret; \ -}) \ -) - -/** - * kfifo_peek - get data from the fifo without removing - * @fifo: address of the fifo to be used - * @val: the var where to store the data to be added - * - * This reads the data from the fifo without removing it from the fifo. - * It returns 0 if the fifo was empty. Otherwise it returns the number - * processed elements. - * - * Note that with only one concurrent reader and one concurrent - * writer, you don't need extra locking to use these macro. - */ -#define kfifo_peek(fifo, val) \ -__kfifo_uint_must_check_helper( \ -({ \ - typeof((fifo) + 1) __tmp = (fifo); \ - typeof((val) + 1) __val = (val); \ - unsigned int __ret; \ - const size_t __recsize = sizeof(*__tmp->rectype); \ - struct __kfifo *__kfifo = &__tmp->kfifo; \ - if (0) \ - __val = (typeof(__tmp->ptr))NULL; \ - if (__recsize) \ - __ret = __kfifo_out_peek_r(__kfifo, __val, sizeof(*__val), \ - __recsize); \ - else { \ - __ret = !kfifo_is_empty(__tmp); \ - if (__ret) { \ - *(typeof(__tmp->type))__val = \ - (__is_kfifo_ptr(__tmp) ? \ - ((typeof(__tmp->type))__kfifo->data) : \ - (__tmp->buf) \ - )[__kfifo->out & __tmp->kfifo.mask]; \ - smp_wmb(); \ - } \ - } \ - __ret; \ -}) \ -) - -/** - * kfifo_in - put data into the fifo - * @fifo: address of the fifo to be used - * @buf: the data to be added - * @n: number of elements to be added - * - * This macro copies the given buffer into the fifo and returns the - * number of copied elements. - * - * Note that with only one concurrent reader and one concurrent - * writer, you don't need extra locking to use these macro. - */ -#define kfifo_in(fifo, buf, n) \ -({ \ - typeof((fifo) + 1) __tmp = (fifo); \ - typeof((buf) + 1) __buf = (buf); \ - unsigned long __n = (n); \ - const size_t __recsize = sizeof(*__tmp->rectype); \ - struct __kfifo *__kfifo = &__tmp->kfifo; \ - if (0) { \ - typeof(__tmp->ptr_const) __dummy __attribute__ ((unused)); \ - __dummy = (typeof(__buf))NULL; \ - } \ - (__recsize) ?\ - __kfifo_in_r(__kfifo, __buf, __n, __recsize) : \ - __kfifo_in(__kfifo, __buf, __n); \ -}) - -/** - * kfifo_in_spinlocked - put data into the fifo using a spinlock for locking - * @fifo: address of the fifo to be used - * @buf: the data to be added - * @n: number of elements to be added - * @lock: pointer to the spinlock to use for locking - * - * This macro copies the given values buffer into the fifo and returns the - * number of copied elements. - */ -#define kfifo_in_spinlocked(fifo, buf, n, lock) \ -({ \ - unsigned long __flags; \ - unsigned int __ret; \ - spin_lock_irqsave(lock, __flags); \ - __ret = kfifo_in(fifo, buf, n); \ - spin_unlock_irqrestore(lock, __flags); \ - __ret; \ -}) - -/* alias for kfifo_in_spinlocked, will be removed in a future release */ -#define kfifo_in_locked(fifo, buf, n, lock) \ - kfifo_in_spinlocked(fifo, buf, n, lock) - -/** - * kfifo_out - get data from the fifo - * @fifo: address of the fifo to be used - * @buf: pointer to the storage buffer - * @n: max. number of elements to get - * - * This macro get some data from the fifo and return the numbers of elements - * copied. - * - * Note that with only one concurrent reader and one concurrent - * writer, you don't need extra locking to use these macro. - */ -#define kfifo_out(fifo, buf, n) \ -__kfifo_uint_must_check_helper( \ -({ \ - typeof((fifo) + 1) __tmp = (fifo); \ - typeof((buf) + 1) __buf = (buf); \ - unsigned long __n = (n); \ - const size_t __recsize = sizeof(*__tmp->rectype); \ - struct __kfifo *__kfifo = &__tmp->kfifo; \ - if (0) { \ - typeof(__tmp->ptr) __dummy = NULL; \ - __buf = __dummy; \ - } \ - (__recsize) ?\ - __kfifo_out_r(__kfifo, __buf, __n, __recsize) : \ - __kfifo_out(__kfifo, __buf, __n); \ -}) \ -) - -/** - * kfifo_out_spinlocked - get data from the fifo using a spinlock for locking - * @fifo: address of the fifo to be used - * @buf: pointer to the storage buffer - * @n: max. number of elements to get - * @lock: pointer to the spinlock to use for locking - * - * This macro get the data from the fifo and return the numbers of elements - * copied. - */ -#define kfifo_out_spinlocked(fifo, buf, n, lock) \ -__kfifo_uint_must_check_helper( \ -({ \ - unsigned long __flags; \ - unsigned int __ret; \ - spin_lock_irqsave(lock, __flags); \ - __ret = kfifo_out(fifo, buf, n); \ - spin_unlock_irqrestore(lock, __flags); \ - __ret; \ -}) \ -) - -/* alias for kfifo_out_spinlocked, will be removed in a future release */ -#define kfifo_out_locked(fifo, buf, n, lock) \ - kfifo_out_spinlocked(fifo, buf, n, lock) - -/** - * kfifo_from_user - puts some data from user space into the fifo - * @fifo: address of the fifo to be used - * @from: pointer to the data to be added - * @len: the length of the data to be added - * @copied: pointer to output variable to store the number of copied bytes - * - * This macro copies at most @len bytes from the @from into the - * fifo, depending of the available space and returns -EFAULT/0. - * - * Note that with only one concurrent reader and one concurrent - * writer, you don't need extra locking to use these macro. - */ -#define kfifo_from_user(fifo, from, len, copied) \ -__kfifo_uint_must_check_helper( \ -({ \ - typeof((fifo) + 1) __tmp = (fifo); \ - const void __user *__from = (from); \ - unsigned int __len = (len); \ - unsigned int *__copied = (copied); \ - const size_t __recsize = sizeof(*__tmp->rectype); \ - struct __kfifo *__kfifo = &__tmp->kfifo; \ - (__recsize) ? \ - __kfifo_from_user_r(__kfifo, __from, __len, __copied, __recsize) : \ - __kfifo_from_user(__kfifo, __from, __len, __copied); \ -}) \ -) - -/** - * kfifo_to_user - copies data from the fifo into user space - * @fifo: address of the fifo to be used - * @to: where the data must be copied - * @len: the size of the destination buffer - * @copied: pointer to output variable to store the number of copied bytes - * - * This macro copies at most @len bytes from the fifo into the - * @to buffer and returns -EFAULT/0. - * - * Note that with only one concurrent reader and one concurrent - * writer, you don't need extra locking to use these macro. - */ -#define kfifo_to_user(fifo, to, len, copied) \ -__kfifo_uint_must_check_helper( \ -({ \ - typeof((fifo) + 1) __tmp = (fifo); \ - void __user *__to = (to); \ - unsigned int __len = (len); \ - unsigned int *__copied = (copied); \ - const size_t __recsize = sizeof(*__tmp->rectype); \ - struct __kfifo *__kfifo = &__tmp->kfifo; \ - (__recsize) ? \ - __kfifo_to_user_r(__kfifo, __to, __len, __copied, __recsize) : \ - __kfifo_to_user(__kfifo, __to, __len, __copied); \ -}) \ -) - -/** - * kfifo_dma_in_prepare - setup a scatterlist for DMA input - * @fifo: address of the fifo to be used - * @sgl: pointer to the scatterlist array - * @nents: number of entries in the scatterlist array - * @len: number of elements to transfer - * - * This macro fills a scatterlist for DMA input. - * It returns the number entries in the scatterlist array. - * - * Note that with only one concurrent reader and one concurrent - * writer, you don't need extra locking to use these macros. - */ -#define kfifo_dma_in_prepare(fifo, sgl, nents, len) \ -({ \ - typeof((fifo) + 1) __tmp = (fifo); \ - struct scatterlist *__sgl = (sgl); \ - int __nents = (nents); \ - unsigned int __len = (len); \ - const size_t __recsize = sizeof(*__tmp->rectype); \ - struct __kfifo *__kfifo = &__tmp->kfifo; \ - (__recsize) ? \ - __kfifo_dma_in_prepare_r(__kfifo, __sgl, __nents, __len, __recsize) : \ - __kfifo_dma_in_prepare(__kfifo, __sgl, __nents, __len); \ -}) - -/** - * kfifo_dma_in_finish - finish a DMA IN operation - * @fifo: address of the fifo to be used - * @len: number of bytes to received - * - * This macro finish a DMA IN operation. The in counter will be updated by - * the len parameter. No error checking will be done. - * - * Note that with only one concurrent reader and one concurrent - * writer, you don't need extra locking to use these macros. - */ -#define kfifo_dma_in_finish(fifo, len) \ -(void)({ \ - typeof((fifo) + 1) __tmp = (fifo); \ - unsigned int __len = (len); \ - const size_t __recsize = sizeof(*__tmp->rectype); \ - struct __kfifo *__kfifo = &__tmp->kfifo; \ - if (__recsize) \ - __kfifo_dma_in_finish_r(__kfifo, __len, __recsize); \ - else \ - __kfifo->in += __len / sizeof(*__tmp->type); \ -}) - -/** - * kfifo_dma_out_prepare - setup a scatterlist for DMA output - * @fifo: address of the fifo to be used - * @sgl: pointer to the scatterlist array - * @nents: number of entries in the scatterlist array - * @len: number of elements to transfer - * - * This macro fills a scatterlist for DMA output which at most @len bytes - * to transfer. - * It returns the number entries in the scatterlist array. - * A zero means there is no space available and the scatterlist is not filled. - * - * Note that with only one concurrent reader and one concurrent - * writer, you don't need extra locking to use these macros. - */ -#define kfifo_dma_out_prepare(fifo, sgl, nents, len) \ -({ \ - typeof((fifo) + 1) __tmp = (fifo); \ - struct scatterlist *__sgl = (sgl); \ - int __nents = (nents); \ - unsigned int __len = (len); \ - const size_t __recsize = sizeof(*__tmp->rectype); \ - struct __kfifo *__kfifo = &__tmp->kfifo; \ - (__recsize) ? \ - __kfifo_dma_out_prepare_r(__kfifo, __sgl, __nents, __len, __recsize) : \ - __kfifo_dma_out_prepare(__kfifo, __sgl, __nents, __len); \ -}) - -/** - * kfifo_dma_out_finish - finish a DMA OUT operation - * @fifo: address of the fifo to be used - * @len: number of bytes transferd - * - * This macro finish a DMA OUT operation. The out counter will be updated by - * the len parameter. No error checking will be done. - * - * Note that with only one concurrent reader and one concurrent - * writer, you don't need extra locking to use these macros. - */ -#define kfifo_dma_out_finish(fifo, len) \ -(void)({ \ - typeof((fifo) + 1) __tmp = (fifo); \ - unsigned int __len = (len); \ - const size_t __recsize = sizeof(*__tmp->rectype); \ - struct __kfifo *__kfifo = &__tmp->kfifo; \ - if (__recsize) \ - __kfifo_dma_out_finish_r(__kfifo, __recsize); \ - else \ - __kfifo->out += __len / sizeof(*__tmp->type); \ -}) - -/** - * kfifo_out_peek - gets some data from the fifo - * @fifo: address of the fifo to be used - * @buf: pointer to the storage buffer - * @n: max. number of elements to get - * - * This macro get the data from the fifo and return the numbers of elements - * copied. The data is not removed from the fifo. - * - * Note that with only one concurrent reader and one concurrent - * writer, you don't need extra locking to use these macro. - */ -#define kfifo_out_peek(fifo, buf, n) \ -__kfifo_uint_must_check_helper( \ -({ \ - typeof((fifo) + 1) __tmp = (fifo); \ - typeof((buf) + 1) __buf = (buf); \ - unsigned long __n = (n); \ - const size_t __recsize = sizeof(*__tmp->rectype); \ - struct __kfifo *__kfifo = &__tmp->kfifo; \ - if (0) { \ - typeof(__tmp->ptr) __dummy __attribute__ ((unused)) = NULL; \ - __buf = __dummy; \ - } \ - (__recsize) ? \ - __kfifo_out_peek_r(__kfifo, __buf, __n, __recsize) : \ - __kfifo_out_peek(__kfifo, __buf, __n); \ -}) \ -) -#endif -#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36)) */ diff --git a/backport/include/linux/kmemleak.h b/backport/include/linux/kmemleak.h deleted file mode 100644 index 83bd199c2934..000000000000 --- a/backport/include/linux/kmemleak.h +++ /dev/null @@ -1,5 +0,0 @@ -#include - -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,30)) -#include_next -#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,25)) */ diff --git a/backport/include/linux/math64.h b/backport/include/linux/math64.h deleted file mode 100644 index eb9e8e15225c..000000000000 --- a/backport/include/linux/math64.h +++ /dev/null @@ -1,10 +0,0 @@ -#ifndef _COMPAT_LINUX_MATH64_H -#define _COMPAT_LINUX_MATH64_H 1 - -#include - -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,25)) -#include_next -#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,25)) */ - -#endif /* _COMPAT_LINUX_MATH64_H */ diff --git a/backport/include/linux/of.h b/backport/include/linux/of.h deleted file mode 100644 index c5dc87c2ef64..000000000000 --- a/backport/include/linux/of.h +++ /dev/null @@ -1,16 +0,0 @@ -#ifndef _COMPAT_LINUX_OF_H -#define _COMPAT_LINUX_OF_H 1 - -#include - -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34)) -#include_next -#else - -#ifdef CONFIG_OF -#include_next -#endif /* CONFIG_OF */ - -#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34)) */ - -#endif /* _COMPAT_LINUX_OF_H */ diff --git a/backport/include/linux/olpc-ec.h b/backport/include/linux/olpc-ec.h deleted file mode 100644 index a5b932a75a29..000000000000 --- a/backport/include/linux/olpc-ec.h +++ /dev/null @@ -1,10 +0,0 @@ -#ifndef _COMPAT_LINUX_OLPC_EC_H -#define _COMPAT_LINUX_OLPC_EC_H - -#include - -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0)) -#include_next -#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(3,6,0)) */ - -#endif /* _COMPAT_LINUX_OLPC_EC_H */ diff --git a/backport/include/linux/pci-aspm.h b/backport/include/linux/pci-aspm.h deleted file mode 100644 index 2bc6efb33300..000000000000 --- a/backport/include/linux/pci-aspm.h +++ /dev/null @@ -1,5 +0,0 @@ -#include - -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,25)) -#include_next -#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,25)) */ diff --git a/backport/include/linux/pm_qos.h b/backport/include/linux/pm_qos.h deleted file mode 100644 index c58c1c1f0161..000000000000 --- a/backport/include/linux/pm_qos.h +++ /dev/null @@ -1,12 +0,0 @@ -#ifndef _COMPAT_LINUX_PM_QOS_H -#define _COMPAT_LINUX_PM_QOS_H 1 - -#include - -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0)) -#include_next -#else -#include -#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0)) */ - -#endif /* _COMPAT_LINUX_PM_QOS_H */ diff --git a/backport/include/linux/pm_qos_params.h b/backport/include/linux/pm_qos_params.h deleted file mode 100644 index 4c8c89eff15c..000000000000 --- a/backport/include/linux/pm_qos_params.h +++ /dev/null @@ -1,42 +0,0 @@ -#include - -#ifndef __COMPAT_LINUX_PM_QOS_PARAMS_H -#define __COMPAT_LINUX_PM_QOS_PARAMS_H - -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)) -#include_next -#else -/* interface for the pm_qos_power infrastructure of the linux kernel. - * - * Mark Gross - */ -#include -#include -#include - -#define PM_QOS_RESERVED 0 -#define PM_QOS_CPU_DMA_LATENCY 1 -#define PM_QOS_NETWORK_LATENCY 2 -#define PM_QOS_NETWORK_THROUGHPUT 3 -#define PM_QOS_SYSTEM_BUS_FREQ 4 - -#define PM_QOS_NUM_CLASSES 5 -#define PM_QOS_DEFAULT_VALUE -1 - -#define pm_qos_add_requirement LINUX_BACKPORT(pm_qos_add_requirement) -int pm_qos_add_requirement(int qos, char *name, s32 value); -#define pm_qos_update_requirement LINUX_BACKPORT(pm_qos_update_requirement) -int pm_qos_update_requirement(int qos, char *name, s32 new_value); -#define pm_qos_remove_requirement LINUX_BACKPORT(pm_qos_remove_requirement) -void pm_qos_remove_requirement(int qos, char *name); - -#define pm_qos_requirement LINUX_BACKPORT(pm_qos_requirement) -int pm_qos_requirement(int qos); - -#define pm_qos_add_notifier LINUX_BACKPORT(pm_qos_add_notifier) -int pm_qos_add_notifier(int qos, struct notifier_block *notifier); -#define pm_qos_remove_notifier LINUX_BACKPORT(pm_qos_remove_notifier) -int pm_qos_remove_notifier(int qos, struct notifier_block *notifier); -#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)) */ - -#endif diff --git a/backport/include/linux/pm_runtime.h b/backport/include/linux/pm_runtime.h deleted file mode 100644 index eec965ba0d73..000000000000 --- a/backport/include/linux/pm_runtime.h +++ /dev/null @@ -1,14 +0,0 @@ -#include - -#ifndef __COMPAT_LINUX_PM_RUNTIME_H -#define __COMPAT_LINUX_PM_RUNTIME_H - -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)) -#include_next -#else - -static inline void pm_runtime_enable(struct device *dev) {} - -#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)) */ - -#endif diff --git a/backport/include/linux/printk.h b/backport/include/linux/printk.h deleted file mode 100644 index c0822ac488ca..000000000000 --- a/backport/include/linux/printk.h +++ /dev/null @@ -1,12 +0,0 @@ -#ifndef _COMPAT_LINUX_PRINTK_H -#define _COMPAT_LINUX_PRINTK_H 1 - -#include - -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,36)) -#include_next -#else -#include -#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,35)) */ - -#endif /* _COMPAT_LINUX_PRINTK_H */ diff --git a/backport/include/linux/rfkill.h b/backport/include/linux/rfkill.h deleted file mode 100644 index da236b26e668..000000000000 --- a/backport/include/linux/rfkill.h +++ /dev/null @@ -1,10 +0,0 @@ -#ifndef __COMPAT_RFKILL_H -#define __COMPAT_RFKILL_H - -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,33)) -#include_next -#else -#include -#endif - -#endif diff --git a/backport/include/linux/semaphore.h b/backport/include/linux/semaphore.h deleted file mode 100644 index 78af4db376fd..000000000000 --- a/backport/include/linux/semaphore.h +++ /dev/null @@ -1,12 +0,0 @@ -#ifndef _COMPAT_LINUX_SEMAPHORE_H -#define _COMPAT_LINUX_SEMAPHORE_H 1 - -#include - -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,25)) -#include_next -#else -#include -#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,25)) */ - -#endif /* _COMPAT_LINUX_SEMAPHORE_H */ diff --git a/backport/include/linux/tracepoint.h b/backport/include/linux/tracepoint.h deleted file mode 100644 index f67d8d396fe4..000000000000 --- a/backport/include/linux/tracepoint.h +++ /dev/null @@ -1,46 +0,0 @@ -#ifndef _COMPAT_LINUX_TRACEPOINT_H -#define _COMPAT_LINUX_TRACEPOINT_H 1 - -#include - -#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,32)) -/* - * Disable all tracing for older kernels - * < 2.6.27 had no tracing - * 2.6.27 had broken tracing - * 2.6.28-2.6.32 didn't have anything like DECLARE_EVENT_CLASS - * and faking it would be extremely difficult - */ -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,28)) -/* - * For 2.6.28+ include the original tracepoint.h (for kernel header - * files that require it to work) but override the defines the code - * uses to disable tracing completely. - */ -#include_next -#endif - -#undef CREATE_TRACE_POINTS - -#undef TRACE_EVENT -#define TRACE_EVENT(name, proto, ...) \ -static inline void trace_ ## name(proto) {} -#undef DECLARE_EVENT_CLASS -#define DECLARE_EVENT_CLASS(...) -#undef DEFINE_EVENT -#define DEFINE_EVENT(evt_class, name, proto, ...) \ -static inline void trace_ ## name(proto) {} -#undef EXPORT_TRACEPOINT_SYMBOL -#define EXPORT_TRACEPOINT_SYMBOL(...) - -#define TP_PROTO(args...) args -#define TP_ARGS(args...) args -#define TP_CONDITION(args...) args - -#else -/* since 2.6.33, tracing hasn't changed, so just include the kernel's file */ -#include_next - -#endif /* (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,32)) */ - -#endif /* _COMPAT_LINUX_TRACEPOINT_H */ diff --git a/backport/include/linux/u64_stats_sync.h b/backport/include/linux/u64_stats_sync.h deleted file mode 100644 index f15116c28279..000000000000 --- a/backport/include/linux/u64_stats_sync.h +++ /dev/null @@ -1,144 +0,0 @@ -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0)) -#include_next -#else -#ifndef _LINUX_U64_STATS_SYNC_H -#define _LINUX_U64_STATS_SYNC_H - -/* - * To properly implement 64bits network statistics on 32bit and 64bit hosts, - * we provide a synchronization point, that is a noop on 64bit or UP kernels. - * - * Key points : - * 1) Use a seqcount on SMP 32bits, with low overhead. - * 2) Whole thing is a noop on 64bit arches or UP kernels. - * 3) Write side must ensure mutual exclusion or one seqcount update could - * be lost, thus blocking readers forever. - * If this synchronization point is not a mutex, but a spinlock or - * spinlock_bh() or disable_bh() : - * 3.1) Write side should not sleep. - * 3.2) Write side should not allow preemption. - * 3.3) If applicable, interrupts should be disabled. - * - * 4) If reader fetches several counters, there is no guarantee the whole values - * are consistent (remember point 1) : this is a noop on 64bit arches anyway) - * - * 5) readers are allowed to sleep or be preempted/interrupted : They perform - * pure reads. But if they have to fetch many values, it's better to not allow - * preemptions/interruptions to avoid many retries. - * - * 6) If counter might be written by an interrupt, readers should block interrupts. - * (On UP, there is no seqcount_t protection, a reader allowing interrupts could - * read partial values) - * - * 7) For softirq uses, readers can use u64_stats_fetch_begin_bh() and - * u64_stats_fetch_retry_bh() helpers - * - * Usage : - * - * Stats producer (writer) should use following template granted it already got - * an exclusive access to counters (a lock is already taken, or per cpu - * data is used [in a non preemptable context]) - * - * spin_lock_bh(...) or other synchronization to get exclusive access - * ... - * u64_stats_update_begin(&stats->syncp); - * stats->bytes64 += len; // non atomic operation - * stats->packets64++; // non atomic operation - * u64_stats_update_end(&stats->syncp); - * - * While a consumer (reader) should use following template to get consistent - * snapshot for each variable (but no guarantee on several ones) - * - * u64 tbytes, tpackets; - * unsigned int start; - * - * do { - * start = u64_stats_fetch_begin(&stats->syncp); - * tbytes = stats->bytes64; // non atomic operation - * tpackets = stats->packets64; // non atomic operation - * } while (u64_stats_fetch_retry(&stats->syncp, start)); - * - * - * Example of use in drivers/net/loopback.c, using per_cpu containers, - * in BH disabled context. - */ -#include - -struct u64_stats_sync { -#if BITS_PER_LONG==32 && defined(CONFIG_SMP) - seqcount_t seq; -#endif -}; - -static inline void u64_stats_update_begin(struct u64_stats_sync *syncp) -{ -#if BITS_PER_LONG==32 && defined(CONFIG_SMP) - write_seqcount_begin(&syncp->seq); -#endif -} - -static inline void u64_stats_update_end(struct u64_stats_sync *syncp) -{ -#if BITS_PER_LONG==32 && defined(CONFIG_SMP) - write_seqcount_end(&syncp->seq); -#endif -} - -static inline unsigned int u64_stats_fetch_begin(const struct u64_stats_sync *syncp) -{ -#if BITS_PER_LONG==32 && defined(CONFIG_SMP) - return read_seqcount_begin(&syncp->seq); -#else -#if BITS_PER_LONG==32 - preempt_disable(); -#endif - return 0; -#endif -} - -static inline bool u64_stats_fetch_retry(const struct u64_stats_sync *syncp, - unsigned int start) -{ -#if BITS_PER_LONG==32 && defined(CONFIG_SMP) - return read_seqcount_retry(&syncp->seq, start); -#else -#if BITS_PER_LONG==32 - preempt_enable(); -#endif - return false; -#endif -} - -/* - * In case softirq handlers can update u64 counters, readers can use following helpers - * - SMP 32bit arches use seqcount protection, irq safe. - * - UP 32bit must disable BH. - * - 64bit have no problem atomically reading u64 values, irq safe. - */ -static inline unsigned int u64_stats_fetch_begin_bh(const struct u64_stats_sync *syncp) -{ -#if BITS_PER_LONG==32 && defined(CONFIG_SMP) - return read_seqcount_begin(&syncp->seq); -#else -#if BITS_PER_LONG==32 - local_bh_disable(); -#endif - return 0; -#endif -} - -static inline bool u64_stats_fetch_retry_bh(const struct u64_stats_sync *syncp, - unsigned int start) -{ -#if BITS_PER_LONG==32 && defined(CONFIG_SMP) - return read_seqcount_retry(&syncp->seq, start); -#else -#if BITS_PER_LONG==32 - local_bh_enable(); -#endif - return false; -#endif -} - -#endif /* _LINUX_U64_STATS_SYNC_H */ -#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0)) */ diff --git a/backport/include/linux/uidgid.h b/backport/include/linux/uidgid.h deleted file mode 100644 index ae1ed808cfd6..000000000000 --- a/backport/include/linux/uidgid.h +++ /dev/null @@ -1,221 +0,0 @@ -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,5,0)) -#include_next -#else - -#ifndef _LINUX_UIDGID_H -#define _LINUX_UIDGID_H - -/* - * A set of types for the internal kernel types representing uids and gids. - * - * The types defined in this header allow distinguishing which uids and gids in - * the kernel are values used by userspace and which uid and gid values are - * the internal kernel values. With the addition of user namespaces the values - * can be different. Using the type system makes it possible for the compiler - * to detect when we overlook these differences. - * - */ -#include -#include - -struct user_namespace; -extern struct user_namespace init_user_ns; - -#ifdef CONFIG_UIDGID_STRICT_TYPE_CHECKS - -typedef struct { - uid_t val; -} kuid_t; - - -typedef struct { - gid_t val; -} kgid_t; - -#define KUIDT_INIT(value) (kuid_t){ value } -#define KGIDT_INIT(value) (kgid_t){ value } - -static inline uid_t __kuid_val(kuid_t uid) -{ - return uid.val; -} - -static inline gid_t __kgid_val(kgid_t gid) -{ - return gid.val; -} - -#else - -typedef uid_t kuid_t; -typedef gid_t kgid_t; - -static inline uid_t __kuid_val(kuid_t uid) -{ - return uid; -} - -static inline gid_t __kgid_val(kgid_t gid) -{ - return gid; -} - -#define KUIDT_INIT(value) ((kuid_t) value ) -#define KGIDT_INIT(value) ((kgid_t) value ) - -#endif - -#define GLOBAL_ROOT_UID KUIDT_INIT(0) -#define GLOBAL_ROOT_GID KGIDT_INIT(0) - -#define INVALID_UID KUIDT_INIT(-1) -#define INVALID_GID KGIDT_INIT(-1) - -static inline bool uid_eq(kuid_t left, kuid_t right) -{ - return __kuid_val(left) == __kuid_val(right); -} - -static inline bool gid_eq(kgid_t left, kgid_t right) -{ - return __kgid_val(left) == __kgid_val(right); -} - -static inline bool uid_gt(kuid_t left, kuid_t right) -{ - return __kuid_val(left) > __kuid_val(right); -} - -static inline bool gid_gt(kgid_t left, kgid_t right) -{ - return __kgid_val(left) > __kgid_val(right); -} - -static inline bool uid_gte(kuid_t left, kuid_t right) -{ - return __kuid_val(left) >= __kuid_val(right); -} - -static inline bool gid_gte(kgid_t left, kgid_t right) -{ - return __kgid_val(left) >= __kgid_val(right); -} - -static inline bool uid_lt(kuid_t left, kuid_t right) -{ - return __kuid_val(left) < __kuid_val(right); -} - -static inline bool gid_lt(kgid_t left, kgid_t right) -{ - return __kgid_val(left) < __kgid_val(right); -} - -static inline bool uid_lte(kuid_t left, kuid_t right) -{ - return __kuid_val(left) <= __kuid_val(right); -} - -static inline bool gid_lte(kgid_t left, kgid_t right) -{ - return __kgid_val(left) <= __kgid_val(right); -} - -static inline bool uid_valid(kuid_t uid) -{ - return !uid_eq(uid, INVALID_UID); -} - -static inline bool gid_valid(kgid_t gid) -{ - return !gid_eq(gid, INVALID_GID); -} - -#ifdef CONFIG_USER_NS - -#define make_kuid LINUX_BACKPORT(make_kuid) -extern kuid_t make_kuid(struct user_namespace *from, uid_t uid); -#define make_kgid LINUX_BACKPORT(make_kgid) -extern kgid_t make_kgid(struct user_namespace *from, gid_t gid); - -#define from_kuid LINUX_BACKPORT(from_kuid) -extern uid_t from_kuid(struct user_namespace *to, kuid_t uid); -#define from_kgid LINUX_BACKPORT(from_kgid) -extern gid_t from_kgid(struct user_namespace *to, kgid_t gid); -#define from_kuid_munged LINUX_BACKPORT(from_kuid_munged) -extern uid_t from_kuid_munged(struct user_namespace *to, kuid_t uid); -#define from_kgid_munged LINUX_BACKPORT(from_kgid_munged) -extern gid_t from_kgid_munged(struct user_namespace *to, kgid_t gid); - -#define kuid_has_mapping LINUX_BACKPORT(kuid_has_mapping) -static inline bool kuid_has_mapping(struct user_namespace *ns, kuid_t uid) -{ - return from_kuid(ns, uid) != (uid_t) -1; -} - -#define kgid_has_mapping LINUX_BACKPORT(kgid_has_mapping) -static inline bool kgid_has_mapping(struct user_namespace *ns, kgid_t gid) -{ - return from_kgid(ns, gid) != (gid_t) -1; -} - -#else - -#define make_kuid LINUX_BACKPORT(make_kuid) -static inline kuid_t make_kuid(struct user_namespace *from, uid_t uid) -{ - return KUIDT_INIT(uid); -} - -#define make_kgid LINUX_BACKPORT(make_kgid) -static inline kgid_t make_kgid(struct user_namespace *from, gid_t gid) -{ - return KGIDT_INIT(gid); -} - -#define from_kuid LINUX_BACKPORT(from_kuid) -static inline uid_t from_kuid(struct user_namespace *to, kuid_t kuid) -{ - return __kuid_val(kuid); -} - -#define from_kgid LINUX_BACKPORT(from_kgid) -static inline gid_t from_kgid(struct user_namespace *to, kgid_t kgid) -{ - return __kgid_val(kgid); -} - -#define from_kuid_munged LINUX_BACKPORT(from_kuid_munged) -static inline uid_t from_kuid_munged(struct user_namespace *to, kuid_t kuid) -{ - uid_t uid = from_kuid(to, kuid); - if (uid == (uid_t)-1) - uid = overflowuid; - return uid; -} - -#define from_kgid_munged LINUX_BACKPORT(from_kgid_munged) -static inline gid_t from_kgid_munged(struct user_namespace *to, kgid_t kgid) -{ - gid_t gid = from_kgid(to, kgid); - if (gid == (gid_t)-1) - gid = overflowgid; - return gid; -} - -#define kuid_has_mapping LINUX_BACKPORT(kuid_has_mapping) -static inline bool kuid_has_mapping(struct user_namespace *ns, kuid_t uid) -{ - return true; -} - -#define kgid_has_mapping LINUX_BACKPORT(kgid_has_mapping) -static inline bool kgid_has_mapping(struct user_namespace *ns, kgid_t gid) -{ - return true; -} - -#endif /* CONFIG_USER_NS */ - -#endif /* _LINUX_UIDGID_H */ -#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(3,5,0) */ diff --git a/backport/include/linux/unaligned/access_ok.h b/backport/include/linux/unaligned/access_ok.h deleted file mode 100644 index 99c1b4d20b0f..000000000000 --- a/backport/include/linux/unaligned/access_ok.h +++ /dev/null @@ -1,67 +0,0 @@ -#ifndef _LINUX_UNALIGNED_ACCESS_OK_H -#define _LINUX_UNALIGNED_ACCESS_OK_H - -#include -#include - -static inline u16 get_unaligned_le16(const void *p) -{ - return le16_to_cpup((__le16 *)p); -} - -static inline u32 get_unaligned_le32(const void *p) -{ - return le32_to_cpup((__le32 *)p); -} - -static inline u64 get_unaligned_le64(const void *p) -{ - return le64_to_cpup((__le64 *)p); -} - -static inline u16 get_unaligned_be16(const void *p) -{ - return be16_to_cpup((__be16 *)p); -} - -static inline u32 get_unaligned_be32(const void *p) -{ - return be32_to_cpup((__be32 *)p); -} - -static inline u64 get_unaligned_be64(const void *p) -{ - return be64_to_cpup((__be64 *)p); -} - -static inline void put_unaligned_le16(u16 val, void *p) -{ - *((__le16 *)p) = cpu_to_le16(val); -} - -static inline void put_unaligned_le32(u32 val, void *p) -{ - *((__le32 *)p) = cpu_to_le32(val); -} - -static inline void put_unaligned_le64(u64 val, void *p) -{ - *((__le64 *)p) = cpu_to_le64(val); -} - -static inline void put_unaligned_be16(u16 val, void *p) -{ - *((__be16 *)p) = cpu_to_be16(val); -} - -static inline void put_unaligned_be32(u32 val, void *p) -{ - *((__be32 *)p) = cpu_to_be32(val); -} - -static inline void put_unaligned_be64(u64 val, void *p) -{ - *((__be64 *)p) = cpu_to_be64(val); -} - -#endif /* _LINUX_UNALIGNED_ACCESS_OK_H */ diff --git a/backport/include/linux/unaligned/be_byteshift.h b/backport/include/linux/unaligned/be_byteshift.h deleted file mode 100644 index 9356b24223ac..000000000000 --- a/backport/include/linux/unaligned/be_byteshift.h +++ /dev/null @@ -1,70 +0,0 @@ -#ifndef _LINUX_UNALIGNED_BE_BYTESHIFT_H -#define _LINUX_UNALIGNED_BE_BYTESHIFT_H - -#include - -static inline u16 __get_unaligned_be16(const u8 *p) -{ - return p[0] << 8 | p[1]; -} - -static inline u32 __get_unaligned_be32(const u8 *p) -{ - return p[0] << 24 | p[1] << 16 | p[2] << 8 | p[3]; -} - -static inline u64 __get_unaligned_be64(const u8 *p) -{ - return (u64)__get_unaligned_be32(p) << 32 | - __get_unaligned_be32(p + 4); -} - -static inline void __put_unaligned_be16(u16 val, u8 *p) -{ - *p++ = val >> 8; - *p++ = val; -} - -static inline void __put_unaligned_be32(u32 val, u8 *p) -{ - __put_unaligned_be16(val >> 16, p); - __put_unaligned_be16(val, p + 2); -} - -static inline void __put_unaligned_be64(u64 val, u8 *p) -{ - __put_unaligned_be32(val >> 32, p); - __put_unaligned_be32(val, p + 4); -} - -static inline u16 get_unaligned_be16(const void *p) -{ - return __get_unaligned_be16((const u8 *)p); -} - -static inline u32 get_unaligned_be32(const void *p) -{ - return __get_unaligned_be32((const u8 *)p); -} - -static inline u64 get_unaligned_be64(const void *p) -{ - return __get_unaligned_be64((const u8 *)p); -} - -static inline void put_unaligned_be16(u16 val, void *p) -{ - __put_unaligned_be16(val, p); -} - -static inline void put_unaligned_be32(u32 val, void *p) -{ - __put_unaligned_be32(val, p); -} - -static inline void put_unaligned_be64(u64 val, void *p) -{ - __put_unaligned_be64(val, p); -} - -#endif /* _LINUX_UNALIGNED_BE_BYTESHIFT_H */ diff --git a/backport/include/linux/unaligned/be_memmove.h b/backport/include/linux/unaligned/be_memmove.h deleted file mode 100644 index c2a76c5c9ed0..000000000000 --- a/backport/include/linux/unaligned/be_memmove.h +++ /dev/null @@ -1,36 +0,0 @@ -#ifndef _LINUX_UNALIGNED_BE_MEMMOVE_H -#define _LINUX_UNALIGNED_BE_MEMMOVE_H - -#include - -static inline u16 get_unaligned_be16(const void *p) -{ - return __get_unaligned_memmove16((const u8 *)p); -} - -static inline u32 get_unaligned_be32(const void *p) -{ - return __get_unaligned_memmove32((const u8 *)p); -} - -static inline u64 get_unaligned_be64(const void *p) -{ - return __get_unaligned_memmove64((const u8 *)p); -} - -static inline void put_unaligned_be16(u16 val, void *p) -{ - __put_unaligned_memmove16(val, p); -} - -static inline void put_unaligned_be32(u32 val, void *p) -{ - __put_unaligned_memmove32(val, p); -} - -static inline void put_unaligned_be64(u64 val, void *p) -{ - __put_unaligned_memmove64(val, p); -} - -#endif /* _LINUX_UNALIGNED_LE_MEMMOVE_H */ diff --git a/backport/include/linux/unaligned/be_struct.h b/backport/include/linux/unaligned/be_struct.h deleted file mode 100644 index 132415836c50..000000000000 --- a/backport/include/linux/unaligned/be_struct.h +++ /dev/null @@ -1,36 +0,0 @@ -#ifndef _LINUX_UNALIGNED_BE_STRUCT_H -#define _LINUX_UNALIGNED_BE_STRUCT_H - -#include - -static inline u16 get_unaligned_be16(const void *p) -{ - return __get_unaligned_cpu16((const u8 *)p); -} - -static inline u32 get_unaligned_be32(const void *p) -{ - return __get_unaligned_cpu32((const u8 *)p); -} - -static inline u64 get_unaligned_be64(const void *p) -{ - return __get_unaligned_cpu64((const u8 *)p); -} - -static inline void put_unaligned_be16(u16 val, void *p) -{ - __put_unaligned_cpu16(val, p); -} - -static inline void put_unaligned_be32(u32 val, void *p) -{ - __put_unaligned_cpu32(val, p); -} - -static inline void put_unaligned_be64(u64 val, void *p) -{ - __put_unaligned_cpu64(val, p); -} - -#endif /* _LINUX_UNALIGNED_BE_STRUCT_H */ diff --git a/backport/include/linux/unaligned/generic.h b/backport/include/linux/unaligned/generic.h deleted file mode 100644 index 02d97ff3df70..000000000000 --- a/backport/include/linux/unaligned/generic.h +++ /dev/null @@ -1,68 +0,0 @@ -#ifndef _LINUX_UNALIGNED_GENERIC_H -#define _LINUX_UNALIGNED_GENERIC_H - -/* - * Cause a link-time error if we try an unaligned access other than - * 1,2,4 or 8 bytes long - */ -extern void __bad_unaligned_access_size(void); - -#define __get_unaligned_le(ptr) ((__force typeof(*(ptr)))({ \ - __builtin_choose_expr(sizeof(*(ptr)) == 1, *(ptr), \ - __builtin_choose_expr(sizeof(*(ptr)) == 2, get_unaligned_le16((ptr)), \ - __builtin_choose_expr(sizeof(*(ptr)) == 4, get_unaligned_le32((ptr)), \ - __builtin_choose_expr(sizeof(*(ptr)) == 8, get_unaligned_le64((ptr)), \ - __bad_unaligned_access_size())))); \ - })) - -#define __get_unaligned_be(ptr) ((__force typeof(*(ptr)))({ \ - __builtin_choose_expr(sizeof(*(ptr)) == 1, *(ptr), \ - __builtin_choose_expr(sizeof(*(ptr)) == 2, get_unaligned_be16((ptr)), \ - __builtin_choose_expr(sizeof(*(ptr)) == 4, get_unaligned_be32((ptr)), \ - __builtin_choose_expr(sizeof(*(ptr)) == 8, get_unaligned_be64((ptr)), \ - __bad_unaligned_access_size())))); \ - })) - -#define __put_unaligned_le(val, ptr) ({ \ - void *__gu_p = (ptr); \ - switch (sizeof(*(ptr))) { \ - case 1: \ - *(u8 *)__gu_p = (__force u8)(val); \ - break; \ - case 2: \ - put_unaligned_le16((__force u16)(val), __gu_p); \ - break; \ - case 4: \ - put_unaligned_le32((__force u32)(val), __gu_p); \ - break; \ - case 8: \ - put_unaligned_le64((__force u64)(val), __gu_p); \ - break; \ - default: \ - __bad_unaligned_access_size(); \ - break; \ - } \ - (void)0; }) - -#define __put_unaligned_be(val, ptr) ({ \ - void *__gu_p = (ptr); \ - switch (sizeof(*(ptr))) { \ - case 1: \ - *(u8 *)__gu_p = (__force u8)(val); \ - break; \ - case 2: \ - put_unaligned_be16((__force u16)(val), __gu_p); \ - break; \ - case 4: \ - put_unaligned_be32((__force u32)(val), __gu_p); \ - break; \ - case 8: \ - put_unaligned_be64((__force u64)(val), __gu_p); \ - break; \ - default: \ - __bad_unaligned_access_size(); \ - break; \ - } \ - (void)0; }) - -#endif /* _LINUX_UNALIGNED_GENERIC_H */ diff --git a/backport/include/linux/unaligned/le_byteshift.h b/backport/include/linux/unaligned/le_byteshift.h deleted file mode 100644 index be376fb79b64..000000000000 --- a/backport/include/linux/unaligned/le_byteshift.h +++ /dev/null @@ -1,70 +0,0 @@ -#ifndef _LINUX_UNALIGNED_LE_BYTESHIFT_H -#define _LINUX_UNALIGNED_LE_BYTESHIFT_H - -#include - -static inline u16 __get_unaligned_le16(const u8 *p) -{ - return p[0] | p[1] << 8; -} - -static inline u32 __get_unaligned_le32(const u8 *p) -{ - return p[0] | p[1] << 8 | p[2] << 16 | p[3] << 24; -} - -static inline u64 __get_unaligned_le64(const u8 *p) -{ - return (u64)__get_unaligned_le32(p + 4) << 32 | - __get_unaligned_le32(p); -} - -static inline void __put_unaligned_le16(u16 val, u8 *p) -{ - *p++ = val; - *p++ = val >> 8; -} - -static inline void __put_unaligned_le32(u32 val, u8 *p) -{ - __put_unaligned_le16(val >> 16, p + 2); - __put_unaligned_le16(val, p); -} - -static inline void __put_unaligned_le64(u64 val, u8 *p) -{ - __put_unaligned_le32(val >> 32, p + 4); - __put_unaligned_le32(val, p); -} - -static inline u16 get_unaligned_le16(const void *p) -{ - return __get_unaligned_le16((const u8 *)p); -} - -static inline u32 get_unaligned_le32(const void *p) -{ - return __get_unaligned_le32((const u8 *)p); -} - -static inline u64 get_unaligned_le64(const void *p) -{ - return __get_unaligned_le64((const u8 *)p); -} - -static inline void put_unaligned_le16(u16 val, void *p) -{ - __put_unaligned_le16(val, p); -} - -static inline void put_unaligned_le32(u32 val, void *p) -{ - __put_unaligned_le32(val, p); -} - -static inline void put_unaligned_le64(u64 val, void *p) -{ - __put_unaligned_le64(val, p); -} - -#endif /* _LINUX_UNALIGNED_LE_BYTESHIFT_H */ diff --git a/backport/include/linux/unaligned/le_memmove.h b/backport/include/linux/unaligned/le_memmove.h deleted file mode 100644 index 269849bee4ec..000000000000 --- a/backport/include/linux/unaligned/le_memmove.h +++ /dev/null @@ -1,36 +0,0 @@ -#ifndef _LINUX_UNALIGNED_LE_MEMMOVE_H -#define _LINUX_UNALIGNED_LE_MEMMOVE_H - -#include - -static inline u16 get_unaligned_le16(const void *p) -{ - return __get_unaligned_memmove16((const u8 *)p); -} - -static inline u32 get_unaligned_le32(const void *p) -{ - return __get_unaligned_memmove32((const u8 *)p); -} - -static inline u64 get_unaligned_le64(const void *p) -{ - return __get_unaligned_memmove64((const u8 *)p); -} - -static inline void put_unaligned_le16(u16 val, void *p) -{ - __put_unaligned_memmove16(val, p); -} - -static inline void put_unaligned_le32(u32 val, void *p) -{ - __put_unaligned_memmove32(val, p); -} - -static inline void put_unaligned_le64(u64 val, void *p) -{ - __put_unaligned_memmove64(val, p); -} - -#endif /* _LINUX_UNALIGNED_LE_MEMMOVE_H */ diff --git a/backport/include/linux/unaligned/le_struct.h b/backport/include/linux/unaligned/le_struct.h deleted file mode 100644 index 088c4572faa8..000000000000 --- a/backport/include/linux/unaligned/le_struct.h +++ /dev/null @@ -1,36 +0,0 @@ -#ifndef _LINUX_UNALIGNED_LE_STRUCT_H -#define _LINUX_UNALIGNED_LE_STRUCT_H - -#include - -static inline u16 get_unaligned_le16(const void *p) -{ - return __get_unaligned_cpu16((const u8 *)p); -} - -static inline u32 get_unaligned_le32(const void *p) -{ - return __get_unaligned_cpu32((const u8 *)p); -} - -static inline u64 get_unaligned_le64(const void *p) -{ - return __get_unaligned_cpu64((const u8 *)p); -} - -static inline void put_unaligned_le16(u16 val, void *p) -{ - __put_unaligned_cpu16(val, p); -} - -static inline void put_unaligned_le32(u32 val, void *p) -{ - __put_unaligned_cpu32(val, p); -} - -static inline void put_unaligned_le64(u64 val, void *p) -{ - __put_unaligned_cpu64(val, p); -} - -#endif /* _LINUX_UNALIGNED_LE_STRUCT_H */ diff --git a/backport/include/linux/unaligned/memmove.h b/backport/include/linux/unaligned/memmove.h deleted file mode 100644 index eeb5a779a4fd..000000000000 --- a/backport/include/linux/unaligned/memmove.h +++ /dev/null @@ -1,45 +0,0 @@ -#ifndef _LINUX_UNALIGNED_MEMMOVE_H -#define _LINUX_UNALIGNED_MEMMOVE_H - -#include -#include - -/* Use memmove here, so gcc does not insert a __builtin_memcpy. */ - -static inline u16 __get_unaligned_memmove16(const void *p) -{ - u16 tmp; - memmove(&tmp, p, 2); - return tmp; -} - -static inline u32 __get_unaligned_memmove32(const void *p) -{ - u32 tmp; - memmove(&tmp, p, 4); - return tmp; -} - -static inline u64 __get_unaligned_memmove64(const void *p) -{ - u64 tmp; - memmove(&tmp, p, 8); - return tmp; -} - -static inline void __put_unaligned_memmove16(u16 val, void *p) -{ - memmove(p, &val, 2); -} - -static inline void __put_unaligned_memmove32(u32 val, void *p) -{ - memmove(p, &val, 4); -} - -static inline void __put_unaligned_memmove64(u64 val, void *p) -{ - memmove(p, &val, 8); -} - -#endif /* _LINUX_UNALIGNED_MEMMOVE_H */ diff --git a/backport/include/linux/unaligned/packed_struct.h b/backport/include/linux/unaligned/packed_struct.h deleted file mode 100644 index 2498bb9fe002..000000000000 --- a/backport/include/linux/unaligned/packed_struct.h +++ /dev/null @@ -1,46 +0,0 @@ -#ifndef _LINUX_UNALIGNED_PACKED_STRUCT_H -#define _LINUX_UNALIGNED_PACKED_STRUCT_H - -#include - -struct __una_u16 { u16 x __attribute__((packed)); }; -struct __una_u32 { u32 x __attribute__((packed)); }; -struct __una_u64 { u64 x __attribute__((packed)); }; - -static inline u16 __get_unaligned_cpu16(const void *p) -{ - const struct __una_u16 *ptr = (const struct __una_u16 *)p; - return ptr->x; -} - -static inline u32 __get_unaligned_cpu32(const void *p) -{ - const struct __una_u32 *ptr = (const struct __una_u32 *)p; - return ptr->x; -} - -static inline u64 __get_unaligned_cpu64(const void *p) -{ - const struct __una_u64 *ptr = (const struct __una_u64 *)p; - return ptr->x; -} - -static inline void __put_unaligned_cpu16(u16 val, void *p) -{ - struct __una_u16 *ptr = (struct __una_u16 *)p; - ptr->x = val; -} - -static inline void __put_unaligned_cpu32(u32 val, void *p) -{ - struct __una_u32 *ptr = (struct __una_u32 *)p; - ptr->x = val; -} - -static inline void __put_unaligned_cpu64(u64 val, void *p) -{ - struct __una_u64 *ptr = (struct __una_u64 *)p; - ptr->x = val; -} - -#endif /* _LINUX_UNALIGNED_PACKED_STRUCT_H */ diff --git a/backport/include/linux/vga_switcheroo.h b/backport/include/linux/vga_switcheroo.h deleted file mode 100644 index 4bda17bf88fa..000000000000 --- a/backport/include/linux/vga_switcheroo.h +++ /dev/null @@ -1,12 +0,0 @@ -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34)) -/* - * XXX: The include guard was sent upstream, drop this - * once the guard is merged. - */ -#ifndef LINUX_VGA_SWITCHEROO_H /* in case this gets upstream */ -#include_next -#ifndef LINUX_VGA_SWITCHEROO_H /* do not redefine once this gets upstream */ -#define LINUX_VGA_SWITCHEROO_H -#endif /* case 1 LINUX_VGA_SWITCHEROO_H */ -#endif /* case 2 LINUX_VGA_SWITCHEROO_H */ -#endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34)) */ diff --git a/backport/include/linux/wireless.h b/backport/include/linux/wireless.h deleted file mode 100644 index 4395b28bb86c..000000000000 --- a/backport/include/linux/wireless.h +++ /dev/null @@ -1,1162 +0,0 @@ -/* - * This file define a set of standard wireless extensions - * - * Version : 22 16.3.07 - * - * Authors : Jean Tourrilhes - HPL - - * Copyright (c) 1997-2007 Jean Tourrilhes, All Rights Reserved. - */ - -#ifndef _LINUX_WIRELESS_H -#define _LINUX_WIRELESS_H - -/************************** DOCUMENTATION **************************/ -/* - * Initial APIs (1996 -> onward) : - * ----------------------------- - * Basically, the wireless extensions are for now a set of standard ioctl - * call + /proc/net/wireless - * - * The entry /proc/net/wireless give statistics and information on the - * driver. - * This is better than having each driver having its entry because - * its centralised and we may remove the driver module safely. - * - * Ioctl are used to configure the driver and issue commands. This is - * better than command line options of insmod because we may want to - * change dynamically (while the driver is running) some parameters. - * - * The ioctl mechanimsm are copied from standard devices ioctl. - * We have the list of command plus a structure descibing the - * data exchanged... - * Note that to add these ioctl, I was obliged to modify : - * # net/core/dev.c (two place + add include) - * # net/ipv4/af_inet.c (one place + add include) - * - * /proc/net/wireless is a copy of /proc/net/dev. - * We have a structure for data passed from the driver to /proc/net/wireless - * Too add this, I've modified : - * # net/core/dev.c (two other places) - * # include/linux/netdevice.h (one place) - * # include/linux/proc_fs.h (one place) - * - * New driver API (2002 -> onward) : - * ------------------------------- - * This file is only concerned with the user space API and common definitions. - * The new driver API is defined and documented in : - * # include/net/iw_handler.h - * - * Note as well that /proc/net/wireless implementation has now moved in : - * # net/core/wireless.c - * - * Wireless Events (2002 -> onward) : - * -------------------------------- - * Events are defined at the end of this file, and implemented in : - * # net/core/wireless.c - * - * Other comments : - * -------------- - * Do not add here things that are redundant with other mechanisms - * (drivers init, ifconfig, /proc/net/dev, ...) and with are not - * wireless specific. - * - * These wireless extensions are not magic : each driver has to provide - * support for them... - * - * IMPORTANT NOTE : As everything in the kernel, this is very much a - * work in progress. Contact me if you have ideas of improvements... - */ - -/***************************** INCLUDES *****************************/ - -#include /* for __u* and __s* typedefs */ -#include /* for "struct sockaddr" et al */ -#include /* for IFNAMSIZ and co... */ - -/***************************** VERSION *****************************/ -/* - * This constant is used to know the availability of the wireless - * extensions and to know which version of wireless extensions it is - * (there is some stuff that will be added in the future...) - * I just plan to increment with each new version. - */ -#define WIRELESS_EXT 22 - -/* - * Changes : - * - * V2 to V3 - * -------- - * Alan Cox start some incompatibles changes. I've integrated a bit more. - * - Encryption renamed to Encode to avoid US regulation problems - * - Frequency changed from float to struct to avoid problems on old 386 - * - * V3 to V4 - * -------- - * - Add sensitivity - * - * V4 to V5 - * -------- - * - Missing encoding definitions in range - * - Access points stuff - * - * V5 to V6 - * -------- - * - 802.11 support (ESSID ioctls) - * - * V6 to V7 - * -------- - * - define IW_ESSID_MAX_SIZE and IW_MAX_AP - * - * V7 to V8 - * -------- - * - Changed my e-mail address - * - More 802.11 support (nickname, rate, rts, frag) - * - List index in frequencies - * - * V8 to V9 - * -------- - * - Support for 'mode of operation' (ad-hoc, managed...) - * - Support for unicast and multicast power saving - * - Change encoding to support larger tokens (>64 bits) - * - Updated iw_params (disable, flags) and use it for NWID - * - Extracted iw_point from iwreq for clarity - * - * V9 to V10 - * --------- - * - Add PM capability to range structure - * - Add PM modifier : MAX/MIN/RELATIVE - * - Add encoding option : IW_ENCODE_NOKEY - * - Add TxPower ioctls (work like TxRate) - * - * V10 to V11 - * ---------- - * - Add WE version in range (help backward/forward compatibility) - * - Add retry ioctls (work like PM) - * - * V11 to V12 - * ---------- - * - Add SIOCSIWSTATS to get /proc/net/wireless programatically - * - Add DEV PRIVATE IOCTL to avoid collisions in SIOCDEVPRIVATE space - * - Add new statistics (frag, retry, beacon) - * - Add average quality (for user space calibration) - * - * V12 to V13 - * ---------- - * - Document creation of new driver API. - * - Extract union iwreq_data from struct iwreq (for new driver API). - * - Rename SIOCSIWNAME as SIOCSIWCOMMIT - * - * V13 to V14 - * ---------- - * - Wireless Events support : define struct iw_event - * - Define additional specific event numbers - * - Add "addr" and "param" fields in union iwreq_data - * - AP scanning stuff (SIOCSIWSCAN and friends) - * - * V14 to V15 - * ---------- - * - Add IW_PRIV_TYPE_ADDR for struct sockaddr private arg - * - Make struct iw_freq signed (both m & e), add explicit padding - * - Add IWEVCUSTOM for driver specific event/scanning token - * - Add IW_MAX_GET_SPY for driver returning a lot of addresses - * - Add IW_TXPOW_RANGE for range of Tx Powers - * - Add IWEVREGISTERED & IWEVEXPIRED events for Access Points - * - Add IW_MODE_MONITOR for passive monitor - * - * V15 to V16 - * ---------- - * - Increase the number of bitrates in iw_range to 32 (for 802.11g) - * - Increase the number of frequencies in iw_range to 32 (for 802.11b+a) - * - Reshuffle struct iw_range for increases, add filler - * - Increase IW_MAX_AP to 64 for driver returning a lot of addresses - * - Remove IW_MAX_GET_SPY because conflict with enhanced spy support - * - Add SIOCSIWTHRSPY/SIOCGIWTHRSPY and "struct iw_thrspy" - * - Add IW_ENCODE_TEMP and iw_range->encoding_login_index - * - * V16 to V17 - * ---------- - * - Add flags to frequency -> auto/fixed - * - Document (struct iw_quality *)->updated, add new flags (INVALID) - * - Wireless Event capability in struct iw_range - * - Add support for relative TxPower (yick !) - * - * V17 to V18 (From Jouni Malinen ) - * ---------- - * - Add support for WPA/WPA2 - * - Add extended encoding configuration (SIOCSIWENCODEEXT and - * SIOCGIWENCODEEXT) - * - Add SIOCSIWGENIE/SIOCGIWGENIE - * - Add SIOCSIWMLME - * - Add SIOCSIWPMKSA - * - Add struct iw_range bit field for supported encoding capabilities - * - Add optional scan request parameters for SIOCSIWSCAN - * - Add SIOCSIWAUTH/SIOCGIWAUTH for setting authentication and WPA - * related parameters (extensible up to 4096 parameter values) - * - Add wireless events: IWEVGENIE, IWEVMICHAELMICFAILURE, - * IWEVASSOCREQIE, IWEVASSOCRESPIE, IWEVPMKIDCAND - * - * V18 to V19 - * ---------- - * - Remove (struct iw_point *)->pointer from events and streams - * - Remove header includes to help user space - * - Increase IW_ENCODING_TOKEN_MAX from 32 to 64 - * - Add IW_QUAL_ALL_UPDATED and IW_QUAL_ALL_INVALID macros - * - Add explicit flag to tell stats are in dBm : IW_QUAL_DBM - * - Add IW_IOCTL_IDX() and IW_EVENT_IDX() macros - * - * V19 to V20 - * ---------- - * - RtNetlink requests support (SET/GET) - * - * V20 to V21 - * ---------- - * - Remove (struct net_device *)->get_wireless_stats() - * - Change length in ESSID and NICK to strlen() instead of strlen()+1 - * - Add IW_RETRY_SHORT/IW_RETRY_LONG retry modifiers - * - Power/Retry relative values no longer * 100000 - * - Add explicit flag to tell stats are in 802.11k RCPI : IW_QUAL_RCPI - * - * V21 to V22 - * ---------- - * - Prevent leaking of kernel space in stream on 64 bits. - */ - -/**************************** CONSTANTS ****************************/ - -/* -------------------------- IOCTL LIST -------------------------- */ - -/* Wireless Identification */ -#define SIOCSIWCOMMIT 0x8B00 /* Commit pending changes to driver */ -#define SIOCGIWNAME 0x8B01 /* get name == wireless protocol */ -/* SIOCGIWNAME is used to verify the presence of Wireless Extensions. - * Common values : "IEEE 802.11-DS", "IEEE 802.11-FH", "IEEE 802.11b"... - * Don't put the name of your driver there, it's useless. */ - -/* Basic operations */ -#define SIOCSIWNWID 0x8B02 /* set network id (pre-802.11) */ -#define SIOCGIWNWID 0x8B03 /* get network id (the cell) */ -#define SIOCSIWFREQ 0x8B04 /* set channel/frequency (Hz) */ -#define SIOCGIWFREQ 0x8B05 /* get channel/frequency (Hz) */ -#define SIOCSIWMODE 0x8B06 /* set operation mode */ -#define SIOCGIWMODE 0x8B07 /* get operation mode */ -#define SIOCSIWSENS 0x8B08 /* set sensitivity (dBm) */ -#define SIOCGIWSENS 0x8B09 /* get sensitivity (dBm) */ - -/* Informative stuff */ -#define SIOCSIWRANGE 0x8B0A /* Unused */ -#define SIOCGIWRANGE 0x8B0B /* Get range of parameters */ -#define SIOCSIWPRIV 0x8B0C /* Unused */ -#define SIOCGIWPRIV 0x8B0D /* get private ioctl interface info */ -#define SIOCSIWSTATS 0x8B0E /* Unused */ -#define SIOCGIWSTATS 0x8B0F /* Get /proc/net/wireless stats */ -/* SIOCGIWSTATS is strictly used between user space and the kernel, and - * is never passed to the driver (i.e. the driver will never see it). */ - -/* Spy support (statistics per MAC address - used for Mobile IP support) */ -#define SIOCSIWSPY 0x8B10 /* set spy addresses */ -#define SIOCGIWSPY 0x8B11 /* get spy info (quality of link) */ -#define SIOCSIWTHRSPY 0x8B12 /* set spy threshold (spy event) */ -#define SIOCGIWTHRSPY 0x8B13 /* get spy threshold */ - -/* Access Point manipulation */ -#define SIOCSIWAP 0x8B14 /* set access point MAC addresses */ -#define SIOCGIWAP 0x8B15 /* get access point MAC addresses */ -#define SIOCGIWAPLIST 0x8B17 /* Deprecated in favor of scanning */ -#define SIOCSIWSCAN 0x8B18 /* trigger scanning (list cells) */ -#define SIOCGIWSCAN 0x8B19 /* get scanning results */ - -/* 802.11 specific support */ -#define SIOCSIWESSID 0x8B1A /* set ESSID (network name) */ -#define SIOCGIWESSID 0x8B1B /* get ESSID */ -#define SIOCSIWNICKN 0x8B1C /* set node name/nickname */ -#define SIOCGIWNICKN 0x8B1D /* get node name/nickname */ -/* As the ESSID and NICKN are strings up to 32 bytes long, it doesn't fit - * within the 'iwreq' structure, so we need to use the 'data' member to - * point to a string in user space, like it is done for RANGE... */ - -/* Other parameters useful in 802.11 and some other devices */ -#define SIOCSIWRATE 0x8B20 /* set default bit rate (bps) */ -#define SIOCGIWRATE 0x8B21 /* get default bit rate (bps) */ -#define SIOCSIWRTS 0x8B22 /* set RTS/CTS threshold (bytes) */ -#define SIOCGIWRTS 0x8B23 /* get RTS/CTS threshold (bytes) */ -#define SIOCSIWFRAG 0x8B24 /* set fragmentation thr (bytes) */ -#define SIOCGIWFRAG 0x8B25 /* get fragmentation thr (bytes) */ -#define SIOCSIWTXPOW 0x8B26 /* set transmit power (dBm) */ -#define SIOCGIWTXPOW 0x8B27 /* get transmit power (dBm) */ -#define SIOCSIWRETRY 0x8B28 /* set retry limits and lifetime */ -#define SIOCGIWRETRY 0x8B29 /* get retry limits and lifetime */ - -/* Encoding stuff (scrambling, hardware security, WEP...) */ -#define SIOCSIWENCODE 0x8B2A /* set encoding token & mode */ -#define SIOCGIWENCODE 0x8B2B /* get encoding token & mode */ -/* Power saving stuff (power management, unicast and multicast) */ -#define SIOCSIWPOWER 0x8B2C /* set Power Management settings */ -#define SIOCGIWPOWER 0x8B2D /* get Power Management settings */ - -/* WPA : Generic IEEE 802.11 informatiom element (e.g., for WPA/RSN/WMM). - * This ioctl uses struct iw_point and data buffer that includes IE id and len - * fields. More than one IE may be included in the request. Setting the generic - * IE to empty buffer (len=0) removes the generic IE from the driver. Drivers - * are allowed to generate their own WPA/RSN IEs, but in these cases, drivers - * are required to report the used IE as a wireless event, e.g., when - * associating with an AP. */ -#define SIOCSIWGENIE 0x8B30 /* set generic IE */ -#define SIOCGIWGENIE 0x8B31 /* get generic IE */ - -/* WPA : IEEE 802.11 MLME requests */ -#define SIOCSIWMLME 0x8B16 /* request MLME operation; uses - * struct iw_mlme */ -/* WPA : Authentication mode parameters */ -#define SIOCSIWAUTH 0x8B32 /* set authentication mode params */ -#define SIOCGIWAUTH 0x8B33 /* get authentication mode params */ - -/* WPA : Extended version of encoding configuration */ -#define SIOCSIWENCODEEXT 0x8B34 /* set encoding token & mode */ -#define SIOCGIWENCODEEXT 0x8B35 /* get encoding token & mode */ - -/* WPA2 : PMKSA cache management */ -#define SIOCSIWPMKSA 0x8B36 /* PMKSA cache operation */ - -/* -------------------- DEV PRIVATE IOCTL LIST -------------------- */ - -/* These 32 ioctl are wireless device private, for 16 commands. - * Each driver is free to use them for whatever purpose it chooses, - * however the driver *must* export the description of those ioctls - * with SIOCGIWPRIV and *must* use arguments as defined below. - * If you don't follow those rules, DaveM is going to hate you (reason : - * it make mixed 32/64bit operation impossible). - */ -#define SIOCIWFIRSTPRIV 0x8BE0 -#define SIOCIWLASTPRIV 0x8BFF -/* Previously, we were using SIOCDEVPRIVATE, but we now have our - * separate range because of collisions with other tools such as - * 'mii-tool'. - * We now have 32 commands, so a bit more space ;-). - * Also, all 'even' commands are only usable by root and don't return the - * content of ifr/iwr to user (but you are not obliged to use the set/get - * convention, just use every other two command). More details in iwpriv.c. - * And I repeat : you are not forced to use them with iwpriv, but you - * must be compliant with it. - */ - -/* ------------------------- IOCTL STUFF ------------------------- */ - -/* The first and the last (range) */ -#define SIOCIWFIRST 0x8B00 -#define SIOCIWLAST SIOCIWLASTPRIV /* 0x8BFF */ -#define IW_IOCTL_IDX(cmd) ((cmd) - SIOCIWFIRST) -#define IW_HANDLER(id, func) \ - [IW_IOCTL_IDX(id)] = func - -/* Odd : get (world access), even : set (root access) */ -#define IW_IS_SET(cmd) (!((cmd) & 0x1)) -#define IW_IS_GET(cmd) ((cmd) & 0x1) - -/* ----------------------- WIRELESS EVENTS ----------------------- */ -/* Those are *NOT* ioctls, do not issue request on them !!! */ -/* Most events use the same identifier as ioctl requests */ - -#define IWEVTXDROP 0x8C00 /* Packet dropped to excessive retry */ -#define IWEVQUAL 0x8C01 /* Quality part of statistics (scan) */ -#define IWEVCUSTOM 0x8C02 /* Driver specific ascii string */ -#define IWEVREGISTERED 0x8C03 /* Discovered a new node (AP mode) */ -#define IWEVEXPIRED 0x8C04 /* Expired a node (AP mode) */ -#define IWEVGENIE 0x8C05 /* Generic IE (WPA, RSN, WMM, ..) - * (scan results); This includes id and - * length fields. One IWEVGENIE may - * contain more than one IE. Scan - * results may contain one or more - * IWEVGENIE events. */ -#define IWEVMICHAELMICFAILURE 0x8C06 /* Michael MIC failure - * (struct iw_michaelmicfailure) - */ -#define IWEVASSOCREQIE 0x8C07 /* IEs used in (Re)Association Request. - * The data includes id and length - * fields and may contain more than one - * IE. This event is required in - * Managed mode if the driver - * generates its own WPA/RSN IE. This - * should be sent just before - * IWEVREGISTERED event for the - * association. */ -#define IWEVASSOCRESPIE 0x8C08 /* IEs used in (Re)Association - * Response. The data includes id and - * length fields and may contain more - * than one IE. This may be sent - * between IWEVASSOCREQIE and - * IWEVREGISTERED events for the - * association. */ -#define IWEVPMKIDCAND 0x8C09 /* PMKID candidate for RSN - * pre-authentication - * (struct iw_pmkid_cand) */ - -#define IWEVFIRST 0x8C00 -#define IW_EVENT_IDX(cmd) ((cmd) - IWEVFIRST) - -/* ------------------------- PRIVATE INFO ------------------------- */ -/* - * The following is used with SIOCGIWPRIV. It allow a driver to define - * the interface (name, type of data) for its private ioctl. - * Privates ioctl are SIOCIWFIRSTPRIV -> SIOCIWLASTPRIV - */ - -#define IW_PRIV_TYPE_MASK 0x7000 /* Type of arguments */ -#define IW_PRIV_TYPE_NONE 0x0000 -#define IW_PRIV_TYPE_BYTE 0x1000 /* Char as number */ -#define IW_PRIV_TYPE_CHAR 0x2000 /* Char as character */ -#define IW_PRIV_TYPE_INT 0x4000 /* 32 bits int */ -#define IW_PRIV_TYPE_FLOAT 0x5000 /* struct iw_freq */ -#define IW_PRIV_TYPE_ADDR 0x6000 /* struct sockaddr */ - -#define IW_PRIV_SIZE_FIXED 0x0800 /* Variable or fixed number of args */ - -#define IW_PRIV_SIZE_MASK 0x07FF /* Max number of those args */ - -/* - * Note : if the number of args is fixed and the size < 16 octets, - * instead of passing a pointer we will put args in the iwreq struct... - */ - -/* ----------------------- OTHER CONSTANTS ----------------------- */ - -/* Maximum frequencies in the range struct */ -#define IW_MAX_FREQUENCIES 32 -/* Note : if you have something like 80 frequencies, - * don't increase this constant and don't fill the frequency list. - * The user will be able to set by channel anyway... */ - -/* Maximum bit rates in the range struct */ -#define IW_MAX_BITRATES 32 - -/* Maximum tx powers in the range struct */ -#define IW_MAX_TXPOWER 8 -/* Note : if you more than 8 TXPowers, just set the max and min or - * a few of them in the struct iw_range. */ - -/* Maximum of address that you may set with SPY */ -#define IW_MAX_SPY 8 - -/* Maximum of address that you may get in the - list of access points in range */ -#define IW_MAX_AP 64 - -/* Maximum size of the ESSID and NICKN strings */ -#define IW_ESSID_MAX_SIZE 32 - -/* Modes of operation */ -#define IW_MODE_AUTO 0 /* Let the driver decides */ -#define IW_MODE_ADHOC 1 /* Single cell network */ -#define IW_MODE_INFRA 2 /* Multi cell network, roaming, ... */ -#define IW_MODE_MASTER 3 /* Synchronisation master or Access Point */ -#define IW_MODE_REPEAT 4 /* Wireless Repeater (forwarder) */ -#define IW_MODE_SECOND 5 /* Secondary master/repeater (backup) */ -#define IW_MODE_MONITOR 6 /* Passive monitor (listen only) */ -#define IW_MODE_MESH 7 /* Mesh (IEEE 802.11s) network */ - -/* Statistics flags (bitmask in updated) */ -#define IW_QUAL_QUAL_UPDATED 0x01 /* Value was updated since last read */ -#define IW_QUAL_LEVEL_UPDATED 0x02 -#define IW_QUAL_NOISE_UPDATED 0x04 -#define IW_QUAL_ALL_UPDATED 0x07 -#define IW_QUAL_DBM 0x08 /* Level + Noise are dBm */ -#define IW_QUAL_QUAL_INVALID 0x10 /* Driver doesn't provide value */ -#define IW_QUAL_LEVEL_INVALID 0x20 -#define IW_QUAL_NOISE_INVALID 0x40 -#define IW_QUAL_RCPI 0x80 /* Level + Noise are 802.11k RCPI */ -#define IW_QUAL_ALL_INVALID 0x70 - -/* Frequency flags */ -#define IW_FREQ_AUTO 0x00 /* Let the driver decides */ -#define IW_FREQ_FIXED 0x01 /* Force a specific value */ - -/* Maximum number of size of encoding token available - * they are listed in the range structure */ -#define IW_MAX_ENCODING_SIZES 8 - -/* Maximum size of the encoding token in bytes */ -#define IW_ENCODING_TOKEN_MAX 64 /* 512 bits (for now) */ - -/* Flags for encoding (along with the token) */ -#define IW_ENCODE_INDEX 0x00FF /* Token index (if needed) */ -#define IW_ENCODE_FLAGS 0xFF00 /* Flags defined below */ -#define IW_ENCODE_MODE 0xF000 /* Modes defined below */ -#define IW_ENCODE_DISABLED 0x8000 /* Encoding disabled */ -#define IW_ENCODE_ENABLED 0x0000 /* Encoding enabled */ -#define IW_ENCODE_RESTRICTED 0x4000 /* Refuse non-encoded packets */ -#define IW_ENCODE_OPEN 0x2000 /* Accept non-encoded packets */ -#define IW_ENCODE_NOKEY 0x0800 /* Key is write only, so not present */ -#define IW_ENCODE_TEMP 0x0400 /* Temporary key */ - -/* Power management flags available (along with the value, if any) */ -#define IW_POWER_ON 0x0000 /* No details... */ -#define IW_POWER_TYPE 0xF000 /* Type of parameter */ -#define IW_POWER_PERIOD 0x1000 /* Value is a period/duration of */ -#define IW_POWER_TIMEOUT 0x2000 /* Value is a timeout (to go asleep) */ -#define IW_POWER_MODE 0x0F00 /* Power Management mode */ -#define IW_POWER_UNICAST_R 0x0100 /* Receive only unicast messages */ -#define IW_POWER_MULTICAST_R 0x0200 /* Receive only multicast messages */ -#define IW_POWER_ALL_R 0x0300 /* Receive all messages though PM */ -#define IW_POWER_FORCE_S 0x0400 /* Force PM procedure for sending unicast */ -#define IW_POWER_REPEATER 0x0800 /* Repeat broadcast messages in PM period */ -#define IW_POWER_MODIFIER 0x000F /* Modify a parameter */ -#define IW_POWER_MIN 0x0001 /* Value is a minimum */ -#define IW_POWER_MAX 0x0002 /* Value is a maximum */ -#define IW_POWER_RELATIVE 0x0004 /* Value is not in seconds/ms/us */ - -/* Transmit Power flags available */ -#define IW_TXPOW_TYPE 0x00FF /* Type of value */ -#define IW_TXPOW_DBM 0x0000 /* Value is in dBm */ -#define IW_TXPOW_MWATT 0x0001 /* Value is in mW */ -#define IW_TXPOW_RELATIVE 0x0002 /* Value is in arbitrary units */ -#define IW_TXPOW_RANGE 0x1000 /* Range of value between min/max */ - -/* Retry limits and lifetime flags available */ -#define IW_RETRY_ON 0x0000 /* No details... */ -#define IW_RETRY_TYPE 0xF000 /* Type of parameter */ -#define IW_RETRY_LIMIT 0x1000 /* Maximum number of retries*/ -#define IW_RETRY_LIFETIME 0x2000 /* Maximum duration of retries in us */ -#define IW_RETRY_MODIFIER 0x00FF /* Modify a parameter */ -#define IW_RETRY_MIN 0x0001 /* Value is a minimum */ -#define IW_RETRY_MAX 0x0002 /* Value is a maximum */ -#define IW_RETRY_RELATIVE 0x0004 /* Value is not in seconds/ms/us */ -#define IW_RETRY_SHORT 0x0010 /* Value is for short packets */ -#define IW_RETRY_LONG 0x0020 /* Value is for long packets */ - -/* Scanning request flags */ -#define IW_SCAN_DEFAULT 0x0000 /* Default scan of the driver */ -#define IW_SCAN_ALL_ESSID 0x0001 /* Scan all ESSIDs */ -#define IW_SCAN_THIS_ESSID 0x0002 /* Scan only this ESSID */ -#define IW_SCAN_ALL_FREQ 0x0004 /* Scan all Frequencies */ -#define IW_SCAN_THIS_FREQ 0x0008 /* Scan only this Frequency */ -#define IW_SCAN_ALL_MODE 0x0010 /* Scan all Modes */ -#define IW_SCAN_THIS_MODE 0x0020 /* Scan only this Mode */ -#define IW_SCAN_ALL_RATE 0x0040 /* Scan all Bit-Rates */ -#define IW_SCAN_THIS_RATE 0x0080 /* Scan only this Bit-Rate */ -/* struct iw_scan_req scan_type */ -#define IW_SCAN_TYPE_ACTIVE 0 -#define IW_SCAN_TYPE_PASSIVE 1 -/* Maximum size of returned data */ -#define IW_SCAN_MAX_DATA 4096 /* In bytes */ - -/* Scan capability flags - in (struct iw_range *)->scan_capa */ -#define IW_SCAN_CAPA_NONE 0x00 -#define IW_SCAN_CAPA_ESSID 0x01 -#define IW_SCAN_CAPA_BSSID 0x02 -#define IW_SCAN_CAPA_CHANNEL 0x04 -#define IW_SCAN_CAPA_MODE 0x08 -#define IW_SCAN_CAPA_RATE 0x10 -#define IW_SCAN_CAPA_TYPE 0x20 -#define IW_SCAN_CAPA_TIME 0x40 - -/* Max number of char in custom event - use multiple of them if needed */ -#define IW_CUSTOM_MAX 256 /* In bytes */ - -/* Generic information element */ -#define IW_GENERIC_IE_MAX 1024 - -/* MLME requests (SIOCSIWMLME / struct iw_mlme) */ -#define IW_MLME_DEAUTH 0 -#define IW_MLME_DISASSOC 1 -#define IW_MLME_AUTH 2 -#define IW_MLME_ASSOC 3 - -/* SIOCSIWAUTH/SIOCGIWAUTH struct iw_param flags */ -#define IW_AUTH_INDEX 0x0FFF -#define IW_AUTH_FLAGS 0xF000 -/* SIOCSIWAUTH/SIOCGIWAUTH parameters (0 .. 4095) - * (IW_AUTH_INDEX mask in struct iw_param flags; this is the index of the - * parameter that is being set/get to; value will be read/written to - * struct iw_param value field) */ -#define IW_AUTH_WPA_VERSION 0 -#define IW_AUTH_CIPHER_PAIRWISE 1 -#define IW_AUTH_CIPHER_GROUP 2 -#define IW_AUTH_KEY_MGMT 3 -#define IW_AUTH_TKIP_COUNTERMEASURES 4 -#define IW_AUTH_DROP_UNENCRYPTED 5 -#define IW_AUTH_80211_AUTH_ALG 6 -#define IW_AUTH_WPA_ENABLED 7 -#define IW_AUTH_RX_UNENCRYPTED_EAPOL 8 -#define IW_AUTH_ROAMING_CONTROL 9 -#define IW_AUTH_PRIVACY_INVOKED 10 -#define IW_AUTH_CIPHER_GROUP_MGMT 11 -#define IW_AUTH_MFP 12 - -/* IW_AUTH_WPA_VERSION values (bit field) */ -#define IW_AUTH_WPA_VERSION_DISABLED 0x00000001 -#define IW_AUTH_WPA_VERSION_WPA 0x00000002 -#define IW_AUTH_WPA_VERSION_WPA2 0x00000004 - -/* IW_AUTH_PAIRWISE_CIPHER, IW_AUTH_GROUP_CIPHER, and IW_AUTH_CIPHER_GROUP_MGMT - * values (bit field) */ -#define IW_AUTH_CIPHER_NONE 0x00000001 -#define IW_AUTH_CIPHER_WEP40 0x00000002 -#define IW_AUTH_CIPHER_TKIP 0x00000004 -#define IW_AUTH_CIPHER_CCMP 0x00000008 -#define IW_AUTH_CIPHER_WEP104 0x00000010 -#define IW_AUTH_CIPHER_AES_CMAC 0x00000020 - -/* IW_AUTH_KEY_MGMT values (bit field) */ -#define IW_AUTH_KEY_MGMT_802_1X 1 -#define IW_AUTH_KEY_MGMT_PSK 2 - -/* IW_AUTH_80211_AUTH_ALG values (bit field) */ -#define IW_AUTH_ALG_OPEN_SYSTEM 0x00000001 -#define IW_AUTH_ALG_SHARED_KEY 0x00000002 -#define IW_AUTH_ALG_LEAP 0x00000004 - -/* IW_AUTH_ROAMING_CONTROL values */ -#define IW_AUTH_ROAMING_ENABLE 0 /* driver/firmware based roaming */ -#define IW_AUTH_ROAMING_DISABLE 1 /* user space program used for roaming - * control */ - -/* IW_AUTH_MFP (management frame protection) values */ -#define IW_AUTH_MFP_DISABLED 0 /* MFP disabled */ -#define IW_AUTH_MFP_OPTIONAL 1 /* MFP optional */ -#define IW_AUTH_MFP_REQUIRED 2 /* MFP required */ - -/* SIOCSIWENCODEEXT definitions */ -#define IW_ENCODE_SEQ_MAX_SIZE 8 -/* struct iw_encode_ext ->alg */ -#define IW_ENCODE_ALG_NONE 0 -#define IW_ENCODE_ALG_WEP 1 -#define IW_ENCODE_ALG_TKIP 2 -#define IW_ENCODE_ALG_CCMP 3 -#define IW_ENCODE_ALG_PMK 4 -#define IW_ENCODE_ALG_AES_CMAC 5 -/* struct iw_encode_ext ->ext_flags */ -#define IW_ENCODE_EXT_TX_SEQ_VALID 0x00000001 -#define IW_ENCODE_EXT_RX_SEQ_VALID 0x00000002 -#define IW_ENCODE_EXT_GROUP_KEY 0x00000004 -#define IW_ENCODE_EXT_SET_TX_KEY 0x00000008 - -/* IWEVMICHAELMICFAILURE : struct iw_michaelmicfailure ->flags */ -#define IW_MICFAILURE_KEY_ID 0x00000003 /* Key ID 0..3 */ -#define IW_MICFAILURE_GROUP 0x00000004 -#define IW_MICFAILURE_PAIRWISE 0x00000008 -#define IW_MICFAILURE_STAKEY 0x00000010 -#define IW_MICFAILURE_COUNT 0x00000060 /* 1 or 2 (0 = count not supported) - */ - -/* Bit field values for enc_capa in struct iw_range */ -#define IW_ENC_CAPA_WPA 0x00000001 -#define IW_ENC_CAPA_WPA2 0x00000002 -#define IW_ENC_CAPA_CIPHER_TKIP 0x00000004 -#define IW_ENC_CAPA_CIPHER_CCMP 0x00000008 -#define IW_ENC_CAPA_4WAY_HANDSHAKE 0x00000010 - -/* Event capability macros - in (struct iw_range *)->event_capa - * Because we have more than 32 possible events, we use an array of - * 32 bit bitmasks. Note : 32 bits = 0x20 = 2^5. */ -#define IW_EVENT_CAPA_BASE(cmd) ((cmd >= SIOCIWFIRSTPRIV) ? \ - (cmd - SIOCIWFIRSTPRIV + 0x60) : \ - (cmd - SIOCIWFIRST)) -#define IW_EVENT_CAPA_INDEX(cmd) (IW_EVENT_CAPA_BASE(cmd) >> 5) -#define IW_EVENT_CAPA_MASK(cmd) (1 << (IW_EVENT_CAPA_BASE(cmd) & 0x1F)) -/* Event capability constants - event autogenerated by the kernel - * This list is valid for most 802.11 devices, customise as needed... */ -#define IW_EVENT_CAPA_K_0 (IW_EVENT_CAPA_MASK(0x8B04) | \ - IW_EVENT_CAPA_MASK(0x8B06) | \ - IW_EVENT_CAPA_MASK(0x8B1A)) -#define IW_EVENT_CAPA_K_1 (IW_EVENT_CAPA_MASK(0x8B2A)) -/* "Easy" macro to set events in iw_range (less efficient) */ -#define IW_EVENT_CAPA_SET(event_capa, cmd) (event_capa[IW_EVENT_CAPA_INDEX(cmd)] |= IW_EVENT_CAPA_MASK(cmd)) -#define IW_EVENT_CAPA_SET_KERNEL(event_capa) {event_capa[0] |= IW_EVENT_CAPA_K_0; event_capa[1] |= IW_EVENT_CAPA_K_1; } - - -/****************************** TYPES ******************************/ - -/* --------------------------- SUBTYPES --------------------------- */ -/* - * Generic format for most parameters that fit in an int - */ -struct iw_param -{ - __s32 value; /* The value of the parameter itself */ - __u8 fixed; /* Hardware should not use auto select */ - __u8 disabled; /* Disable the feature */ - __u16 flags; /* Various specifc flags (if any) */ -}; - -/* - * For all data larger than 16 octets, we need to use a - * pointer to memory allocated in user space. - */ -struct iw_point -{ - void __user *pointer; /* Pointer to the data (in user space) */ - __u16 length; /* number of fields or size in bytes */ - __u16 flags; /* Optional params */ -}; - -#ifdef __KERNEL__ -#ifdef CONFIG_COMPAT - -#include - -struct compat_iw_point { - compat_caddr_t pointer; - __u16 length; - __u16 flags; -}; -#endif -#endif - -/* - * A frequency - * For numbers lower than 10^9, we encode the number in 'm' and - * set 'e' to 0 - * For number greater than 10^9, we divide it by the lowest power - * of 10 to get 'm' lower than 10^9, with 'm'= f / (10^'e')... - * The power of 10 is in 'e', the result of the division is in 'm'. - */ -struct iw_freq -{ - __s32 m; /* Mantissa */ - __s16 e; /* Exponent */ - __u8 i; /* List index (when in range struct) */ - __u8 flags; /* Flags (fixed/auto) */ -}; - -/* - * Quality of the link - */ -struct iw_quality -{ - __u8 qual; /* link quality (%retries, SNR, - %missed beacons or better...) */ - __u8 level; /* signal level (dBm) */ - __u8 noise; /* noise level (dBm) */ - __u8 updated; /* Flags to know if updated */ -}; - -/* - * Packet discarded in the wireless adapter due to - * "wireless" specific problems... - * Note : the list of counter and statistics in net_device_stats - * is already pretty exhaustive, and you should use that first. - * This is only additional stats... - */ -struct iw_discarded -{ - __u32 nwid; /* Rx : Wrong nwid/essid */ - __u32 code; /* Rx : Unable to code/decode (WEP) */ - __u32 fragment; /* Rx : Can't perform MAC reassembly */ - __u32 retries; /* Tx : Max MAC retries num reached */ - __u32 misc; /* Others cases */ -}; - -/* - * Packet/Time period missed in the wireless adapter due to - * "wireless" specific problems... - */ -struct iw_missed -{ - __u32 beacon; /* Missed beacons/superframe */ -}; - -/* - * Quality range (for spy threshold) - */ -struct iw_thrspy -{ - struct sockaddr addr; /* Source address (hw/mac) */ - struct iw_quality qual; /* Quality of the link */ - struct iw_quality low; /* Low threshold */ - struct iw_quality high; /* High threshold */ -}; - -/* - * Optional data for scan request - * - * Note: these optional parameters are controlling parameters for the - * scanning behavior, these do not apply to getting scan results - * (SIOCGIWSCAN). Drivers are expected to keep a local BSS table and - * provide a merged results with all BSSes even if the previous scan - * request limited scanning to a subset, e.g., by specifying an SSID. - * Especially, scan results are required to include an entry for the - * current BSS if the driver is in Managed mode and associated with an AP. - */ -struct iw_scan_req -{ - __u8 scan_type; /* IW_SCAN_TYPE_{ACTIVE,PASSIVE} */ - __u8 essid_len; - __u8 num_channels; /* num entries in channel_list; - * 0 = scan all allowed channels */ - __u8 flags; /* reserved as padding; use zero, this may - * be used in the future for adding flags - * to request different scan behavior */ - struct sockaddr bssid; /* ff:ff:ff:ff:ff:ff for broadcast BSSID or - * individual address of a specific BSS */ - - /* - * Use this ESSID if IW_SCAN_THIS_ESSID flag is used instead of using - * the current ESSID. This allows scan requests for specific ESSID - * without having to change the current ESSID and potentially breaking - * the current association. - */ - __u8 essid[IW_ESSID_MAX_SIZE]; - - /* - * Optional parameters for changing the default scanning behavior. - * These are based on the MLME-SCAN.request from IEEE Std 802.11. - * TU is 1.024 ms. If these are set to 0, driver is expected to use - * reasonable default values. min_channel_time defines the time that - * will be used to wait for the first reply on each channel. If no - * replies are received, next channel will be scanned after this. If - * replies are received, total time waited on the channel is defined by - * max_channel_time. - */ - __u32 min_channel_time; /* in TU */ - __u32 max_channel_time; /* in TU */ - - struct iw_freq channel_list[IW_MAX_FREQUENCIES]; -}; - -/* ------------------------- WPA SUPPORT ------------------------- */ - -/* - * Extended data structure for get/set encoding (this is used with - * SIOCSIWENCODEEXT/SIOCGIWENCODEEXT. struct iw_point and IW_ENCODE_* - * flags are used in the same way as with SIOCSIWENCODE/SIOCGIWENCODE and - * only the data contents changes (key data -> this structure, including - * key data). - * - * If the new key is the first group key, it will be set as the default - * TX key. Otherwise, default TX key index is only changed if - * IW_ENCODE_EXT_SET_TX_KEY flag is set. - * - * Key will be changed with SIOCSIWENCODEEXT in all cases except for - * special "change TX key index" operation which is indicated by setting - * key_len = 0 and ext_flags |= IW_ENCODE_EXT_SET_TX_KEY. - * - * tx_seq/rx_seq are only used when respective - * IW_ENCODE_EXT_{TX,RX}_SEQ_VALID flag is set in ext_flags. Normal - * TKIP/CCMP operation is to set RX seq with SIOCSIWENCODEEXT and start - * TX seq from zero whenever key is changed. SIOCGIWENCODEEXT is normally - * used only by an Authenticator (AP or an IBSS station) to get the - * current TX sequence number. Using TX_SEQ_VALID for SIOCSIWENCODEEXT and - * RX_SEQ_VALID for SIOCGIWENCODEEXT are optional, but can be useful for - * debugging/testing. - */ -struct iw_encode_ext -{ - __u32 ext_flags; /* IW_ENCODE_EXT_* */ - __u8 tx_seq[IW_ENCODE_SEQ_MAX_SIZE]; /* LSB first */ - __u8 rx_seq[IW_ENCODE_SEQ_MAX_SIZE]; /* LSB first */ - struct sockaddr addr; /* ff:ff:ff:ff:ff:ff for broadcast/multicast - * (group) keys or unicast address for - * individual keys */ - __u16 alg; /* IW_ENCODE_ALG_* */ - __u16 key_len; - __u8 key[0]; -}; - -/* SIOCSIWMLME data */ -struct iw_mlme -{ - __u16 cmd; /* IW_MLME_* */ - __u16 reason_code; - struct sockaddr addr; -}; - -/* SIOCSIWPMKSA data */ -#define IW_PMKSA_ADD 1 -#define IW_PMKSA_REMOVE 2 -#define IW_PMKSA_FLUSH 3 - -#define IW_PMKID_LEN 16 - -struct iw_pmksa -{ - __u32 cmd; /* IW_PMKSA_* */ - struct sockaddr bssid; - __u8 pmkid[IW_PMKID_LEN]; -}; - -/* IWEVMICHAELMICFAILURE data */ -struct iw_michaelmicfailure -{ - __u32 flags; - struct sockaddr src_addr; - __u8 tsc[IW_ENCODE_SEQ_MAX_SIZE]; /* LSB first */ -}; - -/* IWEVPMKIDCAND data */ -#define IW_PMKID_CAND_PREAUTH 0x00000001 /* RNS pre-authentication enabled */ -struct iw_pmkid_cand -{ - __u32 flags; /* IW_PMKID_CAND_* */ - __u32 index; /* the smaller the index, the higher the - * priority */ - struct sockaddr bssid; -}; - -/* ------------------------ WIRELESS STATS ------------------------ */ -/* - * Wireless statistics (used for /proc/net/wireless) - */ -struct iw_statistics -{ - __u16 status; /* Status - * - device dependent for now */ - - struct iw_quality qual; /* Quality of the link - * (instant/mean/max) */ - struct iw_discarded discard; /* Packet discarded counts */ - struct iw_missed miss; /* Packet missed counts */ -}; - -/* ------------------------ IOCTL REQUEST ------------------------ */ -/* - * This structure defines the payload of an ioctl, and is used - * below. - * - * Note that this structure should fit on the memory footprint - * of iwreq (which is the same as ifreq), which mean a max size of - * 16 octets = 128 bits. Warning, pointers might be 64 bits wide... - * You should check this when increasing the structures defined - * above in this file... - */ -union iwreq_data -{ - /* Config - generic */ - char name[IFNAMSIZ]; - /* Name : used to verify the presence of wireless extensions. - * Name of the protocol/provider... */ - - struct iw_point essid; /* Extended network name */ - struct iw_param nwid; /* network id (or domain - the cell) */ - struct iw_freq freq; /* frequency or channel : - * 0-1000 = channel - * > 1000 = frequency in Hz */ - - struct iw_param sens; /* signal level threshold */ - struct iw_param bitrate; /* default bit rate */ - struct iw_param txpower; /* default transmit power */ - struct iw_param rts; /* RTS threshold threshold */ - struct iw_param frag; /* Fragmentation threshold */ - __u32 mode; /* Operation mode */ - struct iw_param retry; /* Retry limits & lifetime */ - - struct iw_point encoding; /* Encoding stuff : tokens */ - struct iw_param power; /* PM duration/timeout */ - struct iw_quality qual; /* Quality part of statistics */ - - struct sockaddr ap_addr; /* Access point address */ - struct sockaddr addr; /* Destination address (hw/mac) */ - - struct iw_param param; /* Other small parameters */ - struct iw_point data; /* Other large parameters */ -}; - -/* - * The structure to exchange data for ioctl. - * This structure is the same as 'struct ifreq', but (re)defined for - * convenience... - * Do I need to remind you about structure size (32 octets) ? - */ -struct iwreq -{ - union - { - char ifrn_name[IFNAMSIZ]; /* if name, e.g. "eth0" */ - } ifr_ifrn; - - /* Data part (defined just above) */ - union iwreq_data u; -}; - -/* -------------------------- IOCTL DATA -------------------------- */ -/* - * For those ioctl which want to exchange mode data that what could - * fit in the above structure... - */ - -/* - * Range of parameters - */ - -struct iw_range -{ - /* Informative stuff (to choose between different interface) */ - __u32 throughput; /* To give an idea... */ - /* In theory this value should be the maximum benchmarked - * TCP/IP throughput, because with most of these devices the - * bit rate is meaningless (overhead an co) to estimate how - * fast the connection will go and pick the fastest one. - * I suggest people to play with Netperf or any benchmark... - */ - - /* NWID (or domain id) */ - __u32 min_nwid; /* Minimal NWID we are able to set */ - __u32 max_nwid; /* Maximal NWID we are able to set */ - - /* Old Frequency (backward compat - moved lower ) */ - __u16 old_num_channels; - __u8 old_num_frequency; - - /* Scan capabilities */ - __u8 scan_capa; /* IW_SCAN_CAPA_* bit field */ - - /* Wireless event capability bitmasks */ - __u32 event_capa[6]; - - /* signal level threshold range */ - __s32 sensitivity; - - /* Quality of link & SNR stuff */ - /* Quality range (link, level, noise) - * If the quality is absolute, it will be in the range [0 ; max_qual], - * if the quality is dBm, it will be in the range [max_qual ; 0]. - * Don't forget that we use 8 bit arithmetics... */ - struct iw_quality max_qual; /* Quality of the link */ - /* This should contain the average/typical values of the quality - * indicator. This should be the threshold between a "good" and - * a "bad" link (example : monitor going from green to orange). - * Currently, user space apps like quality monitors don't have any - * way to calibrate the measurement. With this, they can split - * the range between 0 and max_qual in different quality level - * (using a geometric subdivision centered on the average). - * I expect that people doing the user space apps will feedback - * us on which value we need to put in each driver... */ - struct iw_quality avg_qual; /* Quality of the link */ - - /* Rates */ - __u8 num_bitrates; /* Number of entries in the list */ - __s32 bitrate[IW_MAX_BITRATES]; /* list, in bps */ - - /* RTS threshold */ - __s32 min_rts; /* Minimal RTS threshold */ - __s32 max_rts; /* Maximal RTS threshold */ - - /* Frag threshold */ - __s32 min_frag; /* Minimal frag threshold */ - __s32 max_frag; /* Maximal frag threshold */ - - /* Power Management duration & timeout */ - __s32 min_pmp; /* Minimal PM period */ - __s32 max_pmp; /* Maximal PM period */ - __s32 min_pmt; /* Minimal PM timeout */ - __s32 max_pmt; /* Maximal PM timeout */ - __u16 pmp_flags; /* How to decode max/min PM period */ - __u16 pmt_flags; /* How to decode max/min PM timeout */ - __u16 pm_capa; /* What PM options are supported */ - - /* Encoder stuff */ - __u16 encoding_size[IW_MAX_ENCODING_SIZES]; /* Different token sizes */ - __u8 num_encoding_sizes; /* Number of entry in the list */ - __u8 max_encoding_tokens; /* Max number of tokens */ - /* For drivers that need a "login/passwd" form */ - __u8 encoding_login_index; /* token index for login token */ - - /* Transmit power */ - __u16 txpower_capa; /* What options are supported */ - __u8 num_txpower; /* Number of entries in the list */ - __s32 txpower[IW_MAX_TXPOWER]; /* list, in bps */ - - /* Wireless Extension version info */ - __u8 we_version_compiled; /* Must be WIRELESS_EXT */ - __u8 we_version_source; /* Last update of source */ - - /* Retry limits and lifetime */ - __u16 retry_capa; /* What retry options are supported */ - __u16 retry_flags; /* How to decode max/min retry limit */ - __u16 r_time_flags; /* How to decode max/min retry life */ - __s32 min_retry; /* Minimal number of retries */ - __s32 max_retry; /* Maximal number of retries */ - __s32 min_r_time; /* Minimal retry lifetime */ - __s32 max_r_time; /* Maximal retry lifetime */ - - /* Frequency */ - __u16 num_channels; /* Number of channels [0; num - 1] */ - __u8 num_frequency; /* Number of entry in the list */ - struct iw_freq freq[IW_MAX_FREQUENCIES]; /* list */ - /* Note : this frequency list doesn't need to fit channel numbers, - * because each entry contain its channel index */ - - __u32 enc_capa; /* IW_ENC_CAPA_* bit field */ -}; - -/* - * Private ioctl interface information - */ - -struct iw_priv_args -{ - __u32 cmd; /* Number of the ioctl to issue */ - __u16 set_args; /* Type and number of args */ - __u16 get_args; /* Type and number of args */ - char name[IFNAMSIZ]; /* Name of the extension */ -}; - -/* ----------------------- WIRELESS EVENTS ----------------------- */ -/* - * Wireless events are carried through the rtnetlink socket to user - * space. They are encapsulated in the IFLA_WIRELESS field of - * a RTM_NEWLINK message. - */ - -/* - * A Wireless Event. Contains basically the same data as the ioctl... - */ -struct iw_event -{ - __u16 len; /* Real length of this stuff */ - __u16 cmd; /* Wireless IOCTL */ - union iwreq_data u; /* IOCTL fixed payload */ -}; - -/* Size of the Event prefix (including padding and alignement junk) */ -#define IW_EV_LCP_LEN (sizeof(struct iw_event) - sizeof(union iwreq_data)) -/* Size of the various events */ -#define IW_EV_CHAR_LEN (IW_EV_LCP_LEN + IFNAMSIZ) -#define IW_EV_UINT_LEN (IW_EV_LCP_LEN + sizeof(__u32)) -#define IW_EV_FREQ_LEN (IW_EV_LCP_LEN + sizeof(struct iw_freq)) -#define IW_EV_PARAM_LEN (IW_EV_LCP_LEN + sizeof(struct iw_param)) -#define IW_EV_ADDR_LEN (IW_EV_LCP_LEN + sizeof(struct sockaddr)) -#define IW_EV_QUAL_LEN (IW_EV_LCP_LEN + sizeof(struct iw_quality)) - -/* iw_point events are special. First, the payload (extra data) come at - * the end of the event, so they are bigger than IW_EV_POINT_LEN. Second, - * we omit the pointer, so start at an offset. */ -#define IW_EV_POINT_OFF (((char *) &(((struct iw_point *) NULL)->length)) - \ - (char *) NULL) -#define IW_EV_POINT_LEN (IW_EV_LCP_LEN + sizeof(struct iw_point) - \ - IW_EV_POINT_OFF) - -#ifdef __KERNEL__ -#ifdef CONFIG_COMPAT -struct __compat_iw_event { - __u16 len; /* Real length of this stuff */ - __u16 cmd; /* Wireless IOCTL */ - compat_caddr_t pointer; -}; -#define IW_EV_COMPAT_LCP_LEN offsetof(struct __compat_iw_event, pointer) -#define IW_EV_COMPAT_POINT_OFF offsetof(struct compat_iw_point, length) - -/* Size of the various events for compat */ -#define IW_EV_COMPAT_CHAR_LEN (IW_EV_COMPAT_LCP_LEN + IFNAMSIZ) -#define IW_EV_COMPAT_UINT_LEN (IW_EV_COMPAT_LCP_LEN + sizeof(__u32)) -#define IW_EV_COMPAT_FREQ_LEN (IW_EV_COMPAT_LCP_LEN + sizeof(struct iw_freq)) -#define IW_EV_COMPAT_PARAM_LEN (IW_EV_COMPAT_LCP_LEN + sizeof(struct iw_param)) -#define IW_EV_COMPAT_ADDR_LEN (IW_EV_COMPAT_LCP_LEN + sizeof(struct sockaddr)) -#define IW_EV_COMPAT_QUAL_LEN (IW_EV_COMPAT_LCP_LEN + sizeof(struct iw_quality)) -#define IW_EV_COMPAT_POINT_LEN \ - (IW_EV_COMPAT_LCP_LEN + sizeof(struct compat_iw_point) - \ - IW_EV_COMPAT_POINT_OFF) -#endif -#endif - -/* Size of the Event prefix when packed in stream */ -#define IW_EV_LCP_PK_LEN (4) -/* Size of the various events when packed in stream */ -#define IW_EV_CHAR_PK_LEN (IW_EV_LCP_PK_LEN + IFNAMSIZ) -#define IW_EV_UINT_PK_LEN (IW_EV_LCP_PK_LEN + sizeof(__u32)) -#define IW_EV_FREQ_PK_LEN (IW_EV_LCP_PK_LEN + sizeof(struct iw_freq)) -#define IW_EV_PARAM_PK_LEN (IW_EV_LCP_PK_LEN + sizeof(struct iw_param)) -#define IW_EV_ADDR_PK_LEN (IW_EV_LCP_PK_LEN + sizeof(struct sockaddr)) -#define IW_EV_QUAL_PK_LEN (IW_EV_LCP_PK_LEN + sizeof(struct iw_quality)) -#define IW_EV_POINT_PK_LEN (IW_EV_LCP_PK_LEN + 4) - -#endif /* _LINUX_WIRELESS_H */ diff --git a/backport/include/net/codel.h b/backport/include/net/codel.h deleted file mode 100644 index eee0359cd6e5..000000000000 --- a/backport/include/net/codel.h +++ /dev/null @@ -1,363 +0,0 @@ -#include -#include - -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,5,0)) || (defined(TCA_CODEL_MAX) && !defined(COMPAT_CODEL_BACKPORT)) -#include_next -#else - -#ifndef __NET_SCHED_CODEL_H -#define __NET_SCHED_CODEL_H - -/* - * Codel - The Controlled-Delay Active Queue Management algorithm - * - * Copyright (C) 2011-2012 Kathleen Nichols - * Copyright (C) 2011-2012 Van Jacobson - * Copyright (C) 2012 Michael D. Taht - * Copyright (C) 2012 Eric Dumazet - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions, and the following disclaimer, - * without modification. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * 3. The names of the authors may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * Alternatively, provided that this notice is retained in full, this - * software may be distributed under the terms of the GNU General - * Public License ("GPL") version 2, in which case the provisions of the - * GPL apply INSTEAD OF those given above. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH - * DAMAGE. - * - */ - -#include -#include -#include -#include -#include -#include - -/* Controlling Queue Delay (CoDel) algorithm - * ========================================= - * Source : Kathleen Nichols and Van Jacobson - * http://queue.acm.org/detail.cfm?id=2209336 - * - * Implemented on linux by Dave Taht and Eric Dumazet - */ - - -/* CoDel uses a 1024 nsec clock, encoded in u32 - * This gives a range of 2199 seconds, because of signed compares - */ -typedef u32 codel_time_t; -typedef s32 codel_tdiff_t; -#define CODEL_SHIFT 10 -#define MS2TIME(a) ((a * NSEC_PER_MSEC) >> CODEL_SHIFT) - -static inline codel_time_t codel_get_time(void) -{ - u64 ns = ktime_to_ns(ktime_get()); - - return ns >> CODEL_SHIFT; -} - -#define codel_time_after(a, b) ((s32)(a) - (s32)(b) > 0) -#define codel_time_after_eq(a, b) ((s32)(a) - (s32)(b) >= 0) -#define codel_time_before(a, b) ((s32)(a) - (s32)(b) < 0) -#define codel_time_before_eq(a, b) ((s32)(a) - (s32)(b) <= 0) - -/* Qdiscs using codel plugin must use codel_skb_cb in their own cb[] */ -struct codel_skb_cb { - codel_time_t enqueue_time; -}; - -static struct codel_skb_cb *get_codel_cb(const struct sk_buff *skb) -{ - qdisc_cb_private_validate(skb, sizeof(struct codel_skb_cb)); -#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,37)) - return (struct codel_skb_cb *)qdisc_skb_cb((struct sk_buff *) skb)->data; -#else - return (struct codel_skb_cb *)qdisc_skb_cb(skb)->data; -#endif -} - -static codel_time_t codel_get_enqueue_time(const struct sk_buff *skb) -{ - return get_codel_cb(skb)->enqueue_time; -} - -static void codel_set_enqueue_time(struct sk_buff *skb) -{ - get_codel_cb(skb)->enqueue_time = codel_get_time(); -} - -static inline u32 codel_time_to_us(codel_time_t val) -{ - u64 valns = ((u64)val << CODEL_SHIFT); - - do_div(valns, NSEC_PER_USEC); - return (u32)valns; -} - -/** - * struct codel_params - contains codel parameters - * @target: target queue size (in time units) - * @interval: width of moving time window - * @ecn: is Explicit Congestion Notification enabled - */ -struct codel_params { - codel_time_t target; - codel_time_t interval; - bool ecn; -}; - -/** - * struct codel_vars - contains codel variables - * @count: how many drops we've done since the last time we - * entered dropping state - * @lastcount: count at entry to dropping state - * @dropping: set to true if in dropping state - * @rec_inv_sqrt: reciprocal value of sqrt(count) >> 1 - * @first_above_time: when we went (or will go) continuously above target - * for interval - * @drop_next: time to drop next packet, or when we dropped last - * @ldelay: sojourn time of last dequeued packet - */ -struct codel_vars { - u32 count; - u32 lastcount; - bool dropping; - u16 rec_inv_sqrt; - codel_time_t first_above_time; - codel_time_t drop_next; - codel_time_t ldelay; -}; - -#define REC_INV_SQRT_BITS (8 * sizeof(u16)) /* or sizeof_in_bits(rec_inv_sqrt) */ -/* needed shift to get a Q0.32 number from rec_inv_sqrt */ -#define REC_INV_SQRT_SHIFT (32 - REC_INV_SQRT_BITS) - -/** - * struct codel_stats - contains codel shared variables and stats - * @maxpacket: largest packet we've seen so far - * @drop_count: temp count of dropped packets in dequeue() - * ecn_mark: number of packets we ECN marked instead of dropping - */ -struct codel_stats { - u32 maxpacket; - u32 drop_count; - u32 ecn_mark; -}; - -static void codel_params_init(struct codel_params *params) -{ - params->interval = MS2TIME(100); - params->target = MS2TIME(5); - params->ecn = false; -} - -static void codel_vars_init(struct codel_vars *vars) -{ - memset(vars, 0, sizeof(*vars)); -} - -static void codel_stats_init(struct codel_stats *stats) -{ - stats->maxpacket = 256; -} - -/* - * http://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Iterative_methods_for_reciprocal_square_roots - * new_invsqrt = (invsqrt / 2) * (3 - count * invsqrt^2) - * - * Here, invsqrt is a fixed point number (< 1.0), 32bit mantissa, aka Q0.32 - */ -static void codel_Newton_step(struct codel_vars *vars) -{ - u32 invsqrt = ((u32)vars->rec_inv_sqrt) << REC_INV_SQRT_SHIFT; - u32 invsqrt2 = ((u64)invsqrt * invsqrt) >> 32; - u64 val = (3LL << 32) - ((u64)vars->count * invsqrt2); - - val >>= 2; /* avoid overflow in following multiply */ - val = (val * invsqrt) >> (32 - 2 + 1); - - vars->rec_inv_sqrt = val >> REC_INV_SQRT_SHIFT; -} - -/* - * CoDel control_law is t + interval/sqrt(count) - * We maintain in rec_inv_sqrt the reciprocal value of sqrt(count) to avoid - * both sqrt() and divide operation. - */ -static codel_time_t codel_control_law(codel_time_t t, - codel_time_t interval, - u32 rec_inv_sqrt) -{ - return t + reciprocal_divide(interval, rec_inv_sqrt << REC_INV_SQRT_SHIFT); -} - - -static bool codel_should_drop(const struct sk_buff *skb, - struct Qdisc *sch, - struct codel_vars *vars, - struct codel_params *params, - struct codel_stats *stats, - codel_time_t now) -{ - bool ok_to_drop; - - if (!skb) { - vars->first_above_time = 0; - return false; - } - - vars->ldelay = now - codel_get_enqueue_time(skb); -#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,37)) - sch->qstats.backlog -= qdisc_pkt_len((struct sk_buff *)skb); -#else - sch->qstats.backlog -= qdisc_pkt_len(skb); -#endif - -#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,37)) - if (unlikely(qdisc_pkt_len((struct sk_buff *)skb) > stats->maxpacket)) - stats->maxpacket = qdisc_pkt_len((struct sk_buff *)skb); -#else - if (unlikely(qdisc_pkt_len(skb) > stats->maxpacket)) - stats->maxpacket = qdisc_pkt_len(skb); -#endif - - if (codel_time_before(vars->ldelay, params->target) || - sch->qstats.backlog <= stats->maxpacket) { - /* went below - stay below for at least interval */ - vars->first_above_time = 0; - return false; - } - ok_to_drop = false; - if (vars->first_above_time == 0) { - /* just went above from below. If we stay above - * for at least interval we'll say it's ok to drop - */ - vars->first_above_time = now + params->interval; - } else if (codel_time_after(now, vars->first_above_time)) { - ok_to_drop = true; - } - return ok_to_drop; -} - -typedef struct sk_buff * (*codel_skb_dequeue_t)(struct codel_vars *vars, - struct Qdisc *sch); - -static struct sk_buff *codel_dequeue(struct Qdisc *sch, - struct codel_params *params, - struct codel_vars *vars, - struct codel_stats *stats, - codel_skb_dequeue_t dequeue_func) -{ - struct sk_buff *skb = dequeue_func(vars, sch); - codel_time_t now; - bool drop; - - if (!skb) { - vars->dropping = false; - return skb; - } - now = codel_get_time(); - drop = codel_should_drop(skb, sch, vars, params, stats, now); - if (vars->dropping) { - if (!drop) { - /* sojourn time below target - leave dropping state */ - vars->dropping = false; - } else if (codel_time_after_eq(now, vars->drop_next)) { - /* It's time for the next drop. Drop the current - * packet and dequeue the next. The dequeue might - * take us out of dropping state. - * If not, schedule the next drop. - * A large backlog might result in drop rates so high - * that the next drop should happen now, - * hence the while loop. - */ - while (vars->dropping && - codel_time_after_eq(now, vars->drop_next)) { - vars->count++; /* dont care of possible wrap - * since there is no more divide - */ - codel_Newton_step(vars); - if (params->ecn && INET_ECN_set_ce(skb)) { - stats->ecn_mark++; - vars->drop_next = - codel_control_law(vars->drop_next, - params->interval, - vars->rec_inv_sqrt); - goto end; - } - qdisc_drop(skb, sch); - stats->drop_count++; - skb = dequeue_func(vars, sch); - if (!codel_should_drop(skb, sch, - vars, params, stats, now)) { - /* leave dropping state */ - vars->dropping = false; - } else { - /* and schedule the next drop */ - vars->drop_next = - codel_control_law(vars->drop_next, - params->interval, - vars->rec_inv_sqrt); - } - } - } - } else if (drop) { - if (params->ecn && INET_ECN_set_ce(skb)) { - stats->ecn_mark++; - } else { - qdisc_drop(skb, sch); - stats->drop_count++; - - skb = dequeue_func(vars, sch); - drop = codel_should_drop(skb, sch, vars, params, - stats, now); - } - vars->dropping = true; - /* if min went above target close to when we last went below it - * assume that the drop rate that controlled the queue on the - * last cycle is a good starting point to control it now. - */ - if (codel_time_before(now - vars->drop_next, - 16 * params->interval)) { - vars->count = (vars->count - vars->lastcount) | 1; - /* we dont care if rec_inv_sqrt approximation - * is not very precise : - * Next Newton steps will correct it quadratically. - */ - codel_Newton_step(vars); - } else { - vars->count = 1; - vars->rec_inv_sqrt = ~0U >> REC_INV_SQRT_SHIFT; - } - vars->lastcount = vars->count; - vars->drop_next = codel_control_law(now, params->interval, - vars->rec_inv_sqrt); - } -end: - return skb; -} -#endif -#endif diff --git a/backport/include/net/flow_keys.h b/backport/include/net/flow_keys.h deleted file mode 100644 index a875ee6eeb3b..000000000000 --- a/backport/include/net/flow_keys.h +++ /dev/null @@ -1,21 +0,0 @@ -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,3,0)) -#include_next -#else - -#ifndef _NET_FLOW_KEYS_H -#define _NET_FLOW_KEYS_H - -struct flow_keys { - /* (src,dst) must be grouped, in the same way than in IP header */ - __be32 src; - __be32 dst; - union { - __be32 ports; - __be16 port16[2]; - }; - u8 ip_proto; -}; - -extern bool skb_flow_dissect(const struct sk_buff *skb, struct flow_keys *flow); -#endif -#endif diff --git a/backport/include/net/net_namespace.h b/backport/include/net/net_namespace.h deleted file mode 100644 index 0f74944b3823..000000000000 --- a/backport/include/net/net_namespace.h +++ /dev/null @@ -1,10 +0,0 @@ -#ifndef _COMPAT_NET_NET_NAMESPACE_H -#define _COMPAT_NET_NET_NAMESPACE_H 1 - -#include - -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)) -#include_next -#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)) */ - -#endif /* _COMPAT_NET_NET_NAMESPACE_H */ diff --git a/backport/include/pcmcia/cistpl.h b/backport/include/pcmcia/cistpl.h deleted file mode 100644 index 789dc59db726..000000000000 --- a/backport/include/pcmcia/cistpl.h +++ /dev/null @@ -1,10 +0,0 @@ -#include - -#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36) -#include -#endif -#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,37) -#include -#endif - -#include_next diff --git a/backport/include/trace/define_trace.h b/backport/include/trace/define_trace.h deleted file mode 100644 index 0b4072786d49..000000000000 --- a/backport/include/trace/define_trace.h +++ /dev/null @@ -1,5 +0,0 @@ -#include - -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,32)) -#include_next -#endif /* (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,32)) */ diff --git a/devel/doc/makefile-operation b/devel/doc/makefile-operation index 6a96dedf63a2..38cf4e73eb3c 100644 --- a/devel/doc/makefile-operation +++ b/devel/doc/makefile-operation @@ -23,7 +23,7 @@ Once these are in place, the configuration process can start with any of the tools -- menuconfig, defconfig-*, ... When the configuration is complete and exists in .config, the autoconf -header (include/linux/compat_autoconf.h) must be generated. This step is +header (backport-include/backport/autoconf.h) must be generated. This step is also done in the make system (by a small embedded shell script) and needs the .local-symbols so it only includes the symbols from the backport. diff --git a/gentree.py b/gentree.py index 204fffdf396d..3ba73eaf1fc0 100755 --- a/gentree.py +++ b/gentree.py @@ -323,7 +323,7 @@ def process(kerneldir, outdir, copy_list_file, git_revision=None, # do the copy backport_files = [(x, x) for x in [ 'Kconfig', 'Makefile', 'Makefile.build', 'Makefile.kernel', '.gitignore', - 'Makefile.real', 'compat/', 'include/', 'kconfig/', 'defconfigs/', + 'Makefile.real', 'compat/', 'backport-include/', 'kconfig/', 'defconfigs/', 'scripts/', '.blacklist.map', 'udev/', ]] if not args.git_revision: