83 files changed, 2606 insertions, 795 deletions

diff --git a/include/linux/auxvec.h b/include/linux/auxvec.h
index 9a7b374c9fb4..d2bc0d66e65d 100644
--- a/include/linux/auxvec.h
+++ b/include/linux/auxvec.h
@@ -26,6 +26,6 @@
 
 #define AT_SECURE 23   /* secure mode boolean */
 
-#define AT_VECTOR_SIZE  42 /* Size of auxiliary table.  */
+#define AT_VECTOR_SIZE  44 /* Size of auxiliary table.  */
 
 #endif /* _LINUX_AUXVEC_H */
diff --git a/include/linux/compiler-gcc3.h b/include/linux/compiler-gcc3.h
index 4209082ee934..1698b845761f 100644
--- a/include/linux/compiler-gcc3.h
+++ b/include/linux/compiler-gcc3.h
@@ -13,3 +13,4 @@
 #define __must_check            __attribute__((warn_unused_result))
 #endif
 
+#define __always_inline         inline __attribute__((always_inline))
diff --git a/include/linux/compiler-gcc4.h b/include/linux/compiler-gcc4.h
index e913e9beaf69..6f5cc6f0e7a6 100644
--- a/include/linux/compiler-gcc4.h
+++ b/include/linux/compiler-gcc4.h
@@ -3,7 +3,16 @@
 /* These definitions are for GCC v4.x.  */
 #include <linux/compiler-gcc.h>
 
+#ifdef CONFIG_FORCED_INLINING
+# undef inline
+# undef __inline__
+# undef __inline
+# define inline                 inline          __attribute__((always_inline))
+# define __inline__             __inline__      __attribute__((always_inline))
+# define __inline               __inline        __attribute__((always_inline))
+#endif
+
 #define __attribute_used__      __attribute__((__used__))
 #define __must_check            __attribute__((warn_unused_result))
 #define __compiler_offsetof(a,b) __builtin_offsetof(a,b)
-
+#define __always_inline         inline __attribute__((always_inline))
diff --git a/include/linux/cpuset.h b/include/linux/cpuset.h
index c472f972bd6d..3bc606927116 100644
--- a/include/linux/cpuset.h
+++ b/include/linux/cpuset.h
@@ -48,6 +48,9 @@ extern void __cpuset_memory_pressure_bump(void);
 extern struct file_operations proc_cpuset_operations;
 extern char *cpuset_task_status_allowed(struct task_struct *task, char *buffer);
 
+extern void cpuset_lock(void);
+extern void cpuset_unlock(void);
+
 #else /* !CONFIG_CPUSETS */
 
 static inline int cpuset_init_early(void) { return 0; }
@@ -93,6 +96,9 @@ static inline char *cpuset_task_status_allowed(struct task_struct *task,
         return buffer;
 }
 
+static inline void cpuset_lock(void) {}
+static inline void cpuset_unlock(void) {}
+
 #endif /* !CONFIG_CPUSETS */
 
 #endif /* _LINUX_CPUSET_H */
diff --git a/include/linux/device.h b/include/linux/device.h
index 0cdee78e5ce1..58df18d9cd3e 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -49,6 +49,9 @@ struct bus_type {
         int             (*match)(struct device * dev, struct device_driver * drv);
         int             (*uevent)(struct device *dev, char **envp,
                                   int num_envp, char *buffer, int buffer_size);
+        int             (*probe)(struct device * dev);
+        int             (*remove)(struct device * dev);
+        void            (*shutdown)(struct device * dev);
         int             (*suspend)(struct device * dev, pm_message_t state);
         int             (*resume)(struct device * dev);
 };
diff --git a/include/linux/fb.h b/include/linux/fb.h
index a973be2cfe61..2cb19e6503aa 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -608,15 +608,15 @@ struct fb_ops {
         int (*fb_sync)(struct fb_info *info);
 
         /* perform fb specific ioctl (optional) */
-        int (*fb_ioctl)(struct inode *inode, struct file *file, unsigned int cmd,
-                        unsigned long arg, struct fb_info *info);
+        int (*fb_ioctl)(struct fb_info *info, unsigned int cmd,
+                        unsigned long arg);
 
         /* Handle 32bit compat ioctl (optional) */
-        long (*fb_compat_ioctl)(struct file *f, unsigned cmd, unsigned long arg,
-                               struct fb_info *info);
+        int (*fb_compat_ioctl)(struct fb_info *info, unsigned cmd,
+                        unsigned long arg);
 
         /* perform fb specific mmap */
-        int (*fb_mmap)(struct fb_info *info, struct file *file, struct vm_area_struct *vma);
+        int (*fb_mmap)(struct fb_info *info, struct vm_area_struct *vma);
 
         /* save current hardware state */
         void (*fb_save_state)(struct fb_info *info);
diff --git a/include/linux/fs.h b/include/linux/fs.h
index d1e370d25f7b..552cedfa6064 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1383,6 +1383,12 @@ extern int register_chrdev(unsigned int, const char *,
 extern int unregister_chrdev(unsigned int, const char *);
 extern void unregister_chrdev_region(dev_t, unsigned);
 extern int chrdev_open(struct inode *, struct file *);
+extern int get_chrdev_list(char *);
+extern void *acquire_chrdev_list(void);
+extern int count_chrdev_list(void);
+extern void *get_next_chrdev(void *);
+extern int get_chrdev_info(void *, int *, char **);
+extern void release_chrdev_list(void *);
 
 /* fs/block_dev.c */
 #define BDEVNAME_SIZE   32      /* Largest string for a blockdev identifier */
@@ -1391,6 +1397,11 @@ extern const char *bdevname(struct block_device *bdev, char *buffer);
 extern struct block_device *lookup_bdev(const char *);
 extern struct block_device *open_bdev_excl(const char *, int, void *);
 extern void close_bdev_excl(struct block_device *);
+extern void *acquire_blkdev_list(void);
+extern int count_blkdev_list(void);
+extern void *get_next_blkdev(void *);
+extern int get_blkdev_info(void *, int *, char **);
+extern void release_blkdev_list(void *);
 
 extern void init_special_inode(struct inode *, umode_t, dev_t);
 
diff --git a/include/linux/hardirq.h b/include/linux/hardirq.h
index 71d2b8a723b9..eab537091f2a 100644
--- a/include/linux/hardirq.h
+++ b/include/linux/hardirq.h
@@ -93,10 +93,6 @@ extern void synchronize_irq(unsigned int irq);
 struct task_struct;
 
 #ifndef CONFIG_VIRT_CPU_ACCOUNTING
-static inline void account_user_vtime(struct task_struct *tsk)
-{
-}
-
 static inline void account_system_vtime(struct task_struct *tsk)
 {
 }
diff --git a/include/linux/ide.h b/include/linux/ide.h
index f2e1b5b22898..110b3cfac021 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -983,8 +983,13 @@ typedef struct ide_driver_s {
         ide_startstop_t (*abort)(ide_drive_t *, struct request *rq);
         ide_proc_entry_t        *proc;
         struct device_driver    gen_driver;
+        int             (*probe)(ide_drive_t *);
+        void            (*remove)(ide_drive_t *);
+        void            (*shutdown)(ide_drive_t *);
 } ide_driver_t;
 
+#define to_ide_driver(drv) container_of(drv, ide_driver_t, gen_driver)
+
 int generic_ide_ioctl(ide_drive_t *, struct file *, struct block_device *, unsigned, unsigned long);
 
 /*
diff --git a/include/linux/ioc3.h b/include/linux/ioc3.h
new file mode 100644
index 000000000000..e7906a72a4f1
--- /dev/null
+++ b/include/linux/ioc3.h
@@ -0,0 +1,93 @@
+/*
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (c) 2005 Stanislaw Skowronek <skylark@linux-mips.org>
+ */
+
+#ifndef _LINUX_IOC3_H
+#define _LINUX_IOC3_H
+
+#include <asm/sn/ioc3.h>
+
+#define IOC3_MAX_SUBMODULES     32
+
+#define IOC3_CLASS_NONE         0
+#define IOC3_CLASS_BASE_IP27    1
+#define IOC3_CLASS_BASE_IP30    2
+#define IOC3_CLASS_MENET_123    3
+#define IOC3_CLASS_MENET_4      4
+#define IOC3_CLASS_CADDUO       5
+#define IOC3_CLASS_SERIAL       6
+
+/* One of these per IOC3 */
+struct ioc3_driver_data {
+        struct list_head list;
+        int id;                         /* IOC3 sequence number */
+        /* PCI mapping */
+        unsigned long pma;              /* physical address */
+        struct __iomem ioc3 *vma;       /* pointer to registers */
+        struct pci_dev *pdev;           /* PCI device */
+        /* IRQ stuff */
+        int dual_irq;                   /* set if separate IRQs are used */
+        int irq_io, irq_eth;            /* IRQ numbers */
+        /* GPIO magic */
+        spinlock_t gpio_lock;
+        unsigned int gpdr_shadow;
+        /* NIC identifiers */
+        char nic_part[32];
+        char nic_serial[16];
+        char nic_mac[6];
+        /* submodule set */
+        int class;
+        void *data[IOC3_MAX_SUBMODULES];        /* for submodule use */
+        int active[IOC3_MAX_SUBMODULES];        /* set if probe succeeds */
+        /* is_ir_lock must be held while
+         * modifying sio_ie values, so
+         * we can be sure that sio_ie is
+         * not changing when we read it
+         * along with sio_ir.
+         */
+        spinlock_t ir_lock;     /* SIO_IE[SC] mod lock */
+};
+
+/* One per submodule */
+struct ioc3_submodule {
+        char *name;             /* descriptive submodule name */
+        struct module *owner;   /* owning kernel module */
+        int ethernet;           /* set for ethernet drivers */
+        int (*probe) (struct ioc3_submodule *, struct ioc3_driver_data *);
+        int (*remove) (struct ioc3_submodule *, struct ioc3_driver_data *);
+        int id;                 /* assigned by IOC3, index for the "data" array */
+        /* IRQ stuff */
+        unsigned int irq_mask;  /* IOC3 IRQ mask, leave clear for Ethernet */
+        int reset_mask;         /* non-zero if you want the ioc3.c module to reset interrupts */
+        int (*intr) (struct ioc3_submodule *, struct ioc3_driver_data *, unsigned int, struct pt_regs *);
+        /* private submodule data */
+        void *data;             /* assigned by submodule */
+};
+
+/**********************************
+ * Functions needed by submodules *
+ **********************************/
+
+#define IOC3_W_IES              0
+#define IOC3_W_IEC              1
+
+/* registers a submodule for all existing and future IOC3 chips */
+extern int ioc3_register_submodule(struct ioc3_submodule *);
+/* unregisters a submodule */
+extern void ioc3_unregister_submodule(struct ioc3_submodule *);
+/* enables IRQs indicated by irq_mask for a specified IOC3 chip */
+extern void ioc3_enable(struct ioc3_submodule *, struct ioc3_driver_data *, unsigned int);
+/* ackowledges specified IRQs */
+extern void ioc3_ack(struct ioc3_submodule *, struct ioc3_driver_data *, unsigned int);
+/* disables IRQs indicated by irq_mask for a specified IOC3 chip */
+extern void ioc3_disable(struct ioc3_submodule *, struct ioc3_driver_data *, unsigned int);
+/* atomically sets GPCR bits */
+extern void ioc3_gpcr_set(struct ioc3_driver_data *, unsigned int);
+/* general ireg writer */
+extern void ioc3_write_ireg(struct ioc3_driver_data *idd, uint32_t value, int reg);
+
+#endif
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index e6ee2d95da7a..323924edb26a 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -216,6 +216,7 @@ extern void dump_stack(void);
         ((unsigned char *)&addr)[1], \
         ((unsigned char *)&addr)[2], \
         ((unsigned char *)&addr)[3]
+#define NIPQUAD_FMT "%u.%u.%u.%u"
 
 #define NIP6(addr) \
         ntohs((addr).s6_addr16[0]), \
@@ -226,6 +227,7 @@ extern void dump_stack(void);
         ntohs((addr).s6_addr16[5]), \
         ntohs((addr).s6_addr16[6]), \
         ntohs((addr).s6_addr16[7])
+#define NIP6_FMT "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x"
 
 #if defined(__LITTLE_ENDIAN)
 #define HIPQUAD(addr) \
diff --git a/include/linux/mempolicy.h b/include/linux/mempolicy.h
index c7ac77e873b3..d6a53ed6ab6c 100644
--- a/include/linux/mempolicy.h
+++ b/include/linux/mempolicy.h
@@ -132,12 +132,8 @@ struct shared_policy {
         spinlock_t lock;
 };
 
-static inline void mpol_shared_policy_init(struct shared_policy *info)
-{
-        info->root = RB_ROOT;
-        spin_lock_init(&info->lock);
-}
-
+void mpol_shared_policy_init(struct shared_policy *info, int policy,
+                                nodemask_t *nodes);
 int mpol_set_shared_policy(struct shared_policy *info,
                                 struct vm_area_struct *vma,
                                 struct mempolicy *new);
@@ -211,7 +207,8 @@ static inline int mpol_set_shared_policy(struct shared_policy *info,
         return -EINVAL;
 }
 
-static inline void mpol_shared_policy_init(struct shared_policy *info)
+static inline void mpol_shared_policy_init(struct shared_policy *info,
+                                        int policy, nodemask_t *nodes)
 {
 }
 
diff --git a/include/linux/mm.h b/include/linux/mm.h
index c643016499a1..85854b867463 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -512,7 +512,7 @@ static inline void set_page_links(struct page *page, unsigned long zone,
 extern struct page *mem_map;
 #endif
 
-static inline void *lowmem_page_address(struct page *page)
+static __always_inline void *lowmem_page_address(struct page *page)
 {
         return __va(page_to_pfn(page) << PAGE_SHIFT);
 }
diff --git a/include/linux/ncp_fs.h b/include/linux/ncp_fs.h
index 7297e4372c0f..e01342568530 100644
--- a/include/linux/ncp_fs.h
+++ b/include/linux/ncp_fs.h
@@ -201,34 +201,6 @@ static inline struct ncp_inode_info *NCP_FINFO(struct inode *inode)
         return container_of(inode, struct ncp_inode_info, vfs_inode);
 }
 
-#ifdef DEBUG_NCP_MALLOC
-
-#include <linux/slab.h>
-
-extern int ncp_malloced;
-extern int ncp_current_malloced;
-
-static inline void *
- ncp_kmalloc(unsigned int size, int priority)
-{
-        ncp_malloced += 1;
-        ncp_current_malloced += 1;
-        return kmalloc(size, priority);
-}
-
-static inline void ncp_kfree_s(void *obj, int size)
-{
-        ncp_current_malloced -= 1;
-        kfree(obj);
-}
-
-#else                           /* DEBUG_NCP_MALLOC */
-
-#define ncp_kmalloc(s,p) kmalloc(s,p)
-#define ncp_kfree_s(o,s) kfree(o)
-
-#endif                          /* DEBUG_NCP_MALLOC */
-
 /* linux/fs/ncpfs/inode.c */
 int ncp_notify_change(struct dentry *, struct iattr *);
 struct inode *ncp_iget(struct super_block *, struct ncp_entry_info *);
diff --git a/include/linux/netfilter/nf_conntrack_common.h b/include/linux/netfilter/nf_conntrack_common.h
index 6d39b518486b..3ff88c878308 100644
--- a/include/linux/netfilter/nf_conntrack_common.h
+++ b/include/linux/netfilter/nf_conntrack_common.h
@@ -154,6 +154,9 @@ struct ip_conntrack_stat
         unsigned int expect_delete;
 };
 
+/* call to create an explicit dependency on nf_conntrack. */
+extern void need_conntrack(void);
+
 #endif /* __KERNEL__ */
 
 #endif /* _NF_CONNTRACK_COMMON_H */
diff --git a/include/linux/netfilter/x_tables.h b/include/linux/netfilter/x_tables.h
new file mode 100644
index 000000000000..472f04834809
--- /dev/null
+++ b/include/linux/netfilter/x_tables.h
@@ -0,0 +1,224 @@
+#ifndef _X_TABLES_H
+#define _X_TABLES_H
+
+#define XT_FUNCTION_MAXNAMELEN 30
+#define XT_TABLE_MAXNAMELEN 32
+
+/* The argument to IPT_SO_GET_REVISION_*.  Returns highest revision
+ * kernel supports, if >= revision. */
+struct xt_get_revision
+{
+        char name[XT_FUNCTION_MAXNAMELEN-1];
+
+        u_int8_t revision;
+};
+
+/* CONTINUE verdict for targets */
+#define XT_CONTINUE 0xFFFFFFFF
+
+/* For standard target */
+#define XT_RETURN (-NF_REPEAT - 1)
+
+#define XT_ALIGN(s) (((s) + (__alignof__(void *)-1)) & ~(__alignof__(void *)-1))
+
+/* Standard return verdict, or do jump. */
+#define XT_STANDARD_TARGET ""
+/* Error verdict. */
+#define XT_ERROR_TARGET "ERROR"
+
+/*
+ * New IP firewall options for [gs]etsockopt at the RAW IP level.
+ * Unlike BSD Linux inherits IP options so you don't have to use a raw
+ * socket for this. Instead we check rights in the calls. */
+#define XT_BASE_CTL             64      /* base for firewall socket options */
+
+#define XT_SO_SET_REPLACE       (XT_BASE_CTL)
+#define XT_SO_SET_ADD_COUNTERS  (XT_BASE_CTL + 1)
+#define XT_SO_SET_MAX           XT_SO_SET_ADD_COUNTERS
+
+#define XT_SO_GET_INFO                  (XT_BASE_CTL)
+#define XT_SO_GET_ENTRIES               (XT_BASE_CTL + 1)
+#define XT_SO_GET_REVISION_MATCH        (XT_BASE_CTL + 2)
+#define XT_SO_GET_REVISION_TARGET       (XT_BASE_CTL + 3)
+#define XT_SO_GET_MAX                   XT_SO_GET_REVISION_TARGET
+
+#define SET_COUNTER(c,b,p) do { (c).bcnt = (b); (c).pcnt = (p); } while(0)
+#define ADD_COUNTER(c,b,p) do { (c).bcnt += (b); (c).pcnt += (p); } while(0)
+
+struct xt_counters
+{
+        u_int64_t pcnt, bcnt;                   /* Packet and byte counters */
+};
+
+/* The argument to IPT_SO_ADD_COUNTERS. */
+struct xt_counters_info
+{
+        /* Which table. */
+        char name[XT_TABLE_MAXNAMELEN];
+
+        unsigned int num_counters;
+
+        /* The counters (actually `number' of these). */
+        struct xt_counters counters[0];
+};
+
+#define XT_INV_PROTO            0x40    /* Invert the sense of PROTO. */
+
+#ifdef __KERNEL__
+
+#include <linux/netdevice.h>
+
+#define ASSERT_READ_LOCK(x)
+#define ASSERT_WRITE_LOCK(x)
+#include <linux/netfilter_ipv4/listhelp.h>
+
+struct xt_match
+{
+        struct list_head list;
+
+        const char name[XT_FUNCTION_MAXNAMELEN-1];
+
+        u_int8_t revision;
+
+        /* Return true or false: return FALSE and set *hotdrop = 1 to
+           force immediate packet drop. */
+        /* Arguments changed since 2.6.9, as this must now handle
+           non-linear skb, using skb_header_pointer and
+           skb_ip_make_writable. */
+        int (*match)(const struct sk_buff *skb,
+                     const struct net_device *in,
+                     const struct net_device *out,
+                     const void *matchinfo,
+                     int offset,
+                     unsigned int protoff,
+                     int *hotdrop);
+
+        /* Called when user tries to insert an entry of this type. */
+        /* Should return true or false. */
+        int (*checkentry)(const char *tablename,
+                          const void *ip,
+                          void *matchinfo,
+                          unsigned int matchinfosize,
+                          unsigned int hook_mask);
+
+        /* Called when entry of this type deleted. */
+        void (*destroy)(void *matchinfo, unsigned int matchinfosize);
+
+        /* Set this to THIS_MODULE if you are a module, otherwise NULL */
+        struct module *me;
+};
+
+/* Registration hooks for targets. */
+struct xt_target
+{
+        struct list_head list;
+
+        const char name[XT_FUNCTION_MAXNAMELEN-1];
+
+        u_int8_t revision;
+
+        /* Returns verdict. Argument order changed since 2.6.9, as this
+           must now handle non-linear skbs, using skb_copy_bits and
+           skb_ip_make_writable. */
+        unsigned int (*target)(struct sk_buff **pskb,
+                               const struct net_device *in,
+                               const struct net_device *out,
+                               unsigned int hooknum,
+                               const void *targinfo,
+                               void *userdata);
+
+        /* Called when user tries to insert an entry of this type:
+           hook_mask is a bitmask of hooks from which it can be
+           called. */
+        /* Should return true or false. */
+        int (*checkentry)(const char *tablename,
+                          const void *entry,
+                          void *targinfo,
+                          unsigned int targinfosize,
+                          unsigned int hook_mask);
+
+        /* Called when entry of this type deleted. */
+        void (*destroy)(void *targinfo, unsigned int targinfosize);
+
+        /* Set this to THIS_MODULE if you are a module, otherwise NULL */
+        struct module *me;
+};
+
+/* Furniture shopping... */
+struct xt_table
+{
+        struct list_head list;
+
+        /* A unique name... */
+        char name[XT_TABLE_MAXNAMELEN];
+
+        /* What hooks you will enter on */
+        unsigned int valid_hooks;
+
+        /* Lock for the curtain */
+        rwlock_t lock;
+
+        /* Man behind the curtain... */
+        //struct ip6t_table_info *private;
+        void *private;
+
+        /* Set this to THIS_MODULE if you are a module, otherwise NULL */
+        struct module *me;
+
+        int af;         /* address/protocol family */
+};
+
+#include <linux/netfilter_ipv4.h>
+
+/* The table itself */
+struct xt_table_info
+{
+        /* Size per table */
+        unsigned int size;
+        /* Number of entries: FIXME. --RR */
+        unsigned int number;
+        /* Initial number of entries. Needed for module usage count */
+        unsigned int initial_entries;
+
+        /* Entry points and underflows */
+        unsigned int hook_entry[NF_IP_NUMHOOKS];
+        unsigned int underflow[NF_IP_NUMHOOKS];
+
+        /* ipt_entry tables: one per CPU */
+        char *entries[NR_CPUS];
+};
+
+extern int xt_register_target(int af, struct xt_target *target);
+extern void xt_unregister_target(int af, struct xt_target *target);
+extern int xt_register_match(int af, struct xt_match *target);
+extern void xt_unregister_match(int af, struct xt_match *target);
+
+extern int xt_register_table(struct xt_table *table,
+                             struct xt_table_info *bootstrap,
+                             struct xt_table_info *newinfo);
+extern void *xt_unregister_table(struct xt_table *table);
+
+extern struct xt_table_info *xt_replace_table(struct xt_table *table,
+                                              unsigned int num_counters,
+                                              struct xt_table_info *newinfo,
+                                              int *error);
+
+extern struct xt_match *xt_find_match(int af, const char *name, u8 revision);
+extern struct xt_target *xt_find_target(int af, const char *name, u8 revision);
+extern struct xt_target *xt_request_find_target(int af, const char *name, 
+                                                u8 revision);
+extern int xt_find_revision(int af, const char *name, u8 revision, int target,
+                            int *err);
+
+extern struct xt_table *xt_find_table_lock(int af, const char *name);
+extern void xt_table_unlock(struct xt_table *t);
+
+extern int xt_proto_init(int af);
+extern void xt_proto_fini(int af);
+
+extern struct xt_table_info *xt_alloc_table_info(unsigned int size);
+extern void xt_free_table_info(struct xt_table_info *info);
+
+#endif /* __KERNEL__ */
+
+#endif /* _X_TABLES_H */
diff --git a/include/linux/netfilter/xt_CLASSIFY.h b/include/linux/netfilter/xt_CLASSIFY.h
new file mode 100644
index 000000000000..58111355255d
--- /dev/null
+++ b/include/linux/netfilter/xt_CLASSIFY.h
@@ -0,0 +1,8 @@
+#ifndef _XT_CLASSIFY_H
+#define _XT_CLASSIFY_H
+
+struct xt_classify_target_info {
+        u_int32_t priority;
+};
+
+#endif /*_XT_CLASSIFY_H */
diff --git a/include/linux/netfilter/xt_CONNMARK.h b/include/linux/netfilter/xt_CONNMARK.h
new file mode 100644
index 000000000000..9f744689fffc
--- /dev/null
+++ b/include/linux/netfilter/xt_CONNMARK.h
@@ -0,0 +1,25 @@
+#ifndef _XT_CONNMARK_H_target
+#define _XT_CONNMARK_H_target
+
+/* Copyright (C) 2002,2004 MARA Systems AB <http://www.marasystems.com>
+ * by Henrik Nordstrom <hno@marasystems.com>
+ *
+ * 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.
+ */
+
+enum {
+        XT_CONNMARK_SET = 0,
+        XT_CONNMARK_SAVE,
+        XT_CONNMARK_RESTORE
+};
+
+struct xt_connmark_target_info {
+        unsigned long mark;
+        unsigned long mask;
+        u_int8_t mode;
+};
+
+#endif /*_XT_CONNMARK_H_target*/
diff --git a/include/linux/netfilter/xt_MARK.h b/include/linux/netfilter/xt_MARK.h
new file mode 100644
index 000000000000..b021e93ee5d6
--- /dev/null
+++ b/include/linux/netfilter/xt_MARK.h
@@ -0,0 +1,21 @@
+#ifndef _XT_MARK_H_target
+#define _XT_MARK_H_target
+
+/* Version 0 */
+struct xt_mark_target_info {
+        unsigned long mark;
+};
+
+/* Version 1 */
+enum {
+        XT_MARK_SET=0,
+        XT_MARK_AND,
+        XT_MARK_OR,
+};
+
+struct xt_mark_target_info_v1 {
+        unsigned long mark;
+        u_int8_t mode;
+};
+
+#endif /*_XT_MARK_H_target */
diff --git a/include/linux/netfilter/xt_NFQUEUE.h b/include/linux/netfilter/xt_NFQUEUE.h
new file mode 100644
index 000000000000..9a9af79f74d2
--- /dev/null
+++ b/include/linux/netfilter/xt_NFQUEUE.h
@@ -0,0 +1,16 @@
+/* iptables module for using NFQUEUE mechanism
+ *
+ * (C) 2005 Harald Welte <laforge@netfilter.org>
+ *
+ * This software is distributed under GNU GPL v2, 1991
+ * 
+*/
+#ifndef _XT_NFQ_TARGET_H
+#define _XT_NFQ_TARGET_H
+
+/* target info */
+struct xt_NFQ_info {
+        u_int16_t queuenum;
+};
+
+#endif /* _XT_NFQ_TARGET_H */
diff --git a/include/linux/netfilter/xt_comment.h b/include/linux/netfilter/xt_comment.h
new file mode 100644
index 000000000000..eacfedc6b5d0
--- /dev/null
+++ b/include/linux/netfilter/xt_comment.h
@@ -0,0 +1,10 @@
+#ifndef _XT_COMMENT_H
+#define _XT_COMMENT_H
+
+#define XT_MAX_COMMENT_LEN 256
+
+struct xt_comment_info {
+        unsigned char comment[XT_MAX_COMMENT_LEN];
+};
+
+#endif /* XT_COMMENT_H */
diff --git a/include/linux/netfilter/xt_connbytes.h b/include/linux/netfilter/xt_connbytes.h
new file mode 100644
index 000000000000..c022c989754d
--- /dev/null
+++ b/include/linux/netfilter/xt_connbytes.h
@@ -0,0 +1,25 @@
+#ifndef _XT_CONNBYTES_H
+#define _XT_CONNBYTES_H
+
+enum xt_connbytes_what {
+        XT_CONNBYTES_PKTS,
+        XT_CONNBYTES_BYTES,
+        XT_CONNBYTES_AVGPKT,
+};
+
+enum xt_connbytes_direction {
+        XT_CONNBYTES_DIR_ORIGINAL,
+        XT_CONNBYTES_DIR_REPLY,
+        XT_CONNBYTES_DIR_BOTH,
+};
+
+struct xt_connbytes_info
+{
+        struct {
+                aligned_u64 from;       /* count to be matched */
+                aligned_u64 to;         /* count to be matched */
+        } count;
+        u_int8_t what;          /* ipt_connbytes_what */
+        u_int8_t direction;     /* ipt_connbytes_direction */
+};
+#endif
diff --git a/include/linux/netfilter/xt_connmark.h b/include/linux/netfilter/xt_connmark.h
new file mode 100644
index 000000000000..c592f6ae0883
--- /dev/null
+++ b/include/linux/netfilter/xt_connmark.h
@@ -0,0 +1,18 @@
+#ifndef _XT_CONNMARK_H
+#define _XT_CONNMARK_H
+
+/* Copyright (C) 2002,2004 MARA Systems AB <http://www.marasystems.com>
+ * by Henrik Nordstrom <hno@marasystems.com>
+ *
+ * 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.
+ */
+
+struct xt_connmark_info {
+        unsigned long mark, mask;
+        u_int8_t invert;
+};
+
+#endif /*_XT_CONNMARK_H*/
diff --git a/include/linux/netfilter/xt_conntrack.h b/include/linux/netfilter/xt_conntrack.h
new file mode 100644
index 000000000000..34f63cf2e293
--- /dev/null
+++ b/include/linux/netfilter/xt_conntrack.h
@@ -0,0 +1,63 @@
+/* Header file for kernel module to match connection tracking information.
+ * GPL (C) 2001  Marc Boucher (marc@mbsi.ca).
+ */
+
+#ifndef _XT_CONNTRACK_H
+#define _XT_CONNTRACK_H
+
+#include <linux/netfilter/nf_conntrack_tuple_common.h>
+#include <linux/in.h>
+
+#define XT_CONNTRACK_STATE_BIT(ctinfo) (1 << ((ctinfo)%IP_CT_IS_REPLY+1))
+#define XT_CONNTRACK_STATE_INVALID (1 << 0)
+
+#define XT_CONNTRACK_STATE_SNAT (1 << (IP_CT_NUMBER + 1))
+#define XT_CONNTRACK_STATE_DNAT (1 << (IP_CT_NUMBER + 2))
+#define XT_CONNTRACK_STATE_UNTRACKED (1 << (IP_CT_NUMBER + 3))
+
+/* flags, invflags: */
+#define XT_CONNTRACK_STATE      0x01
+#define XT_CONNTRACK_PROTO      0x02
+#define XT_CONNTRACK_ORIGSRC    0x04
+#define XT_CONNTRACK_ORIGDST    0x08
+#define XT_CONNTRACK_REPLSRC    0x10
+#define XT_CONNTRACK_REPLDST    0x20
+#define XT_CONNTRACK_STATUS     0x40
+#define XT_CONNTRACK_EXPIRES    0x80
+
+/* This is exposed to userspace, so remains frozen in time. */
+struct ip_conntrack_old_tuple
+{
+        struct {
+                __u32 ip;
+                union {
+                        __u16 all;
+                } u;
+        } src;
+
+        struct {
+                __u32 ip;
+                union {
+                        __u16 all;
+                } u;
+
+                /* The protocol. */
+                u16 protonum;
+        } dst;
+};
+
+struct xt_conntrack_info
+{
+        unsigned int statemask, statusmask;
+
+        struct ip_conntrack_old_tuple tuple[IP_CT_DIR_MAX];
+        struct in_addr sipmsk[IP_CT_DIR_MAX], dipmsk[IP_CT_DIR_MAX];
+
+        unsigned long expires_min, expires_max;
+
+        /* Flags word */
+        u_int8_t flags;
+        /* Inverse flags */
+        u_int8_t invflags;
+};
+#endif /*_XT_CONNTRACK_H*/
diff --git a/include/linux/netfilter/xt_dccp.h b/include/linux/netfilter/xt_dccp.h
new file mode 100644
index 000000000000..e0221b9d32cb
--- /dev/null
+++ b/include/linux/netfilter/xt_dccp.h
@@ -0,0 +1,23 @@
+#ifndef _XT_DCCP_H_
+#define _XT_DCCP_H_
+
+#define XT_DCCP_SRC_PORTS               0x01
+#define XT_DCCP_DEST_PORTS              0x02
+#define XT_DCCP_TYPE                    0x04
+#define XT_DCCP_OPTION                  0x08
+
+#define XT_DCCP_VALID_FLAGS             0x0f
+
+struct xt_dccp_info {
+        u_int16_t dpts[2];  /* Min, Max */
+        u_int16_t spts[2];  /* Min, Max */
+
+        u_int16_t flags;
+        u_int16_t invflags;
+
+        u_int16_t typemask;
+        u_int8_t option;
+};
+
+#endif /* _XT_DCCP_H_ */
+
diff --git a/include/linux/netfilter/xt_helper.h b/include/linux/netfilter/xt_helper.h
new file mode 100644
index 000000000000..6b42763f999d
--- /dev/null
+++ b/include/linux/netfilter/xt_helper.h
@@ -0,0 +1,8 @@
+#ifndef _XT_HELPER_H
+#define _XT_HELPER_H
+
+struct xt_helper_info {
+        int invert;
+        char name[30];
+};
+#endif /* _XT_HELPER_H */
diff --git a/include/linux/netfilter/xt_length.h b/include/linux/netfilter/xt_length.h
new file mode 100644
index 000000000000..7c2b439f73fe
--- /dev/null
+++ b/include/linux/netfilter/xt_length.h
@@ -0,0 +1,9 @@
+#ifndef _XT_LENGTH_H
+#define _XT_LENGTH_H
+
+struct xt_length_info {
+    u_int16_t   min, max;
+    u_int8_t    invert;
+};
+
+#endif /*_XT_LENGTH_H*/
diff --git a/include/linux/netfilter/xt_limit.h b/include/linux/netfilter/xt_limit.h
new file mode 100644
index 000000000000..b3ce65375ecb
--- /dev/null
+++ b/include/linux/netfilter/xt_limit.h
@@ -0,0 +1,21 @@
+#ifndef _XT_RATE_H
+#define _XT_RATE_H
+
+/* timings are in milliseconds. */
+#define XT_LIMIT_SCALE 10000
+
+/* 1/10,000 sec period => max of 10,000/sec.  Min rate is then 429490
+   seconds, or one every 59 hours. */
+struct xt_rateinfo {
+        u_int32_t avg;    /* Average secs between packets * scale */
+        u_int32_t burst;  /* Period multiplier for upper limit. */
+
+        /* Used internally by the kernel */
+        unsigned long prev;
+        u_int32_t credit;
+        u_int32_t credit_cap, cost;
+
+        /* Ugly, ugly fucker. */
+        struct xt_rateinfo *master;
+};
+#endif /*_XT_RATE_H*/
diff --git a/include/linux/netfilter/xt_mac.h b/include/linux/netfilter/xt_mac.h
new file mode 100644
index 000000000000..b892cdc67e06
--- /dev/null
+++ b/include/linux/netfilter/xt_mac.h
@@ -0,0 +1,8 @@
+#ifndef _XT_MAC_H
+#define _XT_MAC_H
+
+struct xt_mac_info {
+    unsigned char srcaddr[ETH_ALEN];
+    int invert;
+};
+#endif /*_XT_MAC_H*/
diff --git a/include/linux/netfilter/xt_mark.h b/include/linux/netfilter/xt_mark.h
new file mode 100644
index 000000000000..802dd4842caf
--- /dev/null
+++ b/include/linux/netfilter/xt_mark.h
@@ -0,0 +1,9 @@
+#ifndef _XT_MARK_H
+#define _XT_MARK_H
+
+struct xt_mark_info {
+    unsigned long mark, mask;
+    u_int8_t invert;
+};
+
+#endif /*_XT_MARK_H*/
diff --git a/include/linux/netfilter/xt_physdev.h b/include/linux/netfilter/xt_physdev.h
new file mode 100644
index 000000000000..25a7a1815b5b
--- /dev/null
+++ b/include/linux/netfilter/xt_physdev.h
@@ -0,0 +1,24 @@
+#ifndef _XT_PHYSDEV_H
+#define _XT_PHYSDEV_H
+
+#ifdef __KERNEL__
+#include <linux/if.h>
+#endif
+
+#define XT_PHYSDEV_OP_IN                0x01
+#define XT_PHYSDEV_OP_OUT               0x02
+#define XT_PHYSDEV_OP_BRIDGED           0x04
+#define XT_PHYSDEV_OP_ISIN              0x08
+#define XT_PHYSDEV_OP_ISOUT             0x10
+#define XT_PHYSDEV_OP_MASK              (0x20 - 1)
+
+struct xt_physdev_info {
+        char physindev[IFNAMSIZ];
+        char in_mask[IFNAMSIZ];
+        char physoutdev[IFNAMSIZ];
+        char out_mask[IFNAMSIZ];
+        u_int8_t invert;
+        u_int8_t bitmask;
+};
+
+#endif /*_XT_PHYSDEV_H*/
diff --git a/include/linux/netfilter/xt_pkttype.h b/include/linux/netfilter/xt_pkttype.h
new file mode 100644
index 000000000000..f265cf52faea
--- /dev/null
+++ b/include/linux/netfilter/xt_pkttype.h
@@ -0,0 +1,8 @@
+#ifndef _XT_PKTTYPE_H
+#define _XT_PKTTYPE_H
+
+struct xt_pkttype_info {
+        int     pkttype;
+        int     invert;
+};
+#endif /*_XT_PKTTYPE_H*/
diff --git a/include/linux/netfilter/xt_realm.h b/include/linux/netfilter/xt_realm.h
new file mode 100644
index 000000000000..220e87245716
--- /dev/null
+++ b/include/linux/netfilter/xt_realm.h
@@ -0,0 +1,10 @@
+#ifndef _XT_REALM_H
+#define _XT_REALM_H
+
+struct xt_realm_info {
+        u_int32_t id;
+        u_int32_t mask;
+        u_int8_t invert;
+};
+
+#endif /* _XT_REALM_H */
diff --git a/include/linux/netfilter/xt_sctp.h b/include/linux/netfilter/xt_sctp.h
new file mode 100644
index 000000000000..b157897e7792
--- /dev/null
+++ b/include/linux/netfilter/xt_sctp.h
@@ -0,0 +1,107 @@
+#ifndef _XT_SCTP_H_
+#define _XT_SCTP_H_
+
+#define XT_SCTP_SRC_PORTS               0x01
+#define XT_SCTP_DEST_PORTS              0x02
+#define XT_SCTP_CHUNK_TYPES             0x04
+
+#define XT_SCTP_VALID_FLAGS             0x07
+
+#define ELEMCOUNT(x) (sizeof(x)/sizeof(x[0]))
+
+
+struct xt_sctp_flag_info {
+        u_int8_t chunktype;
+        u_int8_t flag;
+        u_int8_t flag_mask;
+};
+
+#define XT_NUM_SCTP_FLAGS       4
+
+struct xt_sctp_info {
+        u_int16_t dpts[2];  /* Min, Max */
+        u_int16_t spts[2];  /* Min, Max */
+
+        u_int32_t chunkmap[256 / sizeof (u_int32_t)];  /* Bit mask of chunks to be matched according to RFC 2960 */
+
+#define SCTP_CHUNK_MATCH_ANY   0x01  /* Match if any of the chunk types are present */
+#define SCTP_CHUNK_MATCH_ALL   0x02  /* Match if all of the chunk types are present */
+#define SCTP_CHUNK_MATCH_ONLY  0x04  /* Match if these are the only chunk types present */
+
+        u_int32_t chunk_match_type;
+        struct xt_sctp_flag_info flag_info[XT_NUM_SCTP_FLAGS];
+        int flag_count;
+
+        u_int32_t flags;
+        u_int32_t invflags;
+};
+
+#define bytes(type) (sizeof(type) * 8)
+
+#define SCTP_CHUNKMAP_SET(chunkmap, type)               \
+        do {                                            \
+                chunkmap[type / bytes(u_int32_t)] |=    \
+                        1 << (type % bytes(u_int32_t)); \
+        } while (0)
+
+#define SCTP_CHUNKMAP_CLEAR(chunkmap, type)                     \
+        do {                                                    \
+                chunkmap[type / bytes(u_int32_t)] &=            \
+                        ~(1 << (type % bytes(u_int32_t)));      \
+        } while (0)
+
+#define SCTP_CHUNKMAP_IS_SET(chunkmap, type)                    \
+({                                                              \
+        (chunkmap[type / bytes (u_int32_t)] &                   \
+                (1 << (type % bytes (u_int32_t)))) ? 1: 0;      \
+})
+
+#define SCTP_CHUNKMAP_RESET(chunkmap)                           \
+        do {                                                    \
+                int i;                                          \
+                for (i = 0; i < ELEMCOUNT(chunkmap); i++)       \
+                        chunkmap[i] = 0;                        \
+        } while (0)
+
+#define SCTP_CHUNKMAP_SET_ALL(chunkmap)                         \
+        do {                                                    \
+                int i;                                          \
+                for (i = 0; i < ELEMCOUNT(chunkmap); i++)       \
+                        chunkmap[i] = ~0;                       \
+        } while (0)
+
+#define SCTP_CHUNKMAP_COPY(destmap, srcmap)                     \
+        do {                                                    \
+                int i;                                          \
+                for (i = 0; i < ELEMCOUNT(chunkmap); i++)       \
+                        destmap[i] = srcmap[i];                 \
+        } while (0)
+
+#define SCTP_CHUNKMAP_IS_CLEAR(chunkmap)                \
+({                                                      \
+        int i;                                          \
+        int flag = 1;                                   \
+        for (i = 0; i < ELEMCOUNT(chunkmap); i++) {     \
+                if (chunkmap[i]) {                      \
+                        flag = 0;                       \
+                        break;                          \
+                }                                       \
+        }                                               \
+        flag;                                           \
+})
+
+#define SCTP_CHUNKMAP_IS_ALL_SET(chunkmap)              \
+({                                                      \
+        int i;                                          \
+        int flag = 1;                                   \
+        for (i = 0; i < ELEMCOUNT(chunkmap); i++) {     \
+                if (chunkmap[i] != ~0) {                \
+                        flag = 0;                       \
+                                break;                  \
+                }                                       \
+        }                                               \
+        flag;                                           \
+})
+
+#endif /* _XT_SCTP_H_ */
+
diff --git a/include/linux/netfilter/xt_state.h b/include/linux/netfilter/xt_state.h
new file mode 100644
index 000000000000..c06f32edee07
--- /dev/null
+++ b/include/linux/netfilter/xt_state.h
@@ -0,0 +1,13 @@
+#ifndef _XT_STATE_H
+#define _XT_STATE_H
+
+#define XT_STATE_BIT(ctinfo) (1 << ((ctinfo)%IP_CT_IS_REPLY+1))
+#define XT_STATE_INVALID (1 << 0)
+
+#define XT_STATE_UNTRACKED (1 << (IP_CT_NUMBER + 1))
+
+struct xt_state_info
+{
+        unsigned int statemask;
+};
+#endif /*_XT_STATE_H*/
diff --git a/include/linux/netfilter/xt_string.h b/include/linux/netfilter/xt_string.h
new file mode 100644
index 000000000000..3b3419f2637d
--- /dev/null
+++ b/include/linux/netfilter/xt_string.h
@@ -0,0 +1,18 @@
+#ifndef _XT_STRING_H
+#define _XT_STRING_H
+
+#define XT_STRING_MAX_PATTERN_SIZE 128
+#define XT_STRING_MAX_ALGO_NAME_SIZE 16
+
+struct xt_string_info
+{
+        u_int16_t from_offset;
+        u_int16_t to_offset;
+        char      algo[XT_STRING_MAX_ALGO_NAME_SIZE];
+        char      pattern[XT_STRING_MAX_PATTERN_SIZE];
+        u_int8_t  patlen;
+        u_int8_t  invert;
+        struct ts_config __attribute__((aligned(8))) *config;
+};
+
+#endif /*_XT_STRING_H*/
diff --git a/include/linux/netfilter/xt_tcpmss.h b/include/linux/netfilter/xt_tcpmss.h
new file mode 100644
index 000000000000..e03274c4c790
--- /dev/null
+++ b/include/linux/netfilter/xt_tcpmss.h
@@ -0,0 +1,9 @@
+#ifndef _XT_TCPMSS_MATCH_H
+#define _XT_TCPMSS_MATCH_H
+
+struct xt_tcpmss_match_info {
+    u_int16_t mss_min, mss_max;
+    u_int8_t invert;
+};
+
+#endif /*_XT_TCPMSS_MATCH_H*/
diff --git a/include/linux/netfilter/xt_tcpudp.h b/include/linux/netfilter/xt_tcpudp.h
new file mode 100644
index 000000000000..78bc65f11adf
--- /dev/null
+++ b/include/linux/netfilter/xt_tcpudp.h
@@ -0,0 +1,36 @@
+#ifndef _XT_TCPUDP_H
+#define _XT_TCPUDP_H
+
+/* TCP matching stuff */
+struct xt_tcp
+{
+        u_int16_t spts[2];                      /* Source port range. */
+        u_int16_t dpts[2];                      /* Destination port range. */
+        u_int8_t option;                        /* TCP Option iff non-zero*/
+        u_int8_t flg_mask;                      /* TCP flags mask byte */
+        u_int8_t flg_cmp;                       /* TCP flags compare byte */
+        u_int8_t invflags;                      /* Inverse flags */
+};
+
+/* Values for "inv" field in struct ipt_tcp. */
+#define XT_TCP_INV_SRCPT        0x01    /* Invert the sense of source ports. */
+#define XT_TCP_INV_DSTPT        0x02    /* Invert the sense of dest ports. */
+#define XT_TCP_INV_FLAGS        0x04    /* Invert the sense of TCP flags. */
+#define XT_TCP_INV_OPTION       0x08    /* Invert the sense of option test. */
+#define XT_TCP_INV_MASK         0x0F    /* All possible flags. */
+
+/* UDP matching stuff */
+struct xt_udp
+{
+        u_int16_t spts[2];                      /* Source port range. */
+        u_int16_t dpts[2];                      /* Destination port range. */
+        u_int8_t invflags;                      /* Inverse flags */
+};
+
+/* Values for "invflags" field in struct ipt_udp. */
+#define XT_UDP_INV_SRCPT        0x01    /* Invert the sense of source ports. */
+#define XT_UDP_INV_DSTPT        0x02    /* Invert the sense of dest ports. */
+#define XT_UDP_INV_MASK 0x03    /* All possible flags. */
+
+
+#endif
diff --git a/include/linux/netfilter_arp/arp_tables.h b/include/linux/netfilter_arp/arp_tables.h
index e98a870a20be..fd21796e5131 100644
--- a/include/linux/netfilter_arp/arp_tables.h
+++ b/include/linux/netfilter_arp/arp_tables.h
@@ -19,8 +19,12 @@
 #include <linux/compiler.h>
 #include <linux/netfilter_arp.h>
 
-#define ARPT_FUNCTION_MAXNAMELEN 30
-#define ARPT_TABLE_MAXNAMELEN 32
+#include <linux/netfilter/x_tables.h>
+
+#define ARPT_FUNCTION_MAXNAMELEN XT_FUNCTION_MAXNAMELEN
+#define ARPT_TABLE_MAXNAMELEN XT_TABLE_MAXNAMELEN
+#define arpt_target xt_target
+#define arpt_table xt_table
 
 #define ARPT_DEV_ADDR_LEN_MAX 16
 
@@ -91,11 +95,6 @@ struct arpt_standard_target
         int verdict;
 };
 
-struct arpt_counters
-{
-        u_int64_t pcnt, bcnt;                   /* Packet and byte counters */
-};
-
 /* Values for "flag" field in struct arpt_ip (general arp structure).
  * No flags defined yet.
  */
@@ -130,7 +129,7 @@ struct arpt_entry
         unsigned int comefrom;
 
         /* Packet and byte counters. */
-        struct arpt_counters counters;
+        struct xt_counters counters;
 
         /* The matches (if any), then the target. */
         unsigned char elems[0];
@@ -141,23 +140,24 @@ struct arpt_entry
  * Unlike BSD Linux inherits IP options so you don't have to use a raw
  * socket for this. Instead we check rights in the calls.
  */
-#define ARPT_BASE_CTL           96      /* base for firewall socket options */
+#define ARPT_CTL_OFFSET         32
+#define ARPT_BASE_CTL           (XT_BASE_CTL+ARPT_CTL_OFFSET)
 
-#define ARPT_SO_SET_REPLACE             (ARPT_BASE_CTL)
-#define ARPT_SO_SET_ADD_COUNTERS        (ARPT_BASE_CTL + 1)
-#define ARPT_SO_SET_MAX                 ARPT_SO_SET_ADD_COUNTERS
+#define ARPT_SO_SET_REPLACE             (XT_SO_SET_REPLACE+ARPT_CTL_OFFSET)
+#define ARPT_SO_SET_ADD_COUNTERS        (XT_SO_SET_ADD_COUNTERS+ARPT_CTL_OFFSET)
+#define ARPT_SO_SET_MAX                 (XT_SO_SET_MAX+ARPT_CTL_OFFSET)
 
-#define ARPT_SO_GET_INFO                (ARPT_BASE_CTL)
-#define ARPT_SO_GET_ENTRIES             (ARPT_BASE_CTL + 1)
-/* #define ARPT_SO_GET_REVISION_MATCH   (ARPT_BASE_CTL + 2)*/
-#define ARPT_SO_GET_REVISION_TARGET     (ARPT_BASE_CTL + 3)
-#define ARPT_SO_GET_MAX                 ARPT_SO_GET_REVISION_TARGET
+#define ARPT_SO_GET_INFO                (XT_SO_GET_INFO+ARPT_CTL_OFFSET)
+#define ARPT_SO_GET_ENTRIES             (XT_SO_GET_ENTRIES+ARPT_CTL_OFFSET)
+/* #define ARPT_SO_GET_REVISION_MATCH   XT_SO_GET_REVISION_MATCH  */
+#define ARPT_SO_GET_REVISION_TARGET     (XT_SO_GET_REVISION_TARGET+ARPT_CTL_OFFSET)
+#define ARPT_SO_GET_MAX                 (XT_SO_GET_REVISION_TARGET+ARPT_CTL_OFFSET)
 
 /* CONTINUE verdict for targets */
-#define ARPT_CONTINUE 0xFFFFFFFF
+#define ARPT_CONTINUE XT_CONTINUE
 
 /* For standard target */
-#define ARPT_RETURN (-NF_REPEAT - 1)
+#define ARPT_RETURN XT_RETURN
 
 /* The argument to ARPT_SO_GET_INFO */
 struct arpt_getinfo
@@ -208,23 +208,14 @@ struct arpt_replace
         /* Number of counters (must be equal to current number of entries). */
         unsigned int num_counters;
         /* The old entries' counters. */
-        struct arpt_counters __user *counters;
+        struct xt_counters __user *counters;
 
         /* The entries (hang off end: not really an array). */
         struct arpt_entry entries[0];
 };
 
 /* The argument to ARPT_SO_ADD_COUNTERS. */
-struct arpt_counters_info
-{
-        /* Which table. */
-        char name[ARPT_TABLE_MAXNAMELEN];
-
-        unsigned int num_counters;
-
-        /* The counters (actually `number' of these). */
-        struct arpt_counters counters[0];
-};
+#define arpt_counters_info xt_counters_info
 
 /* The argument to ARPT_SO_GET_ENTRIES. */
 struct arpt_get_entries
@@ -239,19 +230,10 @@ struct arpt_get_entries
         struct arpt_entry entrytable[0];
 };
 
-/* The argument to ARPT_SO_GET_REVISION_*.  Returns highest revision
- * kernel supports, if >= revision. */
-struct arpt_get_revision
-{
-        char name[ARPT_FUNCTION_MAXNAMELEN-1];
-
-        u_int8_t revision;
-};
-
 /* Standard return verdict, or do jump. */
-#define ARPT_STANDARD_TARGET ""
+#define ARPT_STANDARD_TARGET XT_STANDARD_TARGET
 /* Error verdict. */
-#define ARPT_ERROR_TARGET "ERROR"
+#define ARPT_ERROR_TARGET XT_ERROR_TARGET
 
 /* Helper functions */
 static __inline__ struct arpt_entry_target *arpt_get_target(struct arpt_entry *e)
@@ -281,63 +263,8 @@ static __inline__ struct arpt_entry_target *arpt_get_target(struct arpt_entry *e
  */
 #ifdef __KERNEL__
 
-/* Registration hooks for targets. */
-struct arpt_target
-{
-        struct list_head list;
-
-        const char name[ARPT_FUNCTION_MAXNAMELEN-1];
-
-        u_int8_t revision;
-
-        /* Returns verdict. */
-        unsigned int (*target)(struct sk_buff **pskb,
-                               unsigned int hooknum,
-                               const struct net_device *in,
-                               const struct net_device *out,
-                               const void *targinfo,
-                               void *userdata);
-
-        /* Called when user tries to insert an entry of this type:
-           hook_mask is a bitmask of hooks from which it can be
-           called. */
-        /* Should return true or false. */
-        int (*checkentry)(const char *tablename,
-                          const struct arpt_entry *e,
-                          void *targinfo,
-                          unsigned int targinfosize,
-                          unsigned int hook_mask);
-
-        /* Called when entry of this type deleted. */
-        void (*destroy)(void *targinfo, unsigned int targinfosize);
-
-        /* Set this to THIS_MODULE if you are a module, otherwise NULL */
-        struct module *me;
-};
-
-extern int arpt_register_target(struct arpt_target *target);
-extern void arpt_unregister_target(struct arpt_target *target);
-
-/* Furniture shopping... */
-struct arpt_table
-{
-        struct list_head list;
-
-        /* A unique name... */
-        char name[ARPT_TABLE_MAXNAMELEN];
-
-        /* What hooks you will enter on */
-        unsigned int valid_hooks;
-
-        /* Lock for the curtain */
-        rwlock_t lock;
-
-        /* Man behind the curtain... */
-        struct arpt_table_info *private;
-
-        /* Set this to THIS_MODULE if you are a module, otherwise NULL */
-        struct module *me;
-};
+#define arpt_register_target(tgt) xt_register_target(NF_ARP, tgt)
+#define arpt_unregister_target(tgt) xt_unregister_target(NF_ARP, tgt)
 
 extern int arpt_register_table(struct arpt_table *table,
                                const struct arpt_replace *repl);
diff --git a/include/linux/netfilter_ipv4/ip_conntrack.h b/include/linux/netfilter_ipv4/ip_conntrack.h
index b3432ab59a17..215765f043e6 100644
--- a/include/linux/netfilter_ipv4/ip_conntrack.h
+++ b/include/linux/netfilter_ipv4/ip_conntrack.h
@@ -199,9 +199,6 @@ ip_conntrack_put(struct ip_conntrack *ct)
         nf_conntrack_put(&ct->ct_general);
 }
 
-/* call to create an explicit dependency on ip_conntrack. */
-extern void need_ip_conntrack(void);
-
 extern int invert_tuplepr(struct ip_conntrack_tuple *inverse,
                           const struct ip_conntrack_tuple *orig);
 
diff --git a/include/linux/netfilter_ipv4/ip_tables.h b/include/linux/netfilter_ipv4/ip_tables.h
index d19d65cf4530..76ba24b68515 100644
--- a/include/linux/netfilter_ipv4/ip_tables.h
+++ b/include/linux/netfilter_ipv4/ip_tables.h
@@ -25,8 +25,14 @@
 #include <linux/compiler.h>
 #include <linux/netfilter_ipv4.h>
 
-#define IPT_FUNCTION_MAXNAMELEN 30
-#define IPT_TABLE_MAXNAMELEN 32
+#include <linux/netfilter/x_tables.h>
+
+#define IPT_FUNCTION_MAXNAMELEN XT_FUNCTION_MAXNAMELEN
+#define IPT_TABLE_MAXNAMELEN XT_FUNCTION_MAXNAMELEN
+#define ipt_match xt_match
+#define ipt_target xt_target
+#define ipt_table xt_table
+#define ipt_get_revision xt_get_revision
 
 /* Yes, Virginia, you have to zero the padding. */
 struct ipt_ip {
@@ -102,10 +108,7 @@ struct ipt_standard_target
         int verdict;
 };
 
-struct ipt_counters
-{
-        u_int64_t pcnt, bcnt;                   /* Packet and byte counters */
-};
+#define ipt_counters xt_counters
 
 /* Values for "flag" field in struct ipt_ip (general ip structure). */
 #define IPT_F_FRAG              0x01    /* Set if rule is a fragment rule */
@@ -119,7 +122,7 @@ struct ipt_counters
 #define IPT_INV_SRCIP           0x08    /* Invert the sense of SRC IP. */
 #define IPT_INV_DSTIP           0x10    /* Invert the sense of DST OP. */
 #define IPT_INV_FRAG            0x20    /* Invert the sense of FRAG. */
-#define IPT_INV_PROTO           0x40    /* Invert the sense of PROTO. */
+#define IPT_INV_PROTO           XT_INV_PROTO
 #define IPT_INV_MASK            0x7F    /* All possible flag bits mask. */
 
 /* This structure defines each of the firewall rules.  Consists of 3
@@ -141,7 +144,7 @@ struct ipt_entry
         unsigned int comefrom;
 
         /* Packet and byte counters. */
-        struct ipt_counters counters;
+        struct xt_counters counters;
 
         /* The matches (if any), then the target. */
         unsigned char elems[0];
@@ -151,54 +154,34 @@ struct ipt_entry
  * New IP firewall options for [gs]etsockopt at the RAW IP level.
  * Unlike BSD Linux inherits IP options so you don't have to use a raw
  * socket for this. Instead we check rights in the calls. */
-#define IPT_BASE_CTL            64      /* base for firewall socket options */
+#define IPT_BASE_CTL            XT_BASE_CTL
 
-#define IPT_SO_SET_REPLACE      (IPT_BASE_CTL)
-#define IPT_SO_SET_ADD_COUNTERS (IPT_BASE_CTL + 1)
-#define IPT_SO_SET_MAX          IPT_SO_SET_ADD_COUNTERS
+#define IPT_SO_SET_REPLACE      XT_SO_SET_REPLACE
+#define IPT_SO_SET_ADD_COUNTERS XT_SO_SET_ADD_COUNTERS
+#define IPT_SO_SET_MAX          XT_SO_SET_MAX
 
-#define IPT_SO_GET_INFO                 (IPT_BASE_CTL)
-#define IPT_SO_GET_ENTRIES              (IPT_BASE_CTL + 1)
-#define IPT_SO_GET_REVISION_MATCH       (IPT_BASE_CTL + 2)
-#define IPT_SO_GET_REVISION_TARGET      (IPT_BASE_CTL + 3)
-#define IPT_SO_GET_MAX                  IPT_SO_GET_REVISION_TARGET
+#define IPT_SO_GET_INFO                 XT_SO_GET_INFO
+#define IPT_SO_GET_ENTRIES              XT_SO_GET_ENTRIES
+#define IPT_SO_GET_REVISION_MATCH       XT_SO_GET_REVISION_MATCH
+#define IPT_SO_GET_REVISION_TARGET      XT_SO_GET_REVISION_TARGET
+#define IPT_SO_GET_MAX                  XT_SO_GET_REVISION_TARGET
 
-/* CONTINUE verdict for targets */
-#define IPT_CONTINUE 0xFFFFFFFF
+#define IPT_CONTINUE XT_CONTINUE
+#define IPT_RETURN XT_RETURN
 
-/* For standard target */
-#define IPT_RETURN (-NF_REPEAT - 1)
+#include <linux/netfilter/xt_tcpudp.h>
+#define ipt_udp xt_udp
+#define ipt_tcp xt_tcp
 
-/* TCP matching stuff */
-struct ipt_tcp
-{
-        u_int16_t spts[2];                      /* Source port range. */
-        u_int16_t dpts[2];                      /* Destination port range. */
-        u_int8_t option;                        /* TCP Option iff non-zero*/
-        u_int8_t flg_mask;                      /* TCP flags mask byte */
-        u_int8_t flg_cmp;                       /* TCP flags compare byte */
-        u_int8_t invflags;                      /* Inverse flags */
-};
-
-/* Values for "inv" field in struct ipt_tcp. */
-#define IPT_TCP_INV_SRCPT       0x01    /* Invert the sense of source ports. */
-#define IPT_TCP_INV_DSTPT       0x02    /* Invert the sense of dest ports. */
-#define IPT_TCP_INV_FLAGS       0x04    /* Invert the sense of TCP flags. */
-#define IPT_TCP_INV_OPTION      0x08    /* Invert the sense of option test. */
-#define IPT_TCP_INV_MASK        0x0F    /* All possible flags. */
-
-/* UDP matching stuff */
-struct ipt_udp
-{
-        u_int16_t spts[2];                      /* Source port range. */
-        u_int16_t dpts[2];                      /* Destination port range. */
-        u_int8_t invflags;                      /* Inverse flags */
-};
+#define IPT_TCP_INV_SRCPT       XT_TCP_INV_SRCPT
+#define IPT_TCP_INV_DSTPT       XT_TCP_INV_DSTPT
+#define IPT_TCP_INV_FLAGS       XT_TCP_INV_FLAGS
+#define IPT_TCP_INV_OPTION      XT_TCP_INV_OPTION
+#define IPT_TCP_INV_MASK        XT_TCP_INV_MASK
 
-/* Values for "invflags" field in struct ipt_udp. */
-#define IPT_UDP_INV_SRCPT       0x01    /* Invert the sense of source ports. */
-#define IPT_UDP_INV_DSTPT       0x02    /* Invert the sense of dest ports. */
-#define IPT_UDP_INV_MASK        0x03    /* All possible flags. */
+#define IPT_UDP_INV_SRCPT       XT_UDP_INV_SRCPT
+#define IPT_UDP_INV_DSTPT       XT_UDP_INV_DSTPT
+#define IPT_UDP_INV_MASK        XT_UDP_INV_MASK
 
 /* ICMP matching stuff */
 struct ipt_icmp
@@ -260,23 +243,14 @@ struct ipt_replace
         /* Number of counters (must be equal to current number of entries). */
         unsigned int num_counters;
         /* The old entries' counters. */
-        struct ipt_counters __user *counters;
+        struct xt_counters __user *counters;
 
         /* The entries (hang off end: not really an array). */
         struct ipt_entry entries[0];
 };
 
 /* The argument to IPT_SO_ADD_COUNTERS. */
-struct ipt_counters_info
-{
-        /* Which table. */
-        char name[IPT_TABLE_MAXNAMELEN];
-
-        unsigned int num_counters;
-
-        /* The counters (actually `number' of these). */
-        struct ipt_counters counters[0];
-};
+#define ipt_counters_info xt_counters_info
 
 /* The argument to IPT_SO_GET_ENTRIES. */
 struct ipt_get_entries
@@ -291,19 +265,10 @@ struct ipt_get_entries
         struct ipt_entry entrytable[0];
 };
 
-/* The argument to IPT_SO_GET_REVISION_*.  Returns highest revision
- * kernel supports, if >= revision. */
-struct ipt_get_revision
-{
-        char name[IPT_FUNCTION_MAXNAMELEN-1];
-
-        u_int8_t revision;
-};
-
 /* Standard return verdict, or do jump. */
-#define IPT_STANDARD_TARGET ""
+#define IPT_STANDARD_TARGET XT_STANDARD_TARGET
 /* Error verdict. */
-#define IPT_ERROR_TARGET "ERROR"
+#define IPT_ERROR_TARGET XT_ERROR_TARGET
 
 /* Helper functions */
 static __inline__ struct ipt_entry_target *
@@ -356,103 +321,18 @@ ipt_get_target(struct ipt_entry *e)
 #include <linux/init.h>
 extern void ipt_init(void) __init;
 
-struct ipt_match
-{
-        struct list_head list;
-
-        const char name[IPT_FUNCTION_MAXNAMELEN-1];
-
-        u_int8_t revision;
-
-        /* Return true or false: return FALSE and set *hotdrop = 1 to
-           force immediate packet drop. */
-        /* Arguments changed since 2.4, as this must now handle
-           non-linear skbs, using skb_copy_bits and
-           skb_ip_make_writable. */
-        int (*match)(const struct sk_buff *skb,
-                     const struct net_device *in,
-                     const struct net_device *out,
-                     const void *matchinfo,
-                     int offset,
-                     int *hotdrop);
-
-        /* Called when user tries to insert an entry of this type. */
-        /* Should return true or false. */
-        int (*checkentry)(const char *tablename,
-                          const struct ipt_ip *ip,
-                          void *matchinfo,
-                          unsigned int matchinfosize,
-                          unsigned int hook_mask);
-
-        /* Called when entry of this type deleted. */
-        void (*destroy)(void *matchinfo, unsigned int matchinfosize);
-
-        /* Set this to THIS_MODULE. */
-        struct module *me;
-};
-
-/* Registration hooks for targets. */
-struct ipt_target
-{
-        struct list_head list;
-
-        const char name[IPT_FUNCTION_MAXNAMELEN-1];
-
-        u_int8_t revision;
-
-        /* Called when user tries to insert an entry of this type:
-           hook_mask is a bitmask of hooks from which it can be
-           called. */
-        /* Should return true or false. */
-        int (*checkentry)(const char *tablename,
-                          const struct ipt_entry *e,
-                          void *targinfo,
-                          unsigned int targinfosize,
-                          unsigned int hook_mask);
-
-        /* Called when entry of this type deleted. */
-        void (*destroy)(void *targinfo, unsigned int targinfosize);
-
-        /* Returns verdict.  Argument order changed since 2.4, as this
-           must now handle non-linear skbs, using skb_copy_bits and
-           skb_ip_make_writable. */
-        unsigned int (*target)(struct sk_buff **pskb,
-                               const struct net_device *in,
-                               const struct net_device *out,
-                               unsigned int hooknum,
-                               const void *targinfo,
-                               void *userdata);
-
-        /* Set this to THIS_MODULE. */
-        struct module *me;
-};
+#define ipt_register_target(tgt) xt_register_target(AF_INET, tgt)
+#define ipt_unregister_target(tgt) xt_unregister_target(AF_INET, tgt)
 
-extern int ipt_register_target(struct ipt_target *target);
-extern void ipt_unregister_target(struct ipt_target *target);
+#define ipt_register_match(mtch) xt_register_match(AF_INET, mtch)
+#define ipt_unregister_match(mtch) xt_unregister_match(AF_INET, mtch)
 
-extern int ipt_register_match(struct ipt_match *match);
-extern void ipt_unregister_match(struct ipt_match *match);
+//#define ipt_register_table(tbl, repl) xt_register_table(AF_INET, tbl, repl)
+//#define ipt_unregister_table(tbl) xt_unregister_table(AF_INET, tbl)
 
-/* Furniture shopping... */
-struct ipt_table
-{
-        struct list_head list;
-
-        /* A unique name... */
-        char name[IPT_TABLE_MAXNAMELEN];
-
-        /* What hooks you will enter on */
-        unsigned int valid_hooks;
-
-        /* Lock for the curtain */
-        rwlock_t lock;
-
-        /* Man behind the curtain... */
-        struct ipt_table_info *private;
-
-        /* Set to THIS_MODULE. */
-        struct module *me;
-};
+extern int ipt_register_table(struct ipt_table *table,
+                              const struct ipt_replace *repl);
+extern void ipt_unregister_table(struct ipt_table *table);
 
 /* net/sched/ipt.c: Gimme access to your targets!  Gets target->me. */
 extern struct ipt_target *ipt_find_target(const char *name, u8 revision);
@@ -476,9 +356,6 @@ struct ipt_error
         struct ipt_error_target target;
 };
 
-extern int ipt_register_table(struct ipt_table *table,
-                              const struct ipt_replace *repl);
-extern void ipt_unregister_table(struct ipt_table *table);
 extern unsigned int ipt_do_table(struct sk_buff **pskb,
                                  unsigned int hook,
                                  const struct net_device *in,
@@ -486,6 +363,6 @@ extern unsigned int ipt_do_table(struct sk_buff **pskb,
                                  struct ipt_table *table,
                                  void *userdata);
 
-#define IPT_ALIGN(s) (((s) + (__alignof__(struct ipt_entry)-1)) & ~(__alignof__(struct ipt_entry)-1))
+#define IPT_ALIGN(s) XT_ALIGN(s)
 #endif /*__KERNEL__*/
 #endif /* _IPTABLES_H */
diff --git a/include/linux/netfilter_ipv4/ipt_CLASSIFY.h b/include/linux/netfilter_ipv4/ipt_CLASSIFY.h
index 7596e3dd00ca..a46d511b5c36 100644
--- a/include/linux/netfilter_ipv4/ipt_CLASSIFY.h
+++ b/include/linux/netfilter_ipv4/ipt_CLASSIFY.h
@@ -1,8 +1,7 @@
 #ifndef _IPT_CLASSIFY_H
 #define _IPT_CLASSIFY_H
 
-struct ipt_classify_target_info {
-        u_int32_t priority;
-};
+#include <linux/netfilter/xt_CLASSIFY.h>
+#define ipt_classify_target_info xt_classify_target_info
 
 #endif /*_IPT_CLASSIFY_H */
diff --git a/include/linux/netfilter_ipv4/ipt_CONNMARK.h b/include/linux/netfilter_ipv4/ipt_CONNMARK.h
index d3c02536fc4c..9ecfee0a9e33 100644
--- a/include/linux/netfilter_ipv4/ipt_CONNMARK.h
+++ b/include/linux/netfilter_ipv4/ipt_CONNMARK.h
@@ -9,17 +9,11 @@
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  */
+#include <linux/netfilter/xt_CONNMARK.h>
+#define IPT_CONNMARK_SET        XT_CONNMARK_SET
+#define IPT_CONNMARK_SAVE       XT_CONNMARK_SAVE
+#define IPT_CONNMARK_RESTORE    XT_CONNMARK_RESTORE
 
-enum {
-        IPT_CONNMARK_SET = 0,
-        IPT_CONNMARK_SAVE,
-        IPT_CONNMARK_RESTORE
-};
-
-struct ipt_connmark_target_info {
-        unsigned long mark;
-        unsigned long mask;
-        u_int8_t mode;
-};
+#define ipt_connmark_target_info xt_connmark_target_info
 
 #endif /*_IPT_CONNMARK_H_target*/
diff --git a/include/linux/netfilter_ipv4/ipt_MARK.h b/include/linux/netfilter_ipv4/ipt_MARK.h
index f47485790ed4..697a486a96d3 100644
--- a/include/linux/netfilter_ipv4/ipt_MARK.h
+++ b/include/linux/netfilter_ipv4/ipt_MARK.h
@@ -1,20 +1,18 @@
 #ifndef _IPT_MARK_H_target
 #define _IPT_MARK_H_target
 
+/* Backwards compatibility for old userspace */
+
+#include <linux/netfilter/xt_MARK.h>
+
 /* Version 0 */
-struct ipt_mark_target_info {
-        unsigned long mark;
-};
+#define ipt_mark_target_info xt_mark_target_info
 
 /* Version 1 */
-enum {
-        IPT_MARK_SET=0,
-        IPT_MARK_AND,
-        IPT_MARK_OR
-};
+#define IPT_MARK_SET    XT_MARK_SET
+#define IPT_MARK_AND    XT_MARK_AND
+#define IPT_MARK_OR     XT_MARK_OR
+
+#define ipt_mark_target_info_v1 xt_mark_target_info_v1
 
-struct ipt_mark_target_info_v1 {
-        unsigned long mark;
-        u_int8_t mode;
-};
 #endif /*_IPT_MARK_H_target*/
diff --git a/include/linux/netfilter_ipv4/ipt_NFQUEUE.h b/include/linux/netfilter_ipv4/ipt_NFQUEUE.h
index b5b2943b0c66..97a2a7557cb9 100644
--- a/include/linux/netfilter_ipv4/ipt_NFQUEUE.h
+++ b/include/linux/netfilter_ipv4/ipt_NFQUEUE.h
@@ -8,9 +8,9 @@
 #ifndef _IPT_NFQ_TARGET_H
 #define _IPT_NFQ_TARGET_H
 
-/* target info */
-struct ipt_NFQ_info {
-        u_int16_t queuenum;
-};
+/* Backwards compatibility for old userspace */
+#include <linux/netfilter/xt_NFQUEUE.h>
+
+#define ipt_NFQ_info xt_NFQ_info
 
 #endif /* _IPT_DSCP_TARGET_H */
diff --git a/include/linux/netfilter_ipv4/ipt_comment.h b/include/linux/netfilter_ipv4/ipt_comment.h
index 85c1123c29ce..ae2afc2f7481 100644
--- a/include/linux/netfilter_ipv4/ipt_comment.h
+++ b/include/linux/netfilter_ipv4/ipt_comment.h
@@ -1,10 +1,10 @@
 #ifndef _IPT_COMMENT_H
 #define _IPT_COMMENT_H
 
-#define IPT_MAX_COMMENT_LEN 256
+#include <linux/netfilter/xt_comment.h>
 
-struct ipt_comment_info {
-        unsigned char comment[IPT_MAX_COMMENT_LEN];
-};
+#define IPT_MAX_COMMENT_LEN XT_MAX_COMMENT_LEN
+
+#define ipt_comment_info xt_comment_info
 
 #endif /* _IPT_COMMENT_H */
diff --git a/include/linux/netfilter_ipv4/ipt_connbytes.h b/include/linux/netfilter_ipv4/ipt_connbytes.h
index 9e5532f8d8ac..b04dfa3083c9 100644
--- a/include/linux/netfilter_ipv4/ipt_connbytes.h
+++ b/include/linux/netfilter_ipv4/ipt_connbytes.h
@@ -1,25 +1,18 @@
 #ifndef _IPT_CONNBYTES_H
 #define _IPT_CONNBYTES_H
 
-enum ipt_connbytes_what {
-        IPT_CONNBYTES_PKTS,
-        IPT_CONNBYTES_BYTES,
-        IPT_CONNBYTES_AVGPKT,
-};
+#include <net/netfilter/xt_connbytes.h>
+#define ipt_connbytes_what xt_connbytes_what
 
-enum ipt_connbytes_direction {
-        IPT_CONNBYTES_DIR_ORIGINAL,
-        IPT_CONNBYTES_DIR_REPLY,
-        IPT_CONNBYTES_DIR_BOTH,
-};
+#define IPT_CONNBYTES_PKTS      XT_CONNBYTES_PACKETS
+#define IPT_CONNBYTES_BYTES     XT_CONNBYTES_BYTES
+#define IPT_CONNBYTES_AVGPKT    XT_CONNBYTES_AVGPKT
+
+#define ipt_connbytes_direction         xt_connbytes_direction
+#define IPT_CONNBYTES_DIR_ORIGINAL      XT_CONNBYTES_DIR_ORIGINAL
+#define IPT_CONNBYTES_DIR_REPLY         XT_CONNBYTES_DIR_REPLY
+#define IPT_CONNBYTES_DIR_BOTH          XT_CONNBYTES_DIR_BOTH
+
+#define ipt_connbytes_info xt_connbytes_info
 
-struct ipt_connbytes_info
-{
-        struct {
-                aligned_u64 from;       /* count to be matched */
-                aligned_u64 to;         /* count to be matched */
-        } count;
-        u_int8_t what;          /* ipt_connbytes_what */
-        u_int8_t direction;     /* ipt_connbytes_direction */
-};
 #endif
diff --git a/include/linux/netfilter_ipv4/ipt_connmark.h b/include/linux/netfilter_ipv4/ipt_connmark.h
index 46573270d9aa..c7ba6560d44c 100644
--- a/include/linux/netfilter_ipv4/ipt_connmark.h
+++ b/include/linux/netfilter_ipv4/ipt_connmark.h
@@ -1,18 +1,7 @@
 #ifndef _IPT_CONNMARK_H
 #define _IPT_CONNMARK_H
 
-/* Copyright (C) 2002,2004 MARA Systems AB <http://www.marasystems.com>
- * by Henrik Nordstrom <hno@marasystems.com>
- *
- * 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.
- */
-
-struct ipt_connmark_info {
-        unsigned long mark, mask;
-        u_int8_t invert;
-};
+#include <linux/netfilter/xt_connmark.h>
+#define ipt_connmark_info xt_connmark_info
 
 #endif /*_IPT_CONNMARK_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_conntrack.h b/include/linux/netfilter_ipv4/ipt_conntrack.h
index 413c5658bd3a..cde6762949c5 100644
--- a/include/linux/netfilter_ipv4/ipt_conntrack.h
+++ b/include/linux/netfilter_ipv4/ipt_conntrack.h
@@ -5,56 +5,24 @@
 #ifndef _IPT_CONNTRACK_H
 #define _IPT_CONNTRACK_H
 
-#define IPT_CONNTRACK_STATE_BIT(ctinfo) (1 << ((ctinfo)%IP_CT_IS_REPLY+1))
-#define IPT_CONNTRACK_STATE_INVALID (1 << 0)
+#include <linux/netfilter/xt_conntrack.h>
 
-#define IPT_CONNTRACK_STATE_SNAT (1 << (IP_CT_NUMBER + 1))
-#define IPT_CONNTRACK_STATE_DNAT (1 << (IP_CT_NUMBER + 2))
-#define IPT_CONNTRACK_STATE_UNTRACKED (1 << (IP_CT_NUMBER + 3))
+#define IPT_CONNTRACK_STATE_BIT(ctinfo) XT_CONNTRACK_STATE_BIT(ctinfo)
+#define IPT_CONNTRACK_STATE_INVALID     XT_CONNTRACK_STATE_INVALID
 
-/* flags, invflags: */
-#define IPT_CONNTRACK_STATE     0x01
-#define IPT_CONNTRACK_PROTO     0x02
-#define IPT_CONNTRACK_ORIGSRC   0x04
-#define IPT_CONNTRACK_ORIGDST   0x08
-#define IPT_CONNTRACK_REPLSRC   0x10
-#define IPT_CONNTRACK_REPLDST   0x20
-#define IPT_CONNTRACK_STATUS    0x40
-#define IPT_CONNTRACK_EXPIRES   0x80
-
-/* This is exposed to userspace, so remains frozen in time. */
-struct ip_conntrack_old_tuple
-{
-        struct {
-                __u32 ip;
-                union {
-                        __u16 all;
-                } u;
-        } src;
-
-        struct {
-                __u32 ip;
-                union {
-                        __u16 all;
-                } u;
-
-                /* The protocol. */
-                u16 protonum;
-        } dst;
-};
+#define IPT_CONNTRACK_STATE_SNAT        XT_CONNTRACK_STATE_SNAT
+#define IPT_CONNTRACK_STATE_DNAT        XT_CONNTRACK_STATE_DNAT
+#define IPT_CONNTRACK_STATE_UNTRACKED   XT_CONNTRACK_STATE_UNTRACKED
 
-struct ipt_conntrack_info
-{
-        unsigned int statemask, statusmask;
-
-        struct ip_conntrack_old_tuple tuple[IP_CT_DIR_MAX];
-        struct in_addr sipmsk[IP_CT_DIR_MAX], dipmsk[IP_CT_DIR_MAX];
-
-        unsigned long expires_min, expires_max;
-
-        /* Flags word */
-        u_int8_t flags;
-        /* Inverse flags */
-        u_int8_t invflags;
-};
+/* flags, invflags: */
+#define IPT_CONNTRACK_STATE             XT_CONNTRACK_STATE
+#define IPT_CONNTRACK_PROTO             XT_CONNTRACK_PROTO
+#define IPT_CONNTRACK_ORIGSRC           XT_CONNTRACK_ORIGSRC
+#define IPT_CONNTRACK_ORIGDST           XT_CONNTRACK_ORIGDST
+#define IPT_CONNTRACK_REPLSRC           XT_CONNTRACK_REPLSRC
+#define IPT_CONNTRACK_REPLDST           XT_CONNTRACK_REPLDST
+#define IPT_CONNTRACK_STATUS            XT_CONNTRACK_STATUS
+#define IPT_CONNTRACK_EXPIRES           XT_CONNTRACK_EXPIRES
+
+#define ipt_conntrack_info              xt_conntrack_info
 #endif /*_IPT_CONNTRACK_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_dccp.h b/include/linux/netfilter_ipv4/ipt_dccp.h
index 3cb3a522e62b..e70d11e1f53c 100644
--- a/include/linux/netfilter_ipv4/ipt_dccp.h
+++ b/include/linux/netfilter_ipv4/ipt_dccp.h
@@ -1,23 +1,15 @@
 #ifndef _IPT_DCCP_H_
 #define _IPT_DCCP_H_
 
-#define IPT_DCCP_SRC_PORTS              0x01
-#define IPT_DCCP_DEST_PORTS             0x02
-#define IPT_DCCP_TYPE                   0x04
-#define IPT_DCCP_OPTION                 0x08
+#include <linux/netfilter/xt_dccp.h>
+#define IPT_DCCP_SRC_PORTS      XT_DCCP_SRC_PORTS
+#define IPT_DCCP_DEST_PORTS     XT_DCCP_DEST_PORTS
+#define IPT_DCCP_TYPE           XT_DCCP_TYPE
+#define IPT_DCCP_OPTION         XT_DCCP_OPTION
 
-#define IPT_DCCP_VALID_FLAGS            0x0f
+#define IPT_DCCP_VALID_FLAGS    XT_DCCP_VALID_FLAGS
 
-struct ipt_dccp_info {
-        u_int16_t dpts[2];  /* Min, Max */
-        u_int16_t spts[2];  /* Min, Max */
-
-        u_int16_t flags;
-        u_int16_t invflags;
-
-        u_int16_t typemask;
-        u_int8_t option;
-};
+#define ipt_dccp_info xt_dccp_info
 
 #endif /* _IPT_DCCP_H_ */
 
diff --git a/include/linux/netfilter_ipv4/ipt_helper.h b/include/linux/netfilter_ipv4/ipt_helper.h
index 6f12ecb8c93d..80452c218551 100644
--- a/include/linux/netfilter_ipv4/ipt_helper.h
+++ b/include/linux/netfilter_ipv4/ipt_helper.h
@@ -1,8 +1,7 @@
 #ifndef _IPT_HELPER_H
 #define _IPT_HELPER_H
 
-struct ipt_helper_info {
-        int invert;
-        char name[30];
-};
+#include <linux/netfilter/xt_helper.h>
+#define ipt_helper_info xt_helper_info
+
 #endif /* _IPT_HELPER_H */
diff --git a/include/linux/netfilter_ipv4/ipt_length.h b/include/linux/netfilter_ipv4/ipt_length.h
index 6e0885229615..9b45206ffcef 100644
--- a/include/linux/netfilter_ipv4/ipt_length.h
+++ b/include/linux/netfilter_ipv4/ipt_length.h
@@ -1,9 +1,7 @@
 #ifndef _IPT_LENGTH_H
 #define _IPT_LENGTH_H
 
-struct ipt_length_info {
-    u_int16_t   min, max;
-    u_int8_t    invert;
-};
+#include <linux/netfilter/xt_length.h>
+#define ipt_length_info xt_length_info
 
 #endif /*_IPT_LENGTH_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_limit.h b/include/linux/netfilter_ipv4/ipt_limit.h
index 256453409e21..92f5cd07bbc4 100644
--- a/include/linux/netfilter_ipv4/ipt_limit.h
+++ b/include/linux/netfilter_ipv4/ipt_limit.h
@@ -1,21 +1,8 @@
 #ifndef _IPT_RATE_H
 #define _IPT_RATE_H
 
-/* timings are in milliseconds. */
-#define IPT_LIMIT_SCALE 10000
+#include <linux/netfilter/xt_limit.h>
+#define IPT_LIMIT_SCALE XT_LIMIT_SCALE
+#define ipt_rateinfo xt_rateinfo
 
-/* 1/10,000 sec period => max of 10,000/sec.  Min rate is then 429490
-   seconds, or one every 59 hours. */
-struct ipt_rateinfo {
-        u_int32_t avg;    /* Average secs between packets * scale */
-        u_int32_t burst;  /* Period multiplier for upper limit. */
-
-        /* Used internally by the kernel */
-        unsigned long prev;
-        u_int32_t credit;
-        u_int32_t credit_cap, cost;
-
-        /* Ugly, ugly fucker. */
-        struct ipt_rateinfo *master;
-};
 #endif /*_IPT_RATE_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_mac.h b/include/linux/netfilter_ipv4/ipt_mac.h
index f8d5b8e7ccdb..b186008a3c47 100644
--- a/include/linux/netfilter_ipv4/ipt_mac.h
+++ b/include/linux/netfilter_ipv4/ipt_mac.h
@@ -1,8 +1,7 @@
 #ifndef _IPT_MAC_H
 #define _IPT_MAC_H
 
-struct ipt_mac_info {
-    unsigned char srcaddr[ETH_ALEN];
-    int invert;
-};
+#include <linux/netfilter/xt_mac.h>
+#define ipt_mac_info xt_mac_info
+
 #endif /*_IPT_MAC_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_mark.h b/include/linux/netfilter_ipv4/ipt_mark.h
index f3952b563d4c..bfde67c61224 100644
--- a/include/linux/netfilter_ipv4/ipt_mark.h
+++ b/include/linux/netfilter_ipv4/ipt_mark.h
@@ -1,9 +1,9 @@
 #ifndef _IPT_MARK_H
 #define _IPT_MARK_H
 
-struct ipt_mark_info {
-    unsigned long mark, mask;
-    u_int8_t invert;
-};
+/* Backwards compatibility for old userspace */
+#include <linux/netfilter/xt_mark.h>
+
+#define ipt_mark_info xt_mark_info
 
 #endif /*_IPT_MARK_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_physdev.h b/include/linux/netfilter_ipv4/ipt_physdev.h
index 7538c8655ec0..2400e7140f26 100644
--- a/include/linux/netfilter_ipv4/ipt_physdev.h
+++ b/include/linux/netfilter_ipv4/ipt_physdev.h
@@ -1,24 +1,17 @@
 #ifndef _IPT_PHYSDEV_H
 #define _IPT_PHYSDEV_H
 
-#ifdef __KERNEL__
-#include <linux/if.h>
-#endif
+/* Backwards compatibility for old userspace */
 
-#define IPT_PHYSDEV_OP_IN               0x01
-#define IPT_PHYSDEV_OP_OUT              0x02
-#define IPT_PHYSDEV_OP_BRIDGED          0x04
-#define IPT_PHYSDEV_OP_ISIN             0x08
-#define IPT_PHYSDEV_OP_ISOUT            0x10
-#define IPT_PHYSDEV_OP_MASK             (0x20 - 1)
+#include <linux/netfilter/xt_physdev.h>
 
-struct ipt_physdev_info {
-        char physindev[IFNAMSIZ];
-        char in_mask[IFNAMSIZ];
-        char physoutdev[IFNAMSIZ];
-        char out_mask[IFNAMSIZ];
-        u_int8_t invert;
-        u_int8_t bitmask;
-};
+#define IPT_PHYSDEV_OP_IN               XT_PHYSDEV_OP_IN
+#define IPT_PHYSDEV_OP_OUT              XT_PHYSDEV_OP_OUT
+#define IPT_PHYSDEV_OP_BRIDGED          XT_PHYSDEV_OP_BRIDGED
+#define IPT_PHYSDEV_OP_ISIN             XT_PHYSDEV_OP_ISIN
+#define IPT_PHYSDEV_OP_ISOUT            XT_PHYSDEV_OP_ISOUT
+#define IPT_PHYSDEV_OP_MASK             XT_PHYSDEV_OP_MASK
+
+#define ipt_physdev_info xt_physdev_info
 
 #endif /*_IPT_PHYSDEV_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_pkttype.h b/include/linux/netfilter_ipv4/ipt_pkttype.h
index d53a65848683..ff1fbc949a0c 100644
--- a/include/linux/netfilter_ipv4/ipt_pkttype.h
+++ b/include/linux/netfilter_ipv4/ipt_pkttype.h
@@ -1,8 +1,7 @@
 #ifndef _IPT_PKTTYPE_H
 #define _IPT_PKTTYPE_H
 
-struct ipt_pkttype_info {
-        int     pkttype;
-        int     invert;
-};
+#include <linux/netfilter/xt_pkttype.h>
+#define ipt_pkttype_info xt_pkttype_info
+
 #endif /*_IPT_PKTTYPE_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_realm.h b/include/linux/netfilter_ipv4/ipt_realm.h
index a4d6698723ac..b3996eaa0188 100644
--- a/include/linux/netfilter_ipv4/ipt_realm.h
+++ b/include/linux/netfilter_ipv4/ipt_realm.h
@@ -1,10 +1,7 @@
 #ifndef _IPT_REALM_H
 #define _IPT_REALM_H
 
-struct ipt_realm_info {
-        u_int32_t id;
-        u_int32_t mask;
-        u_int8_t invert;
-};
+#include <linux/netfilter/xt_realm.h>
+#define ipt_realm_info xt_realm_info
 
 #endif /* _IPT_REALM_H */
diff --git a/include/linux/netfilter_ipv4/ipt_state.h b/include/linux/netfilter_ipv4/ipt_state.h
index 5df37868933d..a44a99cc28cc 100644
--- a/include/linux/netfilter_ipv4/ipt_state.h
+++ b/include/linux/netfilter_ipv4/ipt_state.h
@@ -1,13 +1,15 @@
 #ifndef _IPT_STATE_H
 #define _IPT_STATE_H
 
-#define IPT_STATE_BIT(ctinfo) (1 << ((ctinfo)%IP_CT_IS_REPLY+1))
-#define IPT_STATE_INVALID (1 << 0)
+/* Backwards compatibility for old userspace */
 
-#define IPT_STATE_UNTRACKED (1 << (IP_CT_NUMBER + 1))
+#include <linux/netfilter/xt_state.h>
+
+#define IPT_STATE_BIT           XT_STATE_BIT
+#define IPT_STATE_INVALID       XT_STATE_INVALID
+
+#define IPT_STATE_UNTRACKED     XT_STATE_UNTRACKED
+
+#define ipt_state_info          xt_state_info
 
-struct ipt_state_info
-{
-        unsigned int statemask;
-};
 #endif /*_IPT_STATE_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_string.h b/include/linux/netfilter_ipv4/ipt_string.h
index a265f6e44eab..c26de3059903 100644
--- a/include/linux/netfilter_ipv4/ipt_string.h
+++ b/include/linux/netfilter_ipv4/ipt_string.h
@@ -1,18 +1,10 @@
 #ifndef _IPT_STRING_H
 #define _IPT_STRING_H
 
-#define IPT_STRING_MAX_PATTERN_SIZE 128
-#define IPT_STRING_MAX_ALGO_NAME_SIZE 16
+#include <linux/netfilter/xt_string.h>
 
-struct ipt_string_info
-{
-        u_int16_t from_offset;
-        u_int16_t to_offset;
-        char      algo[IPT_STRING_MAX_ALGO_NAME_SIZE];
-        char      pattern[IPT_STRING_MAX_PATTERN_SIZE];
-        u_int8_t  patlen;
-        u_int8_t  invert;
-        struct ts_config __attribute__((aligned(8))) *config;
-};
+#define IPT_STRING_MAX_PATTERN_SIZE XT_STRING_MAX_PATTERN_SIZE
+#define IPT_STRING_MAX_ALGO_NAME_SIZE XT_STRING_MAX_ALGO_NAME_SIZE
+#define ipt_string_info xt_string_info
 
 #endif /*_IPT_STRING_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_tcpmss.h b/include/linux/netfilter_ipv4/ipt_tcpmss.h
index e2b14397f701..18bbc8e8e009 100644
--- a/include/linux/netfilter_ipv4/ipt_tcpmss.h
+++ b/include/linux/netfilter_ipv4/ipt_tcpmss.h
@@ -1,9 +1,7 @@
 #ifndef _IPT_TCPMSS_MATCH_H
 #define _IPT_TCPMSS_MATCH_H
 
-struct ipt_tcpmss_match_info {
-    u_int16_t mss_min, mss_max;
-    u_int8_t invert;
-};
+#include <linux/netfilter/xt_tcpmss.h>
+#define ipt_tcpmss_match_info xt_tcpmss_match_info
 
 #endif /*_IPT_TCPMSS_MATCH_H*/
diff --git a/include/linux/netfilter_ipv6/ip6_tables.h b/include/linux/netfilter_ipv6/ip6_tables.h
index c163ba31aab7..f249b574f0fa 100644
--- a/include/linux/netfilter_ipv6/ip6_tables.h
+++ b/include/linux/netfilter_ipv6/ip6_tables.h
@@ -25,8 +25,15 @@
 #include <linux/compiler.h>
 #include <linux/netfilter_ipv6.h>
 
-#define IP6T_FUNCTION_MAXNAMELEN 30
-#define IP6T_TABLE_MAXNAMELEN 32
+#include <linux/netfilter/x_tables.h>
+
+#define IP6T_FUNCTION_MAXNAMELEN XT_FUNCTION_MAXNAMELEN
+#define IP6T_TABLE_MAXNAMELEN XT_TABLE_MAXNAMELEN
+
+#define ip6t_match xt_match
+#define ip6t_target xt_target
+#define ip6t_table xt_table
+#define ip6t_get_revision xt_get_revision
 
 /* Yes, Virginia, you have to zero the padding. */
 struct ip6t_ip6 {
@@ -104,10 +111,7 @@ struct ip6t_standard_target
         int verdict;
 };
 
-struct ip6t_counters
-{
-        u_int64_t pcnt, bcnt;                   /* Packet and byte counters */
-};
+#define ip6t_counters   xt_counters
 
 /* Values for "flag" field in struct ip6t_ip6 (general ip6 structure). */
 #define IP6T_F_PROTO            0x01    /* Set if rule cares about upper 
@@ -123,7 +127,7 @@ struct ip6t_counters
 #define IP6T_INV_SRCIP          0x08    /* Invert the sense of SRC IP. */
 #define IP6T_INV_DSTIP          0x10    /* Invert the sense of DST OP. */
 #define IP6T_INV_FRAG           0x20    /* Invert the sense of FRAG. */
-#define IP6T_INV_PROTO          0x40    /* Invert the sense of PROTO. */
+#define IP6T_INV_PROTO          XT_INV_PROTO
 #define IP6T_INV_MASK           0x7F    /* All possible flag bits mask. */
 
 /* This structure defines each of the firewall rules.  Consists of 3
@@ -145,7 +149,7 @@ struct ip6t_entry
         unsigned int comefrom;
 
         /* Packet and byte counters. */
-        struct ip6t_counters counters;
+        struct xt_counters counters;
 
         /* The matches (if any), then the target. */
         unsigned char elems[0];
@@ -155,54 +159,41 @@ struct ip6t_entry
  * New IP firewall options for [gs]etsockopt at the RAW IP level.
  * Unlike BSD Linux inherits IP options so you don't have to use
  * a raw socket for this. Instead we check rights in the calls. */
-#define IP6T_BASE_CTL                   64      /* base for firewall socket options */
+#define IP6T_BASE_CTL                   XT_BASE_CTL
 
-#define IP6T_SO_SET_REPLACE             (IP6T_BASE_CTL)
-#define IP6T_SO_SET_ADD_COUNTERS        (IP6T_BASE_CTL + 1)
-#define IP6T_SO_SET_MAX                 IP6T_SO_SET_ADD_COUNTERS
+#define IP6T_SO_SET_REPLACE             XT_SO_SET_REPLACE
+#define IP6T_SO_SET_ADD_COUNTERS        XT_SO_SET_ADD_COUNTERS
+#define IP6T_SO_SET_MAX                 XT_SO_SET_MAX
 
-#define IP6T_SO_GET_INFO                (IP6T_BASE_CTL)
-#define IP6T_SO_GET_ENTRIES             (IP6T_BASE_CTL + 1)
-#define IP6T_SO_GET_REVISION_MATCH      (IP6T_BASE_CTL + 2)
-#define IP6T_SO_GET_REVISION_TARGET     (IP6T_BASE_CTL + 3)
-#define IP6T_SO_GET_MAX                 IP6T_SO_GET_REVISION_TARGET
+#define IP6T_SO_GET_INFO                XT_SO_GET_INFO
+#define IP6T_SO_GET_ENTRIES             XT_SO_GET_ENTRIES
+#define IP6T_SO_GET_REVISION_MATCH      XT_SO_GET_REVISION_MATCH
+#define IP6T_SO_GET_REVISION_TARGET     XT_SO_GET_REVISION_TARGET
+#define IP6T_SO_GET_MAX                 XT_SO_GET_REVISION_TARGET
 
 /* CONTINUE verdict for targets */
-#define IP6T_CONTINUE 0xFFFFFFFF
+#define IP6T_CONTINUE XT_CONTINUE
 
 /* For standard target */
-#define IP6T_RETURN (-NF_REPEAT - 1)
+#define IP6T_RETURN XT_RETURN
 
-/* TCP matching stuff */
-struct ip6t_tcp
-{
-        u_int16_t spts[2];                      /* Source port range. */
-        u_int16_t dpts[2];                      /* Destination port range. */
-        u_int8_t option;                        /* TCP Option iff non-zero*/
-        u_int8_t flg_mask;                      /* TCP flags mask byte */
-        u_int8_t flg_cmp;                       /* TCP flags compare byte */
-        u_int8_t invflags;                      /* Inverse flags */
-};
+/* TCP/UDP matching stuff */
+#include <linux/netfilter/xt_tcpudp.h>
+
+#define ip6t_tcp xt_tcp
+#define ip6t_udp xt_udp
 
 /* Values for "inv" field in struct ipt_tcp. */
-#define IP6T_TCP_INV_SRCPT      0x01    /* Invert the sense of source ports. */
-#define IP6T_TCP_INV_DSTPT      0x02    /* Invert the sense of dest ports. */
-#define IP6T_TCP_INV_FLAGS      0x04    /* Invert the sense of TCP flags. */
-#define IP6T_TCP_INV_OPTION     0x08    /* Invert the sense of option test. */
-#define IP6T_TCP_INV_MASK       0x0F    /* All possible flags. */
-
-/* UDP matching stuff */
-struct ip6t_udp
-{
-        u_int16_t spts[2];                      /* Source port range. */
-        u_int16_t dpts[2];                      /* Destination port range. */
-        u_int8_t invflags;                      /* Inverse flags */
-};
+#define IP6T_TCP_INV_SRCPT      XT_TCP_INV_SRCPT
+#define IP6T_TCP_INV_DSTPT      XT_TCP_INV_DSTPT
+#define IP6T_TCP_INV_FLAGS      XT_TCP_INV_FLAGS
+#define IP6T_TCP_INV_OPTION     XT_TCP_INV_OPTION
+#define IP6T_TCP_INV_MASK       XT_TCP_INV_MASK
 
 /* Values for "invflags" field in struct ipt_udp. */
-#define IP6T_UDP_INV_SRCPT      0x01    /* Invert the sense of source ports. */
-#define IP6T_UDP_INV_DSTPT      0x02    /* Invert the sense of dest ports. */
-#define IP6T_UDP_INV_MASK       0x03    /* All possible flags. */
+#define IP6T_UDP_INV_SRCPT      XT_UDP_INV_SRCPT
+#define IP6T_UDP_INV_DSTPT      XT_UDP_INV_DSTPT
+#define IP6T_UDP_INV_MASK       XT_UDP_INV_MASK
 
 /* ICMP matching stuff */
 struct ip6t_icmp
@@ -264,23 +255,14 @@ struct ip6t_replace
         /* Number of counters (must be equal to current number of entries). */
         unsigned int num_counters;
         /* The old entries' counters. */
-        struct ip6t_counters __user *counters;
+        struct xt_counters __user *counters;
 
         /* The entries (hang off end: not really an array). */
         struct ip6t_entry entries[0];
 };
 
 /* The argument to IP6T_SO_ADD_COUNTERS. */
-struct ip6t_counters_info
-{
-        /* Which table. */
-        char name[IP6T_TABLE_MAXNAMELEN];
-
-        unsigned int num_counters;
-
-        /* The counters (actually `number' of these). */
-        struct ip6t_counters counters[0];
-};
+#define ip6t_counters_info xt_counters_info
 
 /* The argument to IP6T_SO_GET_ENTRIES. */
 struct ip6t_get_entries
@@ -295,19 +277,10 @@ struct ip6t_get_entries
         struct ip6t_entry entrytable[0];
 };
 
-/* The argument to IP6T_SO_GET_REVISION_*.  Returns highest revision
- * kernel supports, if >= revision. */
-struct ip6t_get_revision
-{
-        char name[IP6T_FUNCTION_MAXNAMELEN-1];
-
-        u_int8_t revision;
-};
-
 /* Standard return verdict, or do jump. */
-#define IP6T_STANDARD_TARGET ""
+#define IP6T_STANDARD_TARGET XT_STANDARD_TARGET
 /* Error verdict. */
-#define IP6T_ERROR_TARGET "ERROR"
+#define IP6T_ERROR_TARGET XT_ERROR_TARGET
 
 /* Helper functions */
 static __inline__ struct ip6t_entry_target *
@@ -361,104 +334,11 @@ ip6t_get_target(struct ip6t_entry *e)
 #include <linux/init.h>
 extern void ip6t_init(void) __init;
 
-struct ip6t_match
-{
-        struct list_head list;
-
-        const char name[IP6T_FUNCTION_MAXNAMELEN-1];
-
-        u_int8_t revision;
-
-        /* Return true or false: return FALSE and set *hotdrop = 1 to
-           force immediate packet drop. */
-        /* Arguments changed since 2.6.9, as this must now handle
-           non-linear skb, using skb_header_pointer and
-           skb_ip_make_writable. */
-        int (*match)(const struct sk_buff *skb,
-                     const struct net_device *in,
-                     const struct net_device *out,
-                     const void *matchinfo,
-                     int offset,
-                     unsigned int protoff,
-                     int *hotdrop);
-
-        /* Called when user tries to insert an entry of this type. */
-        /* Should return true or false. */
-        int (*checkentry)(const char *tablename,
-                          const struct ip6t_ip6 *ip,
-                          void *matchinfo,
-                          unsigned int matchinfosize,
-                          unsigned int hook_mask);
-
-        /* Called when entry of this type deleted. */
-        void (*destroy)(void *matchinfo, unsigned int matchinfosize);
-
-        /* Set this to THIS_MODULE if you are a module, otherwise NULL */
-        struct module *me;
-};
-
-/* Registration hooks for targets. */
-struct ip6t_target
-{
-        struct list_head list;
-
-        const char name[IP6T_FUNCTION_MAXNAMELEN-1];
-
-        u_int8_t revision;
-
-        /* Returns verdict. Argument order changed since 2.6.9, as this
-           must now handle non-linear skbs, using skb_copy_bits and
-           skb_ip_make_writable. */
-        unsigned int (*target)(struct sk_buff **pskb,
-                               const struct net_device *in,
-                               const struct net_device *out,
-                               unsigned int hooknum,
-                               const void *targinfo,
-                               void *userdata);
-
-        /* Called when user tries to insert an entry of this type:
-           hook_mask is a bitmask of hooks from which it can be
-           called. */
-        /* Should return true or false. */
-        int (*checkentry)(const char *tablename,
-                          const struct ip6t_entry *e,
-                          void *targinfo,
-                          unsigned int targinfosize,
-                          unsigned int hook_mask);
-
-        /* Called when entry of this type deleted. */
-        void (*destroy)(void *targinfo, unsigned int targinfosize);
-
-        /* Set this to THIS_MODULE if you are a module, otherwise NULL */
-        struct module *me;
-};
-
-extern int ip6t_register_target(struct ip6t_target *target);
-extern void ip6t_unregister_target(struct ip6t_target *target);
-
-extern int ip6t_register_match(struct ip6t_match *match);
-extern void ip6t_unregister_match(struct ip6t_match *match);
+#define ip6t_register_target(tgt) xt_register_target(AF_INET6, tgt)
+#define ip6t_unregister_target(tgt) xt_unregister_target(AF_INET6, tgt)
 
-/* Furniture shopping... */
-struct ip6t_table
-{
-        struct list_head list;
-
-        /* A unique name... */
-        char name[IP6T_TABLE_MAXNAMELEN];
-
-        /* What hooks you will enter on */
-        unsigned int valid_hooks;
-
-        /* Lock for the curtain */
-        rwlock_t lock;
-
-        /* Man behind the curtain... */
-        struct ip6t_table_info *private;
-
-        /* Set this to THIS_MODULE if you are a module, otherwise NULL */
-        struct module *me;
-};
+#define ip6t_register_match(match) xt_register_match(AF_INET6, match)
+#define ip6t_unregister_match(match) xt_unregister_match(AF_INET6, match)
 
 extern int ip6t_register_table(struct ip6t_table *table,
                                const struct ip6t_replace *repl);
diff --git a/include/linux/netfilter_ipv6/ip6t_MARK.h b/include/linux/netfilter_ipv6/ip6t_MARK.h
index 7ade8d8f5246..7cf629a8ab92 100644
--- a/include/linux/netfilter_ipv6/ip6t_MARK.h
+++ b/include/linux/netfilter_ipv6/ip6t_MARK.h
@@ -1,8 +1,9 @@
 #ifndef _IP6T_MARK_H_target
 #define _IP6T_MARK_H_target
 
-struct ip6t_mark_target_info {
-        unsigned long mark;
-};
+/* Backwards compatibility for old userspace */
+#include <linux/netfilter/xt_MARK.h>
 
-#endif /*_IPT_MARK_H_target*/
+#define ip6t_mark_target_info xt_mark_target_info
+
+#endif /*_IP6T_MARK_H_target*/
diff --git a/include/linux/netfilter_ipv6/ip6t_length.h b/include/linux/netfilter_ipv6/ip6t_length.h
index 7fc09f9f9d63..9e9689d03ed7 100644
--- a/include/linux/netfilter_ipv6/ip6t_length.h
+++ b/include/linux/netfilter_ipv6/ip6t_length.h
@@ -1,10 +1,8 @@
 #ifndef _IP6T_LENGTH_H
 #define _IP6T_LENGTH_H
 
-struct ip6t_length_info {
-        u_int16_t  min, max;
-        u_int8_t   invert;
-};
+#include <linux/netfilter/xt_length.h>
+#define ip6t_length_info xt_length_info
 
 #endif /*_IP6T_LENGTH_H*/
         
diff --git a/include/linux/netfilter_ipv6/ip6t_limit.h b/include/linux/netfilter_ipv6/ip6t_limit.h
index f2866e50f3b4..487e5ea342c6 100644
--- a/include/linux/netfilter_ipv6/ip6t_limit.h
+++ b/include/linux/netfilter_ipv6/ip6t_limit.h
@@ -1,21 +1,8 @@
 #ifndef _IP6T_RATE_H
 #define _IP6T_RATE_H
 
-/* timings are in milliseconds. */
-#define IP6T_LIMIT_SCALE 10000
+#include <linux/netfilter/xt_limit.h>
+#define IP6T_LIMIT_SCALE XT_LIMIT_SCALE
+#define ip6t_rateinfo xt_rateinfo
 
-/* 1/10,000 sec period => max of 10,000/sec.  Min rate is then 429490
-   seconds, or one every 59 hours. */
-struct ip6t_rateinfo {
-        u_int32_t avg;    /* Average secs between packets * scale */
-        u_int32_t burst;  /* Period multiplier for upper limit. */
-
-        /* Used internally by the kernel */
-        unsigned long prev;
-        u_int32_t credit;
-        u_int32_t credit_cap, cost;
-
-        /* Ugly, ugly fucker. */
-        struct ip6t_rateinfo *master;
-};
-#endif /*_IPT_RATE_H*/
+#endif /*_IP6T_RATE_H*/
diff --git a/include/linux/netfilter_ipv6/ip6t_mac.h b/include/linux/netfilter_ipv6/ip6t_mac.h
index 87c088c21848..ac58e83e9423 100644
--- a/include/linux/netfilter_ipv6/ip6t_mac.h
+++ b/include/linux/netfilter_ipv6/ip6t_mac.h
@@ -1,8 +1,7 @@
 #ifndef _IP6T_MAC_H
 #define _IP6T_MAC_H
 
-struct ip6t_mac_info {
-    unsigned char srcaddr[ETH_ALEN];
-    int invert;
-};
-#endif /*_IPT_MAC_H*/
+#include <linux/netfilter/xt_mac.h>
+#define ip6t_mac_info xt_mac_info
+
+#endif /*_IP6T_MAC_H*/
diff --git a/include/linux/netfilter_ipv6/ip6t_mark.h b/include/linux/netfilter_ipv6/ip6t_mark.h
index a734441e1c19..ff204951ddc3 100644
--- a/include/linux/netfilter_ipv6/ip6t_mark.h
+++ b/include/linux/netfilter_ipv6/ip6t_mark.h
@@ -1,9 +1,9 @@
 #ifndef _IP6T_MARK_H
 #define _IP6T_MARK_H
 
-struct ip6t_mark_info {
-    unsigned long mark, mask;
-    u_int8_t invert;
-};
+/* Backwards compatibility for old userspace */
+#include <linux/netfilter/xt_mark.h>
+
+#define ip6t_mark_info xt_mark_info
 
 #endif /*_IPT_MARK_H*/
diff --git a/include/linux/netfilter_ipv6/ip6t_physdev.h b/include/linux/netfilter_ipv6/ip6t_physdev.h
index c234731cd66b..c161c0a81b55 100644
--- a/include/linux/netfilter_ipv6/ip6t_physdev.h
+++ b/include/linux/netfilter_ipv6/ip6t_physdev.h
@@ -1,24 +1,17 @@
 #ifndef _IP6T_PHYSDEV_H
 #define _IP6T_PHYSDEV_H
 
-#ifdef __KERNEL__
-#include <linux/if.h>
-#endif
+/* Backwards compatibility for old userspace */
 
-#define IP6T_PHYSDEV_OP_IN              0x01
-#define IP6T_PHYSDEV_OP_OUT             0x02
-#define IP6T_PHYSDEV_OP_BRIDGED         0x04
-#define IP6T_PHYSDEV_OP_ISIN            0x08
-#define IP6T_PHYSDEV_OP_ISOUT           0x10
-#define IP6T_PHYSDEV_OP_MASK            (0x20 - 1)
+#include <linux/netfilter/xt_physdev.h>
 
-struct ip6t_physdev_info {
-        char physindev[IFNAMSIZ];
-        char in_mask[IFNAMSIZ];
-        char physoutdev[IFNAMSIZ];
-        char out_mask[IFNAMSIZ];
-        u_int8_t invert;
-        u_int8_t bitmask;
-};
+#define IP6T_PHYSDEV_OP_IN              XT_PHYSDEV_OP_IN
+#define IP6T_PHYSDEV_OP_OUT             XT_PHYSDEV_OP_OUT
+#define IP6T_PHYSDEV_OP_BRIDGED         XT_PHYSDEV_OP_BRIDGED
+#define IP6T_PHYSDEV_OP_ISIN            XT_PHYSDEV_OP_ISIN
+#define IP6T_PHYSDEV_OP_ISOUT           XT_PHYSDEV_OP_ISOUT
+#define IP6T_PHYSDEV_OP_MASK            XT_PHYSDEV_OP_MASK
+
+#define ip6t_physdev_info xt_physdev_info
 
 #endif /*_IP6T_PHYSDEV_H*/
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 7fb397e3f2d3..5403257ae3e7 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -181,6 +181,7 @@
 #define PCI_DEVICE_ID_LSI_FC929X        0x0626
 #define PCI_DEVICE_ID_LSI_FC939X        0x0642
 #define PCI_DEVICE_ID_LSI_FC949X        0x0640
+#define PCI_DEVICE_ID_LSI_FC949ES       0x0646
 #define PCI_DEVICE_ID_LSI_FC919X        0x0628
 #define PCI_DEVICE_ID_NCR_YELLOWFIN     0x0701
 #define PCI_DEVICE_ID_LSI_61C102        0x0901
diff --git a/include/linux/proc_fs.h b/include/linux/proc_fs.h
index 74488e49166d..aa6322d45198 100644
--- a/include/linux/proc_fs.h
+++ b/include/linux/proc_fs.h
@@ -146,6 +146,11 @@ struct property;
 extern void proc_device_tree_init(void);
 extern void proc_device_tree_add_node(struct device_node *, struct proc_dir_entry *);
 extern void proc_device_tree_add_prop(struct proc_dir_entry *pde, struct property *prop);
+extern void proc_device_tree_remove_prop(struct proc_dir_entry *pde,
+                                         struct property *prop);
+extern void proc_device_tree_update_prop(struct proc_dir_entry *pde,
+                                         struct property *newprop,
+                                         struct property *oldprop);
 #endif /* CONFIG_PROC_DEVICETREE */
 
 extern struct proc_dir_entry *proc_symlink(const char *,
diff --git a/include/linux/raid_class.h b/include/linux/raid_class.h
index 48831eac2910..d0dd38b3a2fd 100644
--- a/include/linux/raid_class.h
+++ b/include/linux/raid_class.h
@@ -31,9 +31,11 @@ enum raid_level {
         RAID_LEVEL_LINEAR,
         RAID_LEVEL_0,
         RAID_LEVEL_1,
+        RAID_LEVEL_10,
         RAID_LEVEL_3,
         RAID_LEVEL_4,
         RAID_LEVEL_5,
+        RAID_LEVEL_50,
         RAID_LEVEL_6,
 };
 
diff --git a/include/linux/sched.h b/include/linux/sched.h
index a72e17135421..2df1a1a2fee5 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -160,6 +160,7 @@ extern unsigned long nr_iowait(void);
 #define SCHED_NORMAL            0
 #define SCHED_FIFO              1
 #define SCHED_RR                2
+#define SCHED_BATCH             3
 
 struct sched_param {
         int sched_priority;
@@ -470,9 +471,9 @@ struct signal_struct {
 
 /*
  * Priority of a process goes from 0..MAX_PRIO-1, valid RT
- * priority is 0..MAX_RT_PRIO-1, and SCHED_NORMAL tasks are
- * in the range MAX_RT_PRIO..MAX_PRIO-1. Priority values
- * are inverted: lower p->prio value means higher priority.
+ * priority is 0..MAX_RT_PRIO-1, and SCHED_NORMAL/SCHED_BATCH
+ * tasks are in the range MAX_RT_PRIO..MAX_PRIO-1. Priority
+ * values are inverted: lower p->prio value means higher priority.
  *
  * The MAX_USER_RT_PRIO value allows the actual maximum
  * RT priority to be separate from the value exported to
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index a8187c3c8a7b..ec351005bf9d 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -136,6 +136,7 @@
 #include <linux/spinlock.h>
 #include <linux/sched.h>
 #include <linux/tty.h>
+#include <linux/mutex.h>
 
 struct uart_port;
 struct uart_info;
@@ -284,7 +285,7 @@ struct uart_state {
         struct uart_info        *info;
         struct uart_port        *port;
 
-        struct semaphore        sem;
+        struct mutex            mutex;
 };
 
 #define UART_XMIT_SIZE  PAGE_SIZE
diff --git a/include/linux/shmem_fs.h b/include/linux/shmem_fs.h
index c3e598276e78..c057f0b32318 100644
--- a/include/linux/shmem_fs.h
+++ b/include/linux/shmem_fs.h
@@ -26,6 +26,8 @@ struct shmem_sb_info {
         unsigned long free_blocks;  /* How many are left for allocation */
         unsigned long max_inodes;   /* How many inodes are allowed */
         unsigned long free_inodes;  /* How many are left for allocation */
+        int policy;                 /* Default NUMA memory alloc policy */
+        nodemask_t policy_nodes;    /* nodemask for preferred and bind */
         spinlock_t    stat_lock;
 };
 
diff --git a/include/linux/smb_fs.h b/include/linux/smb_fs.h
index c4153120ade6..621a3d3662f3 100644
--- a/include/linux/smb_fs.h
+++ b/include/linux/smb_fs.h
@@ -58,53 +58,6 @@ static inline struct smb_inode_info *SMB_I(struct inode *inode)
 /* where to find the base of the SMB packet proper */
 #define smb_base(buf) ((u8 *)(((u8 *)(buf))+4))
 
-#ifdef DEBUG_SMB_MALLOC
-
-#include <linux/slab.h>
-
-extern int smb_malloced;
-extern int smb_current_vmalloced;
-extern int smb_current_kmalloced;
-
-static inline void *
-smb_vmalloc(unsigned int size)
-{
-        smb_malloced += 1;
-        smb_current_vmalloced += 1;
-        return vmalloc(size);
-}
-
-static inline void
-smb_vfree(void *obj)
-{
-        smb_current_vmalloced -= 1;
-        vfree(obj);
-}
-
-static inline void *
-smb_kmalloc(size_t size, int flags)
-{
-        smb_malloced += 1;
-        smb_current_kmalloced += 1;
-        return kmalloc(size, flags);
-}
-
-static inline void
-smb_kfree(void *obj)
-{
-        smb_current_kmalloced -= 1;
-        kfree(obj);
-}
-
-#else /* DEBUG_SMB_MALLOC */
-
-#define smb_kmalloc(s,p)        kmalloc(s,p)
-#define smb_kfree(o)            kfree(o)
-#define smb_vmalloc(s)          vmalloc(s)
-#define smb_vfree(o)            vfree(o)
-
-#endif /* DEBUG_SMB_MALLOC */
-
 /*
  * Flags for the in-memory inode
  */
diff --git a/include/linux/socket.h b/include/linux/socket.h
index 9f4019156fd8..b02dda4ee83d 100644
--- a/include/linux/socket.h
+++ b/include/linux/socket.h
@@ -186,6 +186,7 @@ struct ucred {
 #define AF_PPPOX        24      /* PPPoX sockets                */
 #define AF_WANPIPE      25      /* Wanpipe API Sockets */
 #define AF_LLC          26      /* Linux LLC                    */
+#define AF_TIPC         30      /* TIPC sockets                 */
 #define AF_BLUETOOTH    31      /* Bluetooth sockets            */
 #define AF_MAX          32      /* For now.. */
 
@@ -218,6 +219,7 @@ struct ucred {
 #define PF_PPPOX        AF_PPPOX
 #define PF_WANPIPE      AF_WANPIPE
 #define PF_LLC          AF_LLC
+#define PF_TIPC         AF_TIPC
 #define PF_BLUETOOTH    AF_BLUETOOTH
 #define PF_MAX          AF_MAX
 
@@ -279,6 +281,7 @@ struct ucred {
 #define SOL_LLC         268
 #define SOL_DCCP        269
 #define SOL_NETLINK     270
+#define SOL_TIPC        271
 
 /* IPX options */
 #define IPX_TYPE        1
diff --git a/include/linux/spi/ads7846.h b/include/linux/spi/ads7846.h
new file mode 100644
index 000000000000..72261e0f2ac1
--- /dev/null
+++ b/include/linux/spi/ads7846.h
@@ -0,0 +1,18 @@
+/* linux/spi/ads7846.h */
+
+/* Touchscreen characteristics vary between boards and models.  The
+ * platform_data for the device's "struct device" holds this information.
+ *
+ * It's OK if the min/max values are zero.
+ */
+struct ads7846_platform_data {
+        u16     model;                  /* 7843, 7845, 7846. */
+        u16     vref_delay_usecs;       /* 0 for external vref; etc */
+        u16     x_plate_ohms;
+        u16     y_plate_ohms;
+
+        u16     x_min, x_max;
+        u16     y_min, y_max;
+        u16     pressure_min, pressure_max;
+};
+
diff --git a/include/linux/spi/flash.h b/include/linux/spi/flash.h
new file mode 100644
index 000000000000..3f22932e67a4
--- /dev/null
+++ b/include/linux/spi/flash.h
@@ -0,0 +1,31 @@
+#ifndef LINUX_SPI_FLASH_H
+#define LINUX_SPI_FLASH_H
+
+struct mtd_partition;
+
+/**
+ * struct flash_platform_data: board-specific flash data
+ * @name: optional flash device name (eg, as used with mtdparts=)
+ * @parts: optional array of mtd_partitions for static partitioning
+ * @nr_parts: number of mtd_partitions for static partitoning
+ * @type: optional flash device type (e.g. m25p80 vs m25p64), for use
+ *      with chips that can't be queried for JEDEC or other IDs
+ *
+ * Board init code (in arch/.../mach-xxx/board-yyy.c files) can
+ * provide information about SPI flash parts (such as DataFlash) to
+ * help set up the device and its appropriate default partitioning.
+ *
+ * Note that for DataFlash, sizes for pages, blocks, and sectors are
+ * rarely powers of two; and partitions should be sector-aligned.
+ */
+struct flash_platform_data {
+        char            *name;
+        struct mtd_partition *parts;
+        unsigned int    nr_parts;
+
+        char            *type;
+
+        /* we'll likely add more ... use JEDEC IDs, etc */
+};
+
+#endif
diff --git a/include/linux/spi/spi.h b/include/linux/spi/spi.h
new file mode 100644
index 000000000000..b05f1463a267
--- /dev/null
+++ b/include/linux/spi/spi.h
@@ -0,0 +1,668 @@
+/*
+ * Copyright (C) 2005 David Brownell
+ *
+ * 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_SPI_H
+#define __LINUX_SPI_H
+
+/*
+ * INTERFACES between SPI master-side drivers and SPI infrastructure.
+ * (There's no SPI slave support for Linux yet...)
+ */
+extern struct bus_type spi_bus_type;
+
+/**
+ * struct spi_device - Master side proxy for an SPI slave device
+ * @dev: Driver model representation of the device.
+ * @master: SPI controller used with the device.
+ * @max_speed_hz: Maximum clock rate to be used with this chip
+ *      (on this board); may be changed by the device's driver.
+ * @chip-select: Chipselect, distinguishing chips handled by "master".
+ * @mode: The spi mode defines how data is clocked out and in.
+ *      This may be changed by the device's driver.
+ * @bits_per_word: Data transfers involve one or more words; word sizes
+ *      like eight or 12 bits are common.  In-memory wordsizes are
+ *      powers of two bytes (e.g. 20 bit samples use 32 bits).
+ *      This may be changed by the device's driver.
+ * @irq: Negative, or the number passed to request_irq() to receive
+ *      interrupts from this device.
+ * @controller_state: Controller's runtime state
+ * @controller_data: Board-specific definitions for controller, such as
+ *      FIFO initialization parameters; from board_info.controller_data
+ *
+ * An spi_device is used to interchange data between an SPI slave
+ * (usually a discrete chip) and CPU memory.
+ *
+ * In "dev", the platform_data is used to hold information about this
+ * device that's meaningful to the device's protocol driver, but not
+ * to its controller.  One example might be an identifier for a chip
+ * variant with slightly different functionality.
+ */
+struct spi_device {
+        struct device           dev;
+        struct spi_master       *master;
+        u32                     max_speed_hz;
+        u8                      chip_select;
+        u8                      mode;
+#define SPI_CPHA        0x01                    /* clock phase */
+#define SPI_CPOL        0x02                    /* clock polarity */
+#define SPI_MODE_0      (0|0)                   /* (original MicroWire) */
+#define SPI_MODE_1      (0|SPI_CPHA)
+#define SPI_MODE_2      (SPI_CPOL|0)
+#define SPI_MODE_3      (SPI_CPOL|SPI_CPHA)
+#define SPI_CS_HIGH     0x04                    /* chipselect active high? */
+        u8                      bits_per_word;
+        int                     irq;
+        void                    *controller_state;
+        void                    *controller_data;
+        const char              *modalias;
+
+        // likely need more hooks for more protocol options affecting how
+        // the controller talks to each chip, like:
+        //  - bit order (default is wordwise msb-first)
+        //  - memory packing (12 bit samples into low bits, others zeroed)
+        //  - priority
+        //  - drop chipselect after each word
+        //  - chipselect delays
+        //  - ...
+};
+
+static inline struct spi_device *to_spi_device(struct device *dev)
+{
+        return dev ? container_of(dev, struct spi_device, dev) : NULL;
+}
+
+/* most drivers won't need to care about device refcounting */
+static inline struct spi_device *spi_dev_get(struct spi_device *spi)
+{
+        return (spi && get_device(&spi->dev)) ? spi : NULL;
+}
+
+static inline void spi_dev_put(struct spi_device *spi)
+{
+        if (spi)
+                put_device(&spi->dev);
+}
+
+/* ctldata is for the bus_master driver's runtime state */
+static inline void *spi_get_ctldata(struct spi_device *spi)
+{
+        return spi->controller_state;
+}
+
+static inline void spi_set_ctldata(struct spi_device *spi, void *state)
+{
+        spi->controller_state = state;
+}
+
+
+struct spi_message;
+
+
+
+struct spi_driver {
+        int                     (*probe)(struct spi_device *spi);
+        int                     (*remove)(struct spi_device *spi);
+        void                    (*shutdown)(struct spi_device *spi);
+        int                     (*suspend)(struct spi_device *spi, pm_message_t mesg);
+        int                     (*resume)(struct spi_device *spi);
+        struct device_driver    driver;
+};
+
+static inline struct spi_driver *to_spi_driver(struct device_driver *drv)
+{
+        return drv ? container_of(drv, struct spi_driver, driver) : NULL;
+}
+
+extern int spi_register_driver(struct spi_driver *sdrv);
+
+static inline void spi_unregister_driver(struct spi_driver *sdrv)
+{
+        if (!sdrv)
+                return;
+        driver_unregister(&sdrv->driver);
+}
+
+
+
+/**
+ * struct spi_master - interface to SPI master controller
+ * @cdev: class interface to this driver
+ * @bus_num: board-specific (and often SOC-specific) identifier for a
+ *      given SPI controller.
+ * @num_chipselect: chipselects are used to distinguish individual
+ *      SPI slaves, and are numbered from zero to num_chipselects.
+ *      each slave has a chipselect signal, but it's common that not
+ *      every chipselect is connected to a slave.
+ * @setup: updates the device mode and clocking records used by a
+ *      device's SPI controller; protocol code may call this.
+ * @transfer: adds a message to the controller's transfer queue.
+ * @cleanup: frees controller-specific state
+ *
+ * Each SPI master controller can communicate with one or more spi_device
+ * children.  These make a small bus, sharing MOSI, MISO and SCK signals
+ * but not chip select signals.  Each device may be configured to use a
+ * different clock rate, since those shared signals are ignored unless
+ * the chip is selected.
+ *
+ * The driver for an SPI controller manages access to those devices through
+ * a queue of spi_message transactions, copyin data between CPU memory and
+ * an SPI slave device).  For each such message it queues, it calls the
+ * message's completion function when the transaction completes.
+ */
+struct spi_master {
+        struct class_device     cdev;
+
+        /* other than zero (== assign one dynamically), bus_num is fully
+         * board-specific.  usually that simplifies to being SOC-specific.
+         * example:  one SOC has three SPI controllers, numbered 1..3,
+         * and one board's schematics might show it using SPI-2.  software
+         * would normally use bus_num=2 for that controller.
+         */
+        u16                     bus_num;
+
+        /* chipselects will be integral to many controllers; some others
+         * might use board-specific GPIOs.
+         */
+        u16                     num_chipselect;
+
+        /* setup mode and clock, etc (spi driver may call many times) */
+        int                     (*setup)(struct spi_device *spi);
+
+        /* bidirectional bulk transfers
+         *
+         * + The transfer() method may not sleep; its main role is
+         *   just to add the message to the queue.
+         * + For now there's no remove-from-queue operation, or
+         *   any other request management
+         * + To a given spi_device, message queueing is pure fifo
+         *
+         * + The master's main job is to process its message queue,
+         *   selecting a chip then transferring data
+         * + If there are multiple spi_device children, the i/o queue
+         *   arbitration algorithm is unspecified (round robin, fifo,
+         *   priority, reservations, preemption, etc)
+         *
+         * + Chipselect stays active during the entire message
+         *   (unless modified by spi_transfer.cs_change != 0).
+         * + The message transfers use clock and SPI mode parameters
+         *   previously established by setup() for this device
+         */
+        int                     (*transfer)(struct spi_device *spi,
+                                                struct spi_message *mesg);
+
+        /* called on release() to free memory provided by spi_master */
+        void                    (*cleanup)(const struct spi_device *spi);
+};
+
+static inline void *spi_master_get_devdata(struct spi_master *master)
+{
+        return class_get_devdata(&master->cdev);
+}
+
+static inline void spi_master_set_devdata(struct spi_master *master, void *data)
+{
+        class_set_devdata(&master->cdev, data);
+}
+
+static inline struct spi_master *spi_master_get(struct spi_master *master)
+{
+        if (!master || !class_device_get(&master->cdev))
+                return NULL;
+        return master;
+}
+
+static inline void spi_master_put(struct spi_master *master)
+{
+        if (master)
+                class_device_put(&master->cdev);
+}
+
+
+/* the spi driver core manages memory for the spi_master classdev */
+extern struct spi_master *
+spi_alloc_master(struct device *host, unsigned size);
+
+extern int spi_register_master(struct spi_master *master);
+extern void spi_unregister_master(struct spi_master *master);
+
+extern struct spi_master *spi_busnum_to_master(u16 busnum);
+
+/*---------------------------------------------------------------------------*/
+
+/*
+ * I/O INTERFACE between SPI controller and protocol drivers
+ *
+ * Protocol drivers use a queue of spi_messages, each transferring data
+ * between the controller and memory buffers.
+ *
+ * The spi_messages themselves consist of a series of read+write transfer
+ * segments.  Those segments always read the same number of bits as they
+ * write; but one or the other is easily ignored by passing a null buffer
+ * pointer.  (This is unlike most types of I/O API, because SPI hardware
+ * is full duplex.)
+ *
+ * NOTE:  Allocation of spi_transfer and spi_message memory is entirely
+ * up to the protocol driver, which guarantees the integrity of both (as
+ * well as the data buffers) for as long as the message is queued.
+ */
+
+/**
+ * struct spi_transfer - a read/write buffer pair
+ * @tx_buf: data to be written (dma-safe memory), or NULL
+ * @rx_buf: data to be read (dma-safe memory), or NULL
+ * @tx_dma: DMA address of tx_buf, if spi_message.is_dma_mapped
+ * @rx_dma: DMA address of rx_buf, if spi_message.is_dma_mapped
+ * @len: size of rx and tx buffers (in bytes)
+ * @cs_change: affects chipselect after this transfer completes
+ * @delay_usecs: microseconds to delay after this transfer before
+ *      (optionally) changing the chipselect status, then starting
+ *      the next transfer or completing this spi_message.
+ * @transfer_list: transfers are sequenced through spi_message.transfers
+ *
+ * SPI transfers always write the same number of bytes as they read.
+ * Protocol drivers should always provide rx_buf and/or tx_buf.
+ * In some cases, they may also want to provide DMA addresses for
+ * the data being transferred; that may reduce overhead, when the
+ * underlying driver uses dma.
+ *
+ * If the transmit buffer is null, undefined data will be shifted out
+ * while filling rx_buf.  If the receive buffer is null, the data
+ * shifted in will be discarded.  Only "len" bytes shift out (or in).
+ * It's an error to try to shift out a partial word.  (For example, by
+ * shifting out three bytes with word size of sixteen or twenty bits;
+ * the former uses two bytes per word, the latter uses four bytes.)
+ *
+ * All SPI transfers start with the relevant chipselect active.  Normally
+ * it stays selected until after the last transfer in a message.  Drivers
+ * can affect the chipselect signal using cs_change:
+ *
+ * (i) If the transfer isn't the last one in the message, this flag is
+ * used to make the chipselect briefly go inactive in the middle of the
+ * message.  Toggling chipselect in this way may be needed to terminate
+ * a chip command, letting a single spi_message perform all of group of
+ * chip transactions together.
+ *
+ * (ii) When the transfer is the last one in the message, the chip may
+ * stay selected until the next transfer.  This is purely a performance
+ * hint; the controller driver may need to select a different device
+ * for the next message.
+ *
+ * The code that submits an spi_message (and its spi_transfers)
+ * to the lower layers is responsible for managing its memory.
+ * Zero-initialize every field you don't set up explicitly, to
+ * insulate against future API updates.  After you submit a message
+ * and its transfers, ignore them until its completion callback.
+ */
+struct spi_transfer {
+        /* it's ok if tx_buf == rx_buf (right?)
+         * for MicroWire, one buffer must be null
+         * buffers must work with dma_*map_single() calls, unless
+         *   spi_message.is_dma_mapped reports a pre-existing mapping
+         */
+        const void      *tx_buf;
+        void            *rx_buf;
+        unsigned        len;
+
+        dma_addr_t      tx_dma;
+        dma_addr_t      rx_dma;
+
+        unsigned        cs_change:1;
+        u16             delay_usecs;
+
+        struct list_head transfer_list;
+};
+
+/**
+ * struct spi_message - one multi-segment SPI transaction
+ * @transfers: list of transfer segments in this transaction
+ * @spi: SPI device to which the transaction is queued
+ * @is_dma_mapped: if true, the caller provided both dma and cpu virtual
+ *      addresses for each transfer buffer
+ * @complete: called to report transaction completions
+ * @context: the argument to complete() when it's called
+ * @actual_length: the total number of bytes that were transferred in all
+ *      successful segments
+ * @status: zero for success, else negative errno
+ * @queue: for use by whichever driver currently owns the message
+ * @state: for use by whichever driver currently owns the message
+ *
+ * An spi_message is used to execute an atomic sequence of data transfers,
+ * each represented by a struct spi_transfer.  The sequence is "atomic"
+ * in the sense that no other spi_message may use that SPI bus until that
+ * sequence completes.  On some systems, many such sequences can execute as
+ * as single programmed DMA transfer.  On all systems, these messages are
+ * queued, and might complete after transactions to other devices.  Messages
+ * sent to a given spi_device are alway executed in FIFO order.
+ *
+ * The code that submits an spi_message (and its spi_transfers)
+ * to the lower layers is responsible for managing its memory.
+ * Zero-initialize every field you don't set up explicitly, to
+ * insulate against future API updates.  After you submit a message
+ * and its transfers, ignore them until its completion callback.
+ */
+struct spi_message {
+        struct list_head        transfers;
+
+        struct spi_device       *spi;
+
+        unsigned                is_dma_mapped:1;
+
+        /* REVISIT:  we might want a flag affecting the behavior of the
+         * last transfer ... allowing things like "read 16 bit length L"
+         * immediately followed by "read L bytes".  Basically imposing
+         * a specific message scheduling algorithm.
+         *
+         * Some controller drivers (message-at-a-time queue processing)
+         * could provide that as their default scheduling algorithm.  But
+         * others (with multi-message pipelines) could need a flag to
+         * tell them about such special cases.
+         */
+
+        /* completion is reported through a callback */
+        void                    (*complete)(void *context);
+        void                    *context;
+        unsigned                actual_length;
+        int                     status;
+
+        /* for optional use by whatever driver currently owns the
+         * spi_message ...  between calls to spi_async and then later
+         * complete(), that's the spi_master controller driver.
+         */
+        struct list_head        queue;
+        void                    *state;
+};
+
+static inline void spi_message_init(struct spi_message *m)
+{
+        memset(m, 0, sizeof *m);
+        INIT_LIST_HEAD(&m->transfers);
+}
+
+static inline void
+spi_message_add_tail(struct spi_transfer *t, struct spi_message *m)
+{
+        list_add_tail(&t->transfer_list, &m->transfers);
+}
+
+static inline void
+spi_transfer_del(struct spi_transfer *t)
+{
+        list_del(&t->transfer_list);
+}
+
+/* It's fine to embed message and transaction structures in other data
+ * structures so long as you don't free them while they're in use.
+ */
+
+static inline struct spi_message *spi_message_alloc(unsigned ntrans, gfp_t flags)
+{
+        struct spi_message *m;
+
+        m = kzalloc(sizeof(struct spi_message)
+                        + ntrans * sizeof(struct spi_transfer),
+                        flags);
+        if (m) {
+                int i;
+                struct spi_transfer *t = (struct spi_transfer *)(m + 1);
+
+                INIT_LIST_HEAD(&m->transfers);
+                for (i = 0; i < ntrans; i++, t++)
+                        spi_message_add_tail(t, m);
+        }
+        return m;
+}
+
+static inline void spi_message_free(struct spi_message *m)
+{
+        kfree(m);
+}
+
+/**
+ * spi_setup -- setup SPI mode and clock rate
+ * @spi: the device whose settings are being modified
+ *
+ * SPI protocol drivers may need to update the transfer mode if the
+ * device doesn't work with the mode 0 default.  They may likewise need
+ * to update clock rates or word sizes from initial values.  This function
+ * changes those settings, and must be called from a context that can sleep.
+ * The changes take effect the next time the device is selected and data
+ * is transferred to or from it.
+ */
+static inline int
+spi_setup(struct spi_device *spi)
+{
+        return spi->master->setup(spi);
+}
+
+
+/**
+ * spi_async -- asynchronous SPI transfer
+ * @spi: device with which data will be exchanged
+ * @message: describes the data transfers, including completion callback
+ *
+ * This call may be used in_irq and other contexts which can't sleep,
+ * as well as from task contexts which can sleep.
+ *
+ * The completion callback is invoked in a context which can't sleep.
+ * Before that invocation, the value of message->status is undefined.
+ * When the callback is issued, message->status holds either zero (to
+ * indicate complete success) or a negative error code.  After that
+ * callback returns, the driver which issued the transfer request may
+ * deallocate the associated memory; it's no longer in use by any SPI
+ * core or controller driver code.
+ *
+ * Note that although all messages to a spi_device are handled in
+ * FIFO order, messages may go to different devices in other orders.
+ * Some device might be higher priority, or have various "hard" access
+ * time requirements, for example.
+ *
+ * On detection of any fault during the transfer, processing of
+ * the entire message is aborted, and the device is deselected.
+ * Until returning from the associated message completion callback,
+ * no other spi_message queued to that device will be processed.
+ * (This rule applies equally to all the synchronous transfer calls,
+ * which are wrappers around this core asynchronous primitive.)
+ */
+static inline int
+spi_async(struct spi_device *spi, struct spi_message *message)
+{
+        message->spi = spi;
+        return spi->master->transfer(spi, message);
+}
+
+/*---------------------------------------------------------------------------*/
+
+/* All these synchronous SPI transfer routines are utilities layered
+ * over the core async transfer primitive.  Here, "synchronous" means
+ * they will sleep uninterruptibly until the async transfer completes.
+ */
+
+extern int spi_sync(struct spi_device *spi, struct spi_message *message);
+
+/**
+ * spi_write - SPI synchronous write
+ * @spi: device to which data will be written
+ * @buf: data buffer
+ * @len: data buffer size
+ *
+ * This writes the buffer and returns zero or a negative error code.
+ * Callable only from contexts that can sleep.
+ */
+static inline int
+spi_write(struct spi_device *spi, const u8 *buf, size_t len)
+{
+        struct spi_transfer     t = {
+                        .tx_buf         = buf,
+                        .len            = len,
+                };
+        struct spi_message      m;
+
+        spi_message_init(&m);
+        spi_message_add_tail(&t, &m);
+        return spi_sync(spi, &m);
+}
+
+/**
+ * spi_read - SPI synchronous read
+ * @spi: device from which data will be read
+ * @buf: data buffer
+ * @len: data buffer size
+ *
+ * This writes the buffer and returns zero or a negative error code.
+ * Callable only from contexts that can sleep.
+ */
+static inline int
+spi_read(struct spi_device *spi, u8 *buf, size_t len)
+{
+        struct spi_transfer     t = {
+                        .rx_buf         = buf,
+                        .len            = len,
+                };
+        struct spi_message      m;
+
+        spi_message_init(&m);
+        spi_message_add_tail(&t, &m);
+        return spi_sync(spi, &m);
+}
+
+/* this copies txbuf and rxbuf data; for small transfers only! */
+extern int spi_write_then_read(struct spi_device *spi,
+                const u8 *txbuf, unsigned n_tx,
+                u8 *rxbuf, unsigned n_rx);
+
+/**
+ * spi_w8r8 - SPI synchronous 8 bit write followed by 8 bit read
+ * @spi: device with which data will be exchanged
+ * @cmd: command to be written before data is read back
+ *
+ * This returns the (unsigned) eight bit number returned by the
+ * device, or else a negative error code.  Callable only from
+ * contexts that can sleep.
+ */
+static inline ssize_t spi_w8r8(struct spi_device *spi, u8 cmd)
+{
+        ssize_t                 status;
+        u8                      result;
+
+        status = spi_write_then_read(spi, &cmd, 1, &result, 1);
+
+        /* return negative errno or unsigned value */
+        return (status < 0) ? status : result;
+}
+
+/**
+ * spi_w8r16 - SPI synchronous 8 bit write followed by 16 bit read
+ * @spi: device with which data will be exchanged
+ * @cmd: command to be written before data is read back
+ *
+ * This returns the (unsigned) sixteen bit number returned by the
+ * device, or else a negative error code.  Callable only from
+ * contexts that can sleep.
+ *
+ * The number is returned in wire-order, which is at least sometimes
+ * big-endian.
+ */
+static inline ssize_t spi_w8r16(struct spi_device *spi, u8 cmd)
+{
+        ssize_t                 status;
+        u16                     result;
+
+        status = spi_write_then_read(spi, &cmd, 1, (u8 *) &result, 2);
+
+        /* return negative errno or unsigned value */
+        return (status < 0) ? status : result;
+}
+
+/*---------------------------------------------------------------------------*/
+
+/*
+ * INTERFACE between board init code and SPI infrastructure.
+ *
+ * No SPI driver ever sees these SPI device table segments, but
+ * it's how the SPI core (or adapters that get hotplugged) grows
+ * the driver model tree.
+ *
+ * As a rule, SPI devices can't be probed.  Instead, board init code
+ * provides a table listing the devices which are present, with enough
+ * information to bind and set up the device's driver.  There's basic
+ * support for nonstatic configurations too; enough to handle adding
+ * parport adapters, or microcontrollers acting as USB-to-SPI bridges.
+ */
+
+/* board-specific information about each SPI device */
+struct spi_board_info {
+        /* the device name and module name are coupled, like platform_bus;
+         * "modalias" is normally the driver name.
+         *
+         * platform_data goes to spi_device.dev.platform_data,
+         * controller_data goes to spi_device.controller_data,
+         * irq is copied too
+         */
+        char            modalias[KOBJ_NAME_LEN];
+        const void      *platform_data;
+        void            *controller_data;
+        int             irq;
+
+        /* slower signaling on noisy or low voltage boards */
+        u32             max_speed_hz;
+
+
+        /* bus_num is board specific and matches the bus_num of some
+         * spi_master that will probably be registered later.
+         *
+         * chip_select reflects how this chip is wired to that master;
+         * it's less than num_chipselect.
+         */
+        u16             bus_num;
+        u16             chip_select;
+
+        /* ... may need additional spi_device chip config data here.
+         * avoid stuff protocol drivers can set; but include stuff
+         * needed to behave without being bound to a driver:
+         *  - chipselect polarity
+         *  - quirks like clock rate mattering when not selected
+         */
+};
+
+#ifdef  CONFIG_SPI
+extern int
+spi_register_board_info(struct spi_board_info const *info, unsigned n);
+#else
+/* board init code may ignore whether SPI is configured or not */
+static inline int
+spi_register_board_info(struct spi_board_info const *info, unsigned n)
+        { return 0; }
+#endif
+
+
+/* If you're hotplugging an adapter with devices (parport, usb, etc)
+ * use spi_new_device() to describe each device.  You can also call
+ * spi_unregister_device() to start making that device vanish, but
+ * normally that would be handled by spi_unregister_master().
+ */
+extern struct spi_device *
+spi_new_device(struct spi_master *, struct spi_board_info *);
+
+static inline void
+spi_unregister_device(struct spi_device *spi)
+{
+        if (spi)
+                device_unregister(&spi->dev);
+}
+
+#endif /* __LINUX_SPI_H */
diff --git a/include/linux/spi/spi_bitbang.h b/include/linux/spi/spi_bitbang.h
new file mode 100644
index 000000000000..c961fe9bf3eb
--- /dev/null
+++ b/include/linux/spi/spi_bitbang.h
@@ -0,0 +1,135 @@
+#ifndef __SPI_BITBANG_H
+#define __SPI_BITBANG_H
+
+/*
+ * Mix this utility code with some glue code to get one of several types of
+ * simple SPI master driver.  Two do polled word-at-a-time I/O:
+ *
+ *   -  GPIO/parport bitbangers.  Provide chipselect() and txrx_word[](),
+ *      expanding the per-word routines from the inline templates below.
+ *
+ *   -  Drivers for controllers resembling bare shift registers.  Provide
+ *      chipselect() and txrx_word[](), with custom setup()/cleanup() methods
+ *      that use your controller's clock and chipselect registers.
+ *
+ * Some hardware works well with requests at spi_transfer scope:
+ *
+ *   -  Drivers leveraging smarter hardware, with fifos or DMA; or for half
+ *      duplex (MicroWire) controllers.  Provide chipslect() and txrx_bufs(),
+ *      and custom setup()/cleanup() methods.
+ */
+struct spi_bitbang {
+        struct workqueue_struct *workqueue;
+        struct work_struct      work;
+
+        spinlock_t              lock;
+        struct list_head        queue;
+        u8                      busy;
+        u8                      shutdown;
+        u8                      use_dma;
+
+        struct spi_master       *master;
+
+        void    (*chipselect)(struct spi_device *spi, int is_on);
+#define BITBANG_CS_ACTIVE       1       /* normally nCS, active low */
+#define BITBANG_CS_INACTIVE     0
+
+        /* txrx_bufs() may handle dma mapping for transfers that don't
+         * already have one (transfer.{tx,rx}_dma is zero), or use PIO
+         */
+        int     (*txrx_bufs)(struct spi_device *spi, struct spi_transfer *t);
+
+        /* txrx_word[SPI_MODE_*]() just looks like a shift register */
+        u32     (*txrx_word[4])(struct spi_device *spi,
+                        unsigned nsecs,
+                        u32 word, u8 bits);
+};
+
+/* you can call these default bitbang->master methods from your custom
+ * methods, if you like.
+ */
+extern int spi_bitbang_setup(struct spi_device *spi);
+extern void spi_bitbang_cleanup(const struct spi_device *spi);
+extern int spi_bitbang_transfer(struct spi_device *spi, struct spi_message *m);
+
+/* start or stop queue processing */
+extern int spi_bitbang_start(struct spi_bitbang *spi);
+extern int spi_bitbang_stop(struct spi_bitbang *spi);
+
+#endif  /* __SPI_BITBANG_H */
+
+/*-------------------------------------------------------------------------*/
+
+#ifdef  EXPAND_BITBANG_TXRX
+
+/*
+ * The code that knows what GPIO pins do what should have declared four
+ * functions, ideally as inlines, before #defining EXPAND_BITBANG_TXRX
+ * and including this header:
+ *
+ *  void setsck(struct spi_device *, int is_on);
+ *  void setmosi(struct spi_device *, int is_on);
+ *  int getmiso(struct spi_device *);
+ *  void spidelay(unsigned);
+ *
+ * A non-inlined routine would call bitbang_txrx_*() routines.  The
+ * main loop could easily compile down to a handful of instructions,
+ * especially if the delay is a NOP (to run at peak speed).
+ *
+ * Since this is software, the timings may not be exactly what your board's
+ * chips need ... there may be several reasons you'd need to tweak timings
+ * in these routines, not just make to make it faster or slower to match a
+ * particular CPU clock rate.
+ */
+
+static inline u32
+bitbang_txrx_be_cpha0(struct spi_device *spi,
+                unsigned nsecs, unsigned cpol,
+                u32 word, u8 bits)
+{
+        /* if (cpol == 0) this is SPI_MODE_0; else this is SPI_MODE_2 */
+
+        /* clock starts at inactive polarity */
+        for (word <<= (32 - bits); likely(bits); bits--) {
+
+                /* setup MSB (to slave) on trailing edge */
+                setmosi(spi, word & (1 << 31));
+                spidelay(nsecs);        /* T(setup) */
+
+                setsck(spi, !cpol);
+                spidelay(nsecs);
+
+                /* sample MSB (from slave) on leading edge */
+                word <<= 1;
+                word |= getmiso(spi);
+                setsck(spi, cpol);
+        }
+        return word;
+}
+
+static inline u32
+bitbang_txrx_be_cpha1(struct spi_device *spi,
+                unsigned nsecs, unsigned cpol,
+                u32 word, u8 bits)
+{
+        /* if (cpol == 0) this is SPI_MODE_1; else this is SPI_MODE_3 */
+
+        /* clock starts at inactive polarity */
+        for (word <<= (32 - bits); likely(bits); bits--) {
+
+                /* setup MSB (to slave) on leading edge */
+                setsck(spi, !cpol);
+                setmosi(spi, word & (1 << 31));
+                spidelay(nsecs); /* T(setup) */
+
+                setsck(spi, cpol);
+                spidelay(nsecs);
+
+                /* sample MSB (from slave) on trailing edge */
+                word <<= 1;
+                word |= getmiso(spi);
+        }
+        return word;
+}
+
+#endif  /* EXPAND_BITBANG_TXRX */
diff --git a/include/linux/swap.h b/include/linux/swap.h
index 389d1c382e20..e92054d6530b 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -180,6 +180,11 @@ extern int isolate_lru_page(struct page *p);
 extern int putback_lru_pages(struct list_head *l);
 extern int migrate_pages(struct list_head *l, struct list_head *t,
                 struct list_head *moved, struct list_head *failed);
+#else
+static inline int isolate_lru_page(struct page *p) { return -ENOSYS; }
+static inline int putback_lru_pages(struct list_head *l) { return 0; }
+static inline int migrate_pages(struct list_head *l, struct list_head *t,
+        struct list_head *moved, struct list_head *failed) { return -ENOSYS; }
 #endif
 
 #ifdef CONFIG_MMU
diff --git a/include/linux/tipc.h b/include/linux/tipc.h
new file mode 100644
index 000000000000..243a15f54002
--- /dev/null
+++ b/include/linux/tipc.h
@@ -0,0 +1,212 @@
+/*
+ * include/linux/tipc.h: Include file for TIPC socket interface
+ * 
+ * Copyright (c) 2003-2006, Ericsson AB
+ * Copyright (c) 2005, Wind River Systems
+ * All rights reserved.
+ *
+ * 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.
+ * 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. Neither the names of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * 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.
+ */
+
+#ifndef _LINUX_TIPC_H_
+#define _LINUX_TIPC_H_
+
+#include <linux/types.h>
+
+/*
+ * TIPC addressing primitives
+ */
+ 
+struct tipc_portid {
+        __u32 ref;
+        __u32 node;
+};
+
+struct tipc_name {
+        __u32 type;
+        __u32 instance;
+};
+
+struct tipc_name_seq {
+        __u32 type;
+        __u32 lower;
+        __u32 upper;
+};
+
+static inline __u32 tipc_addr(unsigned int zone,
+                              unsigned int cluster,
+                              unsigned int node)
+{
+        return (zone << 24) | (cluster << 12) | node;
+}
+
+static inline unsigned int tipc_zone(__u32 addr)
+{
+        return addr >> 24;
+}
+
+static inline unsigned int tipc_cluster(__u32 addr)
+{
+        return (addr >> 12) & 0xfff;
+}
+
+static inline unsigned int tipc_node(__u32 addr)
+{
+        return addr & 0xfff;
+}
+
+/*
+ * Application-accessible port name types
+ */
+
+#define TIPC_CFG_SRV            0       /* configuration service name type */
+#define TIPC_TOP_SRV            1       /* topology service name type */
+#define TIPC_RESERVED_TYPES     64      /* lowest user-publishable name type */
+
+/* 
+ * Publication scopes when binding port names and port name sequences
+ */
+
+#define TIPC_ZONE_SCOPE         1
+#define TIPC_CLUSTER_SCOPE      2
+#define TIPC_NODE_SCOPE         3
+
+/*
+ * Limiting values for messages
+ */
+
+#define TIPC_MAX_USER_MSG_SIZE  66000
+
+/*
+ * Message importance levels
+ */
+
+#define TIPC_LOW_IMPORTANCE             0  /* default */
+#define TIPC_MEDIUM_IMPORTANCE          1
+#define TIPC_HIGH_IMPORTANCE            2
+#define TIPC_CRITICAL_IMPORTANCE        3
+
+/* 
+ * Msg rejection/connection shutdown reasons
+ */
+
+#define TIPC_OK                 0
+#define TIPC_ERR_NO_NAME        1
+#define TIPC_ERR_NO_PORT        2
+#define TIPC_ERR_NO_NODE        3
+#define TIPC_ERR_OVERLOAD       4
+#define TIPC_CONN_SHUTDOWN      5
+
+/*
+ * TIPC topology subscription service definitions
+ */
+
+#define TIPC_SUB_PORTS          0x01    /* filter for port availability */
+#define TIPC_SUB_SERVICE        0x02    /* filter for service availability */
+#if 0
+/* The following filter options are not currently implemented */
+#define TIPC_SUB_NO_BIND_EVTS   0x04    /* filter out "publish" events */
+#define TIPC_SUB_NO_UNBIND_EVTS 0x08    /* filter out "withdraw" events */
+#define TIPC_SUB_SINGLE_EVT     0x10    /* expire after first event */
+#endif
+
+#define TIPC_WAIT_FOREVER       ~0      /* timeout for permanent subscription */
+
+struct tipc_subscr {
+        struct tipc_name_seq seq;       /* name sequence of interest */
+        __u32 timeout;                  /* subscription duration (in ms) */
+        __u32 filter;                   /* bitmask of filter options */
+        char usr_handle[8];             /* available for subscriber use */
+};
+
+#define TIPC_PUBLISHED          1       /* publication event */
+#define TIPC_WITHDRAWN          2       /* withdraw event */
+#define TIPC_SUBSCR_TIMEOUT     3       /* subscription timeout event */
+
+struct tipc_event {
+        __u32 event;                    /* event type */
+        __u32 found_lower;              /* matching name seq instances */
+        __u32 found_upper;              /*    "      "    "     "      */
+        struct tipc_portid port;        /* associated port */
+        struct tipc_subscr s;           /* associated subscription */
+};
+
+/*
+ * Socket API
+ */
+
+#ifndef AF_TIPC
+#define AF_TIPC         30
+#endif
+
+#ifndef PF_TIPC
+#define PF_TIPC         AF_TIPC
+#endif
+
+#ifndef SOL_TIPC
+#define SOL_TIPC        271
+#endif
+
+#define TIPC_ADDR_NAMESEQ       1
+#define TIPC_ADDR_MCAST         1
+#define TIPC_ADDR_NAME          2
+#define TIPC_ADDR_ID            3
+
+struct sockaddr_tipc {
+        unsigned short family;
+        unsigned char  addrtype;
+        signed   char  scope;
+        union {
+                struct tipc_portid id;
+                struct tipc_name_seq nameseq;
+                struct {
+                        struct tipc_name name;
+                        __u32 domain; /* 0: own zone */
+                } name;
+        } addr;
+};
+
+/*
+ * Ancillary data objects supported by recvmsg()
+ */
+
+#define TIPC_ERRINFO    1       /* error info */
+#define TIPC_RETDATA    2       /* returned data */
+#define TIPC_DESTNAME   3       /* destination name */
+
+/*
+ * TIPC-specific socket option values
+ */
+
+#define TIPC_IMPORTANCE         127     /* Default: TIPC_LOW_IMPORTANCE */
+#define TIPC_SRC_DROPPABLE      128     /* Default: 0 (resend congested msg) */
+#define TIPC_DEST_DROPPABLE     129     /* Default: based on socket type */
+#define TIPC_CONN_TIMEOUT       130     /* Default: 8000 (ms)  */
+
+#endif
diff --git a/include/linux/tipc_config.h b/include/linux/tipc_config.h
new file mode 100644
index 000000000000..a52c8c64a5a3
--- /dev/null
+++ b/include/linux/tipc_config.h
@@ -0,0 +1,407 @@
+/*
+ * include/linux/tipc_config.h: Include file for TIPC configuration interface
+ * 
+ * Copyright (c) 2003-2006, Ericsson AB
+ * Copyright (c) 2005, Wind River Systems
+ * All rights reserved.
+ *
+ * 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.
+ * 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. Neither the names of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * 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.
+ */
+
+#ifndef _LINUX_TIPC_CONFIG_H_
+#define _LINUX_TIPC_CONFIG_H_
+
+#include <linux/types.h>
+#include <linux/string.h>
+#include <asm/byteorder.h>
+
+/*
+ * Configuration
+ *
+ * All configuration management messaging involves sending a request message
+ * to the TIPC configuration service on a node, which sends a reply message
+ * back.  (In the future multi-message replies may be supported.)
+ *
+ * Both request and reply messages consist of a transport header and payload.
+ * The transport header contains info about the desired operation;
+ * the payload consists of zero or more type/length/value (TLV) items
+ * which specify parameters or results for the operation.
+ *
+ * For many operations, the request and reply messages have a fixed number
+ * of TLVs (usually zero or one); however, some reply messages may return 
+ * a variable number of TLVs.  A failed request is denoted by the presence
+ * of an "error string" TLV in the reply message instead of the TLV(s) the
+ * reply should contain if the request succeeds.
+ */
+ 
+/* 
+ * Public commands:
+ * May be issued by any process.
+ * Accepted by own node, or by remote node only if remote management enabled.                       
+ */
+ 
+#define  TIPC_CMD_NOOP              0x0000    /* tx none, rx none */
+#define  TIPC_CMD_GET_NODES         0x0001    /* tx net_addr, rx node_info(s) */
+#define  TIPC_CMD_GET_MEDIA_NAMES   0x0002    /* tx none, rx media_name(s) */
+#define  TIPC_CMD_GET_BEARER_NAMES  0x0003    /* tx none, rx bearer_name(s) */
+#define  TIPC_CMD_GET_LINKS         0x0004    /* tx net_addr, rx link_info(s) */
+#define  TIPC_CMD_SHOW_NAME_TABLE   0x0005    /* tx name_tbl_query, rx ultra_string */
+#define  TIPC_CMD_SHOW_PORTS        0x0006    /* tx none, rx ultra_string */
+#define  TIPC_CMD_SHOW_LINK_STATS   0x000B    /* tx link_name, rx ultra_string */
+
+#if 0
+#define  TIPC_CMD_SHOW_PORT_STATS   0x0008    /* tx port_ref, rx ultra_string */
+#define  TIPC_CMD_RESET_PORT_STATS  0x0009    /* tx port_ref, rx none */
+#define  TIPC_CMD_GET_ROUTES        0x000A    /* tx ?, rx ? */
+#define  TIPC_CMD_GET_LINK_PEER     0x000D    /* tx link_name, rx ? */
+#endif
+
+/* 
+ * Protected commands:
+ * May only be issued by "network administration capable" process.
+ * Accepted by own node, or by remote node only if remote management enabled
+ * and this node is zone manager.                       
+ */
+
+#define  TIPC_CMD_GET_REMOTE_MNG    0x4003    /* tx none, rx unsigned */
+#define  TIPC_CMD_GET_MAX_PORTS     0x4004    /* tx none, rx unsigned */
+#define  TIPC_CMD_GET_MAX_PUBL      0x4005    /* tx none, rx unsigned */
+#define  TIPC_CMD_GET_MAX_SUBSCR    0x4006    /* tx none, rx unsigned */
+#define  TIPC_CMD_GET_MAX_ZONES     0x4007    /* tx none, rx unsigned */
+#define  TIPC_CMD_GET_MAX_CLUSTERS  0x4008    /* tx none, rx unsigned */
+#define  TIPC_CMD_GET_MAX_NODES     0x4009    /* tx none, rx unsigned */
+#define  TIPC_CMD_GET_MAX_SLAVES    0x400A    /* tx none, rx unsigned */
+#define  TIPC_CMD_GET_NETID         0x400B    /* tx none, rx unsigned */
+
+#define  TIPC_CMD_ENABLE_BEARER     0x4101    /* tx bearer_config, rx none */
+#define  TIPC_CMD_DISABLE_BEARER    0x4102    /* tx bearer_name, rx none */
+#define  TIPC_CMD_SET_LINK_TOL      0x4107    /* tx link_config, rx none */
+#define  TIPC_CMD_SET_LINK_PRI      0x4108    /* tx link_config, rx none */
+#define  TIPC_CMD_SET_LINK_WINDOW   0x4109    /* tx link_config, rx none */
+#define  TIPC_CMD_SET_LOG_SIZE      0x410A    /* tx unsigned, rx none */
+#define  TIPC_CMD_DUMP_LOG          0x410B    /* tx none, rx ultra_string */
+#define  TIPC_CMD_RESET_LINK_STATS  0x410C    /* tx link_name, rx none */
+
+#if 0
+#define  TIPC_CMD_CREATE_LINK       0x4103    /* tx link_create, rx none */
+#define  TIPC_CMD_REMOVE_LINK       0x4104    /* tx link_name, rx none */
+#define  TIPC_CMD_BLOCK_LINK        0x4105    /* tx link_name, rx none */
+#define  TIPC_CMD_UNBLOCK_LINK      0x4106    /* tx link_name, rx none */
+#endif
+
+/* 
+ * Private commands:
+ * May only be issued by "network administration capable" process.
+ * Accepted by own node only; cannot be used on a remote node.                       
+ */
+
+#define  TIPC_CMD_SET_NODE_ADDR     0x8001    /* tx net_addr, rx none */
+#if 0
+#define  TIPC_CMD_SET_ZONE_MASTER   0x8002    /* tx none, rx none */
+#endif
+#define  TIPC_CMD_SET_REMOTE_MNG    0x8003    /* tx unsigned, rx none */
+#define  TIPC_CMD_SET_MAX_PORTS     0x8004    /* tx unsigned, rx none */
+#define  TIPC_CMD_SET_MAX_PUBL      0x8005    /* tx unsigned, rx none */
+#define  TIPC_CMD_SET_MAX_SUBSCR    0x8006    /* tx unsigned, rx none */
+#define  TIPC_CMD_SET_MAX_ZONES     0x8007    /* tx unsigned, rx none */
+#define  TIPC_CMD_SET_MAX_CLUSTERS  0x8008    /* tx unsigned, rx none */
+#define  TIPC_CMD_SET_MAX_NODES     0x8009    /* tx unsigned, rx none */
+#define  TIPC_CMD_SET_MAX_SLAVES    0x800A    /* tx unsigned, rx none */
+#define  TIPC_CMD_SET_NETID         0x800B    /* tx unsigned, rx none */
+
+/*
+ * TLV types defined for TIPC
+ */
+
+#define TIPC_TLV_NONE           0       /* no TLV present */
+#define TIPC_TLV_VOID           1       /* empty TLV (0 data bytes)*/
+#define TIPC_TLV_UNSIGNED       2       /* 32-bit integer */
+#define TIPC_TLV_STRING         3       /* char[128] (max) */
+#define TIPC_TLV_LARGE_STRING   4       /* char[2048] (max) */
+#define TIPC_TLV_ULTRA_STRING   5       /* char[32768] (max) */
+
+#define TIPC_TLV_ERROR_STRING   16      /* char[128] containing "error code" */
+#define TIPC_TLV_NET_ADDR       17      /* 32-bit integer denoting <Z.C.N> */
+#define TIPC_TLV_MEDIA_NAME     18      /* char[TIPC_MAX_MEDIA_NAME] */
+#define TIPC_TLV_BEARER_NAME    19      /* char[TIPC_MAX_BEARER_NAME] */
+#define TIPC_TLV_LINK_NAME      20      /* char[TIPC_MAX_LINK_NAME] */
+#define TIPC_TLV_NODE_INFO      21      /* struct tipc_node_info */
+#define TIPC_TLV_LINK_INFO      22      /* struct tipc_link_info */
+#define TIPC_TLV_BEARER_CONFIG  23      /* struct tipc_bearer_config */
+#define TIPC_TLV_LINK_CONFIG    24      /* struct tipc_link_config */
+#define TIPC_TLV_NAME_TBL_QUERY 25      /* struct tipc_name_table_query */
+#define TIPC_TLV_PORT_REF       26      /* 32-bit port reference */
+
+/*
+ * Maximum sizes of TIPC bearer-related names (including terminating NUL)
+ */ 
+
+#define TIPC_MAX_MEDIA_NAME     16      /* format = media */
+#define TIPC_MAX_IF_NAME        16      /* format = interface */
+#define TIPC_MAX_BEARER_NAME    32      /* format = media:interface */
+#define TIPC_MAX_LINK_NAME      60      /* format = Z.C.N:interface-Z.C.N:interface */
+
+/*
+ * Link priority limits (range from 0 to # priorities - 1)
+ */
+
+#define TIPC_NUM_LINK_PRI 32
+
+/*
+ * Link tolerance limits (min, default, max), in ms
+ */
+
+#define TIPC_MIN_LINK_TOL 50
+#define TIPC_DEF_LINK_TOL 1500
+#define TIPC_MAX_LINK_TOL 30000
+
+/*
+ * Link window limits (min, default, max), in packets
+ */
+
+#define TIPC_MIN_LINK_WIN 16
+#define TIPC_DEF_LINK_WIN 50
+#define TIPC_MAX_LINK_WIN 150
+
+
+struct tipc_node_info {
+        __u32 addr;                     /* network address of node */
+        __u32 up;                       /* 0=down, 1= up */
+};
+
+struct tipc_link_info {
+        __u32 dest;                     /* network address of peer node */
+        __u32 up;                       /* 0=down, 1=up */
+        char str[TIPC_MAX_LINK_NAME];   /* link name */
+};
+
+struct tipc_bearer_config {
+        __u32 priority;                 /* Range [1,31]. Override per link  */
+        __u32 detect_scope;     
+        char name[TIPC_MAX_BEARER_NAME];
+};
+
+struct tipc_link_config {
+        __u32 value;
+        char name[TIPC_MAX_LINK_NAME];
+};
+
+#define TIPC_NTQ_ALLTYPES 0x80000000
+
+struct tipc_name_table_query {
+        __u32 depth;    /* 1:type, 2:+name info, 3:+port info, 4+:+debug info */
+        __u32 type;     /* {t,l,u} info ignored if high bit of "depth" is set */
+        __u32 lowbound; /* (i.e. displays all entries of name table) */
+        __u32 upbound;
+};
+
+/*
+ * The error string TLV is a null-terminated string describing the cause 
+ * of the request failure.  To simplify error processing (and to save space)
+ * the first character of the string can be a special error code character
+ * (lying by the range 0x80 to 0xFF) which represents a pre-defined reason.
+ */
+
+#define TIPC_CFG_TLV_ERROR      "\x80"  /* request contains incorrect TLV(s) */
+#define TIPC_CFG_NOT_NET_ADMIN  "\x81"  /* must be network administrator */
+#define TIPC_CFG_NOT_ZONE_MSTR  "\x82"  /* must be zone master */
+#define TIPC_CFG_NO_REMOTE      "\x83"  /* remote management not enabled */
+#define TIPC_CFG_NOT_SUPPORTED  "\x84"  /* request is not supported by TIPC */
+#define TIPC_CFG_INVALID_VALUE  "\x85"  /* request has invalid argument value */
+
+#if 0
+/* prototypes TLV structures for proposed commands */
+struct tipc_link_create {
+        __u32   domain;
+        struct tipc_media_addr peer_addr;
+        char bearer_name[TIPC_MAX_BEARER_NAME];
+};
+
+struct tipc_route_info {
+        __u32 dest;
+        __u32 router;
+};
+#endif
+
+/*
+ * A TLV consists of a descriptor, followed by the TLV value.
+ * TLV descriptor fields are stored in network byte order; 
+ * TLV values must also be stored in network byte order (where applicable).
+ * TLV descriptors must be aligned to addresses which are multiple of 4,
+ * so up to 3 bytes of padding may exist at the end of the TLV value area.
+ * There must not be any padding between the TLV descriptor and its value.
+ */
+
+struct tlv_desc {
+        __u16 tlv_len;          /* TLV length (descriptor + value) */
+        __u16 tlv_type;         /* TLV identifier */
+};
+
+#define TLV_ALIGNTO 4
+
+#define TLV_ALIGN(datalen) (((datalen)+(TLV_ALIGNTO-1)) & ~(TLV_ALIGNTO-1))
+#define TLV_LENGTH(datalen) (sizeof(struct tlv_desc) + (datalen))
+#define TLV_SPACE(datalen) (TLV_ALIGN(TLV_LENGTH(datalen)))
+#define TLV_DATA(tlv) ((void *)((char *)(tlv) + TLV_LENGTH(0)))
+
+static inline int TLV_OK(const void *tlv, __u16 space)
+{
+        /*
+         * Would also like to check that "tlv" is a multiple of 4,
+         * but don't know how to do this in a portable way.
+         * - Tried doing (!(tlv & (TLV_ALIGNTO-1))), but GCC compiler
+         *   won't allow binary "&" with a pointer.
+         * - Tried casting "tlv" to integer type, but causes warning about size
+         *   mismatch when pointer is bigger than chosen type (int, long, ...).
+         */
+
+        return (space >= TLV_SPACE(0)) &&
+                (ntohs(((struct tlv_desc *)tlv)->tlv_len) <= space);
+}
+
+static inline int TLV_CHECK(const void *tlv, __u16 space, __u16 exp_type)
+{
+        return TLV_OK(tlv, space) && 
+                (ntohs(((struct tlv_desc *)tlv)->tlv_type) == exp_type);
+}
+
+static inline int TLV_SET(void *tlv, __u16 type, void *data, __u16 len)
+{
+        struct tlv_desc *tlv_ptr;
+        int tlv_len;
+
+        tlv_len = TLV_LENGTH(len);
+        tlv_ptr = (struct tlv_desc *)tlv;
+        tlv_ptr->tlv_type = htons(type);
+        tlv_ptr->tlv_len  = htons(tlv_len);
+        if (len && data)
+                memcpy(TLV_DATA(tlv_ptr), data, tlv_len);
+        return TLV_SPACE(len);
+}
+
+/*
+ * A TLV list descriptor simplifies processing of messages 
+ * containing multiple TLVs.
+ */
+
+struct tlv_list_desc {
+        struct tlv_desc *tlv_ptr;       /* ptr to current TLV */
+        __u32 tlv_space;                /* # bytes from curr TLV to list end */
+};
+
+static inline void TLV_LIST_INIT(struct tlv_list_desc *list, 
+                                 void *data, __u32 space)
+{
+        list->tlv_ptr = (struct tlv_desc *)data;
+        list->tlv_space = space;
+}
+             
+static inline int TLV_LIST_EMPTY(struct tlv_list_desc *list)
+{ 
+        return (list->tlv_space == 0);
+}
+
+static inline int TLV_LIST_CHECK(struct tlv_list_desc *list, __u16 exp_type)
+{
+        return TLV_CHECK(list->tlv_ptr, list->tlv_space, exp_type);
+}
+
+static inline void *TLV_LIST_DATA(struct tlv_list_desc *list)
+{
+        return TLV_DATA(list->tlv_ptr);
+}
+
+static inline void TLV_LIST_STEP(struct tlv_list_desc *list)
+{
+        __u16 tlv_space = TLV_ALIGN(ntohs(list->tlv_ptr->tlv_len));
+
+        list->tlv_ptr = (struct tlv_desc *)((char *)list->tlv_ptr + tlv_space);
+        list->tlv_space -= tlv_space;
+}
+
+/*
+ * Configuration messages exchanged via NETLINK_GENERIC use the following
+ * family id, name, version and command.
+ */
+#define TIPC_GENL_NAME          "TIPC"
+#define TIPC_GENL_VERSION       0x1
+#define TIPC_GENL_CMD           0x1
+
+/*
+ * TIPC specific header used in NETLINK_GENERIC requests.
+ */
+struct tipc_genlmsghdr {
+        __u32 dest;             /* Destination address */
+        __u16 cmd;              /* Command */
+        __u16 reserved;         /* Unused */
+};
+
+#define TIPC_GENL_HDRLEN        NLMSG_ALIGN(sizeof(struct tipc_genlmsghdr))
+
+/*
+ * Configuration messages exchanged via TIPC sockets use the TIPC configuration 
+ * message header, which is defined below.  This structure is analogous 
+ * to the Netlink message header, but fields are stored in network byte order 
+ * and no padding is permitted between the header and the message data 
+ * that follows.
+ */
+
+struct tipc_cfg_msg_hdr
+{
+        __u32 tcm_len;          /* Message length (including header) */
+        __u16 tcm_type;         /* Command type */
+        __u16 tcm_flags;        /* Additional flags */
+        char  tcm_reserved[8];  /* Unused */
+};
+
+#define TCM_F_REQUEST   0x1     /* Flag: Request message */
+#define TCM_F_MORE      0x2     /* Flag: Message to be continued */
+
+#define TCM_ALIGN(datalen)  (((datalen)+3) & ~3)
+#define TCM_LENGTH(datalen) (sizeof(struct tipc_cfg_msg_hdr) + datalen)
+#define TCM_SPACE(datalen)  (TCM_ALIGN(TCM_LENGTH(datalen)))
+#define TCM_DATA(tcm_hdr)   ((void *)((char *)(tcm_hdr) + TCM_LENGTH(0)))
+
+static inline int TCM_SET(void *msg, __u16 cmd, __u16 flags,
+                          void *data, __u16 data_len)
+{
+        struct tipc_cfg_msg_hdr *tcm_hdr;
+        int msg_len;
+
+        msg_len = TCM_LENGTH(data_len);
+        tcm_hdr = (struct tipc_cfg_msg_hdr *)msg;
+        tcm_hdr->tcm_len   = htonl(msg_len);
+        tcm_hdr->tcm_type  = htons(cmd);
+        tcm_hdr->tcm_flags = htons(flags);
+        if (data_len && data)
+                memcpy(TCM_DATA(msg), data, data_len);
+        return TCM_SPACE(data_len);
+}
+
+#endif