Merge branch 'x86/oprofile' into oprofile

155 files changed, 4754 insertions, 1019 deletions

diff --git a/include/linux/Kbuild b/include/linux/Kbuild
index 4c4142c5aa6e..7d970678f940 100644
--- a/include/linux/Kbuild
+++ b/include/linux/Kbuild
@@ -97,6 +97,7 @@ header-y += ioctl.h
 header-y += ip6_tunnel.h
 header-y += ipmi_msgdefs.h
 header-y += ipsec.h
+header-y += ip_vs.h
 header-y += ipx.h
 header-y += irda.h
 header-y += iso_fs.h
@@ -249,6 +250,8 @@ unifdef-y += isdn.h
 unifdef-y += isdnif.h
 unifdef-y += isdn_divertif.h
 unifdef-y += isdn_ppp.h
+unifdef-y += ivtv.h
+unifdef-y += ivtvfb.h
 unifdef-y += joystick.h
 unifdef-y += kdev_t.h
 unifdef-y += kd.h
@@ -355,6 +358,7 @@ unifdef-y += virtio_balloon.h
 unifdef-y += virtio_console.h
 unifdef-y += virtio_pci.h
 unifdef-y += virtio_ring.h
+unifdef-y += virtio_rng.h
 unifdef-y += vt.h
 unifdef-y += wait.h
 unifdef-y += wanrouter.h
diff --git a/include/linux/agp_backend.h b/include/linux/agp_backend.h
index 972b12bcfb36..2b8df8b420fd 100644
--- a/include/linux/agp_backend.h
+++ b/include/linux/agp_backend.h
@@ -30,6 +30,8 @@
 #ifndef _AGP_BACKEND_H
 #define _AGP_BACKEND_H 1
 
+#include <linux/list.h>
+
 enum chipset_type {
         NOT_SUPPORTED,
         SUPPORTED,
@@ -78,6 +80,8 @@ struct agp_memory {
         bool is_bound;
         bool is_flushed;
         bool vmalloc_flag;
+        /* list of agp_memory mapped to the aperture */
+        struct list_head mapped_list;
 };
 
 #define AGP_NORMAL_MEMORY 0
@@ -96,6 +100,7 @@ extern struct agp_memory *agp_allocate_memory(struct agp_bridge_data *, size_t,
 extern int agp_copy_info(struct agp_bridge_data *, struct agp_kern_info *);
 extern int agp_bind_memory(struct agp_memory *, off_t);
 extern int agp_unbind_memory(struct agp_memory *);
+extern int agp_rebind_memory(void);
 extern void agp_enable(struct agp_bridge_data *, u32);
 extern struct agp_bridge_data *agp_backend_acquire(struct pci_dev *);
 extern void agp_backend_release(struct agp_bridge_data *);
diff --git a/include/linux/aio.h b/include/linux/aio.h
index b51ddd28444e..09b276c35227 100644
--- a/include/linux/aio.h
+++ b/include/linux/aio.h
@@ -7,7 +7,6 @@
 #include <linux/uio.h>
 
 #include <asm/atomic.h>
-#include <linux/uio.h>
 
 #define AIO_MAXSEGS             4
 #define AIO_KIOGRP_NR_ATOMIC    8
diff --git a/include/linux/bitmap.h b/include/linux/bitmap.h
index 1abfe664c444..89781fd48859 100644
--- a/include/linux/bitmap.h
+++ b/include/linux/bitmap.h
@@ -110,6 +110,7 @@ extern int __bitmap_weight(const unsigned long *bitmap, int bits);
 
 extern int bitmap_scnprintf(char *buf, unsigned int len,
                         const unsigned long *src, int nbits);
+extern int bitmap_scnprintf_len(unsigned int nr_bits);
 extern int __bitmap_parse(const char *buf, unsigned int buflen, int is_user,
                         unsigned long *dst, int nbits);
 extern int bitmap_parse_user(const char __user *ubuf, unsigned int ulen,
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 88d68081a0f1..e61f22be4d0e 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -655,6 +655,7 @@ extern struct request *blk_get_request(struct request_queue *, int, gfp_t);
 extern void blk_insert_request(struct request_queue *, struct request *, int, void *);
 extern void blk_requeue_request(struct request_queue *, struct request *);
 extern void blk_plug_device(struct request_queue *);
+extern void blk_plug_device_unlocked(struct request_queue *);
 extern int blk_remove_plug(struct request_queue *);
 extern void blk_recount_segments(struct request_queue *, struct bio *);
 extern int scsi_cmd_ioctl(struct file *, struct request_queue *,
diff --git a/include/linux/bootmem.h b/include/linux/bootmem.h
index 652470b687c9..95837bfb5256 100644
--- a/include/linux/bootmem.h
+++ b/include/linux/bootmem.h
@@ -97,10 +97,14 @@ extern void *__alloc_bootmem_low_node(pg_data_t *pgdat,
 #ifndef CONFIG_HAVE_ARCH_BOOTMEM_NODE
 #define alloc_bootmem(x) \
         __alloc_bootmem(x, SMP_CACHE_BYTES, __pa(MAX_DMA_ADDRESS))
+#define alloc_bootmem_nopanic(x) \
+        __alloc_bootmem_nopanic(x, SMP_CACHE_BYTES, __pa(MAX_DMA_ADDRESS))
 #define alloc_bootmem_low(x) \
         __alloc_bootmem_low(x, SMP_CACHE_BYTES, 0)
 #define alloc_bootmem_pages(x) \
         __alloc_bootmem(x, PAGE_SIZE, __pa(MAX_DMA_ADDRESS))
+#define alloc_bootmem_pages_nopanic(x) \
+        __alloc_bootmem_nopanic(x, PAGE_SIZE, __pa(MAX_DMA_ADDRESS))
 #define alloc_bootmem_low_pages(x) \
         __alloc_bootmem_low(x, PAGE_SIZE, 0)
 #define alloc_bootmem_node(pgdat, x) \
diff --git a/include/linux/buffer_head.h b/include/linux/buffer_head.h
index 82aa36c53ea7..eadaab44015f 100644
--- a/include/linux/buffer_head.h
+++ b/include/linux/buffer_head.h
@@ -115,7 +115,6 @@ BUFFER_FNS(Uptodate, uptodate)
 BUFFER_FNS(Dirty, dirty)
 TAS_BUFFER_FNS(Dirty, dirty)
 BUFFER_FNS(Lock, locked)
-TAS_BUFFER_FNS(Lock, locked)
 BUFFER_FNS(Req, req)
 TAS_BUFFER_FNS(Req, req)
 BUFFER_FNS(Mapped, mapped)
@@ -205,6 +204,8 @@ void block_invalidatepage(struct page *page, unsigned long offset);
 int block_write_full_page(struct page *page, get_block_t *get_block,
                                 struct writeback_control *wbc);
 int block_read_full_page(struct page*, get_block_t*);
+int block_is_partially_uptodate(struct page *page, read_descriptor_t *desc,
+                                unsigned long from);
 int block_write_begin(struct file *, struct address_space *,
                                 loff_t, unsigned, unsigned,
                                 struct page **, void **, get_block_t*);
@@ -319,10 +320,15 @@ static inline void wait_on_buffer(struct buffer_head *bh)
                 __wait_on_buffer(bh);
 }
 
+static inline int trylock_buffer(struct buffer_head *bh)
+{
+        return likely(!test_and_set_bit(BH_Lock, &bh->b_state));
+}
+
 static inline void lock_buffer(struct buffer_head *bh)
 {
         might_sleep();
-        if (test_set_buffer_locked(bh))
+        if (!trylock_buffer(bh))
                 __lock_buffer(bh);
 }
 
diff --git a/include/linux/byteorder.h b/include/linux/byteorder.h
new file mode 100644
index 000000000000..29f002d73d98
--- /dev/null
+++ b/include/linux/byteorder.h
@@ -0,0 +1,372 @@
+#ifndef _LINUX_BYTEORDER_H
+#define _LINUX_BYTEORDER_H
+
+#include <linux/types.h>
+#include <linux/swab.h>
+
+#if defined(__LITTLE_ENDIAN) && defined(__BIG_ENDIAN)
+# error Fix asm/byteorder.h to define one endianness
+#endif
+
+#if !defined(__LITTLE_ENDIAN) && !defined(__BIG_ENDIAN)
+# error Fix asm/byteorder.h to define arch endianness
+#endif
+
+#ifdef __LITTLE_ENDIAN
+# undef __LITTLE_ENDIAN
+# define __LITTLE_ENDIAN 1234
+#endif
+
+#ifdef __BIG_ENDIAN
+# undef __BIG_ENDIAN
+# define __BIG_ENDIAN 4321
+#endif
+
+#if defined(__LITTLE_ENDIAN) && !defined(__LITTLE_ENDIAN_BITFIELD)
+# define __LITTLE_ENDIAN_BITFIELD
+#endif
+
+#if defined(__BIG_ENDIAN) && !defined(__BIG_ENDIAN_BITFIELD)
+# define __BIG_ENDIAN_BITFIELD
+#endif
+
+#ifdef __LITTLE_ENDIAN
+# define __le16_to_cpu(x) ((__force __u16)(__le16)(x))
+# define __le32_to_cpu(x) ((__force __u32)(__le32)(x))
+# define __le64_to_cpu(x) ((__force __u64)(__le64)(x))
+# define __cpu_to_le16(x) ((__force __le16)(__u16)(x))
+# define __cpu_to_le32(x) ((__force __le32)(__u32)(x))
+# define __cpu_to_le64(x) ((__force __le64)(__u64)(x))
+
+# define __be16_to_cpu(x) __swab16((__force __u16)(__be16)(x))
+# define __be32_to_cpu(x) __swab32((__force __u32)(__be32)(x))
+# define __be64_to_cpu(x) __swab64((__force __u64)(__be64)(x))
+# define __cpu_to_be16(x) ((__force __be16)__swab16(x))
+# define __cpu_to_be32(x) ((__force __be32)__swab32(x))
+# define __cpu_to_be64(x) ((__force __be64)__swab64(x))
+#endif
+
+#ifdef __BIG_ENDIAN
+# define __be16_to_cpu(x) ((__force __u16)(__be16)(x))
+# define __be32_to_cpu(x) ((__force __u32)(__be32)(x))
+# define __be64_to_cpu(x) ((__force __u64)(__be64)(x))
+# define __cpu_to_be16(x) ((__force __be16)(__u16)(x))
+# define __cpu_to_be32(x) ((__force __be32)(__u32)(x))
+# define __cpu_to_be64(x) ((__force __be64)(__u64)(x))
+
+# define __le16_to_cpu(x) __swab16((__force __u16)(__le16)(x))
+# define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x))
+# define __le64_to_cpu(x) __swab64((__force __u64)(__le64)(x))
+# define __cpu_to_le16(x) ((__force __le16)__swab16(x))
+# define __cpu_to_le32(x) ((__force __le32)__swab32(x))
+# define __cpu_to_le64(x) ((__force __le64)__swab64(x))
+#endif
+
+/*
+ * These helpers could be phased out over time as the base version
+ * handles constant folding.
+ */
+#define __constant_htonl(x) __cpu_to_be32(x)
+#define __constant_ntohl(x) __be32_to_cpu(x)
+#define __constant_htons(x) __cpu_to_be16(x)
+#define __constant_ntohs(x) __be16_to_cpu(x)
+
+#define __constant_le16_to_cpu(x) __le16_to_cpu(x)
+#define __constant_le32_to_cpu(x) __le32_to_cpu(x)
+#define __constant_le64_to_cpu(x) __le64_to_cpu(x)
+#define __constant_be16_to_cpu(x) __be16_to_cpu(x)
+#define __constant_be32_to_cpu(x) __be32_to_cpu(x)
+#define __constant_be64_to_cpu(x) __be64_to_cpu(x)
+
+#define __constant_cpu_to_le16(x) __cpu_to_le16(x)
+#define __constant_cpu_to_le32(x) __cpu_to_le32(x)
+#define __constant_cpu_to_le64(x) __cpu_to_le64(x)
+#define __constant_cpu_to_be16(x) __cpu_to_be16(x)
+#define __constant_cpu_to_be32(x) __cpu_to_be32(x)
+#define __constant_cpu_to_be64(x) __cpu_to_be64(x)
+
+static inline void __le16_to_cpus(__u16 *p)
+{
+#ifdef __BIG_ENDIAN
+        __swab16s(p);
+#endif
+}
+
+static inline void __cpu_to_le16s(__u16 *p)
+{
+#ifdef __BIG_ENDIAN
+        __swab16s(p);
+#endif
+}
+
+static inline void __le32_to_cpus(__u32 *p)
+{
+#ifdef __BIG_ENDIAN
+        __swab32s(p);
+#endif
+}
+
+static inline void __cpu_to_le32s(__u32 *p)
+{
+#ifdef __BIG_ENDIAN
+        __swab32s(p);
+#endif
+}
+
+static inline void __le64_to_cpus(__u64 *p)
+{
+#ifdef __BIG_ENDIAN
+        __swab64s(p);
+#endif
+}
+
+static inline void __cpu_to_le64s(__u64 *p)
+{
+#ifdef __BIG_ENDIAN
+        __swab64s(p);
+#endif
+}
+
+static inline void __be16_to_cpus(__u16 *p)
+{
+#ifdef __LITTLE_ENDIAN
+        __swab16s(p);
+#endif
+}
+
+static inline void __cpu_to_be16s(__u16 *p)
+{
+#ifdef __LITTLE_ENDIAN
+        __swab16s(p);
+#endif
+}
+
+static inline void __be32_to_cpus(__u32 *p)
+{
+#ifdef __LITTLE_ENDIAN
+        __swab32s(p);
+#endif
+}
+
+static inline void __cpu_to_be32s(__u32 *p)
+{
+#ifdef __LITTLE_ENDIAN
+        __swab32s(p);
+#endif
+}
+
+static inline void __be64_to_cpus(__u64 *p)
+{
+#ifdef __LITTLE_ENDIAN
+        __swab64s(p);
+#endif
+}
+
+static inline void __cpu_to_be64s(__u64 *p)
+{
+#ifdef __LITTLE_ENDIAN
+        __swab64s(p);
+#endif
+}
+
+static inline __u16 __le16_to_cpup(const __le16 *p)
+{
+#ifdef __LITTLE_ENDIAN
+        return (__force __u16)*p;
+#else
+        return __swab16p((__force __u16 *)p);
+#endif
+}
+
+static inline __u32 __le32_to_cpup(const __le32 *p)
+{
+#ifdef __LITTLE_ENDIAN
+        return (__force __u32)*p;
+#else
+        return __swab32p((__force __u32 *)p);
+#endif
+}
+
+static inline __u64 __le64_to_cpup(const __le64 *p)
+{
+#ifdef __LITTLE_ENDIAN
+        return (__force __u64)*p;
+#else
+        return __swab64p((__force __u64 *)p);
+#endif
+}
+
+static inline __le16 __cpu_to_le16p(const __u16 *p)
+{
+#ifdef __LITTLE_ENDIAN
+        return (__force __le16)*p;
+#else
+        return (__force __le16)__swab16p(p);
+#endif
+}
+
+static inline __le32 __cpu_to_le32p(const __u32 *p)
+{
+#ifdef __LITTLE_ENDIAN
+        return (__force __le32)*p;
+#else
+        return (__force __le32)__swab32p(p);
+#endif
+}
+
+static inline __le64 __cpu_to_le64p(const __u64 *p)
+{
+#ifdef __LITTLE_ENDIAN
+        return (__force __le64)*p;
+#else
+        return (__force __le64)__swab64p(p);
+#endif
+}
+
+static inline __u16 __be16_to_cpup(const __be16 *p)
+{
+#ifdef __BIG_ENDIAN
+        return (__force __u16)*p;
+#else
+        return __swab16p((__force __u16 *)p);
+#endif
+}
+
+static inline __u32 __be32_to_cpup(const __be32 *p)
+{
+#ifdef __BIG_ENDIAN
+        return (__force __u32)*p;
+#else
+        return __swab32p((__force __u32 *)p);
+#endif
+}
+
+static inline __u64 __be64_to_cpup(const __be64 *p)
+{
+#ifdef __BIG_ENDIAN
+        return (__force __u64)*p;
+#else
+        return __swab64p((__force __u64 *)p);
+#endif
+}
+
+static inline __be16 __cpu_to_be16p(const __u16 *p)
+{
+#ifdef __BIG_ENDIAN
+        return (__force __be16)*p;
+#else
+        return (__force __be16)__swab16p(p);
+#endif
+}
+
+static inline __be32 __cpu_to_be32p(const __u32 *p)
+{
+#ifdef __BIG_ENDIAN
+        return (__force __be32)*p;
+#else
+        return (__force __be32)__swab32p(p);
+#endif
+}
+
+static inline __be64 __cpu_to_be64p(const __u64 *p)
+{
+#ifdef __BIG_ENDIAN
+        return (__force __be64)*p;
+#else
+        return (__force __be64)__swab64p(p);
+#endif
+}
+
+#ifdef __KERNEL__
+
+# define le16_to_cpu __le16_to_cpu
+# define le32_to_cpu __le32_to_cpu
+# define le64_to_cpu __le64_to_cpu
+# define be16_to_cpu __be16_to_cpu
+# define be32_to_cpu __be32_to_cpu
+# define be64_to_cpu __be64_to_cpu
+# define cpu_to_le16 __cpu_to_le16
+# define cpu_to_le32 __cpu_to_le32
+# define cpu_to_le64 __cpu_to_le64
+# define cpu_to_be16 __cpu_to_be16
+# define cpu_to_be32 __cpu_to_be32
+# define cpu_to_be64 __cpu_to_be64
+
+# define le16_to_cpup __le16_to_cpup
+# define le32_to_cpup __le32_to_cpup
+# define le64_to_cpup __le64_to_cpup
+# define be16_to_cpup __be16_to_cpup
+# define be32_to_cpup __be32_to_cpup
+# define be64_to_cpup __be64_to_cpup
+# define cpu_to_le16p __cpu_to_le16p
+# define cpu_to_le32p __cpu_to_le32p
+# define cpu_to_le64p __cpu_to_le64p
+# define cpu_to_be16p __cpu_to_be16p
+# define cpu_to_be32p __cpu_to_be32p
+# define cpu_to_be64p __cpu_to_be64p
+
+# define le16_to_cpus __le16_to_cpus
+# define le32_to_cpus __le32_to_cpus
+# define le64_to_cpus __le64_to_cpus
+# define be16_to_cpus __be16_to_cpus
+# define be32_to_cpus __be32_to_cpus
+# define be64_to_cpus __be64_to_cpus
+# define cpu_to_le16s __cpu_to_le16s
+# define cpu_to_le32s __cpu_to_le32s
+# define cpu_to_le64s __cpu_to_le64s
+# define cpu_to_be16s __cpu_to_be16s
+# define cpu_to_be32s __cpu_to_be32s
+# define cpu_to_be64s __cpu_to_be64s
+
+/*
+ * They have to be macros in order to do the constant folding
+ * correctly - if the argument passed into a inline function
+ * it is no longer constant according to gcc..
+ */
+# undef ntohl
+# undef ntohs
+# undef htonl
+# undef htons
+
+# define ___htonl(x) __cpu_to_be32(x)
+# define ___htons(x) __cpu_to_be16(x)
+# define ___ntohl(x) __be32_to_cpu(x)
+# define ___ntohs(x) __be16_to_cpu(x)
+
+# define htonl(x) ___htonl(x)
+# define ntohl(x) ___ntohl(x)
+# define htons(x) ___htons(x)
+# define ntohs(x) ___ntohs(x)
+
+static inline void le16_add_cpu(__le16 *var, u16 val)
+{
+        *var = cpu_to_le16(le16_to_cpup(var) + val);
+}
+
+static inline void le32_add_cpu(__le32 *var, u32 val)
+{
+        *var = cpu_to_le32(le32_to_cpup(var) + val);
+}
+
+static inline void le64_add_cpu(__le64 *var, u64 val)
+{
+        *var = cpu_to_le64(le64_to_cpup(var) + val);
+}
+
+static inline void be16_add_cpu(__be16 *var, u16 val)
+{
+        *var = cpu_to_be16(be16_to_cpup(var) + val);
+}
+
+static inline void be32_add_cpu(__be32 *var, u32 val)
+{
+        *var = cpu_to_be32(be32_to_cpup(var) + val);
+}
+
+static inline void be64_add_cpu(__be64 *var, u64 val)
+{
+        *var = cpu_to_be64(be64_to_cpup(var) + val);
+}
+
+#endif /* __KERNEL__ */
+#endif /* _LINUX_BYTEORDER_H */
diff --git a/include/linux/capability.h b/include/linux/capability.h
index 02673846d205..9d1fe30b6f6c 100644
--- a/include/linux/capability.h
+++ b/include/linux/capability.h
@@ -503,8 +503,19 @@ extern const kernel_cap_t __cap_init_eff_set;
 
 kernel_cap_t cap_set_effective(const kernel_cap_t pE_new);
 
-int capable(int cap);
-int __capable(struct task_struct *t, int cap);
+/**
+ * has_capability - Determine if a task has a superior capability available
+ * @t: The task in question
+ * @cap: The capability to be tested for
+ *
+ * Return true if the specified task has the given superior capability
+ * currently in effect, false if not.
+ *
+ * Note that this does not set PF_SUPERPRIV on the task.
+ */
+#define has_capability(t, cap) (security_capable((t), (cap)) == 0)
+
+extern int capable(int cap);
 
 #endif /* __KERNEL__ */
 
diff --git a/include/linux/coda_linux.h b/include/linux/coda_linux.h
index 31b75311e2ca..dcc228aa335a 100644
--- a/include/linux/coda_linux.h
+++ b/include/linux/coda_linux.h
@@ -37,7 +37,7 @@ extern const struct file_operations coda_ioctl_operations;
 /* operations shared over more than one file */
 int coda_open(struct inode *i, struct file *f);
 int coda_release(struct inode *i, struct file *f);
-int coda_permission(struct inode *inode, int mask, struct nameidata *nd);
+int coda_permission(struct inode *inode, int mask);
 int coda_revalidate_inode(struct dentry *);
 int coda_getattr(struct vfsmount *, struct dentry *, struct kstat *);
 int coda_setattr(struct dentry *, struct iattr *);
diff --git a/include/linux/completion.h b/include/linux/completion.h
index d2961b66d53d..02ef8835999c 100644
--- a/include/linux/completion.h
+++ b/include/linux/completion.h
@@ -49,10 +49,13 @@ extern unsigned long wait_for_completion_timeout(struct completion *x,
                                                    unsigned long timeout);
 extern unsigned long wait_for_completion_interruptible_timeout(
                         struct completion *x, unsigned long timeout);
+extern bool try_wait_for_completion(struct completion *x);
+extern bool completion_done(struct completion *x);
 
 extern void complete(struct completion *);
 extern void complete_all(struct completion *);
 
 #define INIT_COMPLETION(x)      ((x).done = 0)
 
+
 #endif
diff --git a/include/linux/configfs.h b/include/linux/configfs.h
index d62c19ff041c..7f627775c947 100644
--- a/include/linux/configfs.h
+++ b/include/linux/configfs.h
@@ -40,6 +40,7 @@
 #include <linux/list.h>
 #include <linux/kref.h>
 #include <linux/mutex.h>
+#include <linux/err.h>
 
 #include <asm/atomic.h>
 
@@ -129,8 +130,25 @@ struct configfs_attribute {
 /*
  * Users often need to create attribute structures for their configurable
  * attributes, containing a configfs_attribute member and function pointers
- * for the show() and store() operations on that attribute. They can use
- * this macro (similar to sysfs' __ATTR) to make defining attributes easier.
+ * for the show() and store() operations on that attribute. If they don't
+ * need anything else on the extended attribute structure, they can use
+ * this macro to define it  The argument _item is the name of the
+ * config_item structure.
+ */
+#define CONFIGFS_ATTR_STRUCT(_item)                                     \
+struct _item##_attribute {                                              \
+        struct configfs_attribute attr;                                 \
+        ssize_t (*show)(struct _item *, char *);                        \
+        ssize_t (*store)(struct _item *, const char *, size_t);         \
+}
+
+/*
+ * With the extended attribute structure, users can use this macro
+ * (similar to sysfs' __ATTR) to make defining attributes easier.
+ * An example:
+ * #define MYITEM_ATTR(_name, _mode, _show, _store)     \
+ * struct myitem_attribute childless_attr_##_name =     \
+ *         __CONFIGFS_ATTR(_name, _mode, _show, _store)
  */
 #define __CONFIGFS_ATTR(_name, _mode, _show, _store)                    \
 {                                                                       \
@@ -142,6 +160,52 @@ struct configfs_attribute {
         .show   = _show,                                                \
         .store  = _store,                                               \
 }
+/* Here is a readonly version, only requiring a show() operation */
+#define __CONFIGFS_ATTR_RO(_name, _show)                                \
+{                                                                       \
+        .attr   = {                                                     \
+                        .ca_name = __stringify(_name),                  \
+                        .ca_mode = 0444,                                \
+                        .ca_owner = THIS_MODULE,                        \
+        },                                                              \
+        .show   = _show,                                                \
+}
+
+/*
+ * With these extended attributes, the simple show_attribute() and
+ * store_attribute() operations need to call the show() and store() of the
+ * attributes.  This is a common pattern, so we provide a macro to define
+ * them.  The argument _item is the name of the config_item structure.
+ * This macro expects the attributes to be named "struct <name>_attribute"
+ * and the function to_<name>() to exist;
+ */
+#define CONFIGFS_ATTR_OPS(_item)                                        \
+static ssize_t _item##_attr_show(struct config_item *item,              \
+                                 struct configfs_attribute *attr,       \
+                                 char *page)                            \
+{                                                                       \
+        struct _item *_item = to_##_item(item);                         \
+        struct _item##_attribute *_item##_attr =                        \
+                container_of(attr, struct _item##_attribute, attr);     \
+        ssize_t ret = 0;                                                \
+                                                                        \
+        if (_item##_attr->show)                                         \
+                ret = _item##_attr->show(_item, page);                  \
+        return ret;                                                     \
+}                                                                       \
+static ssize_t _item##_attr_store(struct config_item *item,             \
+                                  struct configfs_attribute *attr,      \
+                                  const char *page, size_t count)       \
+{                                                                       \
+        struct _item *_item = to_##_item(item);                         \
+        struct _item##_attribute *_item##_attr =                        \
+                container_of(attr, struct _item##_attribute, attr);     \
+        ssize_t ret = -EINVAL;                                          \
+                                                                        \
+        if (_item##_attr->store)                                        \
+                ret = _item##_attr->store(_item, page, count);          \
+        return ret;                                                     \
+}
 
 /*
  * If allow_link() exists, the item can symlink(2) out to other
diff --git a/include/linux/connector.h b/include/linux/connector.h
index 96a89d3d6727..5c7f9468f753 100644
--- a/include/linux/connector.h
+++ b/include/linux/connector.h
@@ -38,8 +38,9 @@
 #define CN_W1_VAL                       0x1
 #define CN_IDX_V86D                     0x4
 #define CN_VAL_V86D_UVESAFB             0x1
+#define CN_IDX_BB                       0x5     /* BlackBoard, from the TSP GPL sampling framework */
 
-#define CN_NETLINK_USERS                5
+#define CN_NETLINK_USERS                6
 
 /*
  * Maximum connector's message size.
diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h
index 2270ca5ec631..6fd5668aa572 100644
--- a/include/linux/cpufreq.h
+++ b/include/linux/cpufreq.h
@@ -106,6 +106,7 @@ struct cpufreq_policy {
 #define CPUFREQ_ADJUST          (0)
 #define CPUFREQ_INCOMPATIBLE    (1)
 #define CPUFREQ_NOTIFY          (2)
+#define CPUFREQ_START           (3)
 
 #define CPUFREQ_SHARED_TYPE_NONE (0) /* None */
 #define CPUFREQ_SHARED_TYPE_HW   (1) /* HW does needed coordination */
diff --git a/include/linux/cpumask.h b/include/linux/cpumask.h
index 1b5c98e7fef7..d3219d73f8e6 100644
--- a/include/linux/cpumask.h
+++ b/include/linux/cpumask.h
@@ -62,15 +62,7 @@
  * int next_cpu_nr(cpu, mask)           Next cpu past 'cpu', or nr_cpu_ids
  *
  * cpumask_t cpumask_of_cpu(cpu)        Return cpumask with bit 'cpu' set
- *ifdef CONFIG_HAS_CPUMASK_OF_CPU
- * cpumask_of_cpu_ptr_declare(v)        Declares cpumask_t *v
- * cpumask_of_cpu_ptr_next(v, cpu)      Sets v = &cpumask_of_cpu_map[cpu]
- * cpumask_of_cpu_ptr(v, cpu)           Combines above two operations
- *else
- * cpumask_of_cpu_ptr_declare(v)        Declares cpumask_t _v and *v = &_v
- * cpumask_of_cpu_ptr_next(v, cpu)      Sets _v = cpumask_of_cpu(cpu)
- * cpumask_of_cpu_ptr(v, cpu)           Combines above two operations
- *endif
+ *                                      (can be used as an lvalue)
  * CPU_MASK_ALL                         Initializer - all bits set
  * CPU_MASK_NONE                        Initializer - no bits set
  * unsigned long *cpus_addr(mask)       Array of unsigned long's in mask
@@ -273,37 +265,30 @@ static inline void __cpus_shift_left(cpumask_t *dstp,
         bitmap_shift_left(dstp->bits, srcp->bits, n, nbits);
 }
 
+/*
+ * Special-case data structure for "single bit set only" constant CPU masks.
+ *
+ * We pre-generate all the 64 (or 32) possible bit positions, with enough
+ * padding to the left and the right, and return the constant pointer
+ * appropriately offset.
+ */
+extern const unsigned long
+        cpu_bit_bitmap[BITS_PER_LONG+1][BITS_TO_LONGS(NR_CPUS)];
+
+static inline const cpumask_t *get_cpu_mask(unsigned int cpu)
+{
+        const unsigned long *p = cpu_bit_bitmap[1 + cpu % BITS_PER_LONG];
+        p -= cpu / BITS_PER_LONG;
+        return (const cpumask_t *)p;
+}
+
+/*
+ * In cases where we take the address of the cpumask immediately,
+ * gcc optimizes it out (it's a constant) and there's no huge stack
+ * variable created:
+ */
+#define cpumask_of_cpu(cpu) (*get_cpu_mask(cpu))
 
-#ifdef CONFIG_HAVE_CPUMASK_OF_CPU_MAP
-extern cpumask_t *cpumask_of_cpu_map;
-#define cpumask_of_cpu(cpu)     (cpumask_of_cpu_map[cpu])
-#define cpumask_of_cpu_ptr(v, cpu)                                      \
-                const cpumask_t *v = &cpumask_of_cpu(cpu)
-#define cpumask_of_cpu_ptr_declare(v)                                   \
-                const cpumask_t *v
-#define cpumask_of_cpu_ptr_next(v, cpu)                                 \
-                                        v = &cpumask_of_cpu(cpu)
-#else
-#define cpumask_of_cpu(cpu)                                             \
-({                                                                      \
-        typeof(_unused_cpumask_arg_) m;                                 \
-        if (sizeof(m) == sizeof(unsigned long)) {                       \
-                m.bits[0] = 1UL<<(cpu);                                 \
-        } else {                                                        \
-                cpus_clear(m);                                          \
-                cpu_set((cpu), m);                                      \
-        }                                                               \
-        m;                                                              \
-})
-#define cpumask_of_cpu_ptr(v, cpu)                                      \
-                cpumask_t _##v = cpumask_of_cpu(cpu);                   \
-                const cpumask_t *v = &_##v
-#define cpumask_of_cpu_ptr_declare(v)                                   \
-                cpumask_t _##v;                                         \
-                const cpumask_t *v = &_##v
-#define cpumask_of_cpu_ptr_next(v, cpu)                                 \
-                                        _##v = cpumask_of_cpu(cpu)
-#endif
 
 #define CPU_MASK_LAST_WORD BITMAP_LAST_WORD_MASK(NR_CPUS)
 
diff --git a/include/linux/crash_dump.h b/include/linux/crash_dump.h
index 6cd39a927e1f..025e4f575103 100644
--- a/include/linux/crash_dump.h
+++ b/include/linux/crash_dump.h
@@ -8,7 +8,13 @@
 #include <linux/proc_fs.h>
 
 #define ELFCORE_ADDR_MAX        (-1ULL)
+
+#ifdef CONFIG_PROC_VMCORE
 extern unsigned long long elfcorehdr_addr;
+#else
+static const unsigned long long elfcorehdr_addr = ELFCORE_ADDR_MAX;
+#endif
+
 extern ssize_t copy_oldmem_page(unsigned long, char *, size_t,
                                                 unsigned long, int);
 extern const struct file_operations proc_vmcore_operations;
diff --git a/include/linux/cred.h b/include/linux/cred.h
new file mode 100644
index 000000000000..b69222cc1fd2
--- /dev/null
+++ b/include/linux/cred.h
@@ -0,0 +1,50 @@
+/* Credentials management
+ *
+ * Copyright (C) 2008 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public Licence
+ * as published by the Free Software Foundation; either version
+ * 2 of the Licence, or (at your option) any later version.
+ */
+
+#ifndef _LINUX_CRED_H
+#define _LINUX_CRED_H
+
+#define get_current_user()      (get_uid(current->user))
+
+#define task_uid(task)          ((task)->uid)
+#define task_gid(task)          ((task)->gid)
+#define task_euid(task)         ((task)->euid)
+#define task_egid(task)         ((task)->egid)
+
+#define current_uid()           (current->uid)
+#define current_gid()           (current->gid)
+#define current_euid()          (current->euid)
+#define current_egid()          (current->egid)
+#define current_suid()          (current->suid)
+#define current_sgid()          (current->sgid)
+#define current_fsuid()         (current->fsuid)
+#define current_fsgid()         (current->fsgid)
+#define current_cap()           (current->cap_effective)
+
+#define current_uid_gid(_uid, _gid)             \
+do {                                            \
+        *(_uid) = current->uid;                 \
+        *(_gid) = current->gid;                 \
+} while(0)
+
+#define current_euid_egid(_uid, _gid)           \
+do {                                            \
+        *(_uid) = current->euid;                \
+        *(_gid) = current->egid;                \
+} while(0)
+
+#define current_fsuid_fsgid(_uid, _gid)         \
+do {                                            \
+        *(_uid) = current->fsuid;               \
+        *(_gid) = current->fsgid;               \
+} while(0)
+
+#endif /* _LINUX_CRED_H */
diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index 98202c672fde..07aa198f19ed 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -230,6 +230,7 @@ extern void d_delete(struct dentry *);
 extern struct dentry * d_alloc(struct dentry *, const struct qstr *);
 extern struct dentry * d_alloc_anon(struct inode *);
 extern struct dentry * d_splice_alias(struct inode *, struct dentry *);
+extern struct dentry * d_add_ci(struct inode *, struct dentry *, struct qstr *);
 extern void shrink_dcache_sb(struct super_block *);
 extern void shrink_dcache_parent(struct dentry *);
 extern void shrink_dcache_for_umount(struct super_block *);
diff --git a/include/linux/dm9000.h b/include/linux/dm9000.h
index fc82446b6425..c30879cf93bc 100644
--- a/include/linux/dm9000.h
+++ b/include/linux/dm9000.h
@@ -27,6 +27,7 @@
 
 struct dm9000_plat_data {
         unsigned int    flags;
+        unsigned char   dev_addr[6];
 
         /* allow replacement IO routines */
 
diff --git a/include/linux/ethtool.h b/include/linux/ethtool.h
index 8bb5e87df365..b4b038b89ee6 100644
--- a/include/linux/ethtool.h
+++ b/include/linux/ethtool.h
@@ -27,9 +27,24 @@ struct ethtool_cmd {
         __u8    autoneg;        /* Enable or disable autonegotiation */
         __u32   maxtxpkt;       /* Tx pkts before generating tx int */
         __u32   maxrxpkt;       /* Rx pkts before generating rx int */
-        __u32   reserved[4];
+        __u16   speed_hi;
+        __u16   reserved2;
+        __u32   reserved[3];
 };
 
+static inline void ethtool_cmd_speed_set(struct ethtool_cmd *ep,
+                                                __u32 speed)
+{
+
+        ep->speed = (__u16)speed;
+        ep->speed_hi = (__u16)(speed >> 16);
+}
+
+static inline __u32 ethtool_cmd_speed(struct ethtool_cmd *ep)
+{
+        return (ep->speed_hi << 16) | ep->speed;
+}
+
 #define ETHTOOL_BUSINFO_LEN     32
 /* these strings are set to whatever the driver author decides... */
 struct ethtool_drvinfo {
diff --git a/include/linux/file.h b/include/linux/file.h
index 27c64bdc68c9..a20259e248a5 100644
--- a/include/linux/file.h
+++ b/include/linux/file.h
@@ -34,8 +34,9 @@ extern struct file *fget(unsigned int fd);
 extern struct file *fget_light(unsigned int fd, int *fput_needed);
 extern void set_close_on_exec(unsigned int fd, int flag);
 extern void put_filp(struct file *);
+extern int alloc_fd(unsigned start, unsigned flags);
 extern int get_unused_fd(void);
-extern int get_unused_fd_flags(int flags);
+#define get_unused_fd_flags(flags) alloc_fd(0, (flags))
 extern void put_unused_fd(unsigned int fd);
 
 extern void fd_install(unsigned int fd, struct file *file);
diff --git a/include/linux/firmware-map.h b/include/linux/firmware-map.h
index acbdbcc16051..6e199c8dfacc 100644
--- a/include/linux/firmware-map.h
+++ b/include/linux/firmware-map.h
@@ -24,34 +24,8 @@
  */
 #ifdef CONFIG_FIRMWARE_MEMMAP
 
-/**
- * Adds a firmware mapping entry. This function uses kmalloc() for memory
- * allocation. Use firmware_map_add_early() if you want to use the bootmem
- * allocator.
- *
- * That function must be called before late_initcall.
- *
- * @start: Start of the memory range.
- * @end:   End of the memory range (inclusive).
- * @type:  Type of the memory range.
- *
- * Returns 0 on success, or -ENOMEM if no memory could be allocated.
- */
 int firmware_map_add(resource_size_t start, resource_size_t end,
                      const char *type);
-
-/**
- * Adds a firmware mapping entry. This function uses the bootmem allocator
- * for memory allocation. Use firmware_map_add() if you want to use kmalloc().
- *
- * That function must be called before late_initcall.
- *
- * @start: Start of the memory range.
- * @end:   End of the memory range (inclusive).
- * @type:  Type of the memory range.
- *
- * Returns 0 on success, or -ENOMEM if no memory could be allocated.
- */
 int firmware_map_add_early(resource_size_t start, resource_size_t end,
                            const char *type);
 
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 49d8eb7a71be..580b513668fe 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -60,6 +60,8 @@ extern int dir_notify_enable;
 #define MAY_WRITE 2
 #define MAY_READ 4
 #define MAY_APPEND 8
+#define MAY_ACCESS 16
+#define MAY_OPEN 32
 
 #define FMODE_READ 1
 #define FMODE_WRITE 2
@@ -277,7 +279,7 @@ extern int dir_notify_enable;
 #include <linux/types.h>
 #include <linux/kdev_t.h>
 #include <linux/dcache.h>
-#include <linux/namei.h>
+#include <linux/path.h>
 #include <linux/stat.h>
 #include <linux/cache.h>
 #include <linux/kobject.h>
@@ -318,22 +320,23 @@ typedef void (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
  * Attribute flags.  These should be or-ed together to figure out what
  * has been changed!
  */
-#define ATTR_MODE       1
-#define ATTR_UID        2
-#define ATTR_GID        4
-#define ATTR_SIZE       8
-#define ATTR_ATIME      16
-#define ATTR_MTIME      32
-#define ATTR_CTIME      64
-#define ATTR_ATIME_SET  128
-#define ATTR_MTIME_SET  256
-#define ATTR_FORCE      512     /* Not a change, but a change it */
-#define ATTR_ATTR_FLAG  1024
-#define ATTR_KILL_SUID  2048
-#define ATTR_KILL_SGID  4096
-#define ATTR_FILE       8192
-#define ATTR_KILL_PRIV  16384
-#define ATTR_OPEN       32768   /* Truncating from open(O_TRUNC) */
+#define ATTR_MODE       (1 << 0)
+#define ATTR_UID        (1 << 1)
+#define ATTR_GID        (1 << 2)
+#define ATTR_SIZE       (1 << 3)
+#define ATTR_ATIME      (1 << 4)
+#define ATTR_MTIME      (1 << 5)
+#define ATTR_CTIME      (1 << 6)
+#define ATTR_ATIME_SET  (1 << 7)
+#define ATTR_MTIME_SET  (1 << 8)
+#define ATTR_FORCE      (1 << 9) /* Not a change, but a change it */
+#define ATTR_ATTR_FLAG  (1 << 10)
+#define ATTR_KILL_SUID  (1 << 11)
+#define ATTR_KILL_SGID  (1 << 12)
+#define ATTR_FILE       (1 << 13)
+#define ATTR_KILL_PRIV  (1 << 14)
+#define ATTR_OPEN       (1 << 15) /* Truncating from open(O_TRUNC) */
+#define ATTR_TIMES_SET  (1 << 16)
 
 /*
  * This is the Inode Attributes structure, used for notify_change().  It
@@ -440,6 +443,27 @@ static inline size_t iov_iter_count(struct iov_iter *i)
         return i->count;
 }
 
+/*
+ * "descriptor" for what we're up to with a read.
+ * This allows us to use the same read code yet
+ * have multiple different users of the data that
+ * we read from a file.
+ *
+ * The simplest case just copies the data to user
+ * mode.
+ */
+typedef struct {
+        size_t written;
+        size_t count;
+        union {
+                char __user *buf;
+                void *data;
+        } arg;
+        int error;
+} read_descriptor_t;
+
+typedef int (*read_actor_t)(read_descriptor_t *, struct page *,
+                unsigned long, unsigned long);
 
 struct address_space_operations {
         int (*writepage)(struct page *page, struct writeback_control *wbc);
@@ -481,6 +505,8 @@ struct address_space_operations {
         int (*migratepage) (struct address_space *,
                         struct page *, struct page *);
         int (*launder_page) (struct page *);
+        int (*is_partially_uptodate) (struct page *, read_descriptor_t *,
+                                        unsigned long);
 };
 
 /*
@@ -499,7 +525,7 @@ struct backing_dev_info;
 struct address_space {
         struct inode            *host;          /* owner: inode, block_device */
         struct radix_tree_root  page_tree;      /* radix tree of all pages */
-        rwlock_t                tree_lock;      /* and rwlock protecting it */
+        spinlock_t              tree_lock;      /* and lock protecting it */
         unsigned int            i_mmap_writable;/* count VM_SHARED mappings */
         struct prio_tree_root   i_mmap;         /* tree of private and shared mappings */
         struct list_head        i_mmap_nonlinear;/*list VM_NONLINEAR mappings */
@@ -792,7 +818,7 @@ struct file {
 #define f_dentry        f_path.dentry
 #define f_vfsmnt        f_path.mnt
         const struct file_operations    *f_op;
-        atomic_t                f_count;
+        atomic_long_t           f_count;
         unsigned int            f_flags;
         mode_t                  f_mode;
         loff_t                  f_pos;
@@ -821,8 +847,8 @@ extern spinlock_t files_lock;
 #define file_list_lock() spin_lock(&files_lock);
 #define file_list_unlock() spin_unlock(&files_lock);
 
-#define get_file(x)     atomic_inc(&(x)->f_count)
-#define file_count(x)   atomic_read(&(x)->f_count)
+#define get_file(x)     atomic_long_inc(&(x)->f_count)
+#define file_count(x)   atomic_long_read(&(x)->f_count)
 
 #ifdef CONFIG_DEBUG_WRITECOUNT
 static inline void file_take_write(struct file *f)
@@ -1136,7 +1162,7 @@ extern int vfs_permission(struct nameidata *, int);
 extern int vfs_create(struct inode *, struct dentry *, int, struct nameidata *);
 extern int vfs_mkdir(struct inode *, struct dentry *, int);
 extern int vfs_mknod(struct inode *, struct dentry *, int, dev_t);
-extern int vfs_symlink(struct inode *, struct dentry *, const char *, int);
+extern int vfs_symlink(struct inode *, struct dentry *, const char *);
 extern int vfs_link(struct dentry *, struct inode *, struct dentry *);
 extern int vfs_rmdir(struct inode *, struct dentry *);
 extern int vfs_unlink(struct inode *, struct dentry *);
@@ -1195,27 +1221,6 @@ struct block_device_operations {
         struct module *owner;
 };
 
-/*
- * "descriptor" for what we're up to with a read.
- * This allows us to use the same read code yet
- * have multiple different users of the data that
- * we read from a file.
- *
- * The simplest case just copies the data to user
- * mode.
- */
-typedef struct {
-        size_t written;
-        size_t count;
-        union {
-                char __user * buf;
-                void *data;
-        } arg;
-        int error;
-} read_descriptor_t;
-
-typedef int (*read_actor_t)(read_descriptor_t *, struct page *, unsigned long, unsigned long);
-
 /* These macros are for out of kernel modules to test that
  * the kernel supports the unlocked_ioctl and compat_ioctl
  * fields in struct file_operations. */
@@ -1272,7 +1277,7 @@ struct inode_operations {
         void * (*follow_link) (struct dentry *, struct nameidata *);
         void (*put_link) (struct dentry *, struct nameidata *, void *);
         void (*truncate) (struct inode *);
-        int (*permission) (struct inode *, int, struct nameidata *);
+        int (*permission) (struct inode *, int);
         int (*setattr) (struct dentry *, struct iattr *);
         int (*getattr) (struct vfsmount *mnt, struct dentry *, struct kstat *);
         int (*setxattr) (struct dentry *, const char *,const void *,size_t,int);
@@ -1696,9 +1701,9 @@ extern void init_special_inode(struct inode *, umode_t, dev_t);
 extern void make_bad_inode(struct inode *);
 extern int is_bad_inode(struct inode *);
 
-extern const struct file_operations read_fifo_fops;
-extern const struct file_operations write_fifo_fops;
-extern const struct file_operations rdwr_fifo_fops;
+extern const struct file_operations read_pipefifo_fops;
+extern const struct file_operations write_pipefifo_fops;
+extern const struct file_operations rdwr_pipefifo_fops;
 
 extern int fs_may_remount_ro(struct super_block *);
 
@@ -1767,7 +1772,7 @@ extern int do_remount_sb(struct super_block *sb, int flags,
 extern sector_t bmap(struct inode *, sector_t);
 #endif
 extern int notify_change(struct dentry *, struct iattr *);
-extern int permission(struct inode *, int, struct nameidata *);
+extern int inode_permission(struct inode *, int);
 extern int generic_permission(struct inode *, int,
                 int (*check_acl)(struct inode *, int));
 
@@ -1831,7 +1836,7 @@ extern void clear_inode(struct inode *);
 extern void destroy_inode(struct inode *);
 extern struct inode *new_inode(struct super_block *);
 extern int should_remove_suid(struct dentry *);
-extern int remove_suid(struct dentry *);
+extern int file_remove_suid(struct file *);
 
 extern void __insert_inode_hash(struct inode *, unsigned long hashval);
 extern void remove_inode_hash(struct inode *);
diff --git a/include/linux/fs_struct.h b/include/linux/fs_struct.h
index 282f54219129..9e5a06e78d02 100644
--- a/include/linux/fs_struct.h
+++ b/include/linux/fs_struct.h
@@ -7,7 +7,7 @@ struct fs_struct {
         atomic_t count;
         rwlock_t lock;
         int umask;
-        struct path root, pwd, altroot;
+        struct path root, pwd;
 };
 
 #define INIT_FS {                               \
@@ -19,7 +19,6 @@ struct fs_struct {
 extern struct kmem_cache *fs_cachep;
 
 extern void exit_fs(struct task_struct *);
-extern void set_fs_altroot(void);
 extern void set_fs_root(struct fs_struct *, struct path *);
 extern void set_fs_pwd(struct fs_struct *, struct path *);
 extern struct fs_struct *copy_fs_struct(struct fs_struct *);
diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h
index f368d041e02d..bb384068272e 100644
--- a/include/linux/ftrace.h
+++ b/include/linux/ftrace.h
@@ -98,6 +98,27 @@ static inline void tracer_disable(void)
 #endif
 }
 
+/* Ftrace disable/restore without lock. Some synchronization mechanism
+ * must be used to prevent ftrace_enabled to be changed between
+ * disable/restore. */
+static inline int __ftrace_enabled_save(void)
+{
+#ifdef CONFIG_FTRACE
+        int saved_ftrace_enabled = ftrace_enabled;
+        ftrace_enabled = 0;
+        return saved_ftrace_enabled;
+#else
+        return 0;
+#endif
+}
+
+static inline void __ftrace_enabled_restore(int enabled)
+{
+#ifdef CONFIG_FTRACE
+        ftrace_enabled = enabled;
+#endif
+}
+
 #ifdef CONFIG_FRAME_POINTER
 /* TODO: need to fix this for ARM */
 # define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
diff --git a/include/linux/harrier_defs.h b/include/linux/harrier_defs.h
deleted file mode 100644
index efef11db790f..000000000000
--- a/include/linux/harrier_defs.h
+++ /dev/null
@@ -1,212 +0,0 @@
-/*
- * include/linux/harrier_defs.h
- *
- * Definitions for Motorola MCG Harrier North Bridge & Memory controller
- *
- * Author: Dale Farnsworth
- *         dale.farnsworth@mvista.com
- *
- * Extracted from asm-ppc/harrier.h by:
- *         Randy Vinson
- *         rvinson@mvista.com
- *
- * Copyright 2001-2002 MontaVista Software Inc.
- *
- * 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.
- */
-
-#ifndef __ASMPPC_HARRIER_DEFS_H
-#define __ASMPPC_HARRIER_DEFS_H
-
-#define HARRIER_DEFAULT_XCSR_BASE       0xfeff0000
-
-#define HARRIER_VEND_DEV_ID             0x1057480b
-
-#define HARRIER_VENI_OFF                0x00
-
-#define HARRIER_REVI_OFF                0x05
-#define HARRIER_UCTL_OFF                0xd0
-#define HARRIER_XTAL64_MASK             0x02
-
-#define HARRIER_MISC_CSR_OFF            0x1c
-#define HARRIER_RSTOUT                  0x01000000
-#define HARRIER_SYSCON                  0x08000000
-#define HARRIER_EREADY                  0x10000000
-#define HARRIER_ERDYS                   0x20000000
-
-/* Function exception registers */
-#define HARRIER_FEEN_OFF                0x40    /* enable */
-#define HARRIER_FEST_OFF                0x44    /* status */
-#define HARRIER_FEMA_OFF                0x48    /* mask */
-#define HARRIER_FECL_OFF                0x4c    /* clear */
-
-#define HARRIER_FE_DMA                  0x80
-#define HARRIER_FE_MIDB                 0x40
-#define HARRIER_FE_MIM0                 0x20
-#define HARRIER_FE_MIM1                 0x10
-#define HARRIER_FE_MIP                  0x08
-#define HARRIER_FE_UA0                  0x04
-#define HARRIER_FE_UA1                  0x02
-#define HARRIER_FE_ABT                  0x01
-
-#define HARRIER_SERIAL_0_OFF            0xc0
-
-#define HARRIER_MBAR_OFF                0xe0
-#define HARRIER_MBAR_MSK                0xfffc0000
-#define HARRIER_MPIC_CSR_OFF            0xe4
-#define HARRIER_MPIC_OPI_ENABLE         0x40
-#define HARRIER_MPIC_IFEVP_OFF          0x10200
-#define HARRIER_MPIC_IFEVP_VECT_MSK     0xff
-#define HARRIER_MPIC_IFEDE_OFF          0x10210
-
-/*
- * Define the Memory Controller register offsets.
- */
-#define HARRIER_SDBA_OFF                0x110
-#define HARRIER_SDBB_OFF                0x114
-#define HARRIER_SDBC_OFF                0x118
-#define HARRIER_SDBD_OFF                0x11c
-#define HARRIER_SDBE_OFF                0x120
-#define HARRIER_SDBF_OFF                0x124
-#define HARRIER_SDBG_OFF                0x128
-#define HARRIER_SDBH_OFF                0x12c
-
-#define HARRIER_SDB_ENABLE              0x00000100
-#define HARRIER_SDB_SIZE_MASK           0xf
-#define HARRIER_SDB_SIZE_SHIFT          16
-#define HARRIER_SDB_BASE_MASK           0xff
-#define HARRIER_SDB_BASE_SHIFT          24
-
-/*
- * Define outbound register offsets.
- */
-#define HARRIER_OTAD0_OFF               0x220
-#define HARRIER_OTOF0_OFF               0x224
-#define HARRIER_OTAD1_OFF               0x228
-#define HARRIER_OTOF1_OFF               0x22c
-#define HARRIER_OTAD2_OFF               0x230
-#define HARRIER_OTOF2_OFF               0x234
-#define HARRIER_OTAD3_OFF               0x238
-#define HARRIER_OTOF3_OFF               0x23c
-
-#define HARRIER_OTADX_START_MSK         0xffff0000UL
-#define HARRIER_OTADX_END_MSK           0x0000ffffUL
-
-#define HARRIER_OTOFX_OFF_MSK           0xffff0000UL
-#define HARRIER_OTOFX_ENA               0x80UL
-#define HARRIER_OTOFX_WPE               0x10UL
-#define HARRIER_OTOFX_SGE               0x08UL
-#define HARRIER_OTOFX_RAE               0x04UL
-#define HARRIER_OTOFX_MEM               0x02UL
-#define HARRIER_OTOFX_IOM               0x01UL
-
-/*
- * Define generic message passing register offsets
- */
-/* Mirrored registers (visible from both PowerPC and PCI space) */
-#define HARRIER_XCSR_MP_BASE_OFF        0x290   /* base offset in XCSR space */
-#define HARRIER_PMEP_MP_BASE_OFF        0x100   /* base offset in PMEM space */
-#define HARRIER_MGOM0_OFF               0x00    /* outbound msg 0 */
-#define HARRIER_MGOM1_OFF               0x04    /* outbound msg 1 */
-#define HARRIER_MGOD_OFF                0x08    /* outbound doorbells */
-
-#define HARRIER_MGIM0_OFF               0x10    /* inbound msg 0 */
-#define HARRIER_MGIM1_OFF               0x14    /* inbound msg 1 */
-#define HARRIER_MGID_OFF                0x18    /* inbound doorbells */
-
-/* PowerPC-only registers */
-#define HARRIER_MGIDM_OFF               0x20    /* inbound doorbell mask */
-
-/* PCI-only registers */
-#define HARRIER_PMEP_MGST_OFF           0x20    /* (outbound) interrupt status */
-#define HARRIER_PMEP_MGMS_OFF           0x24    /* (outbound) interrupt mask */
-#define HARRIER_MG_OMI0                 (1<<4)
-#define HARRIER_MG_OMI1                 (1<<5)
-
-#define HARRIER_PMEP_MGODM_OFF          0x28    /* outbound doorbell mask */
-
-/*
- * Define PCI configuration space register offsets
- */
-#define HARRIER_XCSR_TO_PCFS_OFF        0x300
-
-/*
- * Define message passing attribute register offset
- */
-#define HARRIER_MPAT_OFF                0x44
-
-/*
- * Define inbound attribute register offsets.
- */
-#define HARRIER_ITSZ0_OFF               0x48
-#define HARRIER_ITAT0_OFF               0x4c
-
-#define HARRIER_ITSZ1_OFF               0x50
-#define HARRIER_ITAT1_OFF               0x54
-
-#define HARRIER_ITSZ2_OFF               0x58
-#define HARRIER_ITAT2_OFF               0x5c
-
-#define HARRIER_ITSZ3_OFF               0x60
-#define HARRIER_ITAT3_OFF               0x64
-
-/* inbound translation size constants */
-#define HARRIER_ITSZ_MSK                0xff
-#define HARRIER_ITSZ_4KB                0x00
-#define HARRIER_ITSZ_8KB                0x01
-#define HARRIER_ITSZ_16KB               0x02
-#define HARRIER_ITSZ_32KB               0x03
-#define HARRIER_ITSZ_64KB               0x04
-#define HARRIER_ITSZ_128KB              0x05
-#define HARRIER_ITSZ_256KB              0x06
-#define HARRIER_ITSZ_512KB              0x07
-#define HARRIER_ITSZ_1MB                0x08
-#define HARRIER_ITSZ_2MB                0x09
-#define HARRIER_ITSZ_4MB                0x0A
-#define HARRIER_ITSZ_8MB                0x0B
-#define HARRIER_ITSZ_16MB               0x0C
-#define HARRIER_ITSZ_32MB               0x0D
-#define HARRIER_ITSZ_64MB               0x0E
-#define HARRIER_ITSZ_128MB              0x0F
-#define HARRIER_ITSZ_256MB              0x10
-#define HARRIER_ITSZ_512MB              0x11
-#define HARRIER_ITSZ_1GB                0x12
-#define HARRIER_ITSZ_2GB                0x13
-
-/* inbound translation offset */
-#define HARRIER_ITOF_SHIFT              0x10
-#define HARRIER_ITOF_MSK                0xffff
-
-/* inbound translation atttributes */
-#define HARRIER_ITAT_PRE                (1<<3)
-#define HARRIER_ITAT_RAE                (1<<4)
-#define HARRIER_ITAT_WPE                (1<<5)
-#define HARRIER_ITAT_MEM                (1<<6)
-#define HARRIER_ITAT_ENA                (1<<7)
-#define HARRIER_ITAT_GBL                (1<<16)
-
-#define HARRIER_LBA_OFF                 0x80
-#define HARRIER_LBA_MSK                 (1<<31)
-
-#define HARRIER_XCSR_SIZE               1024
-
-/* macros to calculate message passing register offsets */
-#define HARRIER_MP_XCSR(x) ((u32)HARRIER_XCSR_MP_BASE_OFF + (u32)x)
-
-#define HARRIER_MP_PMEP(x) ((u32)HARRIER_PMEP_MP_BASE_OFF + (u32)x)
-
-/*
- * Define PCI configuration space register offsets
- */
-#define HARRIER_MPBAR_OFF               PCI_BASE_ADDRESS_0
-#define HARRIER_ITBAR0_OFF              PCI_BASE_ADDRESS_1
-#define HARRIER_ITBAR1_OFF              PCI_BASE_ADDRESS_2
-#define HARRIER_ITBAR2_OFF              PCI_BASE_ADDRESS_3
-#define HARRIER_ITBAR3_OFF              PCI_BASE_ADDRESS_4
-
-#define HARRIER_XCSR_CONFIG(x) ((u32)HARRIER_XCSR_TO_PCFS_OFF + (u32)x)
-
-#endif                          /* __ASMPPC_HARRIER_DEFS_H */
diff --git a/include/linux/hugetlb.h b/include/linux/hugetlb.h
index 9a71d4cc88c8..32e0ef0f6e1f 100644
--- a/include/linux/hugetlb.h
+++ b/include/linux/hugetlb.h
@@ -273,7 +273,10 @@ struct hstate {};
 #define huge_page_mask(h) PAGE_MASK
 #define huge_page_order(h) 0
 #define huge_page_shift(h) PAGE_SHIFT
-#define pages_per_huge_page(h) 1
+static inline unsigned int pages_per_huge_page(struct hstate *h)
+{
+        return 1;
+}
 #endif
 
 #endif /* _LINUX_HUGETLB_H */
diff --git a/include/linux/i2c-id.h b/include/linux/i2c-id.h
index 4862398e05bf..bf34c5f4c051 100644
--- a/include/linux/i2c-id.h
+++ b/include/linux/i2c-id.h
@@ -39,7 +39,6 @@
 #define I2C_DRIVERID_SAA7111A    8      /* video input processor        */
 #define I2C_DRIVERID_SAA7185B   13      /* video encoder                */
 #define I2C_DRIVERID_SAA7110    22      /* video decoder                */
-#define I2C_DRIVERID_MGATVO     23      /* Matrox TVOut                 */
 #define I2C_DRIVERID_SAA5249    24      /* SAA5249 and compatibles      */
 #define I2C_DRIVERID_PCF8583    25      /* real time clock              */
 #define I2C_DRIVERID_SAB3036    26      /* SAB3036 tuner                */
@@ -95,7 +94,6 @@
 #define I2C_HW_B_BT848          0x010005 /* BT848 video boards */
 #define I2C_HW_B_VIA            0x010007 /* Via vt82c586b */
 #define I2C_HW_B_HYDRA          0x010008 /* Apple Hydra Mac I/O */
-#define I2C_HW_B_G400           0x010009 /* Matrox G400 */
 #define I2C_HW_B_I810           0x01000a /* Intel I810 */
 #define I2C_HW_B_VOO            0x01000b /* 3dfx Voodoo 3 / Banshee */
 #define I2C_HW_B_SCX200         0x01000e /* Nat'l Semi SCx200 I2C */
diff --git a/include/linux/i2c-pnx.h b/include/linux/i2c-pnx.h
index e6e9c814da61..f13255e06406 100644
--- a/include/linux/i2c-pnx.h
+++ b/include/linux/i2c-pnx.h
@@ -12,7 +12,9 @@
 #ifndef __I2C_PNX_H__
 #define __I2C_PNX_H__
 
-#include <asm/arch/i2c.h>
+#include <linux/pm.h>
+
+struct platform_device;
 
 struct i2c_pnx_mif {
         int                     ret;            /* Return value */
diff --git a/include/linux/i2o.h b/include/linux/i2o.h
index 7d51cbca49ab..75ae6d8aba4f 100644
--- a/include/linux/i2o.h
+++ b/include/linux/i2o.h
@@ -758,7 +758,7 @@ static inline dma_addr_t i2o_dma_map_single(struct i2o_controller *c, void *ptr,
         }
 
         dma_addr = dma_map_single(&c->pdev->dev, ptr, size, direction);
-        if (!dma_mapping_error(dma_addr)) {
+        if (!dma_mapping_error(&c->pdev->dev, dma_addr)) {
 #ifdef CONFIG_I2O_EXT_ADAPTEC_DMA64
                 if ((sizeof(dma_addr_t) > 4) && c->pae_support) {
                         *mptr++ = cpu_to_le32(0x7C020002);
diff --git a/include/linux/ide.h b/include/linux/ide.h
index b846bc44a27e..87c12ed96954 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -219,18 +219,7 @@ static inline int __ide_default_irq(unsigned long base)
 #include <asm-generic/ide_iops.h>
 #endif
 
-#ifndef MAX_HWIFS
-#if defined(CONFIG_BLACKFIN) || defined(CONFIG_H8300) || defined(CONFIG_XTENSA)
-# define MAX_HWIFS      1
-#else
-# define MAX_HWIFS      10
-#endif
-#endif
-
-#if !defined(MAX_HWIFS) || defined(CONFIG_EMBEDDED)
-#undef MAX_HWIFS
-#define MAX_HWIFS       CONFIG_IDE_MAX_HWIFS
-#endif
+#define MAX_HWIFS       10
 
 /* Currently only m68k, apus and m8xx need it */
 #ifndef IDE_ARCH_ACK_INTR
@@ -509,24 +498,33 @@ struct ide_tp_ops {
 
 extern const struct ide_tp_ops default_tp_ops;
 
+/**
+ * struct ide_port_ops - IDE port operations
+ *
+ * @init_dev:           host specific initialization of a device
+ * @set_pio_mode:       routine to program host for PIO mode
+ * @set_dma_mode:       routine to program host for DMA mode
+ * @selectproc:         tweaks hardware to select drive
+ * @reset_poll:         chipset polling based on hba specifics
+ * @pre_reset:          chipset specific changes to default for device-hba resets
+ * @resetproc:          routine to reset controller after a disk reset
+ * @maskproc:           special host masking for drive selection
+ * @quirkproc:          check host's drive quirk list
+ *
+ * @mdma_filter:        filter MDMA modes
+ * @udma_filter:        filter UDMA modes
+ *
+ * @cable_detect:       detect cable type
+ */
 struct ide_port_ops {
-        /* host specific initialization of a device */
         void    (*init_dev)(ide_drive_t *);
-        /* routine to program host for PIO mode */
         void    (*set_pio_mode)(ide_drive_t *, const u8);
-        /* routine to program host for DMA mode */
         void    (*set_dma_mode)(ide_drive_t *, const u8);
-        /* tweaks hardware to select drive */
         void    (*selectproc)(ide_drive_t *);
-        /* chipset polling based on hba specifics */
         int     (*reset_poll)(ide_drive_t *);
-        /* chipset specific changes to default for device-hba resets */
         void    (*pre_reset)(ide_drive_t *);
-        /* routine to reset controller after a disk reset */
         void    (*resetproc)(ide_drive_t *);
-        /* special host masking for drive selection */
         void    (*maskproc)(ide_drive_t *, int);
-        /* check host's drive quirk list */
         void    (*quirkproc)(ide_drive_t *);
 
         u8      (*mdma_filter)(ide_drive_t *);
diff --git a/include/linux/ieee80211.h b/include/linux/ieee80211.h
index a1630ba0b87c..7f4df7c7659d 100644
--- a/include/linux/ieee80211.h
+++ b/include/linux/ieee80211.h
@@ -506,6 +506,19 @@ struct ieee80211_channel_sw_ie {
         u8 count;
 } __attribute__ ((packed));
 
+/**
+ * struct ieee80211_tim
+ *
+ * This structure refers to "Traffic Indication Map information element"
+ */
+struct ieee80211_tim_ie {
+        u8 dtim_count;
+        u8 dtim_period;
+        u8 bitmap_ctrl;
+        /* variable size: 1 - 251 bytes */
+        u8 virtual_map[0];
+} __attribute__ ((packed));
+
 struct ieee80211_mgmt {
         __le16 frame_control;
         __le16 duration;
diff --git a/include/linux/ihex.h b/include/linux/ihex.h
index 2baace2788a7..31d8629e75a1 100644
--- a/include/linux/ihex.h
+++ b/include/linux/ihex.h
@@ -18,7 +18,7 @@ struct ihex_binrec {
         __be32 addr;
         __be16 len;
         uint8_t data[0];
-} __attribute__((aligned(4)));
+} __attribute__((packed));
 
 /* Find the next record, taking into account the 4-byte alignment */
 static inline const struct ihex_binrec *
diff --git a/include/linux/init.h b/include/linux/init.h
index 42ae95411a93..93538b696e3d 100644
--- a/include/linux/init.h
+++ b/include/linux/init.h
@@ -139,6 +139,7 @@ extern initcall_t __con_initcall_start[], __con_initcall_end[];
 extern initcall_t __security_initcall_start[], __security_initcall_end[];
 
 /* Defined in init/main.c */
+extern int do_one_initcall(initcall_t fn);
 extern char __initdata boot_command_line[];
 extern char *saved_command_line;
 extern unsigned int reset_devices;
@@ -170,6 +171,13 @@ extern void (*late_time_init)(void);
         __attribute__((__section__(".initcall" level ".init"))) = fn
 
 /*
+ * Early initcalls run before initializing SMP.
+ *
+ * Only for built-in code, not modules.
+ */
+#define early_initcall(fn)              __define_initcall("early",fn,early)
+
+/*
  * A "pure" initcall has no dependencies on anything else, and purely
  * initializes variables that couldn't be statically initialized.
  *
diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h
index 62aa4f895abe..58ff4e74b2f3 100644
--- a/include/linux/interrupt.h
+++ b/include/linux/interrupt.h
@@ -223,35 +223,6 @@ static inline int disable_irq_wake(unsigned int irq)
 #define or_softirq_pending(x)  (local_softirq_pending() |= (x))
 #endif
 
-/*
- * Temporary defines for UP kernels, until all code gets fixed.
- */
-#ifndef CONFIG_SMP
-static inline void __deprecated cli(void)
-{
-        local_irq_disable();
-}
-static inline void __deprecated sti(void)
-{
-        local_irq_enable();
-}
-static inline void __deprecated save_flags(unsigned long *x)
-{
-        local_save_flags(*x);
-}
-#define save_flags(x) save_flags(&x)
-static inline void __deprecated restore_flags(unsigned long x)
-{
-        local_irq_restore(x);
-}
-
-static inline void __deprecated save_and_cli(unsigned long *x)
-{
-        local_irq_save(*x);
-}
-#define save_and_cli(x) save_and_cli(&x)
-#endif /* CONFIG_SMP */
-
 /* Some architectures might implement lazy enabling/disabling of
  * interrupts. In some cases, such as stop_machine, we might want
  * to ensure that after a local_irq_disable(), interrupts have
diff --git a/include/linux/ioport.h b/include/linux/ioport.h
index 2cd07cc29687..22d2115458c6 100644
--- a/include/linux/ioport.h
+++ b/include/linux/ioport.h
@@ -118,6 +118,10 @@ extern int allocate_resource(struct resource *root, struct resource *new,
 int adjust_resource(struct resource *res, resource_size_t start,
                     resource_size_t size);
 resource_size_t resource_alignment(struct resource *res);
+static inline resource_size_t resource_size(struct resource *res)
+{
+        return res->end - res->start + 1;
+}
 
 /* Convenience shorthand with allocation */
 #define request_region(start,n,name)    __request_region(&ioport_resource, (start), (n), (name))
diff --git a/include/linux/ip_vs.h b/include/linux/ip_vs.h
new file mode 100644
index 000000000000..ec6eb49af2d8
--- /dev/null
+++ b/include/linux/ip_vs.h
@@ -0,0 +1,245 @@
+/*
+ *      IP Virtual Server
+ *      data structure and functionality definitions
+ */
+
+#ifndef _IP_VS_H
+#define _IP_VS_H
+
+#include <linux/types.h>        /* For __beXX types in userland */
+
+#define IP_VS_VERSION_CODE      0x010201
+#define NVERSION(version)                       \
+        (version >> 16) & 0xFF,                 \
+        (version >> 8) & 0xFF,                  \
+        version & 0xFF
+
+/*
+ *      Virtual Service Flags
+ */
+#define IP_VS_SVC_F_PERSISTENT  0x0001          /* persistent port */
+#define IP_VS_SVC_F_HASHED      0x0002          /* hashed entry */
+
+/*
+ *      Destination Server Flags
+ */
+#define IP_VS_DEST_F_AVAILABLE  0x0001          /* server is available */
+#define IP_VS_DEST_F_OVERLOAD   0x0002          /* server is overloaded */
+
+/*
+ *      IPVS sync daemon states
+ */
+#define IP_VS_STATE_NONE        0x0000          /* daemon is stopped */
+#define IP_VS_STATE_MASTER      0x0001          /* started as master */
+#define IP_VS_STATE_BACKUP      0x0002          /* started as backup */
+
+/*
+ *      IPVS socket options
+ */
+#define IP_VS_BASE_CTL          (64+1024+64)            /* base */
+
+#define IP_VS_SO_SET_NONE       IP_VS_BASE_CTL          /* just peek */
+#define IP_VS_SO_SET_INSERT     (IP_VS_BASE_CTL+1)
+#define IP_VS_SO_SET_ADD        (IP_VS_BASE_CTL+2)
+#define IP_VS_SO_SET_EDIT       (IP_VS_BASE_CTL+3)
+#define IP_VS_SO_SET_DEL        (IP_VS_BASE_CTL+4)
+#define IP_VS_SO_SET_FLUSH      (IP_VS_BASE_CTL+5)
+#define IP_VS_SO_SET_LIST       (IP_VS_BASE_CTL+6)
+#define IP_VS_SO_SET_ADDDEST    (IP_VS_BASE_CTL+7)
+#define IP_VS_SO_SET_DELDEST    (IP_VS_BASE_CTL+8)
+#define IP_VS_SO_SET_EDITDEST   (IP_VS_BASE_CTL+9)
+#define IP_VS_SO_SET_TIMEOUT    (IP_VS_BASE_CTL+10)
+#define IP_VS_SO_SET_STARTDAEMON (IP_VS_BASE_CTL+11)
+#define IP_VS_SO_SET_STOPDAEMON (IP_VS_BASE_CTL+12)
+#define IP_VS_SO_SET_RESTORE    (IP_VS_BASE_CTL+13)
+#define IP_VS_SO_SET_SAVE       (IP_VS_BASE_CTL+14)
+#define IP_VS_SO_SET_ZERO       (IP_VS_BASE_CTL+15)
+#define IP_VS_SO_SET_MAX        IP_VS_SO_SET_ZERO
+
+#define IP_VS_SO_GET_VERSION    IP_VS_BASE_CTL
+#define IP_VS_SO_GET_INFO       (IP_VS_BASE_CTL+1)
+#define IP_VS_SO_GET_SERVICES   (IP_VS_BASE_CTL+2)
+#define IP_VS_SO_GET_SERVICE    (IP_VS_BASE_CTL+3)
+#define IP_VS_SO_GET_DESTS      (IP_VS_BASE_CTL+4)
+#define IP_VS_SO_GET_DEST       (IP_VS_BASE_CTL+5)      /* not used now */
+#define IP_VS_SO_GET_TIMEOUT    (IP_VS_BASE_CTL+6)
+#define IP_VS_SO_GET_DAEMON     (IP_VS_BASE_CTL+7)
+#define IP_VS_SO_GET_MAX        IP_VS_SO_GET_DAEMON
+
+
+/*
+ *      IPVS Connection Flags
+ */
+#define IP_VS_CONN_F_FWD_MASK   0x0007          /* mask for the fwd methods */
+#define IP_VS_CONN_F_MASQ       0x0000          /* masquerading/NAT */
+#define IP_VS_CONN_F_LOCALNODE  0x0001          /* local node */
+#define IP_VS_CONN_F_TUNNEL     0x0002          /* tunneling */
+#define IP_VS_CONN_F_DROUTE     0x0003          /* direct routing */
+#define IP_VS_CONN_F_BYPASS     0x0004          /* cache bypass */
+#define IP_VS_CONN_F_SYNC       0x0020          /* entry created by sync */
+#define IP_VS_CONN_F_HASHED     0x0040          /* hashed entry */
+#define IP_VS_CONN_F_NOOUTPUT   0x0080          /* no output packets */
+#define IP_VS_CONN_F_INACTIVE   0x0100          /* not established */
+#define IP_VS_CONN_F_OUT_SEQ    0x0200          /* must do output seq adjust */
+#define IP_VS_CONN_F_IN_SEQ     0x0400          /* must do input seq adjust */
+#define IP_VS_CONN_F_SEQ_MASK   0x0600          /* in/out sequence mask */
+#define IP_VS_CONN_F_NO_CPORT   0x0800          /* no client port set yet */
+#define IP_VS_CONN_F_TEMPLATE   0x1000          /* template, not connection */
+
+#define IP_VS_SCHEDNAME_MAXLEN  16
+#define IP_VS_IFNAME_MAXLEN     16
+
+
+/*
+ *      The struct ip_vs_service_user and struct ip_vs_dest_user are
+ *      used to set IPVS rules through setsockopt.
+ */
+struct ip_vs_service_user {
+        /* virtual service addresses */
+        u_int16_t               protocol;
+        __be32                  addr;           /* virtual ip address */
+        __be16                  port;
+        u_int32_t               fwmark;         /* firwall mark of service */
+
+        /* virtual service options */
+        char                    sched_name[IP_VS_SCHEDNAME_MAXLEN];
+        unsigned                flags;          /* virtual service flags */
+        unsigned                timeout;        /* persistent timeout in sec */
+        __be32                  netmask;        /* persistent netmask */
+};
+
+
+struct ip_vs_dest_user {
+        /* destination server address */
+        __be32                  addr;
+        __be16                  port;
+
+        /* real server options */
+        unsigned                conn_flags;     /* connection flags */
+        int                     weight;         /* destination weight */
+
+        /* thresholds for active connections */
+        u_int32_t               u_threshold;    /* upper threshold */
+        u_int32_t               l_threshold;    /* lower threshold */
+};
+
+
+/*
+ *      IPVS statistics object (for user space)
+ */
+struct ip_vs_stats_user
+{
+        __u32                   conns;          /* connections scheduled */
+        __u32                   inpkts;         /* incoming packets */
+        __u32                   outpkts;        /* outgoing packets */
+        __u64                   inbytes;        /* incoming bytes */
+        __u64                   outbytes;       /* outgoing bytes */
+
+        __u32                   cps;            /* current connection rate */
+        __u32                   inpps;          /* current in packet rate */
+        __u32                   outpps;         /* current out packet rate */
+        __u32                   inbps;          /* current in byte rate */
+        __u32                   outbps;         /* current out byte rate */
+};
+
+
+/* The argument to IP_VS_SO_GET_INFO */
+struct ip_vs_getinfo {
+        /* version number */
+        unsigned int            version;
+
+        /* size of connection hash table */
+        unsigned int            size;
+
+        /* number of virtual services */
+        unsigned int            num_services;
+};
+
+
+/* The argument to IP_VS_SO_GET_SERVICE */
+struct ip_vs_service_entry {
+        /* which service: user fills in these */
+        u_int16_t               protocol;
+        __be32                  addr;           /* virtual address */
+        __be16                  port;
+        u_int32_t               fwmark;         /* firwall mark of service */
+
+        /* service options */
+        char                    sched_name[IP_VS_SCHEDNAME_MAXLEN];
+        unsigned                flags;          /* virtual service flags */
+        unsigned                timeout;        /* persistent timeout */
+        __be32                  netmask;        /* persistent netmask */
+
+        /* number of real servers */
+        unsigned int            num_dests;
+
+        /* statistics */
+        struct ip_vs_stats_user stats;
+};
+
+
+struct ip_vs_dest_entry {
+        __be32                  addr;           /* destination address */
+        __be16                  port;
+        unsigned                conn_flags;     /* connection flags */
+        int                     weight;         /* destination weight */
+
+        u_int32_t               u_threshold;    /* upper threshold */
+        u_int32_t               l_threshold;    /* lower threshold */
+
+        u_int32_t               activeconns;    /* active connections */
+        u_int32_t               inactconns;     /* inactive connections */
+        u_int32_t               persistconns;   /* persistent connections */
+
+        /* statistics */
+        struct ip_vs_stats_user stats;
+};
+
+
+/* The argument to IP_VS_SO_GET_DESTS */
+struct ip_vs_get_dests {
+        /* which service: user fills in these */
+        u_int16_t               protocol;
+        __be32                  addr;           /* virtual address */
+        __be16                  port;
+        u_int32_t               fwmark;         /* firwall mark of service */
+
+        /* number of real servers */
+        unsigned int            num_dests;
+
+        /* the real servers */
+        struct ip_vs_dest_entry entrytable[0];
+};
+
+
+/* The argument to IP_VS_SO_GET_SERVICES */
+struct ip_vs_get_services {
+        /* number of virtual services */
+        unsigned int            num_services;
+
+        /* service table */
+        struct ip_vs_service_entry entrytable[0];
+};
+
+
+/* The argument to IP_VS_SO_GET_TIMEOUT */
+struct ip_vs_timeout_user {
+        int                     tcp_timeout;
+        int                     tcp_fin_timeout;
+        int                     udp_timeout;
+};
+
+
+/* The argument to IP_VS_SO_GET_DAEMON */
+struct ip_vs_daemon_user {
+        /* sync daemon state (master/backup) */
+        int                     state;
+
+        /* multicast interface name */
+        char                    mcast_ifn[IP_VS_IFNAME_MAXLEN];
+
+        /* SyncID we belong to */
+        int                     syncid;
+};
+
+#endif  /* _IP_VS_H */
diff --git a/include/linux/ivtv.h b/include/linux/ivtv.h
index 794b8daa9378..17ca64b5a66c 100644
--- a/include/linux/ivtv.h
+++ b/include/linux/ivtv.h
@@ -21,11 +21,7 @@
 #ifndef __LINUX_IVTV_H__
 #define __LINUX_IVTV_H__
 
-#ifdef __KERNEL__
-#include <linux/compiler.h> /* need __user */
-#else
-#define __user
-#endif
+#include <linux/compiler.h>
 #include <linux/types.h>
 
 /* ivtv knows several distinct output modes: MPEG streaming,
diff --git a/include/linux/ivtvfb.h b/include/linux/ivtvfb.h
index e980ba62ddcc..e20af47b59ad 100644
--- a/include/linux/ivtvfb.h
+++ b/include/linux/ivtvfb.h
@@ -21,11 +21,7 @@
 #ifndef __LINUX_IVTVFB_H__
 #define __LINUX_IVTVFB_H__
 
-#ifdef __KERNEL__
-#include <linux/compiler.h> /* need __user */
-#else
-#define __user
-#endif
+#include <linux/compiler.h>
 #include <linux/types.h>
 
 /* Framebuffer external API */
diff --git a/include/linux/jffs2.h b/include/linux/jffs2.h
index 6b563cae23df..da720bc3eb15 100644
--- a/include/linux/jffs2.h
+++ b/include/linux/jffs2.h
@@ -7,9 +7,6 @@
  *
  * For licensing information, see the file 'LICENCE' in the
  * jffs2 directory.
- *
- * $Id: jffs2.h,v 1.38 2005/09/26 11:37:23 havasi Exp $
- *
  */
 
 #ifndef __LINUX_JFFS2_H__
diff --git a/include/linux/kallsyms.h b/include/linux/kallsyms.h
index 57aefa160a92..b96144887444 100644
--- a/include/linux/kallsyms.h
+++ b/include/linux/kallsyms.h
@@ -108,8 +108,7 @@ static inline void print_fn_descriptor_symbol(const char *fmt, void *addr)
 
 static inline void print_ip_sym(unsigned long ip)
 {
-        printk("[<%p>]", (void *) ip);
-        print_symbol(" %s\n", ip);
+        printk("[<%p>] %pS\n", (void *) ip, (void *) ip);
 }
 
 #endif /*_LINUX_KALLSYMS_H*/
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index fdbbf72ca2eb..2651f805ba6d 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -75,6 +75,12 @@ extern const char linux_proc_banner[];
  */
 #define upper_32_bits(n) ((u32)(((n) >> 16) >> 16))
 
+/**
+ * lower_32_bits - return bits 0-31 of a number
+ * @n: the number we're accessing
+ */
+#define lower_32_bits(n) ((u32)(n))
+
 #define KERN_EMERG      "<0>"   /* system is unusable                   */
 #define KERN_ALERT      "<1>"   /* action must be taken immediately     */
 #define KERN_CRIT       "<2>"   /* critical conditions                  */
@@ -102,6 +108,13 @@ struct completion;
 struct pt_regs;
 struct user;
 
+#ifdef CONFIG_PREEMPT_VOLUNTARY
+extern int _cond_resched(void);
+# define might_resched() _cond_resched()
+#else
+# define might_resched() do { } while (0)
+#endif
+
 /**
  * might_sleep - annotation for functions that can sleep
  *
@@ -112,13 +125,6 @@ struct user;
  * be bitten later when the calling function happens to sleep when it is not
  * supposed to.
  */
-#ifdef CONFIG_PREEMPT_VOLUNTARY
-extern int _cond_resched(void);
-# define might_resched() _cond_resched()
-#else
-# define might_resched() do { } while (0)
-#endif
-
 #ifdef CONFIG_DEBUG_SPINLOCK_SLEEP
   void __might_sleep(char *file, int line);
 # define might_sleep() \
diff --git a/include/linux/kexec.h b/include/linux/kexec.h
index 3265968cd2cd..17f76fc05173 100644
--- a/include/linux/kexec.h
+++ b/include/linux/kexec.h
@@ -25,8 +25,8 @@
 #error KEXEC_CONTROL_MEMORY_LIMIT not defined
 #endif
 
-#ifndef KEXEC_CONTROL_CODE_SIZE
-#error KEXEC_CONTROL_CODE_SIZE not defined
+#ifndef KEXEC_CONTROL_PAGE_SIZE
+#error KEXEC_CONTROL_PAGE_SIZE not defined
 #endif
 
 #ifndef KEXEC_ARCH
@@ -83,6 +83,7 @@ struct kimage {
 
         unsigned long start;
         struct page *control_code_page;
+        struct page *swap_page;
 
         unsigned long nr_segments;
         struct kexec_segment segment[KEXEC_SEGMENT_MAX];
@@ -98,18 +99,20 @@ struct kimage {
         unsigned int type : 1;
 #define KEXEC_TYPE_DEFAULT 0
 #define KEXEC_TYPE_CRASH   1
+        unsigned int preserve_context : 1;
 };
 
 
 
 /* kexec interface functions */
-extern NORET_TYPE void machine_kexec(struct kimage *image) ATTRIB_NORET;
+extern void machine_kexec(struct kimage *image);
 extern int machine_kexec_prepare(struct kimage *image);
 extern void machine_kexec_cleanup(struct kimage *image);
 extern asmlinkage long sys_kexec_load(unsigned long entry,
                                         unsigned long nr_segments,
                                         struct kexec_segment __user *segments,
                                         unsigned long flags);
+extern int kernel_kexec(void);
 #ifdef CONFIG_COMPAT
 extern asmlinkage long compat_sys_kexec_load(unsigned long entry,
                                 unsigned long nr_segments,
@@ -127,8 +130,8 @@ void vmcoreinfo_append_str(const char *fmt, ...)
         __attribute__ ((format (printf, 1, 2)));
 unsigned long paddr_vmcoreinfo_note(void);
 
-#define VMCOREINFO_OSRELEASE(name) \
-        vmcoreinfo_append_str("OSRELEASE=%s\n", #name)
+#define VMCOREINFO_OSRELEASE(value) \
+        vmcoreinfo_append_str("OSRELEASE=%s\n", value)
 #define VMCOREINFO_PAGESIZE(value) \
         vmcoreinfo_append_str("PAGESIZE=%ld\n", value)
 #define VMCOREINFO_SYMBOL(name) \
@@ -156,8 +159,9 @@ extern struct kimage *kexec_crash_image;
 #define kexec_flush_icache_page(page)
 #endif
 
-#define KEXEC_ON_CRASH  0x00000001
-#define KEXEC_ARCH_MASK 0xffff0000
+#define KEXEC_ON_CRASH          0x00000001
+#define KEXEC_PRESERVE_CONTEXT  0x00000002
+#define KEXEC_ARCH_MASK         0xffff0000
 
 /* These values match the ELF architecture values.
  * Unless there is a good reason that should continue to be the case.
@@ -174,7 +178,12 @@ extern struct kimage *kexec_crash_image;
 #define KEXEC_ARCH_MIPS_LE (10 << 16)
 #define KEXEC_ARCH_MIPS    ( 8 << 16)
 
-#define KEXEC_FLAGS    (KEXEC_ON_CRASH)  /* List of defined/legal kexec flags */
+/* List of defined/legal kexec flags */
+#ifndef CONFIG_KEXEC_JUMP
+#define KEXEC_FLAGS    KEXEC_ON_CRASH
+#else
+#define KEXEC_FLAGS    (KEXEC_ON_CRASH | KEXEC_PRESERVE_CONTEXT)
+#endif
 
 #define VMCOREINFO_BYTES           (4096)
 #define VMCOREINFO_NOTE_NAME       "VMCOREINFO"
diff --git a/include/linux/kvm.h b/include/linux/kvm.h
index 0ea064cbfbc8..69511f74f912 100644
--- a/include/linux/kvm.h
+++ b/include/linux/kvm.h
@@ -371,6 +371,7 @@ struct kvm_trace_rec {
 #define KVM_CAP_PV_MMU 13
 #define KVM_CAP_MP_STATE 14
 #define KVM_CAP_COALESCED_MMIO 15
+#define KVM_CAP_SYNC_MMU 16  /* Changes to host mmap are reflected in guest */
 
 /*
  * ioctls for VM fds
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
index 07d68a8ae8e9..8525afc53107 100644
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@ -121,6 +121,12 @@ struct kvm {
         struct kvm_coalesced_mmio_dev *coalesced_mmio_dev;
         struct kvm_coalesced_mmio_ring *coalesced_mmio_ring;
 #endif
+
+#ifdef KVM_ARCH_WANT_MMU_NOTIFIER
+        struct mmu_notifier mmu_notifier;
+        unsigned long mmu_notifier_seq;
+        long mmu_notifier_count;
+#endif
 };
 
 /* The guest did something we don't support. */
@@ -332,4 +338,22 @@ int kvm_trace_ioctl(unsigned int ioctl, unsigned long arg)
 #define kvm_trace_cleanup() ((void)0)
 #endif
 
+#ifdef KVM_ARCH_WANT_MMU_NOTIFIER
+static inline int mmu_notifier_retry(struct kvm_vcpu *vcpu, unsigned long mmu_seq)
+{
+        if (unlikely(vcpu->kvm->mmu_notifier_count))
+                return 1;
+        /*
+         * Both reads happen under the mmu_lock and both values are
+         * modified under mmu_lock, so there's no need of smb_rmb()
+         * here in between, otherwise mmu_notifier_count should be
+         * read before mmu_notifier_seq, see
+         * mmu_notifier_invalidate_range_end write side.
+         */
+        if (vcpu->kvm->mmu_notifier_seq != mmu_seq)
+                return 1;
+        return 0;
+}
+#endif
+
 #endif
diff --git a/include/linux/libata.h b/include/linux/libata.h
index 5b247b8a6b3b..06b80337303b 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -60,9 +60,9 @@
 
 /* note: prints function name for you */
 #ifdef ATA_DEBUG
-#define DPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
+#define DPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __func__, ## args)
 #ifdef ATA_VERBOSE_DEBUG
-#define VPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
+#define VPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __func__, ## args)
 #else
 #define VPRINTK(fmt, args...)
 #endif  /* ATA_VERBOSE_DEBUG */
@@ -71,7 +71,7 @@
 #define VPRINTK(fmt, args...)
 #endif  /* ATA_DEBUG */
 
-#define BPRINTK(fmt, args...) if (ap->flags & ATA_FLAG_DEBUGMSG) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
+#define BPRINTK(fmt, args...) if (ap->flags & ATA_FLAG_DEBUGMSG) printk(KERN_ERR "%s: " fmt, __func__, ## args)
 
 /* NEW: debug levels */
 #define HAVE_LIBATA_MSG 1
@@ -750,6 +750,7 @@ struct ata_port_operations {
         void (*set_piomode)(struct ata_port *ap, struct ata_device *dev);
         void (*set_dmamode)(struct ata_port *ap, struct ata_device *dev);
         int  (*set_mode)(struct ata_link *link, struct ata_device **r_failed_dev);
+        unsigned int (*read_id)(struct ata_device *dev, struct ata_taskfile *tf, u16 *id);
 
         void (*dev_config)(struct ata_device *dev);
 
@@ -951,6 +952,8 @@ extern void ata_id_string(const u16 *id, unsigned char *s,
                           unsigned int ofs, unsigned int len);
 extern void ata_id_c_string(const u16 *id, unsigned char *s,
                             unsigned int ofs, unsigned int len);
+extern unsigned int ata_do_dev_read_id(struct ata_device *dev,
+                                        struct ata_taskfile *tf, u16 *id);
 extern void ata_qc_complete(struct ata_queued_cmd *qc);
 extern int ata_qc_complete_multiple(struct ata_port *ap, u32 qc_active);
 extern void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
diff --git a/include/linux/list.h b/include/linux/list.h
index 453916bc0412..db35ef02e745 100644
--- a/include/linux/list.h
+++ b/include/linux/list.h
@@ -214,22 +214,62 @@ static inline int list_is_singular(const struct list_head *head)
         return !list_empty(head) && (head->next == head->prev);
 }
 
+static inline void __list_cut_position(struct list_head *list,
+                struct list_head *head, struct list_head *entry)
+{
+        struct list_head *new_first = entry->next;
+        list->next = head->next;
+        list->next->prev = list;
+        list->prev = entry;
+        entry->next = list;
+        head->next = new_first;
+        new_first->prev = head;
+}
+
+/**
+ * list_cut_position - cut a list into two
+ * @list: a new list to add all removed entries
+ * @head: a list with entries
+ * @entry: an entry within head, could be the head itself
+ *      and if so we won't cut the list
+ *
+ * This helper moves the initial part of @head, up to and
+ * including @entry, from @head to @list. You should
+ * pass on @entry an element you know is on @head. @list
+ * should be an empty list or a list you do not care about
+ * losing its data.
+ *
+ */
+static inline void list_cut_position(struct list_head *list,
+                struct list_head *head, struct list_head *entry)
+{
+        if (list_empty(head))
+                return;
+        if (list_is_singular(head) &&
+                (head->next != entry && head != entry))
+                return;
+        if (entry == head)
+                INIT_LIST_HEAD(list);
+        else
+                __list_cut_position(list, head, entry);
+}
+
 static inline void __list_splice(const struct list_head *list,
-                                 struct list_head *head)
+                                 struct list_head *prev,
+                                 struct list_head *next)
 {
         struct list_head *first = list->next;
         struct list_head *last = list->prev;
-        struct list_head *at = head->next;
 
-        first->prev = head;
-        head->next = first;
+        first->prev = prev;
+        prev->next = first;
 
-        last->next = at;
-        at->prev = last;
+        last->next = next;
+        next->prev = last;
 }
 
 /**
- * list_splice - join two lists
+ * list_splice - join two lists, this is designed for stacks
  * @list: the new list to add.
  * @head: the place to add it in the first list.
  */
@@ -237,7 +277,19 @@ static inline void list_splice(const struct list_head *list,
                                 struct list_head *head)
 {
         if (!list_empty(list))
-                __list_splice(list, head);
+                __list_splice(list, head, head->next);
+}
+
+/**
+ * list_splice_tail - join two lists, each list being a queue
+ * @list: the new list to add.
+ * @head: the place to add it in the first list.
+ */
+static inline void list_splice_tail(struct list_head *list,
+                                struct list_head *head)
+{
+        if (!list_empty(list))
+                __list_splice(list, head->prev, head);
 }
 
 /**
@@ -251,7 +303,24 @@ static inline void list_splice_init(struct list_head *list,
                                     struct list_head *head)
 {
         if (!list_empty(list)) {
-                __list_splice(list, head);
+                __list_splice(list, head, head->next);
+                INIT_LIST_HEAD(list);
+        }
+}
+
+/**
+ * list_splice_tail_init - join two lists and reinitialise the emptied list
+ * @list: the new list to add.
+ * @head: the place to add it in the first list.
+ *
+ * Each of the lists is a queue.
+ * The list at @list is reinitialised
+ */
+static inline void list_splice_tail_init(struct list_head *list,
+                                         struct list_head *head)
+{
+        if (!list_empty(list)) {
+                __list_splice(list, head->prev, head);
                 INIT_LIST_HEAD(list);
         }
 }
diff --git a/include/linux/lockdep.h b/include/linux/lockdep.h
index 2486eb4edbf1..331e5f1c2d8e 100644
--- a/include/linux/lockdep.h
+++ b/include/linux/lockdep.h
@@ -89,6 +89,7 @@ struct lock_class {
 
         struct lockdep_subclass_key     *key;
         unsigned int                    subclass;
+        unsigned int                    dep_gen_id;
 
         /*
          * IRQ/softirq usage tracking bits:
@@ -189,6 +190,14 @@ struct lock_chain {
         u64                             chain_key;
 };
 
+#define MAX_LOCKDEP_KEYS_BITS           13
+/*
+ * Subtract one because we offset hlock->class_idx by 1 in order
+ * to make 0 mean no class. This avoids overflowing the class_idx
+ * bitfield and hitting the BUG in hlock_class().
+ */
+#define MAX_LOCKDEP_KEYS                ((1UL << MAX_LOCKDEP_KEYS_BITS) - 1)
+
 struct held_lock {
         /*
          * One-way hash of the dependency chain up to this point. We
@@ -205,14 +214,14 @@ struct held_lock {
          * with zero), here we store the previous hash value:
          */
         u64                             prev_chain_key;
-        struct lock_class               *class;
         unsigned long                   acquire_ip;
         struct lockdep_map              *instance;
-
+        struct lockdep_map              *nest_lock;
 #ifdef CONFIG_LOCK_STAT
         u64                             waittime_stamp;
         u64                             holdtime_stamp;
 #endif
+        unsigned int                    class_idx:MAX_LOCKDEP_KEYS_BITS;
         /*
          * The lock-stack is unified in that the lock chains of interrupt
          * contexts nest ontop of process context chains, but we 'separate'
@@ -226,11 +235,11 @@ struct held_lock {
          * The following field is used to detect when we cross into an
          * interrupt context:
          */
-        int                             irq_context;
-        int                             trylock;
-        int                             read;
-        int                             check;
-        int                             hardirqs_off;
+        unsigned int irq_context:2; /* bit 0 - soft, bit 1 - hard */
+        unsigned int trylock:1;
+        unsigned int read:2;        /* see lock_acquire() comment */
+        unsigned int check:2;       /* see lock_acquire() comment */
+        unsigned int hardirqs_off:1;
 };
 
 /*
@@ -294,11 +303,15 @@ extern void lockdep_init_map(struct lockdep_map *lock, const char *name,
  *   2: full validation
  */
 extern void lock_acquire(struct lockdep_map *lock, unsigned int subclass,
-                         int trylock, int read, int check, unsigned long ip);
+                         int trylock, int read, int check,
+                         struct lockdep_map *nest_lock, unsigned long ip);
 
 extern void lock_release(struct lockdep_map *lock, int nested,
                          unsigned long ip);
 
+extern void lock_set_subclass(struct lockdep_map *lock, unsigned int subclass,
+                              unsigned long ip);
+
 # define INIT_LOCKDEP                           .lockdep_recursion = 0,
 
 #define lockdep_depth(tsk)      (debug_locks ? (tsk)->lockdep_depth : 0)
@@ -313,8 +326,9 @@ static inline void lockdep_on(void)
 {
 }
 
-# define lock_acquire(l, s, t, r, c, i)         do { } while (0)
+# define lock_acquire(l, s, t, r, c, n, i)      do { } while (0)
 # define lock_release(l, n, i)                  do { } while (0)
+# define lock_set_subclass(l, s, i)             do { } while (0)
 # define lockdep_init()                         do { } while (0)
 # define lockdep_info()                         do { } while (0)
 # define lockdep_init_map(lock, name, key, sub) do { (void)(key); } while (0)
@@ -400,9 +414,11 @@ static inline void print_irqtrace_events(struct task_struct *curr)
 
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 # ifdef CONFIG_PROVE_LOCKING
-#  define spin_acquire(l, s, t, i)              lock_acquire(l, s, t, 0, 2, i)
+#  define spin_acquire(l, s, t, i)              lock_acquire(l, s, t, 0, 2, NULL, i)
+#  define spin_acquire_nest(l, s, t, n, i)      lock_acquire(l, s, t, 0, 2, n, i)
 # else
-#  define spin_acquire(l, s, t, i)              lock_acquire(l, s, t, 0, 1, i)
+#  define spin_acquire(l, s, t, i)              lock_acquire(l, s, t, 0, 1, NULL, i)
+#  define spin_acquire_nest(l, s, t, n, i)      lock_acquire(l, s, t, 0, 1, NULL, i)
 # endif
 # define spin_release(l, n, i)                  lock_release(l, n, i)
 #else
@@ -412,11 +428,11 @@ static inline void print_irqtrace_events(struct task_struct *curr)
 
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 # ifdef CONFIG_PROVE_LOCKING
-#  define rwlock_acquire(l, s, t, i)            lock_acquire(l, s, t, 0, 2, i)
-#  define rwlock_acquire_read(l, s, t, i)       lock_acquire(l, s, t, 2, 2, i)
+#  define rwlock_acquire(l, s, t, i)            lock_acquire(l, s, t, 0, 2, NULL, i)
+#  define rwlock_acquire_read(l, s, t, i)       lock_acquire(l, s, t, 2, 2, NULL, i)
 # else
-#  define rwlock_acquire(l, s, t, i)            lock_acquire(l, s, t, 0, 1, i)
-#  define rwlock_acquire_read(l, s, t, i)       lock_acquire(l, s, t, 2, 1, i)
+#  define rwlock_acquire(l, s, t, i)            lock_acquire(l, s, t, 0, 1, NULL, i)
+#  define rwlock_acquire_read(l, s, t, i)       lock_acquire(l, s, t, 2, 1, NULL, i)
 # endif
 # define rwlock_release(l, n, i)                lock_release(l, n, i)
 #else
@@ -427,9 +443,9 @@ static inline void print_irqtrace_events(struct task_struct *curr)
 
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 # ifdef CONFIG_PROVE_LOCKING
-#  define mutex_acquire(l, s, t, i)             lock_acquire(l, s, t, 0, 2, i)
+#  define mutex_acquire(l, s, t, i)             lock_acquire(l, s, t, 0, 2, NULL, i)
 # else
-#  define mutex_acquire(l, s, t, i)             lock_acquire(l, s, t, 0, 1, i)
+#  define mutex_acquire(l, s, t, i)             lock_acquire(l, s, t, 0, 1, NULL, i)
 # endif
 # define mutex_release(l, n, i)                 lock_release(l, n, i)
 #else
@@ -439,11 +455,11 @@ static inline void print_irqtrace_events(struct task_struct *curr)
 
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 # ifdef CONFIG_PROVE_LOCKING
-#  define rwsem_acquire(l, s, t, i)             lock_acquire(l, s, t, 0, 2, i)
-#  define rwsem_acquire_read(l, s, t, i)        lock_acquire(l, s, t, 1, 2, i)
+#  define rwsem_acquire(l, s, t, i)             lock_acquire(l, s, t, 0, 2, NULL, i)
+#  define rwsem_acquire_read(l, s, t, i)        lock_acquire(l, s, t, 1, 2, NULL, i)
 # else
-#  define rwsem_acquire(l, s, t, i)             lock_acquire(l, s, t, 0, 1, i)
-#  define rwsem_acquire_read(l, s, t, i)        lock_acquire(l, s, t, 1, 1, i)
+#  define rwsem_acquire(l, s, t, i)             lock_acquire(l, s, t, 0, 1, NULL, i)
+#  define rwsem_acquire_read(l, s, t, i)        lock_acquire(l, s, t, 1, 1, NULL, i)
 # endif
 # define rwsem_release(l, n, i)                 lock_release(l, n, i)
 #else
@@ -452,4 +468,16 @@ static inline void print_irqtrace_events(struct task_struct *curr)
 # define rwsem_release(l, n, i)                 do { } while (0)
 #endif
 
+#ifdef CONFIG_DEBUG_LOCK_ALLOC
+# ifdef CONFIG_PROVE_LOCKING
+#  define lock_map_acquire(l)           lock_acquire(l, 0, 0, 0, 2, NULL, _THIS_IP_)
+# else
+#  define lock_map_acquire(l)           lock_acquire(l, 0, 0, 0, 1, NULL, _THIS_IP_)
+# endif
+# define lock_map_release(l)                    lock_release(l, 1, _THIS_IP_)
+#else
+# define lock_map_acquire(l)                    do { } while (0)
+# define lock_map_release(l)                    do { } while (0)
+#endif
+
 #endif /* __LINUX_LOCKDEP_H */
diff --git a/include/linux/mISDNdsp.h b/include/linux/mISDNdsp.h
new file mode 100644
index 000000000000..6b71d2dce508
--- /dev/null
+++ b/include/linux/mISDNdsp.h
@@ -0,0 +1,37 @@
+#ifndef __mISDNdsp_H__
+#define __mISDNdsp_H__
+
+struct mISDN_dsp_element_arg {
+        char    *name;
+        char    *def;
+        char    *desc;
+};
+
+struct mISDN_dsp_element {
+        char    *name;
+        void    *(*new)(const char *arg);
+        void    (*free)(void *p);
+        void    (*process_tx)(void *p, unsigned char *data, int len);
+        void    (*process_rx)(void *p, unsigned char *data, int len);
+        int     num_args;
+        struct mISDN_dsp_element_arg
+                *args;
+};
+
+extern int  mISDN_dsp_element_register(struct mISDN_dsp_element *elem);
+extern void mISDN_dsp_element_unregister(struct mISDN_dsp_element *elem);
+
+struct dsp_features {
+        int     hfc_id; /* unique id to identify the chip (or -1) */
+        int     hfc_dtmf; /* set if HFCmulti card supports dtmf */
+        int     hfc_loops; /* set if card supports tone loops */
+        int     hfc_echocanhw; /* set if card supports echocancelation*/
+        int     pcm_id; /* unique id to identify the pcm bus (or -1) */
+        int     pcm_slots; /* number of slots on the pcm bus */
+        int     pcm_banks; /* number of IO banks of pcm bus */
+        int     unclocked; /* data is not clocked (has jitter/loss) */
+        int     unordered; /* data is unordered (packets have index) */
+};
+
+#endif
+
diff --git a/include/linux/mISDNhw.h b/include/linux/mISDNhw.h
new file mode 100644
index 000000000000..e794dfb87504
--- /dev/null
+++ b/include/linux/mISDNhw.h
@@ -0,0 +1,193 @@
+/*
+ *
+ * Author       Karsten Keil <kkeil@novell.com>
+ *
+ *   Basic declarations for the mISDN HW channels
+ *
+ * Copyright 2008  by Karsten Keil <kkeil@novell.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * 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.
+ *
+ */
+
+#ifndef MISDNHW_H
+#define MISDNHW_H
+#include <linux/mISDNif.h>
+#include <linux/timer.h>
+
+/*
+ * HW DEBUG 0xHHHHGGGG
+ * H - hardware driver specific bits
+ * G - for all drivers
+ */
+
+#define DEBUG_HW                0x00000001
+#define DEBUG_HW_OPEN           0x00000002
+#define DEBUG_HW_DCHANNEL       0x00000100
+#define DEBUG_HW_DFIFO          0x00000200
+#define DEBUG_HW_BCHANNEL       0x00001000
+#define DEBUG_HW_BFIFO          0x00002000
+
+#define MAX_DFRAME_LEN_L1       300
+#define MAX_MON_FRAME           32
+#define MAX_LOG_SPACE           2048
+#define MISDN_COPY_SIZE         32
+
+/* channel->Flags bit field */
+#define FLG_TX_BUSY             0       /* tx_buf in use */
+#define FLG_TX_NEXT             1       /* next_skb in use */
+#define FLG_L1_BUSY             2       /* L1 is permanent busy */
+#define FLG_L2_ACTIVATED        3       /* activated from L2 */
+#define FLG_OPEN                5       /* channel is in use */
+#define FLG_ACTIVE              6       /* channel is activated */
+#define FLG_BUSY_TIMER          7
+/* channel type */
+#define FLG_DCHANNEL            8       /* channel is D-channel */
+#define FLG_BCHANNEL            9       /* channel is B-channel */
+#define FLG_ECHANNEL            10      /* channel is E-channel */
+#define FLG_TRANSPARENT         12      /* channel use transparent data */
+#define FLG_HDLC                13      /* channel use hdlc data */
+#define FLG_L2DATA              14      /* channel use L2 DATA primitivs */
+#define FLG_ORIGIN              15      /* channel is on origin site */
+/* channel specific stuff */
+/* arcofi specific */
+#define FLG_ARCOFI_TIMER        16
+#define FLG_ARCOFI_ERROR        17
+/* isar specific */
+#define FLG_INITIALIZED         16
+#define FLG_DLEETX              17
+#define FLG_LASTDLE             18
+#define FLG_FIRST               19
+#define FLG_LASTDATA            20
+#define FLG_NMD_DATA            21
+#define FLG_FTI_RUN             22
+#define FLG_LL_OK               23
+#define FLG_LL_CONN             24
+#define FLG_DTMFSEND            25
+
+/* workq events */
+#define FLG_RECVQUEUE           30
+#define FLG_PHCHANGE            31
+
+#define schedule_event(s, ev)   do { \
+                                        test_and_set_bit(ev, &((s)->Flags)); \
+                                        schedule_work(&((s)->workq)); \
+                                } while (0)
+
+struct dchannel {
+        struct mISDNdevice      dev;
+        u_long                  Flags;
+        struct work_struct      workq;
+        void                    (*phfunc) (struct dchannel *);
+        u_int                   state;
+        void                    *l1;
+        /* HW access */
+        u_char                  (*read_reg) (void *, u_char);
+        void                    (*write_reg) (void *, u_char, u_char);
+        void                    (*read_fifo) (void *, u_char *, int);
+        void                    (*write_fifo) (void *, u_char *, int);
+        void                    *hw;
+        int                     slot;   /* multiport card channel slot */
+        struct timer_list       timer;
+        /* receive data */
+        struct sk_buff          *rx_skb;
+        int                     maxlen;
+        /* send data */
+        struct sk_buff_head     squeue;
+        struct sk_buff_head     rqueue;
+        struct sk_buff          *tx_skb;
+        int                     tx_idx;
+        int                     debug;
+        /* statistics */
+        int                     err_crc;
+        int                     err_tx;
+        int                     err_rx;
+};
+
+typedef int     (dchannel_l1callback)(struct dchannel *, u_int);
+extern int      create_l1(struct dchannel *, dchannel_l1callback *);
+
+/* private L1 commands */
+#define INFO0           0x8002
+#define INFO1           0x8102
+#define INFO2           0x8202
+#define INFO3_P8        0x8302
+#define INFO3_P10       0x8402
+#define INFO4_P8        0x8502
+#define INFO4_P10       0x8602
+#define LOSTFRAMING     0x8702
+#define ANYSIGNAL       0x8802
+#define HW_POWERDOWN    0x8902
+#define HW_RESET_REQ    0x8a02
+#define HW_POWERUP_REQ  0x8b02
+#define HW_DEACT_REQ    0x8c02
+#define HW_ACTIVATE_REQ 0x8e02
+#define HW_D_NOBLOCKED  0x8f02
+#define HW_RESET_IND    0x9002
+#define HW_POWERUP_IND  0x9102
+#define HW_DEACT_IND    0x9202
+#define HW_ACTIVATE_IND 0x9302
+#define HW_DEACT_CNF    0x9402
+#define HW_TESTLOOP     0x9502
+#define HW_TESTRX_RAW   0x9602
+#define HW_TESTRX_HDLC  0x9702
+#define HW_TESTRX_OFF   0x9802
+
+struct layer1;
+extern int      l1_event(struct layer1 *, u_int);
+
+
+struct bchannel {
+        struct mISDNchannel     ch;
+        int                     nr;
+        u_long                  Flags;
+        struct work_struct      workq;
+        u_int                   state;
+        /* HW access */
+        u_char                  (*read_reg) (void *, u_char);
+        void                    (*write_reg) (void *, u_char, u_char);
+        void                    (*read_fifo) (void *, u_char *, int);
+        void                    (*write_fifo) (void *, u_char *, int);
+        void                    *hw;
+        int                     slot;   /* multiport card channel slot */
+        struct timer_list       timer;
+        /* receive data */
+        struct sk_buff          *rx_skb;
+        int                     maxlen;
+        /* send data */
+        struct sk_buff          *next_skb;
+        struct sk_buff          *tx_skb;
+        struct sk_buff_head     rqueue;
+        int                     rcount;
+        int                     tx_idx;
+        int                     debug;
+        /* statistics */
+        int                     err_crc;
+        int                     err_tx;
+        int                     err_rx;
+};
+
+extern int      mISDN_initdchannel(struct dchannel *, int, void *);
+extern int      mISDN_initbchannel(struct bchannel *, int);
+extern int      mISDN_freedchannel(struct dchannel *);
+extern int      mISDN_freebchannel(struct bchannel *);
+extern void     queue_ch_frame(struct mISDNchannel *, u_int,
+                        int, struct sk_buff *);
+extern int      dchannel_senddata(struct dchannel *, struct sk_buff *);
+extern int      bchannel_senddata(struct bchannel *, struct sk_buff *);
+extern void     recv_Dchannel(struct dchannel *);
+extern void     recv_Bchannel(struct bchannel *);
+extern void     recv_Dchannel_skb(struct dchannel *, struct sk_buff *);
+extern void     recv_Bchannel_skb(struct bchannel *, struct sk_buff *);
+extern void     confirm_Bsend(struct bchannel *bch);
+extern int      get_next_bframe(struct bchannel *);
+extern int      get_next_dframe(struct dchannel *);
+
+#endif
diff --git a/include/linux/mISDNif.h b/include/linux/mISDNif.h
new file mode 100644
index 000000000000..8f2d60da04e7
--- /dev/null
+++ b/include/linux/mISDNif.h
@@ -0,0 +1,509 @@
+/*
+ *
+ * Author       Karsten Keil <kkeil@novell.com>
+ *
+ * Copyright 2008  by Karsten Keil <kkeil@novell.com>
+ *
+ * This code is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU LESSER GENERAL PUBLIC LICENSE
+ * version 2.1 as published by the Free Software Foundation.
+ *
+ * This code 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 LESSER GENERAL PUBLIC LICENSE for more details.
+ *
+ */
+
+#ifndef mISDNIF_H
+#define mISDNIF_H
+
+#include <stdarg.h>
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/socket.h>
+
+/*
+ * ABI Version 32 bit
+ *
+ * <8 bit> Major version
+ *              - changed if any interface become backwards incompatible
+ *
+ * <8 bit> Minor version
+ *              - changed if any interface is extended but backwards compatible
+ *
+ * <16 bit> Release number
+ *              - should be incremented on every checkin
+ */
+#define MISDN_MAJOR_VERSION     1
+#define MISDN_MINOR_VERSION     0
+#define MISDN_RELEASE           19
+
+/* primitives for information exchange
+ * generell format
+ * <16  bit  0 >
+ * <8  bit command>
+ *    BIT 8 = 1 LAYER private
+ *    BIT 7 = 1 answer
+ *    BIT 6 = 1 DATA
+ * <8  bit target layer mask>
+ *
+ * Layer = 00 is reserved for general commands
+   Layer = 01  L2 -> HW
+   Layer = 02  HW -> L2
+   Layer = 04  L3 -> L2
+   Layer = 08  L2 -> L3
+ * Layer = FF is reserved for broadcast commands
+ */
+
+#define MISDN_CMDMASK           0xff00
+#define MISDN_LAYERMASK         0x00ff
+
+/* generell commands */
+#define OPEN_CHANNEL            0x0100
+#define CLOSE_CHANNEL           0x0200
+#define CONTROL_CHANNEL         0x0300
+#define CHECK_DATA              0x0400
+
+/* layer 2 -> layer 1 */
+#define PH_ACTIVATE_REQ         0x0101
+#define PH_DEACTIVATE_REQ       0x0201
+#define PH_DATA_REQ             0x2001
+#define MPH_ACTIVATE_REQ        0x0501
+#define MPH_DEACTIVATE_REQ      0x0601
+#define MPH_INFORMATION_REQ     0x0701
+#define PH_CONTROL_REQ          0x0801
+
+/* layer 1 -> layer 2 */
+#define PH_ACTIVATE_IND         0x0102
+#define PH_ACTIVATE_CNF         0x4102
+#define PH_DEACTIVATE_IND       0x0202
+#define PH_DEACTIVATE_CNF       0x4202
+#define PH_DATA_IND             0x2002
+#define MPH_ACTIVATE_IND        0x0502
+#define MPH_DEACTIVATE_IND      0x0602
+#define MPH_INFORMATION_IND     0x0702
+#define PH_DATA_CNF             0x6002
+#define PH_CONTROL_IND          0x0802
+#define PH_CONTROL_CNF          0x4802
+
+/* layer 3 -> layer 2 */
+#define DL_ESTABLISH_REQ        0x1004
+#define DL_RELEASE_REQ          0x1104
+#define DL_DATA_REQ             0x3004
+#define DL_UNITDATA_REQ         0x3104
+#define DL_INFORMATION_REQ      0x0004
+
+/* layer 2 -> layer 3 */
+#define DL_ESTABLISH_IND        0x1008
+#define DL_ESTABLISH_CNF        0x5008
+#define DL_RELEASE_IND          0x1108
+#define DL_RELEASE_CNF          0x5108
+#define DL_DATA_IND             0x3008
+#define DL_UNITDATA_IND         0x3108
+#define DL_INFORMATION_IND      0x0008
+
+/* intern layer 2 managment */
+#define MDL_ASSIGN_REQ          0x1804
+#define MDL_ASSIGN_IND          0x1904
+#define MDL_REMOVE_REQ          0x1A04
+#define MDL_REMOVE_IND          0x1B04
+#define MDL_STATUS_UP_IND       0x1C04
+#define MDL_STATUS_DOWN_IND     0x1D04
+#define MDL_STATUS_UI_IND       0x1E04
+#define MDL_ERROR_IND           0x1F04
+#define MDL_ERROR_RSP           0x5F04
+
+/* DL_INFORMATION_IND types */
+#define DL_INFO_L2_CONNECT      0x0001
+#define DL_INFO_L2_REMOVED      0x0002
+
+/* PH_CONTROL types */
+/* TOUCH TONE IS 0x20XX  XX "0"..."9", "A","B","C","D","*","#" */
+#define DTMF_TONE_VAL           0x2000
+#define DTMF_TONE_MASK          0x007F
+#define DTMF_TONE_START         0x2100
+#define DTMF_TONE_STOP          0x2200
+#define DTMF_HFC_COEF           0x4000
+#define DSP_CONF_JOIN           0x2403
+#define DSP_CONF_SPLIT          0x2404
+#define DSP_RECEIVE_OFF         0x2405
+#define DSP_RECEIVE_ON          0x2406
+#define DSP_ECHO_ON             0x2407
+#define DSP_ECHO_OFF            0x2408
+#define DSP_MIX_ON              0x2409
+#define DSP_MIX_OFF             0x240a
+#define DSP_DELAY               0x240b
+#define DSP_JITTER              0x240c
+#define DSP_TXDATA_ON           0x240d
+#define DSP_TXDATA_OFF          0x240e
+#define DSP_TX_DEJITTER         0x240f
+#define DSP_TX_DEJ_OFF          0x2410
+#define DSP_TONE_PATT_ON        0x2411
+#define DSP_TONE_PATT_OFF       0x2412
+#define DSP_VOL_CHANGE_TX       0x2413
+#define DSP_VOL_CHANGE_RX       0x2414
+#define DSP_BF_ENABLE_KEY       0x2415
+#define DSP_BF_DISABLE          0x2416
+#define DSP_BF_ACCEPT           0x2416
+#define DSP_BF_REJECT           0x2417
+#define DSP_PIPELINE_CFG        0x2418
+#define HFC_VOL_CHANGE_TX       0x2601
+#define HFC_VOL_CHANGE_RX       0x2602
+#define HFC_SPL_LOOP_ON         0x2603
+#define HFC_SPL_LOOP_OFF        0x2604
+
+/* DSP_TONE_PATT_ON parameter */
+#define TONE_OFF                        0x0000
+#define TONE_GERMAN_DIALTONE            0x0001
+#define TONE_GERMAN_OLDDIALTONE         0x0002
+#define TONE_AMERICAN_DIALTONE          0x0003
+#define TONE_GERMAN_DIALPBX             0x0004
+#define TONE_GERMAN_OLDDIALPBX          0x0005
+#define TONE_AMERICAN_DIALPBX           0x0006
+#define TONE_GERMAN_RINGING             0x0007
+#define TONE_GERMAN_OLDRINGING          0x0008
+#define TONE_AMERICAN_RINGPBX           0x000b
+#define TONE_GERMAN_RINGPBX             0x000c
+#define TONE_GERMAN_OLDRINGPBX          0x000d
+#define TONE_AMERICAN_RINGING           0x000e
+#define TONE_GERMAN_BUSY                0x000f
+#define TONE_GERMAN_OLDBUSY             0x0010
+#define TONE_AMERICAN_BUSY              0x0011
+#define TONE_GERMAN_HANGUP              0x0012
+#define TONE_GERMAN_OLDHANGUP           0x0013
+#define TONE_AMERICAN_HANGUP            0x0014
+#define TONE_SPECIAL_INFO               0x0015
+#define TONE_GERMAN_GASSENBESETZT       0x0016
+#define TONE_GERMAN_AUFSCHALTTON        0x0016
+
+/* MPH_INFORMATION_IND */
+#define L1_SIGNAL_LOS_OFF       0x0010
+#define L1_SIGNAL_LOS_ON        0x0011
+#define L1_SIGNAL_AIS_OFF       0x0012
+#define L1_SIGNAL_AIS_ON        0x0013
+#define L1_SIGNAL_RDI_OFF       0x0014
+#define L1_SIGNAL_RDI_ON        0x0015
+#define L1_SIGNAL_SLIP_RX       0x0020
+#define L1_SIGNAL_SLIP_TX       0x0021
+
+/*
+ * protocol ids
+ * D channel 1-31
+ * B channel 33 - 63
+ */
+
+#define ISDN_P_NONE             0
+#define ISDN_P_BASE             0
+#define ISDN_P_TE_S0            0x01
+#define ISDN_P_NT_S0            0x02
+#define ISDN_P_TE_E1            0x03
+#define ISDN_P_NT_E1            0x04
+#define ISDN_P_LAPD_TE          0x10
+#define ISDN_P_LAPD_NT          0x11
+
+#define ISDN_P_B_MASK           0x1f
+#define ISDN_P_B_START          0x20
+
+#define ISDN_P_B_RAW            0x21
+#define ISDN_P_B_HDLC           0x22
+#define ISDN_P_B_X75SLP         0x23
+#define ISDN_P_B_L2DTMF         0x24
+#define ISDN_P_B_L2DSP          0x25
+#define ISDN_P_B_L2DSPHDLC      0x26
+
+#define OPTION_L2_PMX           1
+#define OPTION_L2_PTP           2
+#define OPTION_L2_FIXEDTEI      3
+#define OPTION_L2_CLEANUP       4
+
+/* should be in sync with linux/kobject.h:KOBJ_NAME_LEN */
+#define MISDN_MAX_IDLEN         20
+
+struct mISDNhead {
+        unsigned int    prim;
+        unsigned int    id;
+}  __attribute__((packed));
+
+#define MISDN_HEADER_LEN        sizeof(struct mISDNhead)
+#define MAX_DATA_SIZE           2048
+#define MAX_DATA_MEM            (MAX_DATA_SIZE + MISDN_HEADER_LEN)
+#define MAX_DFRAME_LEN          260
+
+#define MISDN_ID_ADDR_MASK      0xFFFF
+#define MISDN_ID_TEI_MASK       0xFF00
+#define MISDN_ID_SAPI_MASK      0x00FF
+#define MISDN_ID_TEI_ANY        0x7F00
+
+#define MISDN_ID_ANY            0xFFFF
+#define MISDN_ID_NONE           0xFFFE
+
+#define GROUP_TEI               127
+#define TEI_SAPI                63
+#define CTRL_SAPI               0
+
+#define MISDN_MAX_CHANNEL       127
+#define MISDN_CHMAP_SIZE        ((MISDN_MAX_CHANNEL + 1) >> 3)
+
+#define SOL_MISDN       0
+
+struct sockaddr_mISDN {
+        sa_family_t    family;
+        unsigned char   dev;
+        unsigned char   channel;
+        unsigned char   sapi;
+        unsigned char   tei;
+};
+
+/* timer device ioctl */
+#define IMADDTIMER      _IOR('I', 64, int)
+#define IMDELTIMER      _IOR('I', 65, int)
+/* socket ioctls */
+#define IMGETVERSION    _IOR('I', 66, int)
+#define IMGETCOUNT      _IOR('I', 67, int)
+#define IMGETDEVINFO    _IOR('I', 68, int)
+#define IMCTRLREQ       _IOR('I', 69, int)
+#define IMCLEAR_L2      _IOR('I', 70, int)
+
+struct mISDNversion {
+        unsigned char   major;
+        unsigned char   minor;
+        unsigned short  release;
+};
+
+struct mISDN_devinfo {
+        u_int                   id;
+        u_int                   Dprotocols;
+        u_int                   Bprotocols;
+        u_int                   protocol;
+        u_char                  channelmap[MISDN_CHMAP_SIZE];
+        u_int                   nrbchan;
+        char                    name[MISDN_MAX_IDLEN];
+};
+
+static inline int
+test_channelmap(u_int nr, u_char *map)
+{
+        if (nr <= MISDN_MAX_CHANNEL)
+                return map[nr >> 3] & (1 << (nr & 7));
+        else
+                return 0;
+}
+
+static inline void
+set_channelmap(u_int nr, u_char *map)
+{
+        map[nr >> 3] |= (1 << (nr & 7));
+}
+
+static inline void
+clear_channelmap(u_int nr, u_char *map)
+{
+        map[nr >> 3] &= ~(1 << (nr & 7));
+}
+
+/* CONTROL_CHANNEL parameters */
+#define MISDN_CTRL_GETOP                0x0000
+#define MISDN_CTRL_LOOP                 0x0001
+#define MISDN_CTRL_CONNECT              0x0002
+#define MISDN_CTRL_DISCONNECT           0x0004
+#define MISDN_CTRL_PCMCONNECT           0x0010
+#define MISDN_CTRL_PCMDISCONNECT        0x0020
+#define MISDN_CTRL_SETPEER              0x0040
+#define MISDN_CTRL_UNSETPEER            0x0080
+#define MISDN_CTRL_RX_OFF               0x0100
+#define MISDN_CTRL_HW_FEATURES_OP       0x2000
+#define MISDN_CTRL_HW_FEATURES          0x2001
+#define MISDN_CTRL_HFC_OP               0x4000
+#define MISDN_CTRL_HFC_PCM_CONN         0x4001
+#define MISDN_CTRL_HFC_PCM_DISC         0x4002
+#define MISDN_CTRL_HFC_CONF_JOIN        0x4003
+#define MISDN_CTRL_HFC_CONF_SPLIT       0x4004
+#define MISDN_CTRL_HFC_RECEIVE_OFF      0x4005
+#define MISDN_CTRL_HFC_RECEIVE_ON       0x4006
+#define MISDN_CTRL_HFC_ECHOCAN_ON       0x4007
+#define MISDN_CTRL_HFC_ECHOCAN_OFF      0x4008
+
+
+/* socket options */
+#define MISDN_TIME_STAMP                0x0001
+
+struct mISDN_ctrl_req {
+        int             op;
+        int             channel;
+        int             p1;
+        int             p2;
+};
+
+/* muxer options */
+#define MISDN_OPT_ALL           1
+#define MISDN_OPT_TEIMGR        2
+
+#ifdef __KERNEL__
+#include <linux/list.h>
+#include <linux/skbuff.h>
+#include <linux/net.h>
+#include <net/sock.h>
+#include <linux/completion.h>
+
+#define DEBUG_CORE              0x000000ff
+#define DEBUG_CORE_FUNC         0x00000002
+#define DEBUG_SOCKET            0x00000004
+#define DEBUG_MANAGER           0x00000008
+#define DEBUG_SEND_ERR          0x00000010
+#define DEBUG_MSG_THREAD        0x00000020
+#define DEBUG_QUEUE_FUNC        0x00000040
+#define DEBUG_L1                0x0000ff00
+#define DEBUG_L1_FSM            0x00000200
+#define DEBUG_L2                0x00ff0000
+#define DEBUG_L2_FSM            0x00020000
+#define DEBUG_L2_CTRL           0x00040000
+#define DEBUG_L2_RECV           0x00080000
+#define DEBUG_L2_TEI            0x00100000
+#define DEBUG_L2_TEIFSM         0x00200000
+#define DEBUG_TIMER             0x01000000
+
+#define mISDN_HEAD_P(s)         ((struct mISDNhead *)&s->cb[0])
+#define mISDN_HEAD_PRIM(s)      (((struct mISDNhead *)&s->cb[0])->prim)
+#define mISDN_HEAD_ID(s)        (((struct mISDNhead *)&s->cb[0])->id)
+
+/* socket states */
+#define MISDN_OPEN      1
+#define MISDN_BOUND     2
+#define MISDN_CLOSED    3
+
+struct mISDNchannel;
+struct mISDNdevice;
+struct mISDNstack;
+
+struct channel_req {
+        u_int                   protocol;
+        struct sockaddr_mISDN   adr;
+        struct mISDNchannel     *ch;
+};
+
+typedef int     (ctrl_func_t)(struct mISDNchannel *, u_int, void *);
+typedef int     (send_func_t)(struct mISDNchannel *, struct sk_buff *);
+typedef int     (create_func_t)(struct channel_req *);
+
+struct Bprotocol {
+        struct list_head        list;
+        char                    *name;
+        u_int                   Bprotocols;
+        create_func_t           *create;
+};
+
+struct mISDNchannel {
+        struct list_head        list;
+        u_int                   protocol;
+        u_int                   nr;
+        u_long                  opt;
+        u_int                   addr;
+        struct mISDNstack       *st;
+        struct mISDNchannel     *peer;
+        send_func_t             *send;
+        send_func_t             *recv;
+        ctrl_func_t             *ctrl;
+};
+
+struct mISDN_sock_list {
+        struct hlist_head       head;
+        rwlock_t                lock;
+};
+
+struct mISDN_sock {
+        struct sock             sk;
+        struct mISDNchannel     ch;
+        u_int                   cmask;
+        struct mISDNdevice      *dev;
+};
+
+
+
+struct mISDNdevice {
+        struct mISDNchannel     D;
+        u_int                   id;
+        char                    name[MISDN_MAX_IDLEN];
+        u_int                   Dprotocols;
+        u_int                   Bprotocols;
+        u_int                   nrbchan;
+        u_char                  channelmap[MISDN_CHMAP_SIZE];
+        struct list_head        bchannels;
+        struct mISDNchannel     *teimgr;
+        struct device           dev;
+};
+
+struct mISDNstack {
+        u_long                  status;
+        struct mISDNdevice      *dev;
+        struct task_struct      *thread;
+        struct completion       *notify;
+        wait_queue_head_t       workq;
+        struct sk_buff_head     msgq;
+        struct list_head        layer2;
+        struct mISDNchannel     *layer1;
+        struct mISDNchannel     own;
+        struct mutex            lmutex; /* protect lists */
+        struct mISDN_sock_list  l1sock;
+#ifdef MISDN_MSG_STATS
+        u_int                   msg_cnt;
+        u_int                   sleep_cnt;
+        u_int                   stopped_cnt;
+#endif
+};
+
+/* global alloc/queue functions */
+
+static inline struct sk_buff *
+mI_alloc_skb(unsigned int len, gfp_t gfp_mask)
+{
+        struct sk_buff  *skb;
+
+        skb = alloc_skb(len + MISDN_HEADER_LEN, gfp_mask);
+        if (likely(skb))
+                skb_reserve(skb, MISDN_HEADER_LEN);
+        return skb;
+}
+
+static inline struct sk_buff *
+_alloc_mISDN_skb(u_int prim, u_int id, u_int len, void *dp, gfp_t gfp_mask)
+{
+        struct sk_buff  *skb = mI_alloc_skb(len, gfp_mask);
+        struct mISDNhead *hh;
+
+        if (!skb)
+                return NULL;
+        if (len)
+                memcpy(skb_put(skb, len), dp, len);
+        hh = mISDN_HEAD_P(skb);
+        hh->prim = prim;
+        hh->id = id;
+        return skb;
+}
+
+static inline void
+_queue_data(struct mISDNchannel *ch, u_int prim,
+    u_int id, u_int len, void *dp, gfp_t gfp_mask)
+{
+        struct sk_buff          *skb;
+
+        if (!ch->peer)
+                return;
+        skb = _alloc_mISDN_skb(prim, id, len, dp, gfp_mask);
+        if (!skb)
+                return;
+        if (ch->recv(ch->peer, skb))
+                dev_kfree_skb(skb);
+}
+
+/* global register/unregister functions */
+
+extern int      mISDN_register_device(struct mISDNdevice *, char *name);
+extern void     mISDN_unregister_device(struct mISDNdevice *);
+extern int      mISDN_register_Bprotocol(struct Bprotocol *);
+extern void     mISDN_unregister_Bprotocol(struct Bprotocol *);
+
+extern void     set_channel_address(struct mISDNchannel *, u_int, u_int);
+
+#endif /* __KERNEL__ */
+#endif /* mISDNIF_H */
diff --git a/include/linux/maple.h b/include/linux/maple.h
index d31e36ebb436..c23d3f51ba40 100644
--- a/include/linux/maple.h
+++ b/include/linux/maple.h
@@ -2,6 +2,7 @@
 #define __LINUX_MAPLE_H
 
 #include <linux/device.h>
+#include <mach/maple.h>
 
 extern struct bus_type maple_bus_type;
 
@@ -33,6 +34,7 @@ struct mapleq {
         void *sendbuf, *recvbuf, *recvbufdcsp;
         unsigned char length;
         enum maple_code command;
+        struct mutex mutex;
 };
 
 struct maple_devinfo {
@@ -49,7 +51,6 @@ struct maple_devinfo {
 struct maple_device {
         struct maple_driver *driver;
         struct mapleq *mq;
-        void *private_data;
         void (*callback) (struct mapleq * mq);
         unsigned long when, interval, function;
         struct maple_devinfo devinfo;
@@ -61,8 +62,6 @@ struct maple_device {
 
 struct maple_driver {
         unsigned long function;
-        int (*connect) (struct maple_device * dev);
-        void (*disconnect) (struct maple_device * dev);
         struct device_driver drv;
 };
 
@@ -70,10 +69,17 @@ void maple_getcond_callback(struct maple_device *dev,
                             void (*callback) (struct mapleq * mq),
                             unsigned long interval,
                             unsigned long function);
-int maple_driver_register(struct device_driver *drv);
-void maple_add_packet(struct mapleq *mq);
+int maple_driver_register(struct maple_driver *);
+void maple_driver_unregister(struct maple_driver *);
+
+int maple_add_packet_sleeps(struct maple_device *mdev, u32 function,
+        u32 command, u32 length, void *data);
+void maple_clear_dev(struct maple_device *mdev);
 
 #define to_maple_dev(n) container_of(n, struct maple_device, dev)
 #define to_maple_driver(n) container_of(n, struct maple_driver, drv)
 
+#define maple_get_drvdata(d)            dev_get_drvdata(&(d)->dev)
+#define maple_set_drvdata(d,p)          dev_set_drvdata(&(d)->dev, (p))
+
 #endif                          /* __LINUX_MAPLE_H */
diff --git a/include/linux/memstick.h b/include/linux/memstick.h
index 37a5cdb03918..a9f998a3f48b 100644
--- a/include/linux/memstick.h
+++ b/include/linux/memstick.h
@@ -263,6 +263,10 @@ struct memstick_dev {
         /* Get next request from the media driver.                         */
         int                      (*next_request)(struct memstick_dev *card,
                                                  struct memstick_request **mrq);
+        /* Tell the media driver to stop doing things                      */
+        void                     (*stop)(struct memstick_dev *card);
+        /* Allow the media driver to continue                              */
+        void                     (*start)(struct memstick_dev *card);
 
         struct device            dev;
 };
@@ -284,7 +288,7 @@ struct memstick_host {
         /* Notify the host that some requests are pending. */
         void                (*request)(struct memstick_host *host);
         /* Set host IO parameters (power, clock, etc).     */
-        void                (*set_param)(struct memstick_host *host,
+        int                 (*set_param)(struct memstick_host *host,
                                          enum memstick_param param,
                                          int value);
         unsigned long       private[0] ____cacheline_aligned;
diff --git a/include/linux/mfd/core.h b/include/linux/mfd/core.h
index bb3dd0545928..49ef857cdb2d 100644
--- a/include/linux/mfd/core.h
+++ b/include/linux/mfd/core.h
@@ -1,5 +1,3 @@
-#ifndef MFD_CORE_H
-#define MFD_CORE_H
 /*
  * drivers/mfd/mfd-core.h
  *
@@ -13,6 +11,9 @@
  *
  */
 
+#ifndef MFD_CORE_H
+#define MFD_CORE_H
+
 #include <linux/platform_device.h>
 
 /*
@@ -28,7 +29,13 @@ struct mfd_cell {
         int                     (*suspend)(struct platform_device *dev);
         int                     (*resume)(struct platform_device *dev);
 
-        void                    *driver_data; /* driver-specific data */
+        /* driver-specific data for MFD-aware "cell" drivers */
+        void                    *driver_data;
+
+        /* platform_data can be used to either pass data to "generic"
+           driver or as a hook to mfd_cell for the "cell" drivers */
+        void                    *platform_data;
+        size_t                  data_size;
 
         /*
          * This resources can be specified relatievly to the parent device.
@@ -38,18 +45,11 @@ struct mfd_cell {
         const struct resource   *resources;
 };
 
-static inline struct mfd_cell *
-mfd_get_cell(struct platform_device *pdev)
-{
-        return (struct mfd_cell *)pdev->dev.platform_data;
-}
-
-extern int mfd_add_devices(
-                struct platform_device *parent,
-                const struct mfd_cell *cells, int n_devs,
-                struct resource *mem_base,
-                int irq_base);
+extern int mfd_add_devices(struct device *parent, int id,
+                           const struct mfd_cell *cells, int n_devs,
+                           struct resource *mem_base,
+                           int irq_base);
 
-extern void mfd_remove_devices(struct platform_device *parent);
+extern void mfd_remove_devices(struct device *parent);
 
 #endif
diff --git a/include/linux/mfd/t7l66xb.h b/include/linux/mfd/t7l66xb.h
new file mode 100644
index 000000000000..e83c7f2036f9
--- /dev/null
+++ b/include/linux/mfd/t7l66xb.h
@@ -0,0 +1,36 @@
+/*
+ * This file contains the definitions for the T7L66XB
+ *
+ * (C) Copyright 2005 Ian Molton <spyro@f2s.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+#ifndef MFD_T7L66XB_H
+#define MFD_T7L66XB_H
+
+#include <linux/mfd/core.h>
+#include <linux/mfd/tmio.h>
+
+struct t7l66xb_platform_data {
+        int (*enable_clk32k)(struct platform_device *dev);
+        void (*disable_clk32k)(struct platform_device *dev);
+        int (*enable)(struct platform_device *dev);
+        int (*disable)(struct platform_device *dev);
+        int (*suspend)(struct platform_device *dev);
+        int (*resume)(struct platform_device *dev);
+
+        int irq_base; /* The base for subdevice irqs */
+
+        struct tmio_nand_data *nand_data;
+};
+
+
+#define IRQ_T7L66XB_MMC        (1)
+#define IRQ_T7L66XB_NAND       (3)
+
+#define T7L66XB_NR_IRQS 8
+
+#endif
diff --git a/include/linux/mfd/tc6387xb.h b/include/linux/mfd/tc6387xb.h
new file mode 100644
index 000000000000..fa06e0610b8e
--- /dev/null
+++ b/include/linux/mfd/tc6387xb.h
@@ -0,0 +1,23 @@
+/*
+ * This file contains the definitions for the TC6387XB
+ *
+ * (C) Copyright 2005 Ian Molton <spyro@f2s.com>
+ *
+ * May be copied or modified under the terms of the GNU General Public
+ * License.  See linux/COPYING for more information.
+ *
+ */
+#ifndef MFD_TC6387XB_H
+#define MFD_TC6387XB_H
+
+struct tc6387xb_platform_data {
+        int (*enable_clk32k)(struct platform_device *dev);
+        void (*disable_clk32k)(struct platform_device *dev);
+
+        int (*enable)(struct platform_device *dev);
+        int (*disable)(struct platform_device *dev);
+        int (*suspend)(struct platform_device *dev);
+        int (*resume)(struct platform_device *dev);
+};
+
+#endif
diff --git a/include/linux/mfd/tc6393xb.h b/include/linux/mfd/tc6393xb.h
index 7cc824a58f7c..fec7b3f7a81f 100644
--- a/include/linux/mfd/tc6393xb.h
+++ b/include/linux/mfd/tc6393xb.h
@@ -14,8 +14,8 @@
  * published by the Free Software Foundation.
  */
 
-#ifndef TC6393XB_H
-#define TC6393XB_H
+#ifndef MFD_TC6393XB_H
+#define MFD_TC6393XB_H
 
 /* Also one should provide the CK3P6MI clock */
 struct tc6393xb_platform_data {
@@ -29,7 +29,7 @@ struct tc6393xb_platform_data {
         int     (*suspend)(struct platform_device *dev);
         int     (*resume)(struct platform_device *dev);
 
-        int     irq_base;       /* a base for cascaded irq */
+        int     irq_base;       /* base for subdevice irqs */
         int     gpio_base;
 
         struct tmio_nand_data   *nand_data;
@@ -40,9 +40,6 @@ struct tc6393xb_platform_data {
  */
 #define IRQ_TC6393_NAND         0
 #define IRQ_TC6393_MMC          1
-#define IRQ_TC6393_OHCI         2
-#define IRQ_TC6393_SERIAL       3
-#define IRQ_TC6393_FB           4
 
 #define TC6393XB_NR_IRQS        8
 
diff --git a/include/linux/mfd/tmio.h b/include/linux/mfd/tmio.h
index 9438d8c9ac1c..ec612e66391c 100644
--- a/include/linux/mfd/tmio.h
+++ b/include/linux/mfd/tmio.h
@@ -1,6 +1,21 @@
 #ifndef MFD_TMIO_H
 #define MFD_TMIO_H
 
+#define tmio_ioread8(addr) readb(addr)
+#define tmio_ioread16(addr) readw(addr)
+#define tmio_ioread16_rep(r, b, l) readsw(r, b, l)
+#define tmio_ioread32(addr) \
+        (((u32) readw((addr))) | (((u32) readw((addr) + 2)) << 16))
+
+#define tmio_iowrite8(val, addr) writeb((val), (addr))
+#define tmio_iowrite16(val, addr) writew((val), (addr))
+#define tmio_iowrite16_rep(r, b, l) writesw(r, b, l)
+#define tmio_iowrite32(val, addr) \
+        do { \
+        writew((val),       (addr)); \
+        writew((val) >> 16, (addr) + 2); \
+        } while (0)
+
 /*
  * data for the NAND controller
  */
@@ -10,8 +25,4 @@ struct tmio_nand_data {
         unsigned int            num_partitions;
 };
 
-#define TMIO_NAND_CONFIG        "tmio-nand-config"
-#define TMIO_NAND_CONTROL       "tmio-nand-control"
-#define TMIO_NAND_IRQ           "tmio-nand"
-
 #endif
diff --git a/include/linux/mlx4/cq.h b/include/linux/mlx4/cq.h
index 071cf96cf01f..6f65b2c8bb89 100644
--- a/include/linux/mlx4/cq.h
+++ b/include/linux/mlx4/cq.h
@@ -39,17 +39,18 @@
 #include <linux/mlx4/doorbell.h>
 
 struct mlx4_cqe {
-        __be32                  my_qpn;
+        __be32                  vlan_my_qpn;
         __be32                  immed_rss_invalid;
         __be32                  g_mlpath_rqpn;
-        u8                      sl;
-        u8                      reserved1;
+        __be16                  sl_vid;
         __be16                  rlid;
-        __be32                  ipoib_status;
+        __be16                  status;
+        u8                      ipv6_ext_mask;
+        u8                      badfcs_enc;
         __be32                  byte_cnt;
         __be16                  wqe_index;
         __be16                  checksum;
-        u8                      reserved2[3];
+        u8                      reserved[3];
         u8                      owner_sr_opcode;
 };
 
@@ -64,6 +65,11 @@ struct mlx4_err_cqe {
 };
 
 enum {
+        MLX4_CQE_VLAN_PRESENT_MASK      = 1 << 29,
+        MLX4_CQE_QPN_MASK               = 0xffffff,
+};
+
+enum {
         MLX4_CQE_OWNER_MASK     = 0x80,
         MLX4_CQE_IS_SEND_MASK   = 0x40,
         MLX4_CQE_OPCODE_MASK    = 0x1f
@@ -86,13 +92,19 @@ enum {
 };
 
 enum {
-        MLX4_CQE_IPOIB_STATUS_IPV4                      = 1 << 22,
-        MLX4_CQE_IPOIB_STATUS_IPV4F                     = 1 << 23,
-        MLX4_CQE_IPOIB_STATUS_IPV6                      = 1 << 24,
-        MLX4_CQE_IPOIB_STATUS_IPV4OPT                   = 1 << 25,
-        MLX4_CQE_IPOIB_STATUS_TCP                       = 1 << 26,
-        MLX4_CQE_IPOIB_STATUS_UDP                       = 1 << 27,
-        MLX4_CQE_IPOIB_STATUS_IPOK                      = 1 << 28,
+        MLX4_CQE_STATUS_IPV4            = 1 << 6,
+        MLX4_CQE_STATUS_IPV4F           = 1 << 7,
+        MLX4_CQE_STATUS_IPV6            = 1 << 8,
+        MLX4_CQE_STATUS_IPV4OPT         = 1 << 9,
+        MLX4_CQE_STATUS_TCP             = 1 << 10,
+        MLX4_CQE_STATUS_UDP             = 1 << 11,
+        MLX4_CQE_STATUS_IPOK            = 1 << 12,
+};
+
+enum {
+        MLX4_CQE_LLC                     = 1,
+        MLX4_CQE_SNAP                    = 1 << 1,
+        MLX4_CQE_BAD_FCS                 = 1 << 4,
 };
 
 static inline void mlx4_cq_arm(struct mlx4_cq *cq, u32 cmd,
diff --git a/include/linux/mlx4/qp.h b/include/linux/mlx4/qp.h
index e27082cd650e..bf8f11982dae 100644
--- a/include/linux/mlx4/qp.h
+++ b/include/linux/mlx4/qp.h
@@ -164,11 +164,13 @@ enum {
         MLX4_WQE_CTRL_SOLICITED         = 1 << 1,
         MLX4_WQE_CTRL_IP_CSUM           = 1 << 4,
         MLX4_WQE_CTRL_TCP_UDP_CSUM      = 1 << 5,
+        MLX4_WQE_CTRL_INS_VLAN          = 1 << 6,
 };
 
 struct mlx4_wqe_ctrl_seg {
         __be32                  owner_opcode;
-        u8                      reserved2[3];
+        __be16                  vlan_tag;
+        u8                      ins_vlan;
         u8                      fence_size;
         /*
          * High 24 bits are SRC remote buffer; low 8 bits are flags:
diff --git a/include/linux/mm.h b/include/linux/mm.h
index d87a5a5fe87d..72a15dc26bbf 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -73,7 +73,7 @@ extern unsigned int kobjsize(const void *objp);
 #endif
 
 /*
- * vm_flags..
+ * vm_flags in vm_area_struct, see mm_types.h.
  */
 #define VM_READ         0x00000001      /* currently active flags */
 #define VM_WRITE        0x00000002
@@ -744,6 +744,8 @@ struct zap_details {
 struct page *vm_normal_page(struct vm_area_struct *vma, unsigned long addr,
                 pte_t pte);
 
+int zap_vma_ptes(struct vm_area_struct *vma, unsigned long address,
+                unsigned long size);
 unsigned long zap_page_range(struct vm_area_struct *vma, unsigned long address,
                 unsigned long size, struct zap_details *);
 unsigned long unmap_vmas(struct mmu_gather **tlb,
@@ -810,7 +812,6 @@ extern int access_process_vm(struct task_struct *tsk, unsigned long addr, void *
 
 int get_user_pages(struct task_struct *tsk, struct mm_struct *mm, unsigned long start,
                 int len, int write, int force, struct page **pages, struct vm_area_struct **vmas);
-void print_bad_pte(struct vm_area_struct *, pte_t, unsigned long);
 
 extern int try_to_release_page(struct page * page, gfp_t gfp_mask);
 extern void do_invalidatepage(struct page *page, unsigned long offset);
@@ -834,6 +835,19 @@ extern int mprotect_fixup(struct vm_area_struct *vma,
                           unsigned long end, unsigned long newflags);
 
 /*
+ * get_user_pages_fast provides equivalent functionality to get_user_pages,
+ * operating on current and current->mm (force=0 and doesn't return any vmas).
+ *
+ * get_user_pages_fast may take mmap_sem and page tables, so no assumptions
+ * can be made about locking. get_user_pages_fast is to be implemented in a
+ * way that is advantageous (vs get_user_pages()) when the user memory area is
+ * already faulted in and present in ptes. However if the pages have to be
+ * faulted in, it may turn out to be slightly slower).
+ */
+int get_user_pages_fast(unsigned long start, int nr_pages, int write,
+                        struct page **pages);
+
+/*
  * A callback you can register to apply pressure to ageable caches.
  *
  * 'shrink' is passed a count 'nr_to_scan' and a 'gfpmask'.  It should
@@ -1009,7 +1023,6 @@ extern unsigned long absent_pages_in_range(unsigned long start_pfn,
 extern void get_pfn_range_for_nid(unsigned int nid,
                         unsigned long *start_pfn, unsigned long *end_pfn);
 extern unsigned long find_min_pfn_with_active_regions(void);
-extern unsigned long find_max_pfn_with_active_regions(void);
 extern void free_bootmem_with_active_regions(int nid,
                                                 unsigned long max_low_pfn);
 typedef int (*work_fn_t)(unsigned long, unsigned long, void *);
@@ -1072,6 +1085,9 @@ extern struct vm_area_struct *copy_vma(struct vm_area_struct **,
         unsigned long addr, unsigned long len, pgoff_t pgoff);
 extern void exit_mmap(struct mm_struct *);
 
+extern int mm_take_all_locks(struct mm_struct *mm);
+extern void mm_drop_all_locks(struct mm_struct *mm);
+
 #ifdef CONFIG_PROC_FS
 /* From fs/proc/base.c. callers must _not_ hold the mm's exe_file_lock */
 extern void added_exe_file_vma(struct mm_struct *mm);
diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
index 746f975b58ef..bf334138c7c1 100644
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -10,6 +10,7 @@
 #include <linux/rbtree.h>
 #include <linux/rwsem.h>
 #include <linux/completion.h>
+#include <linux/cpumask.h>
 #include <asm/page.h>
 #include <asm/mmu.h>
 
@@ -112,7 +113,7 @@ struct vm_area_struct {
         struct vm_area_struct *vm_next;
 
         pgprot_t vm_page_prot;          /* Access permissions of this VMA. */
-        unsigned long vm_flags;         /* Flags, listed below. */
+        unsigned long vm_flags;         /* Flags, see mm.h. */
 
         struct rb_node vm_rb;
 
@@ -253,6 +254,9 @@ struct mm_struct {
         struct file *exe_file;
         unsigned long num_exe_file_vmas;
 #endif
+#ifdef CONFIG_MMU_NOTIFIER
+        struct mmu_notifier_mm *mmu_notifier_mm;
+#endif
 };
 
 #endif /* _LINUX_MM_TYPES_H */
diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
index 0d508ac17d64..ee6e822d5994 100644
--- a/include/linux/mmc/card.h
+++ b/include/linux/mmc/card.h
@@ -111,6 +111,8 @@ struct mmc_card {
         unsigned                num_info;       /* number of info strings */
         const char              **info;         /* info strings */
         struct sdio_func_tuple  *tuples;        /* unknown common tuples */
+
+        struct dentry           *debugfs_root;
 };
 
 #define mmc_card_mmc(c)         ((c)->type == MMC_TYPE_MMC)
diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h
index 10a2080086ca..9c288c909878 100644
--- a/include/linux/mmc/host.h
+++ b/include/linux/mmc/host.h
@@ -157,6 +157,8 @@ struct mmc_host {
         struct led_trigger      *led;           /* activity led */
 #endif
 
+        struct dentry           *debugfs_root;
+
         unsigned long           private[0] ____cacheline_aligned;
 };
 
diff --git a/include/linux/mmu_notifier.h b/include/linux/mmu_notifier.h
new file mode 100644
index 000000000000..b77486d152cd
--- /dev/null
+++ b/include/linux/mmu_notifier.h
@@ -0,0 +1,279 @@
+#ifndef _LINUX_MMU_NOTIFIER_H
+#define _LINUX_MMU_NOTIFIER_H
+
+#include <linux/list.h>
+#include <linux/spinlock.h>
+#include <linux/mm_types.h>
+
+struct mmu_notifier;
+struct mmu_notifier_ops;
+
+#ifdef CONFIG_MMU_NOTIFIER
+
+/*
+ * The mmu notifier_mm structure is allocated and installed in
+ * mm->mmu_notifier_mm inside the mm_take_all_locks() protected
+ * critical section and it's released only when mm_count reaches zero
+ * in mmdrop().
+ */
+struct mmu_notifier_mm {
+        /* all mmu notifiers registerd in this mm are queued in this list */
+        struct hlist_head list;
+        /* to serialize the list modifications and hlist_unhashed */
+        spinlock_t lock;
+};
+
+struct mmu_notifier_ops {
+        /*
+         * Called either by mmu_notifier_unregister or when the mm is
+         * being destroyed by exit_mmap, always before all pages are
+         * freed. This can run concurrently with other mmu notifier
+         * methods (the ones invoked outside the mm context) and it
+         * should tear down all secondary mmu mappings and freeze the
+         * secondary mmu. If this method isn't implemented you've to
+         * be sure that nothing could possibly write to the pages
+         * through the secondary mmu by the time the last thread with
+         * tsk->mm == mm exits.
+         *
+         * As side note: the pages freed after ->release returns could
+         * be immediately reallocated by the gart at an alias physical
+         * address with a different cache model, so if ->release isn't
+         * implemented because all _software_ driven memory accesses
+         * through the secondary mmu are terminated by the time the
+         * last thread of this mm quits, you've also to be sure that
+         * speculative _hardware_ operations can't allocate dirty
+         * cachelines in the cpu that could not be snooped and made
+         * coherent with the other read and write operations happening
+         * through the gart alias address, so leading to memory
+         * corruption.
+         */
+        void (*release)(struct mmu_notifier *mn,
+                        struct mm_struct *mm);
+
+        /*
+         * clear_flush_young is called after the VM is
+         * test-and-clearing the young/accessed bitflag in the
+         * pte. This way the VM will provide proper aging to the
+         * accesses to the page through the secondary MMUs and not
+         * only to the ones through the Linux pte.
+         */
+        int (*clear_flush_young)(struct mmu_notifier *mn,
+                                 struct mm_struct *mm,
+                                 unsigned long address);
+
+        /*
+         * Before this is invoked any secondary MMU is still ok to
+         * read/write to the page previously pointed to by the Linux
+         * pte because the page hasn't been freed yet and it won't be
+         * freed until this returns. If required set_page_dirty has to
+         * be called internally to this method.
+         */
+        void (*invalidate_page)(struct mmu_notifier *mn,
+                                struct mm_struct *mm,
+                                unsigned long address);
+
+        /*
+         * invalidate_range_start() and invalidate_range_end() must be
+         * paired and are called only when the mmap_sem and/or the
+         * locks protecting the reverse maps are held. The subsystem
+         * must guarantee that no additional references are taken to
+         * the pages in the range established between the call to
+         * invalidate_range_start() and the matching call to
+         * invalidate_range_end().
+         *
+         * Invalidation of multiple concurrent ranges may be
+         * optionally permitted by the driver. Either way the
+         * establishment of sptes is forbidden in the range passed to
+         * invalidate_range_begin/end for the whole duration of the
+         * invalidate_range_begin/end critical section.
+         *
+         * invalidate_range_start() is called when all pages in the
+         * range are still mapped and have at least a refcount of one.
+         *
+         * invalidate_range_end() is called when all pages in the
+         * range have been unmapped and the pages have been freed by
+         * the VM.
+         *
+         * The VM will remove the page table entries and potentially
+         * the page between invalidate_range_start() and
+         * invalidate_range_end(). If the page must not be freed
+         * because of pending I/O or other circumstances then the
+         * invalidate_range_start() callback (or the initial mapping
+         * by the driver) must make sure that the refcount is kept
+         * elevated.
+         *
+         * If the driver increases the refcount when the pages are
+         * initially mapped into an address space then either
+         * invalidate_range_start() or invalidate_range_end() may
+         * decrease the refcount. If the refcount is decreased on
+         * invalidate_range_start() then the VM can free pages as page
+         * table entries are removed.  If the refcount is only
+         * droppped on invalidate_range_end() then the driver itself
+         * will drop the last refcount but it must take care to flush
+         * any secondary tlb before doing the final free on the
+         * page. Pages will no longer be referenced by the linux
+         * address space but may still be referenced by sptes until
+         * the last refcount is dropped.
+         */
+        void (*invalidate_range_start)(struct mmu_notifier *mn,
+                                       struct mm_struct *mm,
+                                       unsigned long start, unsigned long end);
+        void (*invalidate_range_end)(struct mmu_notifier *mn,
+                                     struct mm_struct *mm,
+                                     unsigned long start, unsigned long end);
+};
+
+/*
+ * The notifier chains are protected by mmap_sem and/or the reverse map
+ * semaphores. Notifier chains are only changed when all reverse maps and
+ * the mmap_sem locks are taken.
+ *
+ * Therefore notifier chains can only be traversed when either
+ *
+ * 1. mmap_sem is held.
+ * 2. One of the reverse map locks is held (i_mmap_lock or anon_vma->lock).
+ * 3. No other concurrent thread can access the list (release)
+ */
+struct mmu_notifier {
+        struct hlist_node hlist;
+        const struct mmu_notifier_ops *ops;
+};
+
+static inline int mm_has_notifiers(struct mm_struct *mm)
+{
+        return unlikely(mm->mmu_notifier_mm);
+}
+
+extern int mmu_notifier_register(struct mmu_notifier *mn,
+                                 struct mm_struct *mm);
+extern int __mmu_notifier_register(struct mmu_notifier *mn,
+                                   struct mm_struct *mm);
+extern void mmu_notifier_unregister(struct mmu_notifier *mn,
+                                    struct mm_struct *mm);
+extern void __mmu_notifier_mm_destroy(struct mm_struct *mm);
+extern void __mmu_notifier_release(struct mm_struct *mm);
+extern int __mmu_notifier_clear_flush_young(struct mm_struct *mm,
+                                          unsigned long address);
+extern void __mmu_notifier_invalidate_page(struct mm_struct *mm,
+                                          unsigned long address);
+extern void __mmu_notifier_invalidate_range_start(struct mm_struct *mm,
+                                  unsigned long start, unsigned long end);
+extern void __mmu_notifier_invalidate_range_end(struct mm_struct *mm,
+                                  unsigned long start, unsigned long end);
+
+static inline void mmu_notifier_release(struct mm_struct *mm)
+{
+        if (mm_has_notifiers(mm))
+                __mmu_notifier_release(mm);
+}
+
+static inline int mmu_notifier_clear_flush_young(struct mm_struct *mm,
+                                          unsigned long address)
+{
+        if (mm_has_notifiers(mm))
+                return __mmu_notifier_clear_flush_young(mm, address);
+        return 0;
+}
+
+static inline void mmu_notifier_invalidate_page(struct mm_struct *mm,
+                                          unsigned long address)
+{
+        if (mm_has_notifiers(mm))
+                __mmu_notifier_invalidate_page(mm, address);
+}
+
+static inline void mmu_notifier_invalidate_range_start(struct mm_struct *mm,
+                                  unsigned long start, unsigned long end)
+{
+        if (mm_has_notifiers(mm))
+                __mmu_notifier_invalidate_range_start(mm, start, end);
+}
+
+static inline void mmu_notifier_invalidate_range_end(struct mm_struct *mm,
+                                  unsigned long start, unsigned long end)
+{
+        if (mm_has_notifiers(mm))
+                __mmu_notifier_invalidate_range_end(mm, start, end);
+}
+
+static inline void mmu_notifier_mm_init(struct mm_struct *mm)
+{
+        mm->mmu_notifier_mm = NULL;
+}
+
+static inline void mmu_notifier_mm_destroy(struct mm_struct *mm)
+{
+        if (mm_has_notifiers(mm))
+                __mmu_notifier_mm_destroy(mm);
+}
+
+/*
+ * These two macros will sometime replace ptep_clear_flush.
+ * ptep_clear_flush is impleemnted as macro itself, so this also is
+ * implemented as a macro until ptep_clear_flush will converted to an
+ * inline function, to diminish the risk of compilation failure. The
+ * invalidate_page method over time can be moved outside the PT lock
+ * and these two macros can be later removed.
+ */
+#define ptep_clear_flush_notify(__vma, __address, __ptep)               \
+({                                                                      \
+        pte_t __pte;                                                    \
+        struct vm_area_struct *___vma = __vma;                          \
+        unsigned long ___address = __address;                           \
+        __pte = ptep_clear_flush(___vma, ___address, __ptep);           \
+        mmu_notifier_invalidate_page(___vma->vm_mm, ___address);        \
+        __pte;                                                          \
+})
+
+#define ptep_clear_flush_young_notify(__vma, __address, __ptep)         \
+({                                                                      \
+        int __young;                                                    \
+        struct vm_area_struct *___vma = __vma;                          \
+        unsigned long ___address = __address;                           \
+        __young = ptep_clear_flush_young(___vma, ___address, __ptep);   \
+        __young |= mmu_notifier_clear_flush_young(___vma->vm_mm,        \
+                                                  ___address);          \
+        __young;                                                        \
+})
+
+#else /* CONFIG_MMU_NOTIFIER */
+
+static inline void mmu_notifier_release(struct mm_struct *mm)
+{
+}
+
+static inline int mmu_notifier_clear_flush_young(struct mm_struct *mm,
+                                          unsigned long address)
+{
+        return 0;
+}
+
+static inline void mmu_notifier_invalidate_page(struct mm_struct *mm,
+                                          unsigned long address)
+{
+}
+
+static inline void mmu_notifier_invalidate_range_start(struct mm_struct *mm,
+                                  unsigned long start, unsigned long end)
+{
+}
+
+static inline void mmu_notifier_invalidate_range_end(struct mm_struct *mm,
+                                  unsigned long start, unsigned long end)
+{
+}
+
+static inline void mmu_notifier_mm_init(struct mm_struct *mm)
+{
+}
+
+static inline void mmu_notifier_mm_destroy(struct mm_struct *mm)
+{
+}
+
+#define ptep_clear_flush_young_notify ptep_clear_flush_young
+#define ptep_clear_flush_notify ptep_clear_flush
+
+#endif /* CONFIG_MMU_NOTIFIER */
+
+#endif /* _LINUX_MMU_NOTIFIER_H */
diff --git a/include/linux/mount.h b/include/linux/mount.h
index 4374d1adeb4b..30a1d63b6fb5 100644
--- a/include/linux/mount.h
+++ b/include/linux/mount.h
@@ -47,7 +47,7 @@ struct vfsmount {
         struct list_head mnt_child;     /* and going through their mnt_child */
         int mnt_flags;
         /* 4 bytes hole on 64bits arches */
-        char *mnt_devname;              /* Name of device e.g. /dev/dsk/hda1 */
+        const char *mnt_devname;        /* Name of device e.g. /dev/dsk/hda1 */
         struct list_head mnt_list;
         struct list_head mnt_expire;    /* link in fs-specific expiry list */
         struct list_head mnt_share;     /* circular list of shared mounts */
@@ -105,7 +105,8 @@ extern struct vfsmount *vfs_kern_mount(struct file_system_type *type,
 
 struct nameidata;
 
-extern int do_add_mount(struct vfsmount *newmnt, struct nameidata *nd,
+struct path;
+extern int do_add_mount(struct vfsmount *newmnt, struct path *path,
                         int mnt_flags, struct list_head *fslist);
 
 extern void mark_mounts_for_expiry(struct list_head *mounts);
diff --git a/include/linux/mtd/blktrans.h b/include/linux/mtd/blktrans.h
index 9a6e2f953cba..310e61606415 100644
--- a/include/linux/mtd/blktrans.h
+++ b/include/linux/mtd/blktrans.h
@@ -1,6 +1,4 @@
 /*
- * $Id: blktrans.h,v 1.6 2005/11/07 11:14:54 gleixner Exp $
- *
  * (C) 2003 David Woodhouse <dwmw2@infradead.org>
  *
  * Interface to Linux block layer for MTD 'translation layers'.
diff --git a/include/linux/mtd/cfi.h b/include/linux/mtd/cfi.h
index b0ddf4b25862..d6fb115f5a07 100644
--- a/include/linux/mtd/cfi.h
+++ b/include/linux/mtd/cfi.h
@@ -1,7 +1,6 @@
 
 /* Common Flash Interface structures
  * See http://support.intel.com/design/flash/technote/index.htm
- * $Id: cfi.h,v 1.57 2005/11/15 23:28:17 tpoynor Exp $
  */
 
 #ifndef __MTD_CFI_H__
diff --git a/include/linux/mtd/cfi_endian.h b/include/linux/mtd/cfi_endian.h
index 25724f7d3867..d802f7736be3 100644
--- a/include/linux/mtd/cfi_endian.h
+++ b/include/linux/mtd/cfi_endian.h
@@ -1,8 +1,3 @@
-/*
- * $Id: cfi_endian.h,v 1.11 2002/01/30 23:20:48 awozniak Exp $
- *
- */
-
 #include <asm/byteorder.h>
 
 #ifndef CONFIG_MTD_CFI_ADV_OPTIONS
diff --git a/include/linux/mtd/concat.h b/include/linux/mtd/concat.h
index ed8dc6755219..c02f3d264ecf 100644
--- a/include/linux/mtd/concat.h
+++ b/include/linux/mtd/concat.h
@@ -4,8 +4,6 @@
  * (C) 2002 Robert Kaiser <rkaiser@sysgo.de>
  *
  * This code is GPL
- *
- * $Id: concat.h,v 1.1 2002/03/08 16:34:36 rkaiser Exp $
  */
 
 #ifndef MTD_CONCAT_H
diff --git a/include/linux/mtd/doc2000.h b/include/linux/mtd/doc2000.h
index 9addd073bf15..0a6d516ab71d 100644
--- a/include/linux/mtd/doc2000.h
+++ b/include/linux/mtd/doc2000.h
@@ -6,8 +6,6 @@
  * Copyright (C) 2002-2003 Greg Ungerer <gerg@snapgear.com>
  * Copyright (C) 2002-2003 SnapGear Inc
  *
- * $Id: doc2000.h,v 1.25 2005/11/07 11:14:54 gleixner Exp $
- *
  * Released under GPL
  */
 
diff --git a/include/linux/mtd/flashchip.h b/include/linux/mtd/flashchip.h
index 39e7d2a1be9a..08dd131301c1 100644
--- a/include/linux/mtd/flashchip.h
+++ b/include/linux/mtd/flashchip.h
@@ -5,9 +5,6 @@
  * Contains information about the location and state of a given flash device
  *
  * (C) 2000 Red Hat. GPLd.
- *
- * $Id: flashchip.h,v 1.18 2005/11/07 11:14:54 gleixner Exp $
- *
  */
 
 #ifndef __MTD_FLASHCHIP_H__
diff --git a/include/linux/mtd/ftl.h b/include/linux/mtd/ftl.h
index d99609113307..0be442f881dd 100644
--- a/include/linux/mtd/ftl.h
+++ b/include/linux/mtd/ftl.h
@@ -1,6 +1,4 @@
 /*
- * $Id: ftl.h,v 1.7 2005/11/07 11:14:54 gleixner Exp $
- *
  * Derived from (and probably identical to):
  * ftl.h 1.7 1999/10/25 20:23:17
  *
diff --git a/include/linux/mtd/gen_probe.h b/include/linux/mtd/gen_probe.h
index 256e7342ed1e..df362ddf2949 100644
--- a/include/linux/mtd/gen_probe.h
+++ b/include/linux/mtd/gen_probe.h
@@ -1,7 +1,6 @@
 /*
  * (C) 2001, 2001 Red Hat, Inc.
  * GPL'd
- * $Id: gen_probe.h,v 1.4 2005/11/07 11:14:54 gleixner Exp $
  */
 
 #ifndef __LINUX_MTD_GEN_PROBE_H__
diff --git a/include/linux/mtd/inftl.h b/include/linux/mtd/inftl.h
index 85fd041d44ad..64ee53ce95a9 100644
--- a/include/linux/mtd/inftl.h
+++ b/include/linux/mtd/inftl.h
@@ -2,8 +2,6 @@
  *      inftl.h -- defines to support the Inverse NAND Flash Translation Layer
  *
  *      (C) Copyright 2002, Greg Ungerer (gerg@snapgear.com)
- *
- *      $Id: inftl.h,v 1.7 2005/06/13 13:08:45 sean Exp $
  */
 
 #ifndef __MTD_INFTL_H__
@@ -52,8 +50,6 @@ struct INFTLrecord {
 int INFTL_mount(struct INFTLrecord *s);
 int INFTL_formatblock(struct INFTLrecord *s, int block);
 
-extern char inftlmountrev[];
-
 void INFTL_dumptables(struct INFTLrecord *s);
 void INFTL_dumpVUchains(struct INFTLrecord *s);
 
diff --git a/include/linux/mtd/map.h b/include/linux/mtd/map.h
index 9c1d95491f8b..aa30244492c6 100644
--- a/include/linux/mtd/map.h
+++ b/include/linux/mtd/map.h
@@ -1,6 +1,5 @@
 
 /* Overhauled routines for dealing with different mmap regions of flash */
-/* $Id: map.h,v 1.54 2005/11/07 11:14:54 gleixner Exp $ */
 
 #ifndef __LINUX_MTD_MAP_H__
 #define __LINUX_MTD_MAP_H__
diff --git a/include/linux/mtd/mtd.h b/include/linux/mtd/mtd.h
index 8b5d49133ec6..922636548558 100644
--- a/include/linux/mtd/mtd.h
+++ b/include/linux/mtd/mtd.h
@@ -1,6 +1,4 @@
 /*
- * $Id: mtd.h,v 1.61 2005/11/07 11:14:54 gleixner Exp $
- *
  * Copyright (C) 1999-2003 David Woodhouse <dwmw2@infradead.org> et al.
  *
  * Released under GPL
@@ -274,7 +272,11 @@ static inline void mtd_erase_callback(struct erase_info *instr)
                         printk(KERN_INFO args);         \
         } while(0)
 #else /* CONFIG_MTD_DEBUG */
-#define DEBUG(n, args...) do { } while(0)
+#define DEBUG(n, args...)                               \
+        do {                                            \
+                if (0)                                  \
+                        printk(KERN_INFO args);         \
+        } while(0)
 
 #endif /* CONFIG_MTD_DEBUG */
 
diff --git a/include/linux/mtd/nand.h b/include/linux/mtd/nand.h
index 53ea3dc8b0e8..81774e5facf4 100644
--- a/include/linux/mtd/nand.h
+++ b/include/linux/mtd/nand.h
@@ -5,8 +5,6 @@
  *                     Steven J. Hill <sjhill@realitydiluted.com>
  *                     Thomas Gleixner <tglx@linutronix.de>
  *
- * $Id: nand.h,v 1.74 2005/09/15 13:58:50 vwool Exp $
- *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
@@ -179,6 +177,9 @@ typedef enum {
 #define NAND_MUST_PAD(chip) (!(chip->options & NAND_NO_PADDING))
 #define NAND_HAS_CACHEPROG(chip) ((chip->options & NAND_CACHEPRG))
 #define NAND_HAS_COPYBACK(chip) ((chip->options & NAND_COPYBACK))
+/* Large page NAND with SOFT_ECC should support subpage reads */
+#define NAND_SUBPAGE_READ(chip) ((chip->ecc.mode == NAND_ECC_SOFT) \
+                                        && (chip->page_shift > 9))
 
 /* Mask to zero out the chip options, which come from the id table */
 #define NAND_CHIPOPTIONS_MSK    (0x0000ffff & ~NAND_NO_AUTOINCR)
@@ -276,6 +277,10 @@ struct nand_ecc_ctrl {
         int                     (*read_page)(struct mtd_info *mtd,
                                              struct nand_chip *chip,
                                              uint8_t *buf);
+        int                     (*read_subpage)(struct mtd_info *mtd,
+                                             struct nand_chip *chip,
+                                             uint32_t offs, uint32_t len,
+                                             uint8_t *buf);
         void                    (*write_page)(struct mtd_info *mtd,
                                               struct nand_chip *chip,
                                               const uint8_t *buf);
diff --git a/include/linux/mtd/nand_ecc.h b/include/linux/mtd/nand_ecc.h
index 12c5bc342ead..090da505425d 100644
--- a/include/linux/mtd/nand_ecc.h
+++ b/include/linux/mtd/nand_ecc.h
@@ -3,8 +3,6 @@
  *
  *  Copyright (C) 2000 Steven J. Hill (sjhill@realitydiluted.com)
  *
- * $Id: nand_ecc.h,v 1.4 2004/06/17 02:35:02 dbrown Exp $
- *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
diff --git a/include/linux/mtd/nftl.h b/include/linux/mtd/nftl.h
index 001eec50cac6..dcaf611ed748 100644
--- a/include/linux/mtd/nftl.h
+++ b/include/linux/mtd/nftl.h
@@ -1,6 +1,4 @@
 /*
- * $Id: nftl.h,v 1.16 2004/06/30 14:49:00 dbrown Exp $
- *
  * (C) 1999-2003 David Woodhouse <dwmw2@infradead.org>
  */
 
diff --git a/include/linux/mtd/partitions.h b/include/linux/mtd/partitions.h
index 7c37d7e55abc..5014f7a9f5df 100644
--- a/include/linux/mtd/partitions.h
+++ b/include/linux/mtd/partitions.h
@@ -4,8 +4,6 @@
  * (C) 2000 Nicolas Pitre <nico@cam.org>
  *
  * This code is GPL
- *
- * $Id: partitions.h,v 1.17 2005/11/07 11:14:55 gleixner Exp $
  */
 
 #ifndef MTD_PARTITIONS_H
diff --git a/include/linux/mtd/physmap.h b/include/linux/mtd/physmap.h
index 0dc07d5f3354..c8e63a5ee72e 100644
--- a/include/linux/mtd/physmap.h
+++ b/include/linux/mtd/physmap.h
@@ -2,8 +2,6 @@
  * For boards with physically mapped flash and using
  * drivers/mtd/maps/physmap.c mapping driver.
  *
- * $Id: physmap.h,v 1.4 2005/11/07 11:14:55 gleixner Exp $
- *
  * Copyright (C) 2003 MontaVista Software Inc.
  * Author: Jun Sun, jsun@mvista.com or jsun@junsun.net
  *
diff --git a/include/linux/mtd/plat-ram.h b/include/linux/mtd/plat-ram.h
index 0e37ad07bce2..e07890aff1cf 100644
--- a/include/linux/mtd/plat-ram.h
+++ b/include/linux/mtd/plat-ram.h
@@ -6,8 +6,6 @@
  *
  * Generic platform device based RAM map
  *
- * $Id: plat-ram.h,v 1.2 2005/01/24 00:37:40 bjd Exp $
- *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
diff --git a/include/linux/mtd/pmc551.h b/include/linux/mtd/pmc551.h
index 5cc070c24d88..27ad40aed19f 100644
--- a/include/linux/mtd/pmc551.h
+++ b/include/linux/mtd/pmc551.h
@@ -1,6 +1,4 @@
 /*
- * $Id: pmc551.h,v 1.6 2005/11/07 11:14:55 gleixner Exp $
- *
  * PMC551 PCI Mezzanine Ram Device
  *
  * Author:
@@ -17,7 +15,7 @@
 
 #include <linux/mtd/mtd.h>
 
-#define PMC551_VERSION "$Id: pmc551.h,v 1.6 2005/11/07 11:14:55 gleixner Exp $\n"\
+#define PMC551_VERSION \
        "Ramix PMC551 PCI Mezzanine Ram Driver. (C) 1999,2000 Nortel Networks.\n"
 
 /*
diff --git a/include/linux/mtd/xip.h b/include/linux/mtd/xip.h
index e9d40bdde48c..36efcba15ecd 100644
--- a/include/linux/mtd/xip.h
+++ b/include/linux/mtd/xip.h
@@ -11,8 +11,6 @@
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
- *
- * $Id: xip.h,v 1.5 2005/11/07 11:14:55 gleixner Exp $
  */
 
 #ifndef __LINUX_MTD_XIP_H__
diff --git a/include/linux/namei.h b/include/linux/namei.h
index 24d88e98a626..68f8c3203c89 100644
--- a/include/linux/namei.h
+++ b/include/linux/namei.h
@@ -47,27 +47,24 @@ enum {LAST_NORM, LAST_ROOT, LAST_DOT, LAST_DOTDOT, LAST_BIND};
 #define LOOKUP_DIRECTORY         2
 #define LOOKUP_CONTINUE          4
 #define LOOKUP_PARENT           16
-#define LOOKUP_NOALT            32
 #define LOOKUP_REVAL            64
 /*
  * Intent data
  */
 #define LOOKUP_OPEN             (0x0100)
 #define LOOKUP_CREATE           (0x0200)
-#define LOOKUP_ACCESS           (0x0400)
-#define LOOKUP_CHDIR            (0x0800)
-
-extern int __user_walk(const char __user *, unsigned, struct nameidata *);
-extern int __user_walk_fd(int dfd, const char __user *, unsigned, struct nameidata *);
-#define user_path_walk(name,nd) \
-        __user_walk_fd(AT_FDCWD, name, LOOKUP_FOLLOW, nd)
-#define user_path_walk_link(name,nd) \
-        __user_walk_fd(AT_FDCWD, name, 0, nd)
+
+extern int user_path_at(int, const char __user *, unsigned, struct path *);
+
+#define user_path(name, path) user_path_at(AT_FDCWD, name, LOOKUP_FOLLOW, path)
+#define user_lpath(name, path) user_path_at(AT_FDCWD, name, 0, path)
+#define user_path_dir(name, path) \
+        user_path_at(AT_FDCWD, name, LOOKUP_FOLLOW | LOOKUP_DIRECTORY, path)
+
 extern int path_lookup(const char *, unsigned, struct nameidata *);
 extern int vfs_path_lookup(struct dentry *, struct vfsmount *,
                            const char *, unsigned int, struct nameidata *);
 
-extern int __user_path_lookup_open(const char __user *, unsigned lookup_flags, struct nameidata *nd, int open_flags);
 extern int path_lookup_open(int dfd, const char *name, unsigned lookup_flags, struct nameidata *, int open_flags);
 extern struct file *lookup_instantiate_filp(struct nameidata *nd, struct dentry *dentry,
                 int (*open)(struct inode *, struct file *));
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index b4d056ceab96..488c56e649b5 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -61,9 +61,7 @@ struct wireless_dev;
 #define NET_XMIT_DROP           1       /* skb dropped                  */
 #define NET_XMIT_CN             2       /* congestion notification      */
 #define NET_XMIT_POLICED        3       /* skb is shot by police        */
-#define NET_XMIT_BYPASS         4       /* packet does not leave via dequeue;
-                                           (TC use only - dev_queue_xmit
-                                           returns this as NET_XMIT_SUCCESS) */
+#define NET_XMIT_MASK           0xFFFF  /* qdisc flags in net/sch_generic.h */
 
 /* Backlog congestion levels */
 #define NET_RX_SUCCESS          0   /* keep 'em coming, baby */
@@ -440,6 +438,7 @@ static inline void napi_synchronize(const struct napi_struct *n)
 enum netdev_queue_state_t
 {
         __QUEUE_STATE_XOFF,
+        __QUEUE_STATE_FROZEN,
 };
 
 struct netdev_queue {
@@ -636,7 +635,7 @@ struct net_device
         unsigned int            real_num_tx_queues;
 
         unsigned long           tx_queue_len;   /* Max frames per queue allowed */
-
+        spinlock_t              tx_global_lock;
 /*
  * One part is mostly used on xmit path (device)
  */
@@ -1099,6 +1098,11 @@ static inline int netif_queue_stopped(const struct net_device *dev)
         return netif_tx_queue_stopped(netdev_get_tx_queue(dev, 0));
 }
 
+static inline int netif_tx_queue_frozen(const struct netdev_queue *dev_queue)
+{
+        return test_bit(__QUEUE_STATE_FROZEN, &dev_queue->state);
+}
+
 /**
  *      netif_running - test if up
  *      @dev: network device
@@ -1475,6 +1479,26 @@ static inline void __netif_tx_lock_bh(struct netdev_queue *txq)
         txq->xmit_lock_owner = smp_processor_id();
 }
 
+static inline int __netif_tx_trylock(struct netdev_queue *txq)
+{
+        int ok = spin_trylock(&txq->_xmit_lock);
+        if (likely(ok))
+                txq->xmit_lock_owner = smp_processor_id();
+        return ok;
+}
+
+static inline void __netif_tx_unlock(struct netdev_queue *txq)
+{
+        txq->xmit_lock_owner = -1;
+        spin_unlock(&txq->_xmit_lock);
+}
+
+static inline void __netif_tx_unlock_bh(struct netdev_queue *txq)
+{
+        txq->xmit_lock_owner = -1;
+        spin_unlock_bh(&txq->_xmit_lock);
+}
+
 /**
  *      netif_tx_lock - grab network device transmit lock
  *      @dev: network device
@@ -1484,12 +1508,23 @@ static inline void __netif_tx_lock_bh(struct netdev_queue *txq)
  */
 static inline void netif_tx_lock(struct net_device *dev)
 {
-        int cpu = smp_processor_id();
         unsigned int i;
+        int cpu;
 
+        spin_lock(&dev->tx_global_lock);
+        cpu = smp_processor_id();
         for (i = 0; i < dev->num_tx_queues; i++) {
                 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
+
+                /* We are the only thread of execution doing a
+                 * freeze, but we have to grab the _xmit_lock in
+                 * order to synchronize with threads which are in
+                 * the ->hard_start_xmit() handler and already
+                 * checked the frozen bit.
+                 */
                 __netif_tx_lock(txq, cpu);
+                set_bit(__QUEUE_STATE_FROZEN, &txq->state);
+                __netif_tx_unlock(txq);
         }
 }
 
@@ -1499,40 +1534,22 @@ static inline void netif_tx_lock_bh(struct net_device *dev)
         netif_tx_lock(dev);
 }
 
-static inline int __netif_tx_trylock(struct netdev_queue *txq)
-{
-        int ok = spin_trylock(&txq->_xmit_lock);
-        if (likely(ok))
-                txq->xmit_lock_owner = smp_processor_id();
-        return ok;
-}
-
-static inline int netif_tx_trylock(struct net_device *dev)
-{
-        return __netif_tx_trylock(netdev_get_tx_queue(dev, 0));
-}
-
-static inline void __netif_tx_unlock(struct netdev_queue *txq)
-{
-        txq->xmit_lock_owner = -1;
-        spin_unlock(&txq->_xmit_lock);
-}
-
-static inline void __netif_tx_unlock_bh(struct netdev_queue *txq)
-{
-        txq->xmit_lock_owner = -1;
-        spin_unlock_bh(&txq->_xmit_lock);
-}
-
 static inline void netif_tx_unlock(struct net_device *dev)
 {
         unsigned int i;
 
         for (i = 0; i < dev->num_tx_queues; i++) {
                 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
-                __netif_tx_unlock(txq);
-        }
 
+                /* No need to grab the _xmit_lock here.  If the
+                 * queue is not stopped for another reason, we
+                 * force a schedule.
+                 */
+                clear_bit(__QUEUE_STATE_FROZEN, &txq->state);
+                if (!test_bit(__QUEUE_STATE_XOFF, &txq->state))
+                        __netif_schedule(txq->qdisc);
+        }
+        spin_unlock(&dev->tx_global_lock);
 }
 
 static inline void netif_tx_unlock_bh(struct net_device *dev)
@@ -1556,13 +1573,18 @@ static inline void netif_tx_unlock_bh(struct net_device *dev)
 static inline void netif_tx_disable(struct net_device *dev)
 {
         unsigned int i;
+        int cpu;
 
-        netif_tx_lock_bh(dev);
+        local_bh_disable();
+        cpu = smp_processor_id();
         for (i = 0; i < dev->num_tx_queues; i++) {
                 struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
+
+                __netif_tx_lock(txq, cpu);
                 netif_tx_stop_queue(txq);
+                __netif_tx_unlock(txq);
         }
-        netif_tx_unlock_bh(dev);
+        local_bh_enable();
 }
 
 static inline void netif_addr_lock(struct net_device *dev)
diff --git a/include/linux/netfilter/nf_conntrack_tcp.h b/include/linux/netfilter/nf_conntrack_tcp.h
index 22ce29995f13..a049df4f2236 100644
--- a/include/linux/netfilter/nf_conntrack_tcp.h
+++ b/include/linux/netfilter/nf_conntrack_tcp.h
@@ -30,6 +30,9 @@ enum tcp_conntrack {
 /* Be liberal in window checking */
 #define IP_CT_TCP_FLAG_BE_LIBERAL               0x08
 
+/* Has unacknowledged data */
+#define IP_CT_TCP_FLAG_DATA_UNACKNOWLEDGED      0x10
+
 struct nf_ct_tcp_flags {
         u_int8_t flags;
         u_int8_t mask;
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index 29d261918734..78a5922a2f11 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -42,7 +42,6 @@
 #include <linux/in.h>
 #include <linux/kref.h>
 #include <linux/mm.h>
-#include <linux/namei.h>
 #include <linux/pagemap.h>
 #include <linux/rbtree.h>
 #include <linux/rwsem.h>
@@ -332,7 +331,7 @@ extern int nfs_refresh_inode(struct inode *, struct nfs_fattr *);
 extern int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr);
 extern int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr);
 extern int nfs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
-extern int nfs_permission(struct inode *, int, struct nameidata *);
+extern int nfs_permission(struct inode *, int);
 extern int nfs_open(struct inode *, struct file *);
 extern int nfs_release(struct inode *, struct file *);
 extern int nfs_attribute_timeout(struct inode *inode);
diff --git a/include/linux/of.h b/include/linux/of.h
index 59a61bdc98b6..79886ade070f 100644
--- a/include/linux/of.h
+++ b/include/linux/of.h
@@ -70,5 +70,6 @@ extern int of_n_addr_cells(struct device_node *np);
 extern int of_n_size_cells(struct device_node *np);
 extern const struct of_device_id *of_match_node(
         const struct of_device_id *matches, const struct device_node *node);
+extern int of_modalias_node(struct device_node *node, char *modalias, int len);
 
 #endif /* _LINUX_OF_H */
diff --git a/include/linux/of_spi.h b/include/linux/of_spi.h
new file mode 100644
index 000000000000..5f71ee8c0868
--- /dev/null
+++ b/include/linux/of_spi.h
@@ -0,0 +1,18 @@
+/*
+ * OpenFirmware SPI support routines
+ * Copyright (C) 2008 Secret Lab Technologies Ltd.
+ *
+ * Support routines for deriving SPI device attachments from the device
+ * tree.
+ */
+
+#ifndef __LINUX_OF_SPI_H
+#define __LINUX_OF_SPI_H
+
+#include <linux/of.h>
+#include <linux/spi/spi.h>
+
+extern void of_register_spi_devices(struct spi_master *master,
+                                    struct device_node *np);
+
+#endif /* __LINUX_OF_SPI */
diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h
index 54590a9a103e..c74d3e875314 100644
--- a/include/linux/page-flags.h
+++ b/include/linux/page-flags.h
@@ -163,7 +163,7 @@ static inline int Page##uname(struct page *page) 			\
 
 struct page;    /* forward declaration */
 
-PAGEFLAG(Locked, locked) TESTSCFLAG(Locked, locked)
+TESTPAGEFLAG(Locked, locked)
 PAGEFLAG(Error, error)
 PAGEFLAG(Referenced, referenced) TESTCLEARFLAG(Referenced, referenced)
 PAGEFLAG(Dirty, dirty) TESTSCFLAG(Dirty, dirty) __CLEARPAGEFLAG(Dirty, dirty)
@@ -239,9 +239,6 @@ static inline void __SetPageUptodate(struct page *page)
 {
         smp_wmb();
         __set_bit(PG_uptodate, &(page)->flags);
-#ifdef CONFIG_S390
-        page_clear_dirty(page);
-#endif
 }
 
 static inline void SetPageUptodate(struct page *page)
diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
index ee1ec2c7723c..5da31c12101c 100644
--- a/include/linux/pagemap.h
+++ b/include/linux/pagemap.h
@@ -12,6 +12,7 @@
 #include <asm/uaccess.h>
 #include <linux/gfp.h>
 #include <linux/bitops.h>
+#include <linux/hardirq.h> /* for in_interrupt() */
 
 /*
  * Bits in mapping->flags.  The lower __GFP_BITS_SHIFT bits are the page
@@ -19,6 +20,7 @@
  */
 #define AS_EIO          (__GFP_BITS_SHIFT + 0)  /* IO error on async write */
 #define AS_ENOSPC       (__GFP_BITS_SHIFT + 1)  /* ENOSPC on async write */
+#define AS_MM_ALL_LOCKS (__GFP_BITS_SHIFT + 2)  /* under mm_take_all_locks() */
 
 static inline void mapping_set_error(struct address_space *mapping, int error)
 {
@@ -62,6 +64,121 @@ static inline void mapping_set_gfp_mask(struct address_space *m, gfp_t mask)
 #define page_cache_release(page)        put_page(page)
 void release_pages(struct page **pages, int nr, int cold);
 
+/*
+ * speculatively take a reference to a page.
+ * If the page is free (_count == 0), then _count is untouched, and 0
+ * is returned. Otherwise, _count is incremented by 1 and 1 is returned.
+ *
+ * This function must be called inside the same rcu_read_lock() section as has
+ * been used to lookup the page in the pagecache radix-tree (or page table):
+ * this allows allocators to use a synchronize_rcu() to stabilize _count.
+ *
+ * Unless an RCU grace period has passed, the count of all pages coming out
+ * of the allocator must be considered unstable. page_count may return higher
+ * than expected, and put_page must be able to do the right thing when the
+ * page has been finished with, no matter what it is subsequently allocated
+ * for (because put_page is what is used here to drop an invalid speculative
+ * reference).
+ *
+ * This is the interesting part of the lockless pagecache (and lockless
+ * get_user_pages) locking protocol, where the lookup-side (eg. find_get_page)
+ * has the following pattern:
+ * 1. find page in radix tree
+ * 2. conditionally increment refcount
+ * 3. check the page is still in pagecache (if no, goto 1)
+ *
+ * Remove-side that cares about stability of _count (eg. reclaim) has the
+ * following (with tree_lock held for write):
+ * A. atomically check refcount is correct and set it to 0 (atomic_cmpxchg)
+ * B. remove page from pagecache
+ * C. free the page
+ *
+ * There are 2 critical interleavings that matter:
+ * - 2 runs before A: in this case, A sees elevated refcount and bails out
+ * - A runs before 2: in this case, 2 sees zero refcount and retries;
+ *   subsequently, B will complete and 1 will find no page, causing the
+ *   lookup to return NULL.
+ *
+ * It is possible that between 1 and 2, the page is removed then the exact same
+ * page is inserted into the same position in pagecache. That's OK: the
+ * old find_get_page using tree_lock could equally have run before or after
+ * such a re-insertion, depending on order that locks are granted.
+ *
+ * Lookups racing against pagecache insertion isn't a big problem: either 1
+ * will find the page or it will not. Likewise, the old find_get_page could run
+ * either before the insertion or afterwards, depending on timing.
+ */
+static inline int page_cache_get_speculative(struct page *page)
+{
+        VM_BUG_ON(in_interrupt());
+
+#if !defined(CONFIG_SMP) && defined(CONFIG_CLASSIC_RCU)
+# ifdef CONFIG_PREEMPT
+        VM_BUG_ON(!in_atomic());
+# endif
+        /*
+         * Preempt must be disabled here - we rely on rcu_read_lock doing
+         * this for us.
+         *
+         * Pagecache won't be truncated from interrupt context, so if we have
+         * found a page in the radix tree here, we have pinned its refcount by
+         * disabling preempt, and hence no need for the "speculative get" that
+         * SMP requires.
+         */
+        VM_BUG_ON(page_count(page) == 0);
+        atomic_inc(&page->_count);
+
+#else
+        if (unlikely(!get_page_unless_zero(page))) {
+                /*
+                 * Either the page has been freed, or will be freed.
+                 * In either case, retry here and the caller should
+                 * do the right thing (see comments above).
+                 */
+                return 0;
+        }
+#endif
+        VM_BUG_ON(PageTail(page));
+
+        return 1;
+}
+
+/*
+ * Same as above, but add instead of inc (could just be merged)
+ */
+static inline int page_cache_add_speculative(struct page *page, int count)
+{
+        VM_BUG_ON(in_interrupt());
+
+#if !defined(CONFIG_SMP) && defined(CONFIG_CLASSIC_RCU)
+# ifdef CONFIG_PREEMPT
+        VM_BUG_ON(!in_atomic());
+# endif
+        VM_BUG_ON(page_count(page) == 0);
+        atomic_add(count, &page->_count);
+
+#else
+        if (unlikely(!atomic_add_unless(&page->_count, count, 0)))
+                return 0;
+#endif
+        VM_BUG_ON(PageCompound(page) && page != compound_head(page));
+
+        return 1;
+}
+
+static inline int page_freeze_refs(struct page *page, int count)
+{
+        return likely(atomic_cmpxchg(&page->_count, count, 0) == count);
+}
+
+static inline void page_unfreeze_refs(struct page *page, int count)
+{
+        VM_BUG_ON(page_count(page) != 0);
+        VM_BUG_ON(count == 0);
+
+        atomic_set(&page->_count, count);
+}
+
 #ifdef CONFIG_NUMA
 extern struct page *__page_cache_alloc(gfp_t gfp);
 #else
@@ -133,13 +250,6 @@ static inline struct page *read_mapping_page(struct address_space *mapping,
         return read_cache_page(mapping, index, filler, data);
 }
 
-int add_to_page_cache(struct page *page, struct address_space *mapping,
-                                pgoff_t index, gfp_t gfp_mask);
-int add_to_page_cache_lru(struct page *page, struct address_space *mapping,
-                                pgoff_t index, gfp_t gfp_mask);
-extern void remove_from_page_cache(struct page *page);
-extern void __remove_from_page_cache(struct page *page);
-
 /*
  * Return byte-offset into filesystem object for page.
  */
@@ -161,13 +271,28 @@ extern int __lock_page_killable(struct page *page);
 extern void __lock_page_nosync(struct page *page);
 extern void unlock_page(struct page *page);
 
+static inline void set_page_locked(struct page *page)
+{
+        set_bit(PG_locked, &page->flags);
+}
+
+static inline void clear_page_locked(struct page *page)
+{
+        clear_bit(PG_locked, &page->flags);
+}
+
+static inline int trylock_page(struct page *page)
+{
+        return !test_and_set_bit(PG_locked, &page->flags);
+}
+
 /*
  * lock_page may only be called if we have the page's inode pinned.
  */
 static inline void lock_page(struct page *page)
 {
         might_sleep();
-        if (TestSetPageLocked(page))
+        if (!trylock_page(page))
                 __lock_page(page);
 }
 
@@ -179,7 +304,7 @@ static inline void lock_page(struct page *page)
 static inline int lock_page_killable(struct page *page)
 {
         might_sleep();
-        if (TestSetPageLocked(page))
+        if (!trylock_page(page))
                 return __lock_page_killable(page);
         return 0;
 }
@@ -191,7 +316,7 @@ static inline int lock_page_killable(struct page *page)
 static inline void lock_page_nosync(struct page *page)
 {
         might_sleep();
-        if (TestSetPageLocked(page))
+        if (!trylock_page(page))
                 __lock_page_nosync(page);
 }
         
@@ -276,4 +401,27 @@ static inline int fault_in_pages_readable(const char __user *uaddr, int size)
         return ret;
 }
 
+int add_to_page_cache_locked(struct page *page, struct address_space *mapping,
+                                pgoff_t index, gfp_t gfp_mask);
+int add_to_page_cache_lru(struct page *page, struct address_space *mapping,
+                                pgoff_t index, gfp_t gfp_mask);
+extern void remove_from_page_cache(struct page *page);
+extern void __remove_from_page_cache(struct page *page);
+
+/*
+ * Like add_to_page_cache_locked, but used to add newly allocated pages:
+ * the page is new, so we can just run set_page_locked() against it.
+ */
+static inline int add_to_page_cache(struct page *page,
+                struct address_space *mapping, pgoff_t offset, gfp_t gfp_mask)
+{
+        int error;
+
+        set_page_locked(page);
+        error = add_to_page_cache_locked(page, mapping, offset, gfp_mask);
+        if (unlikely(error))
+                clear_page_locked(page);
+        return error;
+}
+
 #endif /* _LINUX_PAGEMAP_H */
diff --git a/include/linux/parport.h b/include/linux/parport.h
index dcb9e01a69ca..6a0d7cdb5774 100644
--- a/include/linux/parport.h
+++ b/include/linux/parport.h
@@ -560,5 +560,8 @@ extern int parport_device_proc_unregister(struct pardevice *device);
 
 #endif /*  !CONFIG_PARPORT_NOT_PC  */
 
+extern unsigned long parport_default_timeslice;
+extern int parport_default_spintime;
+
 #endif /* __KERNEL__ */
 #endif /* _PARPORT_H_ */
diff --git a/include/linux/parser.h b/include/linux/parser.h
index cc554ca8bc78..7dcd05075756 100644
--- a/include/linux/parser.h
+++ b/include/linux/parser.h
@@ -14,7 +14,7 @@ struct match_token {
         const char *pattern;
 };
 
-typedef const struct match_token match_table_t[];
+typedef struct match_token match_table_t[];
 
 /* Maximum number of arguments that match_token will find in a pattern */
 enum {MAX_OPT_ARGS = 3};
diff --git a/include/linux/pci-aspm.h b/include/linux/pci-aspm.h
index a1a1e618e996..91ba0b338b47 100644
--- a/include/linux/pci-aspm.h
+++ b/include/linux/pci-aspm.h
@@ -27,6 +27,7 @@ extern void pcie_aspm_init_link_state(struct pci_dev *pdev);
 extern void pcie_aspm_exit_link_state(struct pci_dev *pdev);
 extern void pcie_aspm_pm_state_change(struct pci_dev *pdev);
 extern void pci_disable_link_state(struct pci_dev *pdev, int state);
+extern void pcie_no_aspm(void);
 #else
 static inline void pcie_aspm_init_link_state(struct pci_dev *pdev)
 {
@@ -40,6 +41,10 @@ static inline void pcie_aspm_pm_state_change(struct pci_dev *pdev)
 static inline void pci_disable_link_state(struct pci_dev *pdev, int state)
 {
 }
+
+static inline void pcie_no_aspm(void)
+{
+}
 #endif
 
 #ifdef CONFIG_PCIEASPM_DEBUG /* this depends on CONFIG_PCIEASPM */
diff --git a/include/linux/pci.h b/include/linux/pci.h
index 1d296d31abe0..c0e14008a3c2 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -124,6 +124,8 @@ enum pci_dev_flags {
          * generation too.
          */
         PCI_DEV_FLAGS_MSI_INTX_DISABLE_BUG = (__force pci_dev_flags_t) 1,
+        /* Device configuration is irrevocably lost if disabled into D3 */
+        PCI_DEV_FLAGS_NO_D3 = (__force pci_dev_flags_t) 2,
 };
 
 typedef unsigned short __bitwise pci_bus_flags_t;
@@ -639,6 +641,7 @@ int pci_restore_state(struct pci_dev *dev);
 int pci_set_power_state(struct pci_dev *dev, pci_power_t state);
 pci_power_t pci_choose_state(struct pci_dev *dev, pm_message_t state);
 bool pci_pme_capable(struct pci_dev *dev, pci_power_t state);
+void pci_pme_active(struct pci_dev *dev, bool enable);
 int pci_enable_wake(struct pci_dev *dev, pci_power_t state, int enable);
 pci_power_t pci_target_state(struct pci_dev *dev);
 int pci_prepare_to_sleep(struct pci_dev *dev);
@@ -678,10 +681,12 @@ void pci_enable_bridges(struct pci_bus *bus);
 /* Proper probing supporting hot-pluggable devices */
 int __must_check __pci_register_driver(struct pci_driver *, struct module *,
                                        const char *mod_name);
-static inline int __must_check pci_register_driver(struct pci_driver *driver)
-{
-        return __pci_register_driver(driver, THIS_MODULE, KBUILD_MODNAME);
-}
+
+/*
+ * pci_register_driver must be a macro so that KBUILD_MODNAME can be expanded
+ */
+#define pci_register_driver(driver)             \
+        __pci_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)
 
 void pci_unregister_driver(struct pci_driver *dev);
 void pci_remove_behind_bridge(struct pci_dev *dev);
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 917d48e5ea06..4463ca5b8934 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -753,6 +753,7 @@
 #define PCI_VENDOR_ID_TI                0x104c
 #define PCI_DEVICE_ID_TI_TVP4020        0x3d07
 #define PCI_DEVICE_ID_TI_4450           0x8011
+#define PCI_DEVICE_ID_TI_TSB43AB22      0x8023
 #define PCI_DEVICE_ID_TI_XX21_XX11      0x8031
 #define PCI_DEVICE_ID_TI_XX21_XX11_FM   0x8033
 #define PCI_DEVICE_ID_TI_XX21_XX11_SD   0x8034
@@ -1837,7 +1838,13 @@
 #define PCI_DEVICE_ID_MOXA_C320         0x3200
 
 #define PCI_VENDOR_ID_CCD               0x1397
+#define PCI_DEVICE_ID_CCD_HFC4S         0x08B4
+#define PCI_SUBDEVICE_ID_CCD_PMX2S      0x1234
+#define PCI_DEVICE_ID_CCD_HFC8S         0x16B8
 #define PCI_DEVICE_ID_CCD_2BD0          0x2bd0
+#define PCI_DEVICE_ID_CCD_HFCE1         0x30B1
+#define PCI_SUBDEVICE_ID_CCD_SPD4S      0x3136
+#define PCI_SUBDEVICE_ID_CCD_SPDE1      0x3137
 #define PCI_DEVICE_ID_CCD_B000          0xb000
 #define PCI_DEVICE_ID_CCD_B006          0xb006
 #define PCI_DEVICE_ID_CCD_B007          0xb007
@@ -1847,8 +1854,32 @@
 #define PCI_DEVICE_ID_CCD_B00B          0xb00b
 #define PCI_DEVICE_ID_CCD_B00C          0xb00c
 #define PCI_DEVICE_ID_CCD_B100          0xb100
+#define PCI_SUBDEVICE_ID_CCD_IOB4ST     0xB520
+#define PCI_SUBDEVICE_ID_CCD_IOB8STR    0xB521
+#define PCI_SUBDEVICE_ID_CCD_IOB8ST     0xB522
+#define PCI_SUBDEVICE_ID_CCD_IOB1E1     0xB523
+#define PCI_SUBDEVICE_ID_CCD_SWYX4S     0xB540
+#define PCI_SUBDEVICE_ID_CCD_JH4S20     0xB550
+#define PCI_SUBDEVICE_ID_CCD_IOB8ST_1   0xB552
+#define PCI_SUBDEVICE_ID_CCD_BN4S       0xB560
+#define PCI_SUBDEVICE_ID_CCD_BN8S       0xB562
+#define PCI_SUBDEVICE_ID_CCD_BNE1       0xB563
+#define PCI_SUBDEVICE_ID_CCD_BNE1D      0xB564
+#define PCI_SUBDEVICE_ID_CCD_BNE1DP     0xB565
+#define PCI_SUBDEVICE_ID_CCD_BN2S       0xB566
+#define PCI_SUBDEVICE_ID_CCD_BN1SM      0xB567
+#define PCI_SUBDEVICE_ID_CCD_BN4SM      0xB568
+#define PCI_SUBDEVICE_ID_CCD_BN2SM      0xB569
+#define PCI_SUBDEVICE_ID_CCD_BNE1M      0xB56A
+#define PCI_SUBDEVICE_ID_CCD_BN8SP      0xB56B
+#define PCI_SUBDEVICE_ID_CCD_HFC4S      0xB620
+#define PCI_SUBDEVICE_ID_CCD_HFC8S      0xB622
 #define PCI_DEVICE_ID_CCD_B700          0xb700
 #define PCI_DEVICE_ID_CCD_B701          0xb701
+#define PCI_SUBDEVICE_ID_CCD_HFCE1      0xC523
+#define PCI_SUBDEVICE_ID_CCD_OV2S       0xE884
+#define PCI_SUBDEVICE_ID_CCD_OV4S       0xE888
+#define PCI_SUBDEVICE_ID_CCD_OV8S       0xE998
 
 #define PCI_VENDOR_ID_EXAR              0x13a8
 #define PCI_DEVICE_ID_EXAR_XR17C152     0x0152
@@ -2151,8 +2182,6 @@
 #define PCI_DEVICE_ID_HERC_WIN          0x5732
 #define PCI_DEVICE_ID_HERC_UNI          0x5832
 
-#define PCI_VENDOR_ID_RDC               0x17f3
-
 #define PCI_VENDOR_ID_SITECOM           0x182d
 #define PCI_DEVICE_ID_SITECOM_DC105V2   0x3069
 
@@ -2528,6 +2557,9 @@
 
 #define PCI_VENDOR_ID_3COM_2            0xa727
 
+#define PCI_VENDOR_ID_DIGIUM            0xd161
+#define PCI_DEVICE_ID_DIGIUM_HFC4S      0xb410
+
 #define PCI_SUBVENDOR_ID_EXSYS          0xd84d
 #define PCI_SUBDEVICE_ID_EXSYS_4014     0x4014
 #define PCI_SUBDEVICE_ID_EXSYS_4055     0x4055
diff --git a/include/linux/pci_regs.h b/include/linux/pci_regs.h
index 19958b929905..450684f7eaac 100644
--- a/include/linux/pci_regs.h
+++ b/include/linux/pci_regs.h
@@ -374,6 +374,7 @@
 #define  PCI_EXP_DEVCAP_ATN_BUT 0x1000  /* Attention Button Present */
 #define  PCI_EXP_DEVCAP_ATN_IND 0x2000  /* Attention Indicator Present */
 #define  PCI_EXP_DEVCAP_PWR_IND 0x4000  /* Power Indicator Present */
+#define  PCI_EXP_DEVCAP_RBER    0x8000  /* Role-Based Error Reporting */
 #define  PCI_EXP_DEVCAP_PWR_VAL 0x3fc0000 /* Slot Power Limit Value */
 #define  PCI_EXP_DEVCAP_PWR_SCL 0xc000000 /* Slot Power Limit Scale */
 #define PCI_EXP_DEVCTL          8       /* Device Control */
diff --git a/include/linux/percpu.h b/include/linux/percpu.h
index 4cdd393e71e1..fac3337547eb 100644
--- a/include/linux/percpu.h
+++ b/include/linux/percpu.h
@@ -74,11 +74,6 @@ struct percpu_data {
         (__typeof__(ptr))__p->ptrs[(cpu)];                \
 })
 
-extern void *percpu_populate(void *__pdata, size_t size, gfp_t gfp, int cpu);
-extern void percpu_depopulate(void *__pdata, int cpu);
-extern int __percpu_populate_mask(void *__pdata, size_t size, gfp_t gfp,
-                                  cpumask_t *mask);
-extern void __percpu_depopulate_mask(void *__pdata, cpumask_t *mask);
 extern void *__percpu_alloc_mask(size_t size, gfp_t gfp, cpumask_t *mask);
 extern void percpu_free(void *__pdata);
 
@@ -86,26 +81,6 @@ extern void percpu_free(void *__pdata);
 
 #define percpu_ptr(ptr, cpu) ({ (void)(cpu); (ptr); })
 
-static inline void percpu_depopulate(void *__pdata, int cpu)
-{
-}
-
-static inline void __percpu_depopulate_mask(void *__pdata, cpumask_t *mask)
-{
-}
-
-static inline void *percpu_populate(void *__pdata, size_t size, gfp_t gfp,
-                                    int cpu)
-{
-        return percpu_ptr(__pdata, cpu);
-}
-
-static inline int __percpu_populate_mask(void *__pdata, size_t size, gfp_t gfp,
-                                         cpumask_t *mask)
-{
-        return 0;
-}
-
 static __always_inline void *__percpu_alloc_mask(size_t size, gfp_t gfp, cpumask_t *mask)
 {
         return kzalloc(size, gfp);
@@ -118,10 +93,6 @@ static inline void percpu_free(void *__pdata)
 
 #endif /* CONFIG_SMP */
 
-#define percpu_populate_mask(__pdata, size, gfp, mask) \
-        __percpu_populate_mask((__pdata), (size), (gfp), &(mask))
-#define percpu_depopulate_mask(__pdata, mask) \
-        __percpu_depopulate_mask((__pdata), &(mask))
 #define percpu_alloc_mask(size, gfp, mask) \
         __percpu_alloc_mask((size), (gfp), &(mask))
 
diff --git a/include/linux/pm_qos_params.h b/include/linux/pm_qos_params.h
index 2e4e97bd19f7..d74f75ed1e47 100644
--- a/include/linux/pm_qos_params.h
+++ b/include/linux/pm_qos_params.h
@@ -1,6 +1,6 @@
 /* interface for the pm_qos_power infrastructure of the linux kernel.
  *
- * Mark Gross
+ * Mark Gross <mgross@linux.intel.com>
  */
 #include <linux/list.h>
 #include <linux/notifier.h>
diff --git a/include/linux/power_supply.h b/include/linux/power_supply.h
index 68ed19ccf1f7..ea96ead1d39d 100644
--- a/include/linux/power_supply.h
+++ b/include/linux/power_supply.h
@@ -78,6 +78,7 @@ enum power_supply_property {
         POWER_SUPPLY_PROP_CHARGE_EMPTY,
         POWER_SUPPLY_PROP_CHARGE_NOW,
         POWER_SUPPLY_PROP_CHARGE_AVG,
+        POWER_SUPPLY_PROP_CHARGE_COUNTER,
         POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
         POWER_SUPPLY_PROP_ENERGY_EMPTY_DESIGN,
         POWER_SUPPLY_PROP_ENERGY_FULL,
diff --git a/include/linux/proc_fs.h b/include/linux/proc_fs.h
index f560d1705afe..fb61850d1cfc 100644
--- a/include/linux/proc_fs.h
+++ b/include/linux/proc_fs.h
@@ -282,11 +282,16 @@ union proc_op {
                 struct task_struct *task);
 };
 
+struct ctl_table_header;
+struct ctl_table;
+
 struct proc_inode {
         struct pid *pid;
         int fd;
         union proc_op op;
         struct proc_dir_entry *pde;
+        struct ctl_table_header *sysctl;
+        struct ctl_table *sysctl_entry;
         struct inode vfs_inode;
 };
 
diff --git a/include/linux/ptrace.h b/include/linux/ptrace.h
index c6f5f9dd0cee..ea7416c901d1 100644
--- a/include/linux/ptrace.h
+++ b/include/linux/ptrace.h
@@ -121,6 +121,74 @@ static inline void ptrace_unlink(struct task_struct *child)
 int generic_ptrace_peekdata(struct task_struct *tsk, long addr, long data);
 int generic_ptrace_pokedata(struct task_struct *tsk, long addr, long data);
 
+/**
+ * task_ptrace - return %PT_* flags that apply to a task
+ * @task:       pointer to &task_struct in question
+ *
+ * Returns the %PT_* flags that apply to @task.
+ */
+static inline int task_ptrace(struct task_struct *task)
+{
+        return task->ptrace;
+}
+
+/**
+ * ptrace_event - possibly stop for a ptrace event notification
+ * @mask:       %PT_* bit to check in @current->ptrace
+ * @event:      %PTRACE_EVENT_* value to report if @mask is set
+ * @message:    value for %PTRACE_GETEVENTMSG to return
+ *
+ * This checks the @mask bit to see if ptrace wants stops for this event.
+ * If so we stop, reporting @event and @message to the ptrace parent.
+ *
+ * Returns nonzero if we did a ptrace notification, zero if not.
+ *
+ * Called without locks.
+ */
+static inline int ptrace_event(int mask, int event, unsigned long message)
+{
+        if (mask && likely(!(current->ptrace & mask)))
+                return 0;
+        current->ptrace_message = message;
+        ptrace_notify((event << 8) | SIGTRAP);
+        return 1;
+}
+
+/**
+ * ptrace_init_task - initialize ptrace state for a new child
+ * @child:              new child task
+ * @ptrace:             true if child should be ptrace'd by parent's tracer
+ *
+ * This is called immediately after adding @child to its parent's children
+ * list.  @ptrace is false in the normal case, and true to ptrace @child.
+ *
+ * Called with current's siglock and write_lock_irq(&tasklist_lock) held.
+ */
+static inline void ptrace_init_task(struct task_struct *child, bool ptrace)
+{
+        INIT_LIST_HEAD(&child->ptrace_entry);
+        INIT_LIST_HEAD(&child->ptraced);
+        child->parent = child->real_parent;
+        child->ptrace = 0;
+        if (unlikely(ptrace)) {
+                child->ptrace = current->ptrace;
+                ptrace_link(child, current->parent);
+        }
+}
+
+/**
+ * ptrace_release_task - final ptrace-related cleanup of a zombie being reaped
+ * @task:       task in %EXIT_DEAD state
+ *
+ * Called with write_lock(&tasklist_lock) held.
+ */
+static inline void ptrace_release_task(struct task_struct *task)
+{
+        BUG_ON(!list_empty(&task->ptraced));
+        ptrace_unlink(task);
+        BUG_ON(!list_empty(&task->ptrace_entry));
+}
+
 #ifndef force_successful_syscall_return
 /*
  * System call handlers that, upon successful completion, need to return a
@@ -246,6 +314,10 @@ static inline void user_enable_block_step(struct task_struct *task)
 #define arch_ptrace_stop(code, info)            do { } while (0)
 #endif
 
+extern int task_current_syscall(struct task_struct *target, long *callno,
+                                unsigned long args[6], unsigned int maxargs,
+                                unsigned long *sp, unsigned long *pc);
+
 #endif
 
 #endif
diff --git a/include/linux/quotaops.h b/include/linux/quotaops.h
index 742187f7a05c..ca6b9b5c8d52 100644
--- a/include/linux/quotaops.h
+++ b/include/linux/quotaops.h
@@ -43,6 +43,8 @@ int dquot_mark_dquot_dirty(struct dquot *dquot);
 
 int vfs_quota_on(struct super_block *sb, int type, int format_id,
         char *path, int remount);
+int vfs_quota_on_path(struct super_block *sb, int type, int format_id,
+        struct path *path);
 int vfs_quota_on_mount(struct super_block *sb, char *qf_name,
         int format_id, int type);
 int vfs_quota_off(struct super_block *sb, int type, int remount);
diff --git a/include/linux/radix-tree.h b/include/linux/radix-tree.h
index b8ce2b444bb5..a916c6660dfa 100644
--- a/include/linux/radix-tree.h
+++ b/include/linux/radix-tree.h
@@ -99,12 +99,15 @@ do {									\
  *
  * The notable exceptions to this rule are the following functions:
  * radix_tree_lookup
+ * radix_tree_lookup_slot
  * radix_tree_tag_get
  * radix_tree_gang_lookup
+ * radix_tree_gang_lookup_slot
  * radix_tree_gang_lookup_tag
+ * radix_tree_gang_lookup_tag_slot
  * radix_tree_tagged
  *
- * The first 4 functions are able to be called locklessly, using RCU. The
+ * The first 7 functions are able to be called locklessly, using RCU. The
  * caller must ensure calls to these functions are made within rcu_read_lock()
  * regions. Other readers (lock-free or otherwise) and modifications may be
  * running concurrently.
@@ -159,6 +162,9 @@ void *radix_tree_delete(struct radix_tree_root *, unsigned long);
 unsigned int
 radix_tree_gang_lookup(struct radix_tree_root *root, void **results,
                         unsigned long first_index, unsigned int max_items);
+unsigned int
+radix_tree_gang_lookup_slot(struct radix_tree_root *root, void ***results,
+                        unsigned long first_index, unsigned int max_items);
 unsigned long radix_tree_next_hole(struct radix_tree_root *root,
                                 unsigned long index, unsigned long max_scan);
 int radix_tree_preload(gfp_t gfp_mask);
@@ -173,6 +179,10 @@ unsigned int
 radix_tree_gang_lookup_tag(struct radix_tree_root *root, void **results,
                 unsigned long first_index, unsigned int max_items,
                 unsigned int tag);
+unsigned int
+radix_tree_gang_lookup_tag_slot(struct radix_tree_root *root, void ***results,
+                unsigned long first_index, unsigned int max_items,
+                unsigned int tag);
 int radix_tree_tagged(struct radix_tree_root *root, unsigned int tag);
 
 static inline void radix_tree_preload_end(void)
diff --git a/include/linux/raid/md_k.h b/include/linux/raid/md_k.h
index 9f2549ac0e2d..c200b9a34aff 100644
--- a/include/linux/raid/md_k.h
+++ b/include/linux/raid/md_k.h
@@ -128,6 +128,7 @@ struct mddev_s
 #define MD_CHANGE_DEVS  0       /* Some device status has changed */
 #define MD_CHANGE_CLEAN 1       /* transition to or from 'clean' */
 #define MD_CHANGE_PENDING 2     /* superblock update in progress */
+#define MD_NOTIFY_ARRAY_STATE 3 /* atomic context wants to notify userspace */
 
         int                             ro;
 
diff --git a/include/linux/rcuclassic.h b/include/linux/rcuclassic.h
index 8c774905dcfe..4ab843622727 100644
--- a/include/linux/rcuclassic.h
+++ b/include/linux/rcuclassic.h
@@ -117,7 +117,7 @@ extern int rcu_needs_cpu(int cpu);
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 extern struct lockdep_map rcu_lock_map;
 # define rcu_read_acquire()     \
-                        lock_acquire(&rcu_lock_map, 0, 0, 2, 1, _THIS_IP_)
+                        lock_acquire(&rcu_lock_map, 0, 0, 2, 1, NULL, _THIS_IP_)
 # define rcu_read_release()     lock_release(&rcu_lock_map, 1, _THIS_IP_)
 #else
 # define rcu_read_acquire()     do { } while (0)
diff --git a/include/linux/rculist.h b/include/linux/rculist.h
index b0f39be08b6c..eb4443c7e05b 100644
--- a/include/linux/rculist.h
+++ b/include/linux/rculist.h
@@ -98,6 +98,34 @@ static inline void list_del_rcu(struct list_head *entry)
 }
 
 /**
+ * hlist_del_init_rcu - deletes entry from hash list with re-initialization
+ * @n: the element to delete from the hash list.
+ *
+ * Note: list_unhashed() on the node return true after this. It is
+ * useful for RCU based read lockfree traversal if the writer side
+ * must know if the list entry is still hashed or already unhashed.
+ *
+ * In particular, it means that we can not poison the forward pointers
+ * that may still be used for walking the hash list and we can only
+ * zero the pprev pointer so list_unhashed() will return true after
+ * this.
+ *
+ * The caller must take whatever precautions are necessary (such as
+ * holding appropriate locks) to avoid racing with another
+ * list-mutation primitive, such as hlist_add_head_rcu() or
+ * hlist_del_rcu(), running on this same list.  However, it is
+ * perfectly legal to run concurrently with the _rcu list-traversal
+ * primitives, such as hlist_for_each_entry_rcu().
+ */
+static inline void hlist_del_init_rcu(struct hlist_node *n)
+{
+        if (!hlist_unhashed(n)) {
+                __hlist_del(n);
+                n->pprev = NULL;
+        }
+}
+
+/**
  * list_replace_rcu - replace old entry by new one
  * @old : the element to be replaced
  * @new : the new element to insert
diff --git a/include/linux/reboot.h b/include/linux/reboot.h
index b93b541cf111..988e55fe649b 100644
--- a/include/linux/reboot.h
+++ b/include/linux/reboot.h
@@ -59,6 +59,7 @@ extern void machine_crash_shutdown(struct pt_regs *);
  * Architecture independent implemenations of sys_reboot commands.
  */
 
+extern void kernel_restart_prepare(char *cmd);
 extern void kernel_restart(char *cmd);
 extern void kernel_halt(void);
 extern void kernel_power_off(void);
diff --git a/include/linux/regulator/bq24022.h b/include/linux/regulator/bq24022.h
new file mode 100644
index 000000000000..e84b0a9feda5
--- /dev/null
+++ b/include/linux/regulator/bq24022.h
@@ -0,0 +1,21 @@
+/*
+ * Support for TI bq24022 (bqTINY-II) Dual Input (USB/AC Adpater)
+ * 1-Cell Li-Ion Charger connected via GPIOs.
+ *
+ * Copyright (c) 2008 Philipp Zabel
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+
+/**
+ * bq24022_mach_info - platform data for bq24022
+ * @gpio_nce: GPIO line connected to the nCE pin, used to enable / disable charging
+ * @gpio_iset2: GPIO line connected to the ISET2 pin, used to limit charging current to 100 mA / 500 mA
+ */
+struct bq24022_mach_info {
+        int gpio_nce;
+        int gpio_iset2;
+};
diff --git a/include/linux/regulator/consumer.h b/include/linux/regulator/consumer.h
new file mode 100644
index 000000000000..afdc4558bb94
--- /dev/null
+++ b/include/linux/regulator/consumer.h
@@ -0,0 +1,284 @@
+/*
+ * consumer.h -- SoC Regulator consumer support.
+ *
+ * Copyright (C) 2007, 2008 Wolfson Microelectronics PLC.
+ *
+ * Author: Liam Girdwood <lg@opensource.wolfsonmicro.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Regulator Consumer Interface.
+ *
+ * A Power Management Regulator framework for SoC based devices.
+ * Features:-
+ *   o Voltage and current level control.
+ *   o Operating mode control.
+ *   o Regulator status.
+ *   o sysfs entries for showing client devices and status
+ *
+ * EXPERIMENTAL FEATURES:
+ *   Dynamic Regulator operating Mode Switching (DRMS) - allows regulators
+ *   to use most efficient operating mode depending upon voltage and load and
+ *   is transparent to client drivers.
+ *
+ *   e.g. Devices x,y,z share regulator r. Device x and y draw 20mA each during
+ *   IO and 1mA at idle. Device z draws 100mA when under load and 5mA when
+ *   idling. Regulator r has > 90% efficiency in NORMAL mode at loads > 100mA
+ *   but this drops rapidly to 60% when below 100mA. Regulator r has > 90%
+ *   efficiency in IDLE mode at loads < 10mA. Thus regulator r will operate
+ *   in normal mode for loads > 10mA and in IDLE mode for load <= 10mA.
+ *
+ */
+
+#ifndef __LINUX_REGULATOR_CONSUMER_H_
+#define __LINUX_REGULATOR_CONSUMER_H_
+
+/*
+ * Regulator operating modes.
+ *
+ * Regulators can run in a variety of different operating modes depending on
+ * output load. This allows further system power savings by selecting the
+ * best (and most efficient) regulator mode for a desired load.
+ *
+ * Most drivers will only care about NORMAL. The modes below are generic and
+ * will probably not match the naming convention of your regulator data sheet
+ * but should match the use cases in the datasheet.
+ *
+ * In order of power efficiency (least efficient at top).
+ *
+ *  Mode       Description
+ *  FAST       Regulator can handle fast changes in it's load.
+ *             e.g. useful in CPU voltage & frequency scaling where
+ *             load can quickly increase with CPU frequency increases.
+ *
+ *  NORMAL     Normal regulator power supply mode. Most drivers will
+ *             use this mode.
+ *
+ *  IDLE       Regulator runs in a more efficient mode for light
+ *             loads. Can be used for devices that have a low power
+ *             requirement during periods of inactivity. This mode
+ *             may be more noisy than NORMAL and may not be able
+ *             to handle fast load switching.
+ *
+ *  STANDBY    Regulator runs in the most efficient mode for very
+ *             light loads. Can be used by devices when they are
+ *             in a sleep/standby state. This mode is likely to be
+ *             the most noisy and may not be able to handle fast load
+ *             switching.
+ *
+ * NOTE: Most regulators will only support a subset of these modes. Some
+ * will only just support NORMAL.
+ *
+ * These modes can be OR'ed together to make up a mask of valid register modes.
+ */
+
+#define REGULATOR_MODE_FAST                     0x1
+#define REGULATOR_MODE_NORMAL                   0x2
+#define REGULATOR_MODE_IDLE                     0x4
+#define REGULATOR_MODE_STANDBY                  0x8
+
+/*
+ * Regulator notifier events.
+ *
+ * UNDER_VOLTAGE  Regulator output is under voltage.
+ * OVER_CURRENT   Regulator output current is too high.
+ * REGULATION_OUT Regulator output is out of regulation.
+ * FAIL           Regulator output has failed.
+ * OVER_TEMP      Regulator over temp.
+ * FORCE_DISABLE  Regulator shut down by software.
+ *
+ * NOTE: These events can be OR'ed together when passed into handler.
+ */
+
+#define REGULATOR_EVENT_UNDER_VOLTAGE           0x01
+#define REGULATOR_EVENT_OVER_CURRENT            0x02
+#define REGULATOR_EVENT_REGULATION_OUT          0x04
+#define REGULATOR_EVENT_FAIL                    0x08
+#define REGULATOR_EVENT_OVER_TEMP               0x10
+#define REGULATOR_EVENT_FORCE_DISABLE           0x20
+
+struct regulator;
+
+/**
+ * struct regulator_bulk_data - Data used for bulk regulator operations.
+ *
+ * @supply   The name of the supply.  Initialised by the user before
+ *           using the bulk regulator APIs.
+ * @consumer The regulator consumer for the supply.  This will be managed
+ *           by the bulk API.
+ *
+ * The regulator APIs provide a series of regulator_bulk_() API calls as
+ * a convenience to consumers which require multiple supplies.  This
+ * structure is used to manage data for these calls.
+ */
+struct regulator_bulk_data {
+        const char *supply;
+        struct regulator *consumer;
+};
+
+#if defined(CONFIG_REGULATOR)
+
+/* regulator get and put */
+struct regulator *__must_check regulator_get(struct device *dev,
+                                             const char *id);
+void regulator_put(struct regulator *regulator);
+
+/* regulator output control and status */
+int regulator_enable(struct regulator *regulator);
+int regulator_disable(struct regulator *regulator);
+int regulator_force_disable(struct regulator *regulator);
+int regulator_is_enabled(struct regulator *regulator);
+
+int regulator_bulk_get(struct device *dev, int num_consumers,
+                       struct regulator_bulk_data *consumers);
+int regulator_bulk_enable(int num_consumers,
+                          struct regulator_bulk_data *consumers);
+int regulator_bulk_disable(int num_consumers,
+                           struct regulator_bulk_data *consumers);
+void regulator_bulk_free(int num_consumers,
+                         struct regulator_bulk_data *consumers);
+
+int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV);
+int regulator_get_voltage(struct regulator *regulator);
+int regulator_set_current_limit(struct regulator *regulator,
+                               int min_uA, int max_uA);
+int regulator_get_current_limit(struct regulator *regulator);
+
+int regulator_set_mode(struct regulator *regulator, unsigned int mode);
+unsigned int regulator_get_mode(struct regulator *regulator);
+int regulator_set_optimum_mode(struct regulator *regulator, int load_uA);
+
+/* regulator notifier block */
+int regulator_register_notifier(struct regulator *regulator,
+                              struct notifier_block *nb);
+int regulator_unregister_notifier(struct regulator *regulator,
+                                struct notifier_block *nb);
+
+/* driver data - core doesn't touch */
+void *regulator_get_drvdata(struct regulator *regulator);
+void regulator_set_drvdata(struct regulator *regulator, void *data);
+
+#else
+
+/*
+ * Make sure client drivers will still build on systems with no software
+ * controllable voltage or current regulators.
+ */
+static inline struct regulator *__must_check regulator_get(struct device *dev,
+        const char *id)
+{
+        /* Nothing except the stubbed out regulator API should be
+         * looking at the value except to check if it is an error
+         * value so the actual return value doesn't matter.
+         */
+        return (struct regulator *)id;
+}
+static inline void regulator_put(struct regulator *regulator)
+{
+}
+
+static inline int regulator_enable(struct regulator *regulator)
+{
+        return 0;
+}
+
+static inline int regulator_disable(struct regulator *regulator)
+{
+        return 0;
+}
+
+static inline int regulator_is_enabled(struct regulator *regulator)
+{
+        return 1;
+}
+
+static inline int regulator_bulk_get(struct device *dev,
+                                     int num_consumers,
+                                     struct regulator_bulk_data *consumers)
+{
+        return 0;
+}
+
+static inline int regulator_bulk_enable(int num_consumers,
+                                        struct regulator_bulk_data *consumers)
+{
+        return 0;
+}
+
+static inline int regulator_bulk_disable(int num_consumers,
+                                         struct regulator_bulk_data *consumers)
+{
+        return 0;
+}
+
+static inline void regulator_bulk_free(int num_consumers,
+                                       struct regulator_bulk_data *consumers)
+{
+}
+
+static inline int regulator_set_voltage(struct regulator *regulator,
+                                        int min_uV, int max_uV)
+{
+        return 0;
+}
+
+static inline int regulator_get_voltage(struct regulator *regulator)
+{
+        return 0;
+}
+
+static inline int regulator_set_current_limit(struct regulator *regulator,
+                                             int min_uA, int max_uA)
+{
+        return 0;
+}
+
+static inline int regulator_get_current_limit(struct regulator *regulator)
+{
+        return 0;
+}
+
+static inline int regulator_set_mode(struct regulator *regulator,
+        unsigned int mode)
+{
+        return 0;
+}
+
+static inline unsigned int regulator_get_mode(struct regulator *regulator)
+{
+        return REGULATOR_MODE_NORMAL;
+}
+
+static inline int regulator_set_optimum_mode(struct regulator *regulator,
+                                        int load_uA)
+{
+        return REGULATOR_MODE_NORMAL;
+}
+
+static inline int regulator_register_notifier(struct regulator *regulator,
+                              struct notifier_block *nb)
+{
+        return 0;
+}
+
+static inline int regulator_unregister_notifier(struct regulator *regulator,
+                                struct notifier_block *nb)
+{
+        return 0;
+}
+
+static inline void *regulator_get_drvdata(struct regulator *regulator)
+{
+        return NULL;
+}
+
+static inline void regulator_set_drvdata(struct regulator *regulator,
+        void *data)
+{
+}
+
+#endif
+
+#endif
diff --git a/include/linux/regulator/driver.h b/include/linux/regulator/driver.h
new file mode 100644
index 000000000000..1d712c7172a2
--- /dev/null
+++ b/include/linux/regulator/driver.h
@@ -0,0 +1,99 @@
+/*
+ * driver.h -- SoC Regulator driver support.
+ *
+ * Copyright (C) 2007, 2008 Wolfson Microelectronics PLC.
+ *
+ * Author: Liam Girdwood <lg@opensource.wolfsonmicro.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Regulator Driver Interface.
+ */
+
+#ifndef __LINUX_REGULATOR_DRIVER_H_
+#define __LINUX_REGULATOR_DRIVER_H_
+
+#include <linux/device.h>
+#include <linux/regulator/consumer.h>
+
+struct regulator_constraints;
+struct regulator_dev;
+
+/**
+ * struct regulator_ops - regulator operations.
+ *
+ * This struct describes regulator operations.
+ */
+struct regulator_ops {
+
+        /* get/set regulator voltage */
+        int (*set_voltage) (struct regulator_dev *, int min_uV, int max_uV);
+        int (*get_voltage) (struct regulator_dev *);
+
+        /* get/set regulator current  */
+        int (*set_current_limit) (struct regulator_dev *,
+                                 int min_uA, int max_uA);
+        int (*get_current_limit) (struct regulator_dev *);
+
+        /* enable/disable regulator */
+        int (*enable) (struct regulator_dev *);
+        int (*disable) (struct regulator_dev *);
+        int (*is_enabled) (struct regulator_dev *);
+
+        /* get/set regulator operating mode (defined in regulator.h) */
+        int (*set_mode) (struct regulator_dev *, unsigned int mode);
+        unsigned int (*get_mode) (struct regulator_dev *);
+
+        /* get most efficient regulator operating mode for load */
+        unsigned int (*get_optimum_mode) (struct regulator_dev *, int input_uV,
+                                          int output_uV, int load_uA);
+
+        /* the operations below are for configuration of regulator state when
+         * it's parent PMIC enters a global STANBY/HIBERNATE state */
+
+        /* set regulator suspend voltage */
+        int (*set_suspend_voltage) (struct regulator_dev *, int uV);
+
+        /* enable/disable regulator in suspend state */
+        int (*set_suspend_enable) (struct regulator_dev *);
+        int (*set_suspend_disable) (struct regulator_dev *);
+
+        /* set regulator suspend operating mode (defined in regulator.h) */
+        int (*set_suspend_mode) (struct regulator_dev *, unsigned int mode);
+};
+
+/*
+ * Regulators can either control voltage or current.
+ */
+enum regulator_type {
+        REGULATOR_VOLTAGE,
+        REGULATOR_CURRENT,
+};
+
+/**
+ * struct regulator_desc - Regulator descriptor
+ *
+ */
+struct regulator_desc {
+        const char *name;
+        int id;
+        struct regulator_ops *ops;
+        int irq;
+        enum regulator_type type;
+        struct module *owner;
+};
+
+
+struct regulator_dev *regulator_register(struct regulator_desc *regulator_desc,
+                                          void *reg_data);
+void regulator_unregister(struct regulator_dev *rdev);
+
+int regulator_notifier_call_chain(struct regulator_dev *rdev,
+                                  unsigned long event, void *data);
+
+void *rdev_get_drvdata(struct regulator_dev *rdev);
+int rdev_get_id(struct regulator_dev *rdev);
+
+#endif
diff --git a/include/linux/regulator/fixed.h b/include/linux/regulator/fixed.h
new file mode 100644
index 000000000000..1387a5d2190e
--- /dev/null
+++ b/include/linux/regulator/fixed.h
@@ -0,0 +1,22 @@
+/*
+ * fixed.h
+ *
+ * Copyright 2008 Wolfson Microelectronics PLC.
+ *
+ * Author: Mark Brown <broonie@opensource.wolfsonmicro.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.
+ */
+
+#ifndef __REGULATOR_FIXED_H
+#define __REGULATOR_FIXED_H
+
+struct fixed_voltage_config {
+        const char *supply_name;
+        int microvolts;
+};
+
+#endif
diff --git a/include/linux/regulator/machine.h b/include/linux/regulator/machine.h
new file mode 100644
index 000000000000..11e737dbfcf2
--- /dev/null
+++ b/include/linux/regulator/machine.h
@@ -0,0 +1,104 @@
+/*
+ * machine.h -- SoC Regulator support, machine/board driver API.
+ *
+ * Copyright (C) 2007, 2008 Wolfson Microelectronics PLC.
+ *
+ * Author: Liam Girdwood <lg@opensource.wolfsonmicro.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Regulator Machine/Board Interface.
+ */
+
+#ifndef __LINUX_REGULATOR_MACHINE_H_
+#define __LINUX_REGULATOR_MACHINE_H_
+
+#include <linux/regulator/consumer.h>
+#include <linux/suspend.h>
+
+struct regulator;
+
+/*
+ * Regulator operation constraint flags. These flags are used to enable
+ * certain regulator operations and can be OR'ed together.
+ *
+ * VOLTAGE:  Regulator output voltage can be changed by software on this
+ *           board/machine.
+ * CURRENT:  Regulator output current can be changed by software on this
+ *           board/machine.
+ * MODE:     Regulator operating mode can be changed by software on this
+ *           board/machine.
+ * STATUS:   Regulator can be enabled and disabled.
+ * DRMS:     Dynamic Regulator Mode Switching is enabled for this regulator.
+ */
+
+#define REGULATOR_CHANGE_VOLTAGE        0x1
+#define REGULATOR_CHANGE_CURRENT        0x2
+#define REGULATOR_CHANGE_MODE           0x4
+#define REGULATOR_CHANGE_STATUS         0x8
+#define REGULATOR_CHANGE_DRMS           0x10
+
+/**
+ * struct regulator_state - regulator state during low power syatem states
+ *
+ * This describes a regulators state during a system wide low power state.
+ */
+struct regulator_state {
+        int uV; /* suspend voltage */
+        unsigned int mode; /* suspend regulator operating mode */
+        int enabled; /* is regulator enabled in this suspend state */
+};
+
+/**
+ * struct regulation_constraints - regulator operating constraints.
+ *
+ * This struct describes regulator and board/machine specific constraints.
+ */
+struct regulation_constraints {
+
+        char *name;
+
+        /* voltage output range (inclusive) - for voltage control */
+        int min_uV;
+        int max_uV;
+
+        /* current output range (inclusive) - for current control */
+        int min_uA;
+        int max_uA;
+
+        /* valid regulator operating modes for this machine */
+        unsigned int valid_modes_mask;
+
+        /* valid operations for regulator on this machine */
+        unsigned int valid_ops_mask;
+
+        /* regulator input voltage - only if supply is another regulator */
+        int input_uV;
+
+        /* regulator suspend states for global PMIC STANDBY/HIBERNATE */
+        struct regulator_state state_disk;
+        struct regulator_state state_mem;
+        struct regulator_state state_standby;
+        suspend_state_t initial_state; /* suspend state to set at init */
+
+        /* constriant flags */
+        unsigned always_on:1;   /* regulator never off when system is on */
+        unsigned boot_on:1;     /* bootloader/firmware enabled regulator */
+        unsigned apply_uV:1;    /* apply uV constraint iff min == max */
+};
+
+int regulator_set_supply(const char *regulator, const char *regulator_supply);
+
+const char *regulator_get_supply(const char *regulator);
+
+int regulator_set_machine_constraints(const char *regulator,
+        struct regulation_constraints *constraints);
+
+int regulator_set_device_supply(const char *regulator, struct device *dev,
+                                const char *supply);
+
+int regulator_suspend_prepare(suspend_state_t state);
+
+#endif
diff --git a/include/linux/reiserfs_xattr.h b/include/linux/reiserfs_xattr.h
index 66a96814d614..af135ae895db 100644
--- a/include/linux/reiserfs_xattr.h
+++ b/include/linux/reiserfs_xattr.h
@@ -55,7 +55,7 @@ int reiserfs_removexattr(struct dentry *dentry, const char *name);
 int reiserfs_delete_xattrs(struct inode *inode);
 int reiserfs_chown_xattrs(struct inode *inode, struct iattr *attrs);
 int reiserfs_xattr_init(struct super_block *sb, int mount_flags);
-int reiserfs_permission(struct inode *inode, int mask, struct nameidata *nd);
+int reiserfs_permission(struct inode *inode, int mask);
 
 int reiserfs_xattr_del(struct inode *, const char *);
 int reiserfs_xattr_get(const struct inode *, const char *, void *, size_t);
diff --git a/include/linux/relay.h b/include/linux/relay.h
index 6cd8c4425fc7..953fc055e875 100644
--- a/include/linux/relay.h
+++ b/include/linux/relay.h
@@ -48,6 +48,7 @@ struct rchan_buf
         size_t *padding;                /* padding counts per sub-buffer */
         size_t prev_padding;            /* temporary variable */
         size_t bytes_consumed;          /* bytes consumed in cur read subbuf */
+        size_t early_bytes;             /* bytes consumed before VFS inited */
         unsigned int cpu;               /* this buf's cpu */
 } ____cacheline_aligned;
 
@@ -68,6 +69,7 @@ struct rchan
         int is_global;                  /* One global buffer ? */
         struct list_head list;          /* for channel list */
         struct dentry *parent;          /* parent dentry passed to open */
+        int has_base_filename;          /* has a filename associated? */
         char base_filename[NAME_MAX];   /* saved base filename */
 };
 
@@ -169,6 +171,9 @@ struct rchan *relay_open(const char *base_filename,
                          size_t n_subbufs,
                          struct rchan_callbacks *cb,
                          void *private_data);
+extern int relay_late_setup_files(struct rchan *chan,
+                                  const char *base_filename,
+                                  struct dentry *parent);
 extern void relay_close(struct rchan *chan);
 extern void relay_flush(struct rchan *chan);
 extern void relay_subbufs_consumed(struct rchan *chan,
diff --git a/include/linux/rfkill.h b/include/linux/rfkill.h
index c5f6e54ec6ae..741d1a62cc3f 100644
--- a/include/linux/rfkill.h
+++ b/include/linux/rfkill.h
@@ -68,7 +68,8 @@ enum rfkill_state {
  * @user_claim_unsupported: Whether the hardware supports exclusive
  *      RF-kill control by userspace. Set this before registering.
  * @user_claim: Set when the switch is controlled exlusively by userspace.
- * @mutex: Guards switch state transitions
+ * @mutex: Guards switch state transitions.  It serializes callbacks
+ *      and also protects the state.
  * @data: Pointer to the RF button drivers private data which will be
  *      passed along when toggling radio state.
  * @toggle_radio(): Mandatory handler to control state of the radio.
@@ -89,12 +90,13 @@ struct rfkill {
         const char *name;
         enum rfkill_type type;
 
-        enum rfkill_state state;
         bool user_claim_unsupported;
         bool user_claim;
 
+        /* the mutex serializes callbacks and also protects
+         * the state */
         struct mutex mutex;
-
+        enum rfkill_state state;
         void *data;
         int (*toggle_radio)(void *data, enum rfkill_state state);
         int (*get_state)(void *data, enum rfkill_state *state);
diff --git a/include/linux/rmap.h b/include/linux/rmap.h
index 1383692ac5bd..69407f85e10b 100644
--- a/include/linux/rmap.h
+++ b/include/linux/rmap.h
@@ -26,6 +26,14 @@
  */
 struct anon_vma {
         spinlock_t lock;        /* Serialize access to vma list */
+        /*
+         * NOTE: the LSB of the head.next is set by
+         * mm_take_all_locks() _after_ taking the above lock. So the
+         * head must only be read/written after taking the above lock
+         * to be sure to see a valid next pointer. The LSB bit itself
+         * is serialized by a system wide lock only visible to
+         * mm_take_all_locks() (mm_all_locks_mutex).
+         */
         struct list_head head;  /* List of private "related" vmas */
 };
 
diff --git a/include/linux/rtc.h b/include/linux/rtc.h
index b01fe004cb5e..91f597ad6acc 100644
--- a/include/linux/rtc.h
+++ b/include/linux/rtc.h
@@ -225,8 +225,6 @@ typedef struct rtc_task {
 int rtc_register(rtc_task_t *task);
 int rtc_unregister(rtc_task_t *task);
 int rtc_control(rtc_task_t *t, unsigned int cmd, unsigned long arg);
-void rtc_get_rtc_time(struct rtc_time *rtc_tm);
-irqreturn_t rtc_interrupt(int irq, void *dev_id);
 
 #endif /* __KERNEL__ */
 
diff --git a/include/linux/rtnetlink.h b/include/linux/rtnetlink.h
index f4d386c191f5..ca643b13b026 100644
--- a/include/linux/rtnetlink.h
+++ b/include/linux/rtnetlink.h
@@ -755,13 +755,6 @@ extern void __rtnl_unlock(void);
         } \
 } while(0)
 
-#define BUG_TRAP(x) do { \
-        if (unlikely(!(x))) { \
-                printk(KERN_ERR "KERNEL: assertion (%s) failed at %s (%d)\n", \
-                        #x,  __FILE__ , __LINE__); \
-        } \
-} while(0)
-
 static inline u32 rtm_get_table(struct rtattr **rta, u8 table)
 {
         return RTA_GET_U32(rta[RTA_TABLE-1]);
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 42036ffe6b00..cfb0d87b99fc 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -87,6 +87,7 @@ struct sched_param {
 #include <linux/task_io_accounting.h>
 #include <linux/kobject.h>
 #include <linux/latencytop.h>
+#include <linux/cred.h>
 
 #include <asm/processor.h>
 
@@ -292,7 +293,6 @@ extern void sched_show_task(struct task_struct *p);
 
 #ifdef CONFIG_DETECT_SOFTLOCKUP
 extern void softlockup_tick(void);
-extern void spawn_softlockup_task(void);
 extern void touch_softlockup_watchdog(void);
 extern void touch_all_softlockup_watchdogs(void);
 extern unsigned int  softlockup_panic;
@@ -506,9 +506,6 @@ struct signal_struct {
         unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw;
         unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt;
         unsigned long inblock, oublock, cinblock, coublock;
-#ifdef CONFIG_TASK_XACCT
-        u64 rchar, wchar, syscr, syscw;
-#endif
         struct task_io_accounting ioac;
 
         /*
@@ -1257,10 +1254,6 @@ struct task_struct {
 
         unsigned long ptrace_message;
         siginfo_t *last_siginfo; /* For ptrace use.  */
-#ifdef CONFIG_TASK_XACCT
-/* i/o counters(bytes read/written, #syscalls */
-        u64 rchar, wchar, syscr, syscw;
-#endif
         struct task_io_accounting ioac;
 #if defined(CONFIG_TASK_XACCT)
         u64 acct_rss_mem1;      /* accumulated rss usage */
@@ -1559,16 +1552,10 @@ static inline int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask)
 
 extern unsigned long long sched_clock(void);
 
-#ifndef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK
-static inline void sched_clock_init(void)
-{
-}
-
-static inline u64 sched_clock_cpu(int cpu)
-{
-        return sched_clock();
-}
+extern void sched_clock_init(void);
+extern u64 sched_clock_cpu(int cpu);
 
+#ifndef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK
 static inline void sched_clock_tick(void)
 {
 }
@@ -1580,28 +1567,11 @@ static inline void sched_clock_idle_sleep_event(void)
 static inline void sched_clock_idle_wakeup_event(u64 delta_ns)
 {
 }
-
-#ifdef CONFIG_NO_HZ
-static inline void sched_clock_tick_stop(int cpu)
-{
-}
-
-static inline void sched_clock_tick_start(int cpu)
-{
-}
-#endif
-
-#else /* CONFIG_HAVE_UNSTABLE_SCHED_CLOCK */
-extern void sched_clock_init(void);
-extern u64 sched_clock_cpu(int cpu);
+#else
 extern void sched_clock_tick(void);
 extern void sched_clock_idle_sleep_event(void);
 extern void sched_clock_idle_wakeup_event(u64 delta_ns);
-#ifdef CONFIG_NO_HZ
-extern void sched_clock_tick_stop(int cpu);
-extern void sched_clock_tick_start(int cpu);
 #endif
-#endif /* CONFIG_HAVE_UNSTABLE_SCHED_CLOCK */
 
 /*
  * For kernel-internal use: high-speed (but slightly incorrect) per-cpu
@@ -1797,7 +1767,7 @@ extern int kill_pid_info_as_uid(int, struct siginfo *, struct pid *, uid_t, uid_
 extern int kill_pgrp(struct pid *pid, int sig, int priv);
 extern int kill_pid(struct pid *pid, int sig, int priv);
 extern int kill_proc_info(int, struct siginfo *, pid_t);
-extern void do_notify_parent(struct task_struct *, int);
+extern int do_notify_parent(struct task_struct *, int);
 extern void force_sig(int, struct task_struct *);
 extern void force_sig_specific(int, struct task_struct *);
 extern int send_sig(int, struct task_struct *, int);
@@ -1883,9 +1853,13 @@ extern void set_task_comm(struct task_struct *tsk, char *from);
 extern char *get_task_comm(char *to, struct task_struct *tsk);
 
 #ifdef CONFIG_SMP
-extern void wait_task_inactive(struct task_struct * p);
+extern unsigned long wait_task_inactive(struct task_struct *, long match_state);
 #else
-#define wait_task_inactive(p)   do { } while (0)
+static inline unsigned long wait_task_inactive(struct task_struct *p,
+                                               long match_state)
+{
+        return 1;
+}
 #endif
 
 #define next_task(p)    list_entry(rcu_dereference((p)->tasks.next), struct task_struct, tasks)
@@ -2139,16 +2113,7 @@ static inline void set_task_cpu(struct task_struct *p, unsigned int cpu)
 
 #endif /* CONFIG_SMP */
 
-#ifdef HAVE_ARCH_PICK_MMAP_LAYOUT
 extern void arch_pick_mmap_layout(struct mm_struct *mm);
-#else
-static inline void arch_pick_mmap_layout(struct mm_struct *mm)
-{
-        mm->mmap_base = TASK_UNMAPPED_BASE;
-        mm->get_unmapped_area = arch_get_unmapped_area;
-        mm->unmap_area = arch_unmap_area;
-}
-#endif
 
 #ifdef CONFIG_TRACING
 extern void
@@ -2196,22 +2161,22 @@ extern long sched_group_rt_period(struct task_group *tg);
 #ifdef CONFIG_TASK_XACCT
 static inline void add_rchar(struct task_struct *tsk, ssize_t amt)
 {
-        tsk->rchar += amt;
+        tsk->ioac.rchar += amt;
 }
 
 static inline void add_wchar(struct task_struct *tsk, ssize_t amt)
 {
-        tsk->wchar += amt;
+        tsk->ioac.wchar += amt;
 }
 
 static inline void inc_syscr(struct task_struct *tsk)
 {
-        tsk->syscr++;
+        tsk->ioac.syscr++;
 }
 
 static inline void inc_syscw(struct task_struct *tsk)
 {
-        tsk->syscw++;
+        tsk->ioac.syscw++;
 }
 #else
 static inline void add_rchar(struct task_struct *tsk, ssize_t amt)
@@ -2231,14 +2196,6 @@ static inline void inc_syscw(struct task_struct *tsk)
 }
 #endif
 
-#ifdef CONFIG_SMP
-void migration_init(void);
-#else
-static inline void migration_init(void)
-{
-}
-#endif
-
 #ifndef TASK_SIZE_OF
 #define TASK_SIZE_OF(tsk)       TASK_SIZE
 #endif
diff --git a/include/linux/security.h b/include/linux/security.h
index f0e9adb22ac2..80c4d002864c 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -46,8 +46,8 @@ struct audit_krule;
  */
 extern int cap_capable(struct task_struct *tsk, int cap);
 extern int cap_settime(struct timespec *ts, struct timezone *tz);
-extern int cap_ptrace(struct task_struct *parent, struct task_struct *child,
-                      unsigned int mode);
+extern int cap_ptrace_may_access(struct task_struct *child, unsigned int mode);
+extern int cap_ptrace_traceme(struct task_struct *parent);
 extern int cap_capget(struct task_struct *target, kernel_cap_t *effective, kernel_cap_t *inheritable, kernel_cap_t *permitted);
 extern int cap_capset_check(struct task_struct *target, kernel_cap_t *effective, kernel_cap_t *inheritable, kernel_cap_t *permitted);
 extern void cap_capset_set(struct task_struct *target, kernel_cap_t *effective, kernel_cap_t *inheritable, kernel_cap_t *permitted);
@@ -1157,17 +1157,24 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
  *      @alter contains the flag indicating whether changes are to be made.
  *      Return 0 if permission is granted.
  *
- * @ptrace:
- *      Check permission before allowing the @parent process to trace the
+ * @ptrace_may_access:
+ *      Check permission before allowing the current process to trace the
  *      @child process.
  *      Security modules may also want to perform a process tracing check
  *      during an execve in the set_security or apply_creds hooks of
  *      binprm_security_ops if the process is being traced and its security
  *      attributes would be changed by the execve.
- *      @parent contains the task_struct structure for parent process.
- *      @child contains the task_struct structure for child process.
+ *      @child contains the task_struct structure for the target process.
  *      @mode contains the PTRACE_MODE flags indicating the form of access.
  *      Return 0 if permission is granted.
+ * @ptrace_traceme:
+ *      Check that the @parent process has sufficient permission to trace the
+ *      current process before allowing the current process to present itself
+ *      to the @parent process for tracing.
+ *      The parent process will still have to undergo the ptrace_may_access
+ *      checks before it is allowed to trace this one.
+ *      @parent contains the task_struct structure for debugger process.
+ *      Return 0 if permission is granted.
  * @capget:
  *      Get the @effective, @inheritable, and @permitted capability sets for
  *      the @target process.  The hook may also perform permission checking to
@@ -1287,8 +1294,8 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
 struct security_operations {
         char name[SECURITY_NAME_MAX + 1];
 
-        int (*ptrace) (struct task_struct *parent, struct task_struct *child,
-                       unsigned int mode);
+        int (*ptrace_may_access) (struct task_struct *child, unsigned int mode);
+        int (*ptrace_traceme) (struct task_struct *parent);
         int (*capget) (struct task_struct *target,
                        kernel_cap_t *effective,
                        kernel_cap_t *inheritable, kernel_cap_t *permitted);
@@ -1362,7 +1369,7 @@ struct security_operations {
                              struct inode *new_dir, struct dentry *new_dentry);
         int (*inode_readlink) (struct dentry *dentry);
         int (*inode_follow_link) (struct dentry *dentry, struct nameidata *nd);
-        int (*inode_permission) (struct inode *inode, int mask, struct nameidata *nd);
+        int (*inode_permission) (struct inode *inode, int mask);
         int (*inode_setattr)    (struct dentry *dentry, struct iattr *attr);
         int (*inode_getattr) (struct vfsmount *mnt, struct dentry *dentry);
         void (*inode_delete) (struct inode *inode);
@@ -1560,8 +1567,8 @@ extern struct dentry *securityfs_create_dir(const char *name, struct dentry *par
 extern void securityfs_remove(struct dentry *dentry);
 
 /* Security operations */
-int security_ptrace(struct task_struct *parent, struct task_struct *child,
-                    unsigned int mode);
+int security_ptrace_may_access(struct task_struct *child, unsigned int mode);
+int security_ptrace_traceme(struct task_struct *parent);
 int security_capget(struct task_struct *target,
                     kernel_cap_t *effective,
                     kernel_cap_t *inheritable,
@@ -1628,7 +1635,7 @@ int security_inode_rename(struct inode *old_dir, struct dentry *old_dentry,
                           struct inode *new_dir, struct dentry *new_dentry);
 int security_inode_readlink(struct dentry *dentry);
 int security_inode_follow_link(struct dentry *dentry, struct nameidata *nd);
-int security_inode_permission(struct inode *inode, int mask, struct nameidata *nd);
+int security_inode_permission(struct inode *inode, int mask);
 int security_inode_setattr(struct dentry *dentry, struct iattr *attr);
 int security_inode_getattr(struct vfsmount *mnt, struct dentry *dentry);
 void security_inode_delete(struct inode *inode);
@@ -1742,11 +1749,15 @@ static inline int security_init(void)
         return 0;
 }
 
-static inline int security_ptrace(struct task_struct *parent,
-                                  struct task_struct *child,
-                                  unsigned int mode)
+static inline int security_ptrace_may_access(struct task_struct *child,
+                                             unsigned int mode)
+{
+        return cap_ptrace_may_access(child, mode);
+}
+
+static inline int security_ptrace_traceme(struct task_struct *parent)
 {
-        return cap_ptrace(parent, child, mode);
+        return cap_ptrace_traceme(parent);
 }
 
 static inline int security_capget(struct task_struct *target,
@@ -2021,8 +2032,7 @@ static inline int security_inode_follow_link(struct dentry *dentry,
         return 0;
 }
 
-static inline int security_inode_permission(struct inode *inode, int mask,
-                                             struct nameidata *nd)
+static inline int security_inode_permission(struct inode *inode, int mask)
 {
         return 0;
 }
diff --git a/include/linux/seq_file.h b/include/linux/seq_file.h
index a66304a09955..a1783b229ef4 100644
--- a/include/linux/seq_file.h
+++ b/include/linux/seq_file.h
@@ -4,6 +4,8 @@
 #include <linux/types.h>
 #include <linux/string.h>
 #include <linux/mutex.h>
+#include <linux/cpumask.h>
+#include <linux/nodemask.h>
 
 struct seq_operations;
 struct file;
@@ -47,6 +49,16 @@ int seq_path(struct seq_file *, struct path *, char *);
 int seq_dentry(struct seq_file *, struct dentry *, char *);
 int seq_path_root(struct seq_file *m, struct path *path, struct path *root,
                   char *esc);
+int seq_bitmap(struct seq_file *m, unsigned long *bits, unsigned int nr_bits);
+static inline int seq_cpumask(struct seq_file *m, cpumask_t *mask)
+{
+        return seq_bitmap(m, mask->bits, NR_CPUS);
+}
+
+static inline int seq_nodemask(struct seq_file *m, nodemask_t *mask)
+{
+        return seq_bitmap(m, mask->bits, MAX_NUMNODES);
+}
 
 int single_open(struct file *, int (*)(struct seq_file *, void *), void *);
 int single_release(struct inode *, struct file *);
diff --git a/include/linux/serio.h b/include/linux/serio.h
index e72716cca577..25641d9e0ea8 100644
--- a/include/linux/serio.h
+++ b/include/linux/serio.h
@@ -87,11 +87,10 @@ void serio_unregister_port(struct serio *serio);
 void serio_unregister_child_port(struct serio *serio);
 
 int __serio_register_driver(struct serio_driver *drv, struct module *owner, const char *mod_name);
-static inline int serio_register_driver(struct serio_driver *drv)
+static inline int __must_check serio_register_driver(struct serio_driver *drv)
 {
         return __serio_register_driver(drv, THIS_MODULE, KBUILD_MODNAME);
 }
-int serio_register_driver(struct serio_driver *drv);
 void serio_unregister_driver(struct serio_driver *drv);
 
 static inline int serio_write(struct serio *serio, unsigned char data)
diff --git a/include/linux/shmem_fs.h b/include/linux/shmem_fs.h
index f2d12d5a21b8..fd83f2584b15 100644
--- a/include/linux/shmem_fs.h
+++ b/include/linux/shmem_fs.h
@@ -43,7 +43,7 @@ static inline struct shmem_inode_info *SHMEM_I(struct inode *inode)
 }
 
 #ifdef CONFIG_TMPFS_POSIX_ACL
-int shmem_permission(struct inode *, int, struct nameidata *);
+int shmem_permission(struct inode *, int);
 int shmem_acl_init(struct inode *, struct inode *);
 void shmem_acl_destroy_inode(struct inode *);
 
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 7ea44f6621f2..358661c9990e 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -243,6 +243,7 @@ typedef unsigned char *sk_buff_data_t;
  *      @tc_index: Traffic control index
  *      @tc_verd: traffic control verdict
  *      @ndisc_nodetype: router type (from link layer)
+ *      @do_not_encrypt: set to prevent encryption of this frame
  *      @dma_cookie: a cookie to one of several possible DMA operations
  *              done by skb DMA functions
  *      @secmark: security marking
@@ -316,7 +317,10 @@ struct sk_buff {
 #ifdef CONFIG_IPV6_NDISC_NODETYPE
         __u8                    ndisc_nodetype:2;
 #endif
-        /* 14 bit hole */
+#if defined(CONFIG_MAC80211) || defined(CONFIG_MAC80211_MODULE)
+        __u8                    do_not_encrypt:1;
+#endif
+        /* 0/13/14 bit hole */
 
 #ifdef CONFIG_NET_DMA
         dma_cookie_t            dma_cookie;
@@ -897,7 +901,7 @@ extern unsigned char *__pskb_pull_tail(struct sk_buff *skb, int delta);
 static inline unsigned char *__pskb_pull(struct sk_buff *skb, unsigned int len)
 {
         if (len > skb_headlen(skb) &&
-            !__pskb_pull_tail(skb, len-skb_headlen(skb)))
+            !__pskb_pull_tail(skb, len - skb_headlen(skb)))
                 return NULL;
         skb->len -= len;
         return skb->data += len;
@@ -914,7 +918,7 @@ static inline int pskb_may_pull(struct sk_buff *skb, unsigned int len)
                 return 1;
         if (unlikely(len > skb->len))
                 return 0;
-        return __pskb_pull_tail(skb, len-skb_headlen(skb)) != NULL;
+        return __pskb_pull_tail(skb, len - skb_headlen(skb)) != NULL;
 }
 
 /**
@@ -1317,7 +1321,7 @@ static inline int skb_padto(struct sk_buff *skb, unsigned int len)
         unsigned int size = skb->len;
         if (likely(size >= len))
                 return 0;
-        return skb_pad(skb, len-size);
+        return skb_pad(skb, len - size);
 }
 
 static inline int skb_add_data(struct sk_buff *skb,
diff --git a/include/linux/slab.h b/include/linux/slab.h
index 41103910f8a2..5ff9676c1e2c 100644
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@ -58,7 +58,7 @@ int slab_is_available(void);
 
 struct kmem_cache *kmem_cache_create(const char *, size_t, size_t,
                         unsigned long,
-                        void (*)(struct kmem_cache *, void *));
+                        void (*)(void *));
 void kmem_cache_destroy(struct kmem_cache *);
 int kmem_cache_shrink(struct kmem_cache *);
 void kmem_cache_free(struct kmem_cache *, void *);
@@ -96,6 +96,7 @@ int kmem_ptr_validate(struct kmem_cache *cachep, const void *ptr);
 /*
  * Common kmalloc functions provided by all allocators
  */
+void * __must_check __krealloc(const void *, size_t, gfp_t);
 void * __must_check krealloc(const void *, size_t, gfp_t);
 void kfree(const void *);
 size_t ksize(const void *);
diff --git a/include/linux/slub_def.h b/include/linux/slub_def.h
index d117ea2825a9..2f5c16b1aacd 100644
--- a/include/linux/slub_def.h
+++ b/include/linux/slub_def.h
@@ -46,6 +46,7 @@ struct kmem_cache_cpu {
 struct kmem_cache_node {
         spinlock_t list_lock;   /* Protect partial list and nr_partial */
         unsigned long nr_partial;
+        unsigned long min_partial;
         struct list_head partial;
 #ifdef CONFIG_SLUB_DEBUG
         atomic_long_t nr_slabs;
@@ -85,7 +86,7 @@ struct kmem_cache {
         struct kmem_cache_order_objects min;
         gfp_t allocflags;       /* gfp flags to use on each alloc */
         int refcount;           /* Refcount for slab cache destroy */
-        void (*ctor)(struct kmem_cache *, void *);
+        void (*ctor)(void *);
         int inuse;              /* Offset to metadata */
         int align;              /* Alignment */
         const char *name;       /* Name (only for display!) */
diff --git a/include/linux/smp.h b/include/linux/smp.h
index 48262f86c969..66484d4a8459 100644
--- a/include/linux/smp.h
+++ b/include/linux/smp.h
@@ -74,15 +74,10 @@ void __smp_call_function_single(int cpuid, struct call_single_data *data);
 #ifdef CONFIG_USE_GENERIC_SMP_HELPERS
 void generic_smp_call_function_single_interrupt(void);
 void generic_smp_call_function_interrupt(void);
-void init_call_single_data(void);
 void ipi_call_lock(void);
 void ipi_call_unlock(void);
 void ipi_call_lock_irq(void);
 void ipi_call_unlock_irq(void);
-#else
-static inline void init_call_single_data(void)
-{
-}
 #endif
 
 /*
diff --git a/include/linux/snmp.h b/include/linux/snmp.h
index 5df62ef1280c..7a6e6bba4a71 100644
--- a/include/linux/snmp.h
+++ b/include/linux/snmp.h
@@ -214,6 +214,8 @@ enum
         LINUX_MIB_TCPDSACKIGNOREDOLD,           /* TCPSACKIgnoredOld */
         LINUX_MIB_TCPDSACKIGNOREDNOUNDO,        /* TCPSACKIgnoredNoUndo */
         LINUX_MIB_TCPSPURIOUSRTOS,              /* TCPSpuriousRTOs */
+        LINUX_MIB_TCPMD5NOTFOUND,               /* TCPMD5NotFound */
+        LINUX_MIB_TCPMD5UNEXPECTED,             /* TCPMD5Unexpected */
         __LINUX_MIB_MAX
 };
 
diff --git a/include/linux/socket.h b/include/linux/socket.h
index 950af631e7fb..dc5086fe7736 100644
--- a/include/linux/socket.h
+++ b/include/linux/socket.h
@@ -189,7 +189,8 @@ struct ucred {
 #define AF_BLUETOOTH    31      /* Bluetooth sockets            */
 #define AF_IUCV         32      /* IUCV sockets                 */
 #define AF_RXRPC        33      /* RxRPC sockets                */
-#define AF_MAX          34      /* For now.. */
+#define AF_ISDN         34      /* mISDN sockets                */
+#define AF_MAX          35      /* For now.. */
 
 /* Protocol families, same as address families. */
 #define PF_UNSPEC       AF_UNSPEC
@@ -225,6 +226,7 @@ struct ucred {
 #define PF_BLUETOOTH    AF_BLUETOOTH
 #define PF_IUCV         AF_IUCV
 #define PF_RXRPC        AF_RXRPC
+#define PF_ISDN         AF_ISDN
 #define PF_MAX          AF_MAX
 
 /* Maximum queue length specifiable by listen.  */
diff --git a/include/linux/spi/orion_spi.h b/include/linux/spi/orion_spi.h
new file mode 100644
index 000000000000..b4d9fa6f797c
--- /dev/null
+++ b/include/linux/spi/orion_spi.h
@@ -0,0 +1,17 @@
+/*
+ * orion_spi.h
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#ifndef __LINUX_SPI_ORION_SPI_H
+#define __LINUX_SPI_ORION_SPI_H
+
+struct orion_spi_info {
+        u32     tclk;           /* no <linux/clk.h> support yet */
+};
+
+
+#endif
diff --git a/include/linux/spi/spi.h b/include/linux/spi/spi.h
index a9cc29d46653..4be01bb44377 100644
--- a/include/linux/spi/spi.h
+++ b/include/linux/spi/spi.h
@@ -778,8 +778,20 @@ spi_register_board_info(struct spi_board_info const *info, unsigned n)
  * 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().
+ *
+ * You can also use spi_alloc_device() and spi_add_device() to use a two
+ * stage registration sequence for each spi_device.  This gives the caller
+ * some more control over the spi_device structure before it is registered,
+ * but requires that caller to initialize fields that would otherwise
+ * be defined using the board info.
  */
 extern struct spi_device *
+spi_alloc_device(struct spi_master *master);
+
+extern int
+spi_add_device(struct spi_device *spi);
+
+extern struct spi_device *
 spi_new_device(struct spi_master *, struct spi_board_info *);
 
 static inline void
diff --git a/include/linux/spinlock.h b/include/linux/spinlock.h
index 61e5610ad165..e0c0fccced46 100644
--- a/include/linux/spinlock.h
+++ b/include/linux/spinlock.h
@@ -183,8 +183,14 @@ do {								\
 
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 # define spin_lock_nested(lock, subclass) _spin_lock_nested(lock, subclass)
+# define spin_lock_nest_lock(lock, nest_lock)                           \
+         do {                                                           \
+                 typecheck(struct lockdep_map *, &(nest_lock)->dep_map);\
+                 _spin_lock_nest_lock(lock, &(nest_lock)->dep_map);     \
+         } while (0)
 #else
 # define spin_lock_nested(lock, subclass) _spin_lock(lock)
+# define spin_lock_nest_lock(lock, nest_lock) _spin_lock(lock)
 #endif
 
 #define write_lock(lock)                _write_lock(lock)
diff --git a/include/linux/spinlock_api_smp.h b/include/linux/spinlock_api_smp.h
index 8a2307ce7296..d79845d034b5 100644
--- a/include/linux/spinlock_api_smp.h
+++ b/include/linux/spinlock_api_smp.h
@@ -22,6 +22,8 @@ int in_lock_functions(unsigned long addr);
 void __lockfunc _spin_lock(spinlock_t *lock)            __acquires(lock);
 void __lockfunc _spin_lock_nested(spinlock_t *lock, int subclass)
                                                         __acquires(lock);
+void __lockfunc _spin_lock_nest_lock(spinlock_t *lock, struct lockdep_map *map)
+                                                        __acquires(lock);
 void __lockfunc _read_lock(rwlock_t *lock)              __acquires(lock);
 void __lockfunc _write_lock(rwlock_t *lock)             __acquires(lock);
 void __lockfunc _spin_lock_bh(spinlock_t *lock)         __acquires(lock);
diff --git a/include/linux/ssb/ssb.h b/include/linux/ssb/ssb.h
index 4bf8cade9dbc..e530026eedf7 100644
--- a/include/linux/ssb/ssb.h
+++ b/include/linux/ssb/ssb.h
@@ -427,9 +427,9 @@ static inline int ssb_dma_mapping_error(struct ssb_device *dev, dma_addr_t addr)
 {
         switch (dev->bus->bustype) {
         case SSB_BUSTYPE_PCI:
-                return pci_dma_mapping_error(addr);
+                return pci_dma_mapping_error(dev->bus->host_pci, addr);
         case SSB_BUSTYPE_SSB:
-                return dma_mapping_error(addr);
+                return dma_mapping_error(dev->dev, addr);
         default:
                 __ssb_dma_not_implemented(dev);
         }
diff --git a/include/linux/stop_machine.h b/include/linux/stop_machine.h
index 5bfc553bdb21..f1cb0ba6d715 100644
--- a/include/linux/stop_machine.h
+++ b/include/linux/stop_machine.h
@@ -5,41 +5,43 @@
    (and more).  So the "read" side to such a lock is anything which
    diables preeempt. */
 #include <linux/cpu.h>
+#include <linux/cpumask.h>
 #include <asm/system.h>
 
 #if defined(CONFIG_STOP_MACHINE) && defined(CONFIG_SMP)
+
+/* Deprecated, but useful for transition. */
+#define ALL_CPUS ~0U
+
 /**
- * stop_machine_run: freeze the machine on all CPUs and run this function
+ * stop_machine: freeze the machine on all CPUs and run this function
  * @fn: the function to run
  * @data: the data ptr for the @fn()
- * @cpu: the cpu to run @fn() on (or any, if @cpu == NR_CPUS.
+ * @cpus: the cpus to run the @fn() on (NULL = any online cpu)
  *
- * Description: This causes a thread to be scheduled on every other cpu,
- * each of which disables interrupts, and finally interrupts are disabled
- * on the current CPU.  The result is that noone is holding a spinlock
- * or inside any other preempt-disabled region when @fn() runs.
+ * Description: This causes a thread to be scheduled on every cpu,
+ * each of which disables interrupts.  The result is that noone is
+ * holding a spinlock or inside any other preempt-disabled region when
+ * @fn() runs.
  *
  * This can be thought of as a very heavy write lock, equivalent to
  * grabbing every spinlock in the kernel. */
-int stop_machine_run(int (*fn)(void *), void *data, unsigned int cpu);
+int stop_machine(int (*fn)(void *), void *data, const cpumask_t *cpus);
 
 /**
- * __stop_machine_run: freeze the machine on all CPUs and run this function
+ * __stop_machine: freeze the machine on all CPUs and run this function
  * @fn: the function to run
  * @data: the data ptr for the @fn
- * @cpu: the cpu to run @fn on (or any, if @cpu == NR_CPUS.
+ * @cpus: the cpus to run the @fn() on (NULL = any online cpu)
  *
- * Description: This is a special version of the above, which returns the
- * thread which has run @fn(): kthread_stop will return the return value
- * of @fn().  Used by hotplug cpu.
+ * Description: This is a special version of the above, which assumes cpus
+ * won't come or go while it's being called.  Used by hotplug cpu.
  */
-struct task_struct *__stop_machine_run(int (*fn)(void *), void *data,
-                                       unsigned int cpu);
-
+int __stop_machine(int (*fn)(void *), void *data, const cpumask_t *cpus);
 #else
 
-static inline int stop_machine_run(int (*fn)(void *), void *data,
-                                   unsigned int cpu)
+static inline int stop_machine(int (*fn)(void *), void *data,
+                               const cpumask_t *cpus)
 {
         int ret;
         local_irq_disable();
@@ -48,4 +50,18 @@ static inline int stop_machine_run(int (*fn)(void *), void *data,
         return ret;
 }
 #endif /* CONFIG_SMP */
+
+static inline int __deprecated stop_machine_run(int (*fn)(void *), void *data,
+                                                unsigned int cpu)
+{
+        /* If they don't care which cpu fn runs on, just pick one. */
+        if (cpu == NR_CPUS)
+                return stop_machine(fn, data, NULL);
+        else if (cpu == ~0U)
+                return stop_machine(fn, data, &cpu_possible_map);
+        else {
+                cpumask_t cpus = cpumask_of_cpu(cpu);
+                return stop_machine(fn, data, &cpus);
+        }
+}
 #endif /* _LINUX_STOP_MACHINE */
diff --git a/include/linux/suspend.h b/include/linux/suspend.h
index e8e69159af71..2ce8207686e2 100644
--- a/include/linux/suspend.h
+++ b/include/linux/suspend.h
@@ -217,11 +217,11 @@ struct platform_hibernation_ops {
 #ifdef CONFIG_HIBERNATION
 /* kernel/power/snapshot.c */
 extern void __register_nosave_region(unsigned long b, unsigned long e, int km);
-static inline void register_nosave_region(unsigned long b, unsigned long e)
+static inline void __init register_nosave_region(unsigned long b, unsigned long e)
 {
         __register_nosave_region(b, e, 0);
 }
-static inline void register_nosave_region_late(unsigned long b, unsigned long e)
+static inline void __init register_nosave_region_late(unsigned long b, unsigned long e)
 {
         __register_nosave_region(b, e, 1);
 }
@@ -278,4 +278,6 @@ static inline void register_nosave_region_late(unsigned long b, unsigned long e)
 }
 #endif
 
+extern struct mutex pm_mutex;
+
 #endif /* _LINUX_SUSPEND_H */
diff --git a/include/linux/swab.h b/include/linux/swab.h
new file mode 100644
index 000000000000..270d5c208a89
--- /dev/null
+++ b/include/linux/swab.h
@@ -0,0 +1,309 @@
+#ifndef _LINUX_SWAB_H
+#define _LINUX_SWAB_H
+
+#include <linux/types.h>
+#include <linux/compiler.h>
+#include <asm/byteorder.h>
+
+/*
+ * casts are necessary for constants, because we never know how for sure
+ * how U/UL/ULL map to __u16, __u32, __u64. At least not in a portable way.
+ */
+#define __const_swab16(x) ((__u16)(                             \
+        (((__u16)(x) & (__u16)0x00ffU) << 8) |                  \
+        (((__u16)(x) & (__u16)0xff00U) >> 8)))
+
+#define __const_swab32(x) ((__u32)(                             \
+        (((__u32)(x) & (__u32)0x000000ffUL) << 24) |            \
+        (((__u32)(x) & (__u32)0x0000ff00UL) <<  8) |            \
+        (((__u32)(x) & (__u32)0x00ff0000UL) >>  8) |            \
+        (((__u32)(x) & (__u32)0xff000000UL) >> 24)))
+
+#define __const_swab64(x) ((__u64)(                             \
+        (((__u64)(x) & (__u64)0x00000000000000ffULL) << 56) |   \
+        (((__u64)(x) & (__u64)0x000000000000ff00ULL) << 40) |   \
+        (((__u64)(x) & (__u64)0x0000000000ff0000ULL) << 24) |   \
+        (((__u64)(x) & (__u64)0x00000000ff000000ULL) <<  8) |   \
+        (((__u64)(x) & (__u64)0x000000ff00000000ULL) >>  8) |   \
+        (((__u64)(x) & (__u64)0x0000ff0000000000ULL) >> 24) |   \
+        (((__u64)(x) & (__u64)0x00ff000000000000ULL) >> 40) |   \
+        (((__u64)(x) & (__u64)0xff00000000000000ULL) >> 56)))
+
+#define __const_swahw32(x) ((__u32)(                            \
+        (((__u32)(x) & (__u32)0x0000ffffUL) << 16) |            \
+        (((__u32)(x) & (__u32)0xffff0000UL) >> 16)))
+
+#define __const_swahb32(x) ((__u32)(                            \
+        (((__u32)(x) & (__u32)0x00ff00ffUL) << 8) |             \
+        (((__u32)(x) & (__u32)0xff00ff00UL) >> 8)))
+
+/*
+ * Implement the following as inlines, but define the interface using
+ * macros to allow constant folding when possible:
+ * ___swab16, ___swab32, ___swab64, ___swahw32, ___swahb32
+ */
+
+static inline __attribute_const__ __u16 ___swab16(__u16 val)
+{
+#ifdef __arch_swab16
+        return __arch_swab16(val);
+#elif defined(__arch_swab16p)
+        return __arch_swab16p(&val);
+#else
+        return __const_swab16(val);
+#endif
+}
+
+static inline __attribute_const__ __u32 ___swab32(__u32 val)
+{
+#ifdef __arch_swab32
+        return __arch_swab32(val);
+#elif defined(__arch_swab32p)
+        return __arch_swab32p(&val);
+#else
+        return __const_swab32(val);
+#endif
+}
+
+static inline __attribute_const__ __u64 ___swab64(__u64 val)
+{
+#ifdef __arch_swab64
+        return __arch_swab64(val);
+#elif defined(__arch_swab64p)
+        return __arch_swab64p(&val);
+#elif defined(__SWAB_64_THRU_32__)
+        __u32 h = val >> 32;
+        __u32 l = val & ((1ULL << 32) - 1);
+        return (((__u64)___swab32(l)) << 32) | ((__u64)(___swab32(h)));
+#else
+        return __const_swab64(val);
+#endif
+}
+
+static inline __attribute_const__ __u32 ___swahw32(__u32 val)
+{
+#ifdef __arch_swahw32
+        return __arch_swahw32(val);
+#elif defined(__arch_swahw32p)
+        return __arch_swahw32p(&val);
+#else
+        return __const_swahw32(val);
+#endif
+}
+
+static inline __attribute_const__ __u32 ___swahb32(__u32 val)
+{
+#ifdef __arch_swahb32
+        return __arch_swahb32(val);
+#elif defined(__arch_swahb32p)
+        return __arch_swahb32p(&val);
+#else
+        return __const_swahb32(val);
+#endif
+}
+
+/**
+ * __swab16 - return a byteswapped 16-bit value
+ * @x: value to byteswap
+ */
+#define __swab16(x)                             \
+        (__builtin_constant_p((__u16)(x)) ?     \
+        __const_swab16((x)) :                   \
+        ___swab16((x)))
+
+/**
+ * __swab32 - return a byteswapped 32-bit value
+ * @x: value to byteswap
+ */
+#define __swab32(x)                             \
+        (__builtin_constant_p((__u32)(x)) ?     \
+        __const_swab32((x)) :                   \
+        ___swab32((x)))
+
+/**
+ * __swab64 - return a byteswapped 64-bit value
+ * @x: value to byteswap
+ */
+#define __swab64(x)                             \
+        (__builtin_constant_p((__u64)(x)) ?     \
+        __const_swab64((x)) :                   \
+        ___swab64((x)))
+
+/**
+ * __swahw32 - return a word-swapped 32-bit value
+ * @x: value to wordswap
+ *
+ * __swahw32(0x12340000) is 0x00001234
+ */
+#define __swahw32(x)                            \
+        (__builtin_constant_p((__u32)(x)) ?     \
+        __const_swahw32((x)) :                  \
+        ___swahw32((x)))
+
+/**
+ * __swahb32 - return a high and low byte-swapped 32-bit value
+ * @x: value to byteswap
+ *
+ * __swahb32(0x12345678) is 0x34127856
+ */
+#define __swahb32(x)                            \
+        (__builtin_constant_p((__u32)(x)) ?     \
+        __const_swahb32((x)) :                  \
+        ___swahb32((x)))
+
+/**
+ * __swab16p - return a byteswapped 16-bit value from a pointer
+ * @p: pointer to a naturally-aligned 16-bit value
+ */
+static inline __u16 __swab16p(const __u16 *p)
+{
+#ifdef __arch_swab16p
+        return __arch_swab16p(p);
+#else
+        return __swab16(*p);
+#endif
+}
+
+/**
+ * __swab32p - return a byteswapped 32-bit value from a pointer
+ * @p: pointer to a naturally-aligned 32-bit value
+ */
+static inline __u32 __swab32p(const __u32 *p)
+{
+#ifdef __arch_swab32p
+        return __arch_swab32p(p);
+#else
+        return __swab32(*p);
+#endif
+}
+
+/**
+ * __swab64p - return a byteswapped 64-bit value from a pointer
+ * @p: pointer to a naturally-aligned 64-bit value
+ */
+static inline __u64 __swab64p(const __u64 *p)
+{
+#ifdef __arch_swab64p
+        return __arch_swab64p(p);
+#else
+        return __swab64(*p);
+#endif
+}
+
+/**
+ * __swahw32p - return a wordswapped 32-bit value from a pointer
+ * @p: pointer to a naturally-aligned 32-bit value
+ *
+ * See __swahw32() for details of wordswapping.
+ */
+static inline __u32 __swahw32p(const __u32 *p)
+{
+#ifdef __arch_swahw32p
+        return __arch_swahw32p(p);
+#else
+        return __swahw32(*p);
+#endif
+}
+
+/**
+ * __swahb32p - return a high and low byteswapped 32-bit value from a pointer
+ * @p: pointer to a naturally-aligned 32-bit value
+ *
+ * See __swahb32() for details of high/low byteswapping.
+ */
+static inline __u32 __swahb32p(const __u32 *p)
+{
+#ifdef __arch_swahb32p
+        return __arch_swahb32p(p);
+#else
+        return __swahb32(*p);
+#endif
+}
+
+/**
+ * __swab16s - byteswap a 16-bit value in-place
+ * @p: pointer to a naturally-aligned 16-bit value
+ */
+static inline void __swab16s(__u16 *p)
+{
+#ifdef __arch_swab16s
+        __arch_swab16s(p);
+#else
+        *p = __swab16p(p);
+#endif
+}
+/**
+ * __swab32s - byteswap a 32-bit value in-place
+ * @p: pointer to a naturally-aligned 32-bit value
+ */
+static inline void __swab32s(__u32 *p)
+{
+#ifdef __arch_swab32s
+        __arch_swab32s(p);
+#else
+        *p = __swab32p(p);
+#endif
+}
+
+/**
+ * __swab64s - byteswap a 64-bit value in-place
+ * @p: pointer to a naturally-aligned 64-bit value
+ */
+static inline void __swab64s(__u64 *p)
+{
+#ifdef __arch_swab64s
+        __arch_swab64s(p);
+#else
+        *p = __swab64p(p);
+#endif
+}
+
+/**
+ * __swahw32s - wordswap a 32-bit value in-place
+ * @p: pointer to a naturally-aligned 32-bit value
+ *
+ * See __swahw32() for details of wordswapping
+ */
+static inline void __swahw32s(__u32 *p)
+{
+#ifdef __arch_swahw32s
+        __arch_swahw32s(p);
+#else
+        *p = __swahw32p(p);
+#endif
+}
+
+/**
+ * __swahb32s - high and low byteswap a 32-bit value in-place
+ * @p: pointer to a naturally-aligned 32-bit value
+ *
+ * See __swahb32() for details of high and low byte swapping
+ */
+static inline void __swahb32s(__u32 *p)
+{
+#ifdef __arch_swahb32s
+        __arch_swahb32s(p);
+#else
+        *p = __swahb32p(p);
+#endif
+}
+
+#ifdef __KERNEL__
+# define swab16 __swab16
+# define swab32 __swab32
+# define swab64 __swab64
+# define swahw32 __swahw32
+# define swahb32 __swahb32
+# define swab16p __swab16p
+# define swab32p __swab32p
+# define swab64p __swab64p
+# define swahw32p __swahw32p
+# define swahb32p __swahb32p
+# define swab16s __swab16s
+# define swab32s __swab32s
+# define swab64s __swab64s
+# define swahw32s __swahw32s
+# define swahb32s __swahb32s
+#endif /* __KERNEL__ */
+
+#endif /* _LINUX_SWAB_H */
diff --git a/include/linux/swap.h b/include/linux/swap.h
index 0b3377650c85..de40f169a4e4 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -237,7 +237,6 @@ extern struct page *swapin_readahead(swp_entry_t, gfp_t,
 
 /* linux/mm/swapfile.c */
 extern long total_swap_pages;
-extern unsigned int nr_swapfiles;
 extern void si_swapinfo(struct sysinfo *);
 extern swp_entry_t get_swap_page(void);
 extern swp_entry_t get_swap_page_of_type(int);
@@ -254,8 +253,6 @@ extern int can_share_swap_page(struct page *);
 extern int remove_exclusive_swap_page(struct page *);
 struct backing_dev_info;
 
-extern spinlock_t swap_lock;
-
 /* linux/mm/thrash.c */
 extern struct mm_struct * swap_token_mm;
 extern void grab_swap_token(void);
diff --git a/include/linux/sysctl.h b/include/linux/sysctl.h
index 24141b4d1a11..d0437f36921f 100644
--- a/include/linux/sysctl.h
+++ b/include/linux/sysctl.h
@@ -947,6 +947,22 @@ struct ctl_table;
 struct nsproxy;
 struct ctl_table_root;
 
+struct ctl_table_set {
+        struct list_head list;
+        struct ctl_table_set *parent;
+        int (*is_seen)(struct ctl_table_set *);
+};
+
+extern void setup_sysctl_set(struct ctl_table_set *p,
+        struct ctl_table_set *parent,
+        int (*is_seen)(struct ctl_table_set *));
+
+struct ctl_table_header;
+
+extern void sysctl_head_get(struct ctl_table_header *);
+extern void sysctl_head_put(struct ctl_table_header *);
+extern int sysctl_is_seen(struct ctl_table_header *);
+extern struct ctl_table_header *sysctl_head_grab(struct ctl_table_header *);
 extern struct ctl_table_header *sysctl_head_next(struct ctl_table_header *prev);
 extern struct ctl_table_header *__sysctl_head_next(struct nsproxy *namespaces,
                                                 struct ctl_table_header *prev);
@@ -1049,8 +1065,8 @@ struct ctl_table
 
 struct ctl_table_root {
         struct list_head root_list;
-        struct list_head header_list;
-        struct list_head *(*lookup)(struct ctl_table_root *root,
+        struct ctl_table_set default_set;
+        struct ctl_table_set *(*lookup)(struct ctl_table_root *root,
                                            struct nsproxy *namespaces);
         int (*permissions)(struct ctl_table_root *root,
                         struct nsproxy *namespaces, struct ctl_table *table);
@@ -1063,9 +1079,14 @@ struct ctl_table_header
         struct ctl_table *ctl_table;
         struct list_head ctl_entry;
         int used;
+        int count;
         struct completion *unregistering;
         struct ctl_table *ctl_table_arg;
         struct ctl_table_root *root;
+        struct ctl_table_set *set;
+        struct ctl_table *attached_by;
+        struct ctl_table *attached_to;
+        struct ctl_table_header *parent;
 };
 
 /* struct ctl_path describes where in the hierarchy a table is added */
diff --git a/include/linux/task_io_accounting.h b/include/linux/task_io_accounting.h
index 44d00e9cceea..5e88afc9a2fb 100644
--- a/include/linux/task_io_accounting.h
+++ b/include/linux/task_io_accounting.h
@@ -8,8 +8,19 @@
  * Blame akpm@osdl.org for all this.
  */
 
-#ifdef CONFIG_TASK_IO_ACCOUNTING
 struct task_io_accounting {
+#ifdef CONFIG_TASK_XACCT
+        /* bytes read */
+        u64 rchar;
+        /*  bytes written */
+        u64 wchar;
+        /* # of read syscalls */
+        u64 syscr;
+        /* # of write syscalls */
+        u64 syscw;
+#endif /* CONFIG_TASK_XACCT */
+
+#ifdef CONFIG_TASK_IO_ACCOUNTING
         /*
          * The number of bytes which this task has caused to be read from
          * storage.
@@ -30,8 +41,5 @@ struct task_io_accounting {
          * information loss in doing that.
          */
         u64 cancelled_write_bytes;
+#endif /* CONFIG_TASK_IO_ACCOUNTING */
 };
-#else
-struct task_io_accounting {
-};
-#endif
diff --git a/include/linux/task_io_accounting_ops.h b/include/linux/task_io_accounting_ops.h
index ff46c6fad79d..4d090f9ee608 100644
--- a/include/linux/task_io_accounting_ops.h
+++ b/include/linux/task_io_accounting_ops.h
@@ -40,9 +40,17 @@ static inline void task_io_account_cancelled_write(size_t bytes)
         current->ioac.cancelled_write_bytes += bytes;
 }
 
-static inline void task_io_accounting_init(struct task_struct *tsk)
+static inline void task_io_accounting_init(struct task_io_accounting *ioac)
 {
-        memset(&tsk->ioac, 0, sizeof(tsk->ioac));
+        memset(ioac, 0, sizeof(*ioac));
+}
+
+static inline void task_blk_io_accounting_add(struct task_io_accounting *dst,
+                                                struct task_io_accounting *src)
+{
+        dst->read_bytes += src->read_bytes;
+        dst->write_bytes += src->write_bytes;
+        dst->cancelled_write_bytes += src->cancelled_write_bytes;
 }
 
 #else
@@ -69,9 +77,37 @@ static inline void task_io_account_cancelled_write(size_t bytes)
 {
 }
 
-static inline void task_io_accounting_init(struct task_struct *tsk)
+static inline void task_io_accounting_init(struct task_io_accounting *ioac)
+{
+}
+
+static inline void task_blk_io_accounting_add(struct task_io_accounting *dst,
+                                                struct task_io_accounting *src)
 {
 }
 
-#endif          /* CONFIG_TASK_IO_ACCOUNTING */
-#endif          /* __TASK_IO_ACCOUNTING_OPS_INCLUDED */
+#endif /* CONFIG_TASK_IO_ACCOUNTING */
+
+#ifdef CONFIG_TASK_XACCT
+static inline void task_chr_io_accounting_add(struct task_io_accounting *dst,
+                                                struct task_io_accounting *src)
+{
+        dst->rchar += src->rchar;
+        dst->wchar += src->wchar;
+        dst->syscr += src->syscr;
+        dst->syscw += src->syscw;
+}
+#else
+static inline void task_chr_io_accounting_add(struct task_io_accounting *dst,
+                                                struct task_io_accounting *src)
+{
+}
+#endif /* CONFIG_TASK_XACCT */
+
+static inline void task_io_accounting_add(struct task_io_accounting *dst,
+                                                struct task_io_accounting *src)
+{
+        task_chr_io_accounting_add(dst, src);
+        task_blk_io_accounting_add(dst, src);
+}
+#endif /* __TASK_IO_ACCOUNTING_OPS_INCLUDED */
diff --git a/include/linux/tracehook.h b/include/linux/tracehook.h
new file mode 100644
index 000000000000..b48d81969574
--- /dev/null
+++ b/include/linux/tracehook.h
@@ -0,0 +1,582 @@
+/*
+ * Tracing hooks
+ *
+ * Copyright (C) 2008 Red Hat, Inc.  All rights reserved.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ *
+ * This file defines hook entry points called by core code where
+ * user tracing/debugging support might need to do something.  These
+ * entry points are called tracehook_*().  Each hook declared below
+ * has a detailed kerneldoc comment giving the context (locking et
+ * al) from which it is called, and the meaning of its return value.
+ *
+ * Each function here typically has only one call site, so it is ok
+ * to have some nontrivial tracehook_*() inlines.  In all cases, the
+ * fast path when no tracing is enabled should be very short.
+ *
+ * The purpose of this file and the tracehook_* layer is to consolidate
+ * the interface that the kernel core and arch code uses to enable any
+ * user debugging or tracing facility (such as ptrace).  The interfaces
+ * here are carefully documented so that maintainers of core and arch
+ * code do not need to think about the implementation details of the
+ * tracing facilities.  Likewise, maintainers of the tracing code do not
+ * need to understand all the calling core or arch code in detail, just
+ * documented circumstances of each call, such as locking conditions.
+ *
+ * If the calling core code changes so that locking is different, then
+ * it is ok to change the interface documented here.  The maintainer of
+ * core code changing should notify the maintainers of the tracing code
+ * that they need to work out the change.
+ *
+ * Some tracehook_*() inlines take arguments that the current tracing
+ * implementations might not necessarily use.  These function signatures
+ * are chosen to pass in all the information that is on hand in the
+ * caller and might conceivably be relevant to a tracer, so that the
+ * core code won't have to be updated when tracing adds more features.
+ * If a call site changes so that some of those parameters are no longer
+ * already on hand without extra work, then the tracehook_* interface
+ * can change so there is no make-work burden on the core code.  The
+ * maintainer of core code changing should notify the maintainers of the
+ * tracing code that they need to work out the change.
+ */
+
+#ifndef _LINUX_TRACEHOOK_H
+#define _LINUX_TRACEHOOK_H      1
+
+#include <linux/sched.h>
+#include <linux/ptrace.h>
+#include <linux/security.h>
+struct linux_binprm;
+
+/**
+ * tracehook_expect_breakpoints - guess if task memory might be touched
+ * @task:               current task, making a new mapping
+ *
+ * Return nonzero if @task is expected to want breakpoint insertion in
+ * its memory at some point.  A zero return is no guarantee it won't
+ * be done, but this is a hint that it's known to be likely.
+ *
+ * May be called with @task->mm->mmap_sem held for writing.
+ */
+static inline int tracehook_expect_breakpoints(struct task_struct *task)
+{
+        return (task_ptrace(task) & PT_PTRACED) != 0;
+}
+
+/*
+ * ptrace report for syscall entry and exit looks identical.
+ */
+static inline void ptrace_report_syscall(struct pt_regs *regs)
+{
+        int ptrace = task_ptrace(current);
+
+        if (!(ptrace & PT_PTRACED))
+                return;
+
+        ptrace_notify(SIGTRAP | ((ptrace & PT_TRACESYSGOOD) ? 0x80 : 0));
+
+        /*
+         * this isn't the same as continuing with a signal, but it will do
+         * for normal use.  strace only continues with a signal if the
+         * stopping signal is not SIGTRAP.  -brl
+         */
+        if (current->exit_code) {
+                send_sig(current->exit_code, current, 1);
+                current->exit_code = 0;
+        }
+}
+
+/**
+ * tracehook_report_syscall_entry - task is about to attempt a system call
+ * @regs:               user register state of current task
+ *
+ * This will be called if %TIF_SYSCALL_TRACE has been set, when the
+ * current task has just entered the kernel for a system call.
+ * Full user register state is available here.  Changing the values
+ * in @regs can affect the system call number and arguments to be tried.
+ * It is safe to block here, preventing the system call from beginning.
+ *
+ * Returns zero normally, or nonzero if the calling arch code should abort
+ * the system call.  That must prevent normal entry so no system call is
+ * made.  If @task ever returns to user mode after this, its register state
+ * is unspecified, but should be something harmless like an %ENOSYS error
+ * return.  It should preserve enough information so that syscall_rollback()
+ * can work (see asm-generic/syscall.h).
+ *
+ * Called without locks, just after entering kernel mode.
+ */
+static inline __must_check int tracehook_report_syscall_entry(
+        struct pt_regs *regs)
+{
+        ptrace_report_syscall(regs);
+        return 0;
+}
+
+/**
+ * tracehook_report_syscall_exit - task has just finished a system call
+ * @regs:               user register state of current task
+ * @step:               nonzero if simulating single-step or block-step
+ *
+ * This will be called if %TIF_SYSCALL_TRACE has been set, when the
+ * current task has just finished an attempted system call.  Full
+ * user register state is available here.  It is safe to block here,
+ * preventing signals from being processed.
+ *
+ * If @step is nonzero, this report is also in lieu of the normal
+ * trap that would follow the system call instruction because
+ * user_enable_block_step() or user_enable_single_step() was used.
+ * In this case, %TIF_SYSCALL_TRACE might not be set.
+ *
+ * Called without locks, just before checking for pending signals.
+ */
+static inline void tracehook_report_syscall_exit(struct pt_regs *regs, int step)
+{
+        ptrace_report_syscall(regs);
+}
+
+/**
+ * tracehook_unsafe_exec - check for exec declared unsafe due to tracing
+ * @task:               current task doing exec
+ *
+ * Return %LSM_UNSAFE_* bits applied to an exec because of tracing.
+ *
+ * Called with task_lock() held on @task.
+ */
+static inline int tracehook_unsafe_exec(struct task_struct *task)
+{
+        int unsafe = 0;
+        int ptrace = task_ptrace(task);
+        if (ptrace & PT_PTRACED) {
+                if (ptrace & PT_PTRACE_CAP)
+                        unsafe |= LSM_UNSAFE_PTRACE_CAP;
+                else
+                        unsafe |= LSM_UNSAFE_PTRACE;
+        }
+        return unsafe;
+}
+
+/**
+ * tracehook_tracer_task - return the task that is tracing the given task
+ * @tsk:                task to consider
+ *
+ * Returns NULL if noone is tracing @task, or the &struct task_struct
+ * pointer to its tracer.
+ *
+ * Must called under rcu_read_lock().  The pointer returned might be kept
+ * live only by RCU.  During exec, this may be called with task_lock()
+ * held on @task, still held from when tracehook_unsafe_exec() was called.
+ */
+static inline struct task_struct *tracehook_tracer_task(struct task_struct *tsk)
+{
+        if (task_ptrace(tsk) & PT_PTRACED)
+                return rcu_dereference(tsk->parent);
+        return NULL;
+}
+
+/**
+ * tracehook_report_exec - a successful exec was completed
+ * @fmt:                &struct linux_binfmt that performed the exec
+ * @bprm:               &struct linux_binprm containing exec details
+ * @regs:               user-mode register state
+ *
+ * An exec just completed, we are shortly going to return to user mode.
+ * The freshly initialized register state can be seen and changed in @regs.
+ * The name, file and other pointers in @bprm are still on hand to be
+ * inspected, but will be freed as soon as this returns.
+ *
+ * Called with no locks, but with some kernel resources held live
+ * and a reference on @fmt->module.
+ */
+static inline void tracehook_report_exec(struct linux_binfmt *fmt,
+                                         struct linux_binprm *bprm,
+                                         struct pt_regs *regs)
+{
+        if (!ptrace_event(PT_TRACE_EXEC, PTRACE_EVENT_EXEC, 0) &&
+            unlikely(task_ptrace(current) & PT_PTRACED))
+                send_sig(SIGTRAP, current, 0);
+}
+
+/**
+ * tracehook_report_exit - task has begun to exit
+ * @exit_code:          pointer to value destined for @current->exit_code
+ *
+ * @exit_code points to the value passed to do_exit(), which tracing
+ * might change here.  This is almost the first thing in do_exit(),
+ * before freeing any resources or setting the %PF_EXITING flag.
+ *
+ * Called with no locks held.
+ */
+static inline void tracehook_report_exit(long *exit_code)
+{
+        ptrace_event(PT_TRACE_EXIT, PTRACE_EVENT_EXIT, *exit_code);
+}
+
+/**
+ * tracehook_prepare_clone - prepare for new child to be cloned
+ * @clone_flags:        %CLONE_* flags from clone/fork/vfork system call
+ *
+ * This is called before a new user task is to be cloned.
+ * Its return value will be passed to tracehook_finish_clone().
+ *
+ * Called with no locks held.
+ */
+static inline int tracehook_prepare_clone(unsigned clone_flags)
+{
+        if (clone_flags & CLONE_UNTRACED)
+                return 0;
+
+        if (clone_flags & CLONE_VFORK) {
+                if (current->ptrace & PT_TRACE_VFORK)
+                        return PTRACE_EVENT_VFORK;
+        } else if ((clone_flags & CSIGNAL) != SIGCHLD) {
+                if (current->ptrace & PT_TRACE_CLONE)
+                        return PTRACE_EVENT_CLONE;
+        } else if (current->ptrace & PT_TRACE_FORK)
+                return PTRACE_EVENT_FORK;
+
+        return 0;
+}
+
+/**
+ * tracehook_finish_clone - new child created and being attached
+ * @child:              new child task
+ * @clone_flags:        %CLONE_* flags from clone/fork/vfork system call
+ * @trace:              return value from tracehook_prepare_clone()
+ *
+ * This is called immediately after adding @child to its parent's children list.
+ * The @trace value is that returned by tracehook_prepare_clone().
+ *
+ * Called with current's siglock and write_lock_irq(&tasklist_lock) held.
+ */
+static inline void tracehook_finish_clone(struct task_struct *child,
+                                          unsigned long clone_flags, int trace)
+{
+        ptrace_init_task(child, (clone_flags & CLONE_PTRACE) || trace);
+}
+
+/**
+ * tracehook_report_clone - in parent, new child is about to start running
+ * @trace:              return value from tracehook_prepare_clone()
+ * @regs:               parent's user register state
+ * @clone_flags:        flags from parent's system call
+ * @pid:                new child's PID in the parent's namespace
+ * @child:              new child task
+ *
+ * Called after a child is set up, but before it has been started
+ * running.  @trace is the value returned by tracehook_prepare_clone().
+ * This is not a good place to block, because the child has not started
+ * yet.  Suspend the child here if desired, and then block in
+ * tracehook_report_clone_complete().  This must prevent the child from
+ * self-reaping if tracehook_report_clone_complete() uses the @child
+ * pointer; otherwise it might have died and been released by the time
+ * tracehook_report_report_clone_complete() is called.
+ *
+ * Called with no locks held, but the child cannot run until this returns.
+ */
+static inline void tracehook_report_clone(int trace, struct pt_regs *regs,
+                                          unsigned long clone_flags,
+                                          pid_t pid, struct task_struct *child)
+{
+        if (unlikely(trace) || unlikely(clone_flags & CLONE_PTRACE)) {
+                /*
+                 * The child starts up with an immediate SIGSTOP.
+                 */
+                sigaddset(&child->pending.signal, SIGSTOP);
+                set_tsk_thread_flag(child, TIF_SIGPENDING);
+        }
+}
+
+/**
+ * tracehook_report_clone_complete - new child is running
+ * @trace:              return value from tracehook_prepare_clone()
+ * @regs:               parent's user register state
+ * @clone_flags:        flags from parent's system call
+ * @pid:                new child's PID in the parent's namespace
+ * @child:              child task, already running
+ *
+ * This is called just after the child has started running.  This is
+ * just before the clone/fork syscall returns, or blocks for vfork
+ * child completion if @clone_flags has the %CLONE_VFORK bit set.
+ * The @child pointer may be invalid if a self-reaping child died and
+ * tracehook_report_clone() took no action to prevent it from self-reaping.
+ *
+ * Called with no locks held.
+ */
+static inline void tracehook_report_clone_complete(int trace,
+                                                   struct pt_regs *regs,
+                                                   unsigned long clone_flags,
+                                                   pid_t pid,
+                                                   struct task_struct *child)
+{
+        if (unlikely(trace))
+                ptrace_event(0, trace, pid);
+}
+
+/**
+ * tracehook_report_vfork_done - vfork parent's child has exited or exec'd
+ * @child:              child task, already running
+ * @pid:                new child's PID in the parent's namespace
+ *
+ * Called after a %CLONE_VFORK parent has waited for the child to complete.
+ * The clone/vfork system call will return immediately after this.
+ * The @child pointer may be invalid if a self-reaping child died and
+ * tracehook_report_clone() took no action to prevent it from self-reaping.
+ *
+ * Called with no locks held.
+ */
+static inline void tracehook_report_vfork_done(struct task_struct *child,
+                                               pid_t pid)
+{
+        ptrace_event(PT_TRACE_VFORK_DONE, PTRACE_EVENT_VFORK_DONE, pid);
+}
+
+/**
+ * tracehook_prepare_release_task - task is being reaped, clean up tracing
+ * @task:               task in %EXIT_DEAD state
+ *
+ * This is called in release_task() just before @task gets finally reaped
+ * and freed.  This would be the ideal place to remove and clean up any
+ * tracing-related state for @task.
+ *
+ * Called with no locks held.
+ */
+static inline void tracehook_prepare_release_task(struct task_struct *task)
+{
+}
+
+/**
+ * tracehook_finish_release_task - final tracing clean-up
+ * @task:               task in %EXIT_DEAD state
+ *
+ * This is called in release_task() when @task is being in the middle of
+ * being reaped.  After this, there must be no tracing entanglements.
+ *
+ * Called with write_lock_irq(&tasklist_lock) held.
+ */
+static inline void tracehook_finish_release_task(struct task_struct *task)
+{
+        ptrace_release_task(task);
+}
+
+/**
+ * tracehook_signal_handler - signal handler setup is complete
+ * @sig:                number of signal being delivered
+ * @info:               siginfo_t of signal being delivered
+ * @ka:                 sigaction setting that chose the handler
+ * @regs:               user register state
+ * @stepping:           nonzero if debugger single-step or block-step in use
+ *
+ * Called by the arch code after a signal handler has been set up.
+ * Register and stack state reflects the user handler about to run.
+ * Signal mask changes have already been made.
+ *
+ * Called without locks, shortly before returning to user mode
+ * (or handling more signals).
+ */
+static inline void tracehook_signal_handler(int sig, siginfo_t *info,
+                                            const struct k_sigaction *ka,
+                                            struct pt_regs *regs, int stepping)
+{
+        if (stepping)
+                ptrace_notify(SIGTRAP);
+}
+
+/**
+ * tracehook_consider_ignored_signal - suppress short-circuit of ignored signal
+ * @task:               task receiving the signal
+ * @sig:                signal number being sent
+ * @handler:            %SIG_IGN or %SIG_DFL
+ *
+ * Return zero iff tracing doesn't care to examine this ignored signal,
+ * so it can short-circuit normal delivery and never even get queued.
+ * Either @handler is %SIG_DFL and @sig's default is ignore, or it's %SIG_IGN.
+ *
+ * Called with @task->sighand->siglock held.
+ */
+static inline int tracehook_consider_ignored_signal(struct task_struct *task,
+                                                    int sig,
+                                                    void __user *handler)
+{
+        return (task_ptrace(task) & PT_PTRACED) != 0;
+}
+
+/**
+ * tracehook_consider_fatal_signal - suppress special handling of fatal signal
+ * @task:               task receiving the signal
+ * @sig:                signal number being sent
+ * @handler:            %SIG_DFL or %SIG_IGN
+ *
+ * Return nonzero to prevent special handling of this termination signal.
+ * Normally @handler is %SIG_DFL.  It can be %SIG_IGN if @sig is ignored,
+ * in which case force_sig() is about to reset it to %SIG_DFL.
+ * When this returns zero, this signal might cause a quick termination
+ * that does not give the debugger a chance to intercept the signal.
+ *
+ * Called with or without @task->sighand->siglock held.
+ */
+static inline int tracehook_consider_fatal_signal(struct task_struct *task,
+                                                  int sig,
+                                                  void __user *handler)
+{
+        return (task_ptrace(task) & PT_PTRACED) != 0;
+}
+
+/**
+ * tracehook_force_sigpending - let tracing force signal_pending(current) on
+ *
+ * Called when recomputing our signal_pending() flag.  Return nonzero
+ * to force the signal_pending() flag on, so that tracehook_get_signal()
+ * will be called before the next return to user mode.
+ *
+ * Called with @current->sighand->siglock held.
+ */
+static inline int tracehook_force_sigpending(void)
+{
+        return 0;
+}
+
+/**
+ * tracehook_get_signal - deliver synthetic signal to traced task
+ * @task:               @current
+ * @regs:               task_pt_regs(@current)
+ * @info:               details of synthetic signal
+ * @return_ka:          sigaction for synthetic signal
+ *
+ * Return zero to check for a real pending signal normally.
+ * Return -1 after releasing the siglock to repeat the check.
+ * Return a signal number to induce an artifical signal delivery,
+ * setting *@info and *@return_ka to specify its details and behavior.
+ *
+ * The @return_ka->sa_handler value controls the disposition of the
+ * signal, no matter the signal number.  For %SIG_DFL, the return value
+ * is a representative signal to indicate the behavior (e.g. %SIGTERM
+ * for death, %SIGQUIT for core dump, %SIGSTOP for job control stop,
+ * %SIGTSTP for stop unless in an orphaned pgrp), but the signal number
+ * reported will be @info->si_signo instead.
+ *
+ * Called with @task->sighand->siglock held, before dequeuing pending signals.
+ */
+static inline int tracehook_get_signal(struct task_struct *task,
+                                       struct pt_regs *regs,
+                                       siginfo_t *info,
+                                       struct k_sigaction *return_ka)
+{
+        return 0;
+}
+
+/**
+ * tracehook_notify_jctl - report about job control stop/continue
+ * @notify:             nonzero if this is the last thread in the group to stop
+ * @why:                %CLD_STOPPED or %CLD_CONTINUED
+ *
+ * This is called when we might call do_notify_parent_cldstop().
+ * It's called when about to stop for job control; we are already in
+ * %TASK_STOPPED state, about to call schedule().  It's also called when
+ * a delayed %CLD_STOPPED or %CLD_CONTINUED report is ready to be made.
+ *
+ * Return nonzero to generate a %SIGCHLD with @why, which is
+ * normal if @notify is nonzero.
+ *
+ * Called with no locks held.
+ */
+static inline int tracehook_notify_jctl(int notify, int why)
+{
+        return notify || (current->ptrace & PT_PTRACED);
+}
+
+#define DEATH_REAP                      -1
+#define DEATH_DELAYED_GROUP_LEADER      -2
+
+/**
+ * tracehook_notify_death - task is dead, ready to notify parent
+ * @task:               @current task now exiting
+ * @death_cookie:       value to pass to tracehook_report_death()
+ * @group_dead:         nonzero if this was the last thread in the group to die
+ *
+ * A return value >= 0 means call do_notify_parent() with that signal
+ * number.  Negative return value can be %DEATH_REAP to self-reap right
+ * now, or %DEATH_DELAYED_GROUP_LEADER to a zombie without notifying our
+ * parent.  Note that a return value of 0 means a do_notify_parent() call
+ * that sends no signal, but still wakes up a parent blocked in wait*().
+ *
+ * Called with write_lock_irq(&tasklist_lock) held.
+ */
+static inline int tracehook_notify_death(struct task_struct *task,
+                                         void **death_cookie, int group_dead)
+{
+        if (task->exit_signal == -1)
+                return task->ptrace ? SIGCHLD : DEATH_REAP;
+
+        /*
+         * If something other than our normal parent is ptracing us, then
+         * send it a SIGCHLD instead of honoring exit_signal.  exit_signal
+         * only has special meaning to our real parent.
+         */
+        if (thread_group_empty(task) && !ptrace_reparented(task))
+                return task->exit_signal;
+
+        return task->ptrace ? SIGCHLD : DEATH_DELAYED_GROUP_LEADER;
+}
+
+/**
+ * tracehook_report_death - task is dead and ready to be reaped
+ * @task:               @current task now exiting
+ * @signal:             return value from tracheook_notify_death()
+ * @death_cookie:       value passed back from tracehook_notify_death()
+ * @group_dead:         nonzero if this was the last thread in the group to die
+ *
+ * Thread has just become a zombie or is about to self-reap.  If positive,
+ * @signal is the signal number just sent to the parent (usually %SIGCHLD).
+ * If @signal is %DEATH_REAP, this thread will self-reap.  If @signal is
+ * %DEATH_DELAYED_GROUP_LEADER, this is a delayed_group_leader() zombie.
+ * The @death_cookie was passed back by tracehook_notify_death().
+ *
+ * If normal reaping is not inhibited, @task->exit_state might be changing
+ * in parallel.
+ *
+ * Called without locks.
+ */
+static inline void tracehook_report_death(struct task_struct *task,
+                                          int signal, void *death_cookie,
+                                          int group_dead)
+{
+}
+
+#ifdef TIF_NOTIFY_RESUME
+/**
+ * set_notify_resume - cause tracehook_notify_resume() to be called
+ * @task:               task that will call tracehook_notify_resume()
+ *
+ * Calling this arranges that @task will call tracehook_notify_resume()
+ * before returning to user mode.  If it's already running in user mode,
+ * it will enter the kernel and call tracehook_notify_resume() soon.
+ * If it's blocked, it will not be woken.
+ */
+static inline void set_notify_resume(struct task_struct *task)
+{
+        if (!test_and_set_tsk_thread_flag(task, TIF_NOTIFY_RESUME))
+                kick_process(task);
+}
+
+/**
+ * tracehook_notify_resume - report when about to return to user mode
+ * @regs:               user-mode registers of @current task
+ *
+ * This is called when %TIF_NOTIFY_RESUME has been set.  Now we are
+ * about to return to user mode, and the user state in @regs can be
+ * inspected or adjusted.  The caller in arch code has cleared
+ * %TIF_NOTIFY_RESUME before the call.  If the flag gets set again
+ * asynchronously, this will be called again before we return to
+ * user mode.
+ *
+ * Called without locks.
+ */
+static inline void tracehook_notify_resume(struct pt_regs *regs)
+{
+}
+#endif  /* TIF_NOTIFY_RESUME */
+
+#endif  /* <linux/tracehook.h> */
diff --git a/include/linux/tty.h b/include/linux/tty.h
index e3579cb086e0..0cbec74ec086 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -331,6 +331,8 @@ extern int tty_write_room(struct tty_struct *tty);
 extern void tty_driver_flush_buffer(struct tty_struct *tty);
 extern void tty_throttle(struct tty_struct *tty);
 extern void tty_unthrottle(struct tty_struct *tty);
+extern int tty_do_resize(struct tty_struct *tty, struct tty_struct *real_tty,
+                                                struct winsize *ws);
 
 extern int is_current_pgrp_orphaned(void);
 extern struct pid *tty_get_pgrp(struct tty_struct *tty);
diff --git a/include/linux/tty_driver.h b/include/linux/tty_driver.h
index e1065ac0d922..16d27944c321 100644
--- a/include/linux/tty_driver.h
+++ b/include/linux/tty_driver.h
@@ -168,6 +168,18 @@
  *
  *      Optional: If not provided then the write method is called under
  *      the atomic write lock to keep it serialized with the ldisc.
+ *
+ * int (*resize)(struct tty_struct *tty, struct tty_struct *real_tty,
+ *                              unsigned int rows, unsigned int cols);
+ *
+ *      Called when a termios request is issued which changes the
+ *      requested terminal geometry.
+ *
+ *      Optional: the default action is to update the termios structure
+ *      without error. This is usually the correct behaviour. Drivers should
+ *      not force errors here if they are not resizable objects (eg a serial
+ *      line). See tty_do_resize() if you need to wrap the standard method
+ *      in your own logic - the usual case.
  */
 
 #include <linux/fs.h>
@@ -206,6 +218,8 @@ struct tty_operations {
         int (*tiocmget)(struct tty_struct *tty, struct file *file);
         int (*tiocmset)(struct tty_struct *tty, struct file *file,
                         unsigned int set, unsigned int clear);
+        int (*resize)(struct tty_struct *tty, struct tty_struct *real_tty,
+                                struct winsize *ws);
 #ifdef CONFIG_CONSOLE_POLL
         int (*poll_init)(struct tty_driver *driver, int line, char *options);
         int (*poll_get_char)(struct tty_driver *driver, int line);
diff --git a/include/linux/usb.h b/include/linux/usb.h
index 5811c5da69f9..0924cd9c30f6 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -110,6 +110,8 @@ enum usb_interface_condition {
  * @sysfs_files_created: sysfs attributes exist
  * @needs_remote_wakeup: flag set when the driver requires remote-wakeup
  *      capability during autosuspend.
+ * @needs_binding: flag set when the driver should be re-probed or unbound
+ *      following a reset or suspend operation it doesn't support.
  * @dev: driver model's view of this device
  * @usb_dev: if an interface is bound to the USB major, this will point
  *      to the sysfs representation for that device.
diff --git a/include/linux/usb/musb.h b/include/linux/usb/musb.h
new file mode 100644
index 000000000000..630962c04ca4
--- /dev/null
+++ b/include/linux/usb/musb.h
@@ -0,0 +1,98 @@
+/*
+ * This is used to for host and peripheral modes of the driver for
+ * Inventra (Multidrop) Highspeed Dual-Role Controllers:  (M)HDRC.
+ *
+ * Board initialization should put one of these into dev->platform_data,
+ * probably on some platform_device named "musb_hdrc".  It encapsulates
+ * key configuration differences between boards.
+ */
+
+/* The USB role is defined by the connector used on the board, so long as
+ * standards are being followed.  (Developer boards sometimes won't.)
+ */
+enum musb_mode {
+        MUSB_UNDEFINED = 0,
+        MUSB_HOST,              /* A or Mini-A connector */
+        MUSB_PERIPHERAL,        /* B or Mini-B connector */
+        MUSB_OTG                /* Mini-AB connector */
+};
+
+struct clk;
+
+struct musb_hdrc_eps_bits {
+        const char      name[16];
+        u8              bits;
+};
+
+struct musb_hdrc_config {
+        /* MUSB configuration-specific details */
+        unsigned        multipoint:1;   /* multipoint device */
+        unsigned        dyn_fifo:1;     /* supports dynamic fifo sizing */
+        unsigned        soft_con:1;     /* soft connect required */
+        unsigned        utm_16:1;       /* utm data witdh is 16 bits */
+        unsigned        big_endian:1;   /* true if CPU uses big-endian */
+        unsigned        mult_bulk_tx:1; /* Tx ep required for multbulk pkts */
+        unsigned        mult_bulk_rx:1; /* Rx ep required for multbulk pkts */
+        unsigned        high_iso_tx:1;  /* Tx ep required for HB iso */
+        unsigned        high_iso_rx:1;  /* Rx ep required for HD iso */
+        unsigned        dma:1;          /* supports DMA */
+        unsigned        vendor_req:1;   /* vendor registers required */
+
+        u8              num_eps;        /* number of endpoints _with_ ep0 */
+        u8              dma_channels;   /* number of dma channels */
+        u8              dyn_fifo_size;  /* dynamic size in bytes */
+        u8              vendor_ctrl;    /* vendor control reg width */
+        u8              vendor_stat;    /* vendor status reg witdh */
+        u8              dma_req_chan;   /* bitmask for required dma channels */
+        u8              ram_bits;       /* ram address size */
+
+        struct musb_hdrc_eps_bits *eps_bits;
+};
+
+struct musb_hdrc_platform_data {
+        /* MUSB_HOST, MUSB_PERIPHERAL, or MUSB_OTG */
+        u8              mode;
+
+        /* for clk_get() */
+        const char      *clock;
+
+        /* (HOST or OTG) switch VBUS on/off */
+        int             (*set_vbus)(struct device *dev, int is_on);
+
+        /* (HOST or OTG) mA/2 power supplied on (default = 8mA) */
+        u8              power;
+
+        /* (PERIPHERAL) mA/2 max power consumed (default = 100mA) */
+        u8              min_power;
+
+        /* (HOST or OTG) msec/2 after VBUS on till power good */
+        u8              potpgt;
+
+        /* Power the device on or off */
+        int             (*set_power)(int state);
+
+        /* Turn device clock on or off */
+        int             (*set_clock)(struct clk *clock, int is_on);
+
+        /* MUSB configuration-specific details */
+        struct musb_hdrc_config *config;
+};
+
+
+/* TUSB 6010 support */
+
+#define TUSB6010_OSCCLK_60      16667   /* psec/clk @ 60.0 MHz */
+#define TUSB6010_REFCLK_24      41667   /* psec/clk @ 24.0 MHz XI */
+#define TUSB6010_REFCLK_19      52083   /* psec/clk @ 19.2 MHz CLKIN */
+
+#ifdef  CONFIG_ARCH_OMAP2
+
+extern int __init tusb6010_setup_interface(
+                struct musb_hdrc_platform_data *data,
+                unsigned ps_refclk, unsigned waitpin,
+                unsigned async_cs, unsigned sync_cs,
+                unsigned irq, unsigned dmachan);
+
+extern int tusb6010_platform_retime(unsigned is_refclk);
+
+#endif  /* OMAP2 */
diff --git a/include/linux/usb/serial.h b/include/linux/usb/serial.h
index 09a3e6a7518f..655341d0f534 100644
--- a/include/linux/usb/serial.h
+++ b/include/linux/usb/serial.h
@@ -17,7 +17,8 @@
 #include <linux/mutex.h>
 
 #define SERIAL_TTY_MAJOR        188     /* Nice legal number now */
-#define SERIAL_TTY_MINORS       255     /* loads of devices :) */
+#define SERIAL_TTY_MINORS       254     /* loads of devices :) */
+#define SERIAL_TTY_NO_MINOR     255     /* No minor was assigned */
 
 /* The maximum number of ports one device can grab at once */
 #define MAX_NUM_PORTS           8
diff --git a/include/linux/videodev.h b/include/linux/videodev.h
index 9385a566aed8..15a653d41132 100644
--- a/include/linux/videodev.h
+++ b/include/linux/videodev.h
@@ -17,6 +17,21 @@
 
 #if defined(CONFIG_VIDEO_V4L1_COMPAT) || !defined (__KERNEL__)
 
+#define VID_TYPE_CAPTURE        1       /* Can capture */
+#define VID_TYPE_TUNER          2       /* Can tune */
+#define VID_TYPE_TELETEXT       4       /* Does teletext */
+#define VID_TYPE_OVERLAY        8       /* Overlay onto frame buffer */
+#define VID_TYPE_CHROMAKEY      16      /* Overlay by chromakey */
+#define VID_TYPE_CLIPPING       32      /* Can clip */
+#define VID_TYPE_FRAMERAM       64      /* Uses the frame buffer memory */
+#define VID_TYPE_SCALES         128     /* Scalable */
+#define VID_TYPE_MONOCHROME     256     /* Monochrome only */
+#define VID_TYPE_SUBCAPTURE     512     /* Can capture subareas of the image */
+#define VID_TYPE_MPEG_DECODER   1024    /* Can decode MPEG streams */
+#define VID_TYPE_MPEG_ENCODER   2048    /* Can encode MPEG streams */
+#define VID_TYPE_MJPEG_DECODER  4096    /* Can decode MJPEG streams */
+#define VID_TYPE_MJPEG_ENCODER  8192    /* Can encode MJPEG streams */
+
 struct video_capability
 {
         char name[32];
diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
index 2e66a95e8d32..e65a6bed4e3e 100644
--- a/include/linux/videodev2.h
+++ b/include/linux/videodev2.h
@@ -55,13 +55,13 @@
  */
 #ifndef __LINUX_VIDEODEV2_H
 #define __LINUX_VIDEODEV2_H
+
 #ifdef __KERNEL__
 #include <linux/time.h>     /* need struct timeval */
-#include <linux/compiler.h> /* need __user */
 #else
-#define __user
 #include <sys/time.h>
 #endif
+#include <linux/compiler.h>
 #include <linux/ioctl.h>
 #include <linux/types.h>
 
@@ -71,6 +71,11 @@
  */
 #define VIDEO_MAX_FRAME               32
 
+#ifndef __KERNEL__
+
+/* These defines are V4L1 specific and should not be used with the V4L2 API!
+   They will be removed from this header in the future. */
+
 #define VID_TYPE_CAPTURE        1       /* Can capture */
 #define VID_TYPE_TUNER          2       /* Can tune */
 #define VID_TYPE_TELETEXT       4       /* Does teletext */
@@ -85,14 +90,15 @@
 #define VID_TYPE_MPEG_ENCODER   2048    /* Can encode MPEG streams */
 #define VID_TYPE_MJPEG_DECODER  4096    /* Can decode MJPEG streams */
 #define VID_TYPE_MJPEG_ENCODER  8192    /* Can encode MJPEG streams */
+#endif
 
 /*
  *      M I S C E L L A N E O U S
  */
 
 /*  Four-character-code (FOURCC) */
-#define v4l2_fourcc(a,b,c,d)\
-        (((__u32)(a)<<0)|((__u32)(b)<<8)|((__u32)(c)<<16)|((__u32)(d)<<24))
+#define v4l2_fourcc(a, b, c, d)\
+        ((__u32)(a) | ((__u32)(b) << 8) | ((__u32)(c) << 16) | ((__u32)(d) << 24))
 
 /*
  *      E N U M S
@@ -226,8 +232,7 @@ struct v4l2_fract {
 /*
  *      D R I V E R   C A P A B I L I T I E S
  */
-struct v4l2_capability
-{
+struct v4l2_capability {
         __u8    driver[16];     /* i.e. "bttv" */
         __u8    card[32];       /* i.e. "Hauppauge WinTV" */
         __u8    bus_info[32];   /* "PCI:" + pci_name(pci_dev) */
@@ -259,8 +264,7 @@ struct v4l2_capability
 /*
  *      V I D E O   I M A G E   F O R M A T
  */
-struct v4l2_pix_format
-{
+struct v4l2_pix_format {
         __u32                   width;
         __u32                   height;
         __u32                   pixelformat;
@@ -272,68 +276,69 @@ struct v4l2_pix_format
 };
 
 /*      Pixel format         FOURCC                        depth  Description  */
-#define V4L2_PIX_FMT_RGB332  v4l2_fourcc('R','G','B','1') /*  8  RGB-3-3-2     */
-#define V4L2_PIX_FMT_RGB444  v4l2_fourcc('R','4','4','4') /* 16  xxxxrrrr ggggbbbb */
-#define V4L2_PIX_FMT_RGB555  v4l2_fourcc('R','G','B','O') /* 16  RGB-5-5-5     */
-#define V4L2_PIX_FMT_RGB565  v4l2_fourcc('R','G','B','P') /* 16  RGB-5-6-5     */
-#define V4L2_PIX_FMT_RGB555X v4l2_fourcc('R','G','B','Q') /* 16  RGB-5-5-5 BE  */
-#define V4L2_PIX_FMT_RGB565X v4l2_fourcc('R','G','B','R') /* 16  RGB-5-6-5 BE  */
-#define V4L2_PIX_FMT_BGR24   v4l2_fourcc('B','G','R','3') /* 24  BGR-8-8-8     */
-#define V4L2_PIX_FMT_RGB24   v4l2_fourcc('R','G','B','3') /* 24  RGB-8-8-8     */
-#define V4L2_PIX_FMT_BGR32   v4l2_fourcc('B','G','R','4') /* 32  BGR-8-8-8-8   */
-#define V4L2_PIX_FMT_RGB32   v4l2_fourcc('R','G','B','4') /* 32  RGB-8-8-8-8   */
-#define V4L2_PIX_FMT_GREY    v4l2_fourcc('G','R','E','Y') /*  8  Greyscale     */
-#define V4L2_PIX_FMT_Y16     v4l2_fourcc('Y','1','6',' ') /* 16  Greyscale     */
-#define V4L2_PIX_FMT_PAL8    v4l2_fourcc('P','A','L','8') /*  8  8-bit palette */
-#define V4L2_PIX_FMT_YVU410  v4l2_fourcc('Y','V','U','9') /*  9  YVU 4:1:0     */
-#define V4L2_PIX_FMT_YVU420  v4l2_fourcc('Y','V','1','2') /* 12  YVU 4:2:0     */
-#define V4L2_PIX_FMT_YUYV    v4l2_fourcc('Y','U','Y','V') /* 16  YUV 4:2:2     */
-#define V4L2_PIX_FMT_UYVY    v4l2_fourcc('U','Y','V','Y') /* 16  YUV 4:2:2     */
-#define V4L2_PIX_FMT_YUV422P v4l2_fourcc('4','2','2','P') /* 16  YVU422 planar */
-#define V4L2_PIX_FMT_YUV411P v4l2_fourcc('4','1','1','P') /* 16  YVU411 planar */
-#define V4L2_PIX_FMT_Y41P    v4l2_fourcc('Y','4','1','P') /* 12  YUV 4:1:1     */
-#define V4L2_PIX_FMT_YUV444  v4l2_fourcc('Y','4','4','4') /* 16  xxxxyyyy uuuuvvvv */
-#define V4L2_PIX_FMT_YUV555  v4l2_fourcc('Y','U','V','O') /* 16  YUV-5-5-5     */
-#define V4L2_PIX_FMT_YUV565  v4l2_fourcc('Y','U','V','P') /* 16  YUV-5-6-5     */
-#define V4L2_PIX_FMT_YUV32   v4l2_fourcc('Y','U','V','4') /* 32  YUV-8-8-8-8   */
+#define V4L2_PIX_FMT_RGB332  v4l2_fourcc('R', 'G', 'B', '1') /*  8  RGB-3-3-2     */
+#define V4L2_PIX_FMT_RGB444  v4l2_fourcc('R', '4', '4', '4') /* 16  xxxxrrrr ggggbbbb */
+#define V4L2_PIX_FMT_RGB555  v4l2_fourcc('R', 'G', 'B', 'O') /* 16  RGB-5-5-5     */
+#define V4L2_PIX_FMT_RGB565  v4l2_fourcc('R', 'G', 'B', 'P') /* 16  RGB-5-6-5     */
+#define V4L2_PIX_FMT_RGB555X v4l2_fourcc('R', 'G', 'B', 'Q') /* 16  RGB-5-5-5 BE  */
+#define V4L2_PIX_FMT_RGB565X v4l2_fourcc('R', 'G', 'B', 'R') /* 16  RGB-5-6-5 BE  */
+#define V4L2_PIX_FMT_BGR24   v4l2_fourcc('B', 'G', 'R', '3') /* 24  BGR-8-8-8     */
+#define V4L2_PIX_FMT_RGB24   v4l2_fourcc('R', 'G', 'B', '3') /* 24  RGB-8-8-8     */
+#define V4L2_PIX_FMT_BGR32   v4l2_fourcc('B', 'G', 'R', '4') /* 32  BGR-8-8-8-8   */
+#define V4L2_PIX_FMT_RGB32   v4l2_fourcc('R', 'G', 'B', '4') /* 32  RGB-8-8-8-8   */
+#define V4L2_PIX_FMT_GREY    v4l2_fourcc('G', 'R', 'E', 'Y') /*  8  Greyscale     */
+#define V4L2_PIX_FMT_Y16     v4l2_fourcc('Y', '1', '6', ' ') /* 16  Greyscale     */
+#define V4L2_PIX_FMT_PAL8    v4l2_fourcc('P', 'A', 'L', '8') /*  8  8-bit palette */
+#define V4L2_PIX_FMT_YVU410  v4l2_fourcc('Y', 'V', 'U', '9') /*  9  YVU 4:1:0     */
+#define V4L2_PIX_FMT_YVU420  v4l2_fourcc('Y', 'V', '1', '2') /* 12  YVU 4:2:0     */
+#define V4L2_PIX_FMT_YUYV    v4l2_fourcc('Y', 'U', 'Y', 'V') /* 16  YUV 4:2:2     */
+#define V4L2_PIX_FMT_UYVY    v4l2_fourcc('U', 'Y', 'V', 'Y') /* 16  YUV 4:2:2     */
+#define V4L2_PIX_FMT_YUV422P v4l2_fourcc('4', '2', '2', 'P') /* 16  YVU422 planar */
+#define V4L2_PIX_FMT_YUV411P v4l2_fourcc('4', '1', '1', 'P') /* 16  YVU411 planar */
+#define V4L2_PIX_FMT_Y41P    v4l2_fourcc('Y', '4', '1', 'P') /* 12  YUV 4:1:1     */
+#define V4L2_PIX_FMT_YUV444  v4l2_fourcc('Y', '4', '4', '4') /* 16  xxxxyyyy uuuuvvvv */
+#define V4L2_PIX_FMT_YUV555  v4l2_fourcc('Y', 'U', 'V', 'O') /* 16  YUV-5-5-5     */
+#define V4L2_PIX_FMT_YUV565  v4l2_fourcc('Y', 'U', 'V', 'P') /* 16  YUV-5-6-5     */
+#define V4L2_PIX_FMT_YUV32   v4l2_fourcc('Y', 'U', 'V', '4') /* 32  YUV-8-8-8-8   */
 
 /* two planes -- one Y, one Cr + Cb interleaved  */
-#define V4L2_PIX_FMT_NV12    v4l2_fourcc('N','V','1','2') /* 12  Y/CbCr 4:2:0  */
-#define V4L2_PIX_FMT_NV21    v4l2_fourcc('N','V','2','1') /* 12  Y/CrCb 4:2:0  */
+#define V4L2_PIX_FMT_NV12    v4l2_fourcc('N', 'V', '1', '2') /* 12  Y/CbCr 4:2:0  */
+#define V4L2_PIX_FMT_NV21    v4l2_fourcc('N', 'V', '2', '1') /* 12  Y/CrCb 4:2:0  */
 
 /*  The following formats are not defined in the V4L2 specification */
-#define V4L2_PIX_FMT_YUV410  v4l2_fourcc('Y','U','V','9') /*  9  YUV 4:1:0     */
-#define V4L2_PIX_FMT_YUV420  v4l2_fourcc('Y','U','1','2') /* 12  YUV 4:2:0     */
-#define V4L2_PIX_FMT_YYUV    v4l2_fourcc('Y','Y','U','V') /* 16  YUV 4:2:2     */
-#define V4L2_PIX_FMT_HI240   v4l2_fourcc('H','I','2','4') /*  8  8-bit color   */
-#define V4L2_PIX_FMT_HM12    v4l2_fourcc('H','M','1','2') /*  8  YUV 4:2:0 16x16 macroblocks */
+#define V4L2_PIX_FMT_YUV410  v4l2_fourcc('Y', 'U', 'V', '9') /*  9  YUV 4:1:0     */
+#define V4L2_PIX_FMT_YUV420  v4l2_fourcc('Y', 'U', '1', '2') /* 12  YUV 4:2:0     */
+#define V4L2_PIX_FMT_YYUV    v4l2_fourcc('Y', 'Y', 'U', 'V') /* 16  YUV 4:2:2     */
+#define V4L2_PIX_FMT_HI240   v4l2_fourcc('H', 'I', '2', '4') /*  8  8-bit color   */
+#define V4L2_PIX_FMT_HM12    v4l2_fourcc('H', 'M', '1', '2') /*  8  YUV 4:2:0 16x16 macroblocks */
 
 /* see http://www.siliconimaging.com/RGB%20Bayer.htm */
-#define V4L2_PIX_FMT_SBGGR8  v4l2_fourcc('B','A','8','1') /*  8  BGBG.. GRGR.. */
-#define V4L2_PIX_FMT_SGBRG8  v4l2_fourcc('G','B','R','G') /*  8  GBGB.. RGRG.. */
-#define V4L2_PIX_FMT_SBGGR16 v4l2_fourcc('B','Y','R','2') /* 16  BGBG.. GRGR.. */
+#define V4L2_PIX_FMT_SBGGR8  v4l2_fourcc('B', 'A', '8', '1') /*  8  BGBG.. GRGR.. */
+#define V4L2_PIX_FMT_SGBRG8  v4l2_fourcc('G', 'B', 'R', 'G') /*  8  GBGB.. RGRG.. */
+#define V4L2_PIX_FMT_SBGGR16 v4l2_fourcc('B', 'Y', 'R', '2') /* 16  BGBG.. GRGR.. */
 
 /* compressed formats */
-#define V4L2_PIX_FMT_MJPEG    v4l2_fourcc('M','J','P','G') /* Motion-JPEG   */
-#define V4L2_PIX_FMT_JPEG     v4l2_fourcc('J','P','E','G') /* JFIF JPEG     */
-#define V4L2_PIX_FMT_DV       v4l2_fourcc('d','v','s','d') /* 1394          */
-#define V4L2_PIX_FMT_MPEG     v4l2_fourcc('M','P','E','G') /* MPEG-1/2/4    */
+#define V4L2_PIX_FMT_MJPEG    v4l2_fourcc('M', 'J', 'P', 'G') /* Motion-JPEG   */
+#define V4L2_PIX_FMT_JPEG     v4l2_fourcc('J', 'P', 'E', 'G') /* JFIF JPEG     */
+#define V4L2_PIX_FMT_DV       v4l2_fourcc('d', 'v', 's', 'd') /* 1394          */
+#define V4L2_PIX_FMT_MPEG     v4l2_fourcc('M', 'P', 'E', 'G') /* MPEG-1/2/4    */
 
 /*  Vendor-specific formats   */
-#define V4L2_PIX_FMT_WNVA     v4l2_fourcc('W','N','V','A') /* Winnov hw compress */
-#define V4L2_PIX_FMT_SN9C10X  v4l2_fourcc('S','9','1','0') /* SN9C10x compression */
-#define V4L2_PIX_FMT_PWC1     v4l2_fourcc('P','W','C','1') /* pwc older webcam */
-#define V4L2_PIX_FMT_PWC2     v4l2_fourcc('P','W','C','2') /* pwc newer webcam */
-#define V4L2_PIX_FMT_ET61X251 v4l2_fourcc('E','6','2','5') /* ET61X251 compression */
-#define V4L2_PIX_FMT_SPCA501  v4l2_fourcc('S','5','0','1') /* YUYV per line */
-#define V4L2_PIX_FMT_SPCA561  v4l2_fourcc('S','5','6','1') /* compressed GBRG bayer */
-#define V4L2_PIX_FMT_PAC207   v4l2_fourcc('P','2','0','7') /* compressed BGGR bayer */
+#define V4L2_PIX_FMT_WNVA     v4l2_fourcc('W', 'N', 'V', 'A') /* Winnov hw compress */
+#define V4L2_PIX_FMT_SN9C10X  v4l2_fourcc('S', '9', '1', '0') /* SN9C10x compression */
+#define V4L2_PIX_FMT_PWC1     v4l2_fourcc('P', 'W', 'C', '1') /* pwc older webcam */
+#define V4L2_PIX_FMT_PWC2     v4l2_fourcc('P', 'W', 'C', '2') /* pwc newer webcam */
+#define V4L2_PIX_FMT_ET61X251 v4l2_fourcc('E', '6', '2', '5') /* ET61X251 compression */
+#define V4L2_PIX_FMT_SPCA501  v4l2_fourcc('S', '5', '0', '1') /* YUYV per line */
+#define V4L2_PIX_FMT_SPCA505  v4l2_fourcc('S', '5', '0', '5') /* YYUV per line */
+#define V4L2_PIX_FMT_SPCA508  v4l2_fourcc('S', '5', '0', '8') /* YUVY per line */
+#define V4L2_PIX_FMT_SPCA561  v4l2_fourcc('S', '5', '6', '1') /* compressed GBRG bayer */
+#define V4L2_PIX_FMT_PAC207   v4l2_fourcc('P', '2', '0', '7') /* compressed BGGR bayer */
 
 /*
  *      F O R M A T   E N U M E R A T I O N
  */
-struct v4l2_fmtdesc
-{
+struct v4l2_fmtdesc {
         __u32               index;             /* Format number      */
         enum v4l2_buf_type  type;              /* buffer type        */
         __u32               flags;
@@ -349,21 +354,18 @@ struct v4l2_fmtdesc
 /*
  *      F R A M E   S I Z E   E N U M E R A T I O N
  */
-enum v4l2_frmsizetypes
-{
+enum v4l2_frmsizetypes {
         V4L2_FRMSIZE_TYPE_DISCRETE      = 1,
         V4L2_FRMSIZE_TYPE_CONTINUOUS    = 2,
         V4L2_FRMSIZE_TYPE_STEPWISE      = 3,
 };
 
-struct v4l2_frmsize_discrete
-{
+struct v4l2_frmsize_discrete {
         __u32                   width;          /* Frame width [pixel] */
         __u32                   height;         /* Frame height [pixel] */
 };
 
-struct v4l2_frmsize_stepwise
-{
+struct v4l2_frmsize_stepwise {
         __u32                   min_width;      /* Minimum frame width [pixel] */
         __u32                   max_width;      /* Maximum frame width [pixel] */
         __u32                   step_width;     /* Frame width step size [pixel] */
@@ -372,8 +374,7 @@ struct v4l2_frmsize_stepwise
         __u32                   step_height;    /* Frame height step size [pixel] */
 };
 
-struct v4l2_frmsizeenum
-{
+struct v4l2_frmsizeenum {
         __u32                   index;          /* Frame size number */
         __u32                   pixel_format;   /* Pixel format */
         __u32                   type;           /* Frame size type the device supports. */
@@ -389,22 +390,19 @@ struct v4l2_frmsizeenum
 /*
  *      F R A M E   R A T E   E N U M E R A T I O N
  */
-enum v4l2_frmivaltypes
-{
+enum v4l2_frmivaltypes {
         V4L2_FRMIVAL_TYPE_DISCRETE      = 1,
         V4L2_FRMIVAL_TYPE_CONTINUOUS    = 2,
         V4L2_FRMIVAL_TYPE_STEPWISE      = 3,
 };
 
-struct v4l2_frmival_stepwise
-{
+struct v4l2_frmival_stepwise {
         struct v4l2_fract       min;            /* Minimum frame interval [s] */
         struct v4l2_fract       max;            /* Maximum frame interval [s] */
         struct v4l2_fract       step;           /* Frame interval step size [s] */
 };
 
-struct v4l2_frmivalenum
-{
+struct v4l2_frmivalenum {
         __u32                   index;          /* Frame format index */
         __u32                   pixel_format;   /* Pixel format */
         __u32                   width;          /* Frame width */
@@ -423,8 +421,7 @@ struct v4l2_frmivalenum
 /*
  *      T I M E C O D E
  */
-struct v4l2_timecode
-{
+struct v4l2_timecode {
         __u32   type;
         __u32   flags;
         __u8    frames;
@@ -449,8 +446,7 @@ struct v4l2_timecode
 #define V4L2_TC_USERBITS_8BITCHARS      0x0008
 /* The above is based on SMPTE timecodes */
 
-struct v4l2_jpegcompression
-{
+struct v4l2_jpegcompression {
         int quality;
 
         int  APPn;              /* Number of APP segment to be written,
@@ -482,16 +478,14 @@ struct v4l2_jpegcompression
 /*
  *      M E M O R Y - M A P P I N G   B U F F E R S
  */
-struct v4l2_requestbuffers
-{
+struct v4l2_requestbuffers {
         __u32                   count;
         enum v4l2_buf_type      type;
         enum v4l2_memory        memory;
         __u32                   reserved[2];
 };
 
-struct v4l2_buffer
-{
+struct v4l2_buffer {
         __u32                   index;
         enum v4l2_buf_type      type;
         __u32                   bytesused;
@@ -525,13 +519,12 @@ struct v4l2_buffer
 /*
  *      O V E R L A Y   P R E V I E W
  */
-struct v4l2_framebuffer
-{
+struct v4l2_framebuffer {
         __u32                   capability;
         __u32                   flags;
 /* FIXME: in theory we should pass something like PCI device + memory
  * region + offset instead of some physical address */
-        void*                   base;
+        void                    *base;
         struct v4l2_pix_format  fmt;
 };
 /*  Flags for the 'capability' field. Read only */
@@ -550,14 +543,12 @@ struct v4l2_framebuffer
 #define V4L2_FBUF_FLAG_GLOBAL_ALPHA     0x0010
 #define V4L2_FBUF_FLAG_LOCAL_INV_ALPHA  0x0020
 
-struct v4l2_clip
-{
+struct v4l2_clip {
         struct v4l2_rect        c;
         struct v4l2_clip        __user *next;
 };
 
-struct v4l2_window
-{
+struct v4l2_window {
         struct v4l2_rect        w;
         enum v4l2_field         field;
         __u32                   chromakey;
@@ -570,8 +561,7 @@ struct v4l2_window
 /*
  *      C A P T U R E   P A R A M E T E R S
  */
-struct v4l2_captureparm
-{
+struct v4l2_captureparm {
         __u32              capability;    /*  Supported modes */
         __u32              capturemode;   /*  Current mode */
         struct v4l2_fract  timeperframe;  /*  Time per frame in .1us units */
@@ -584,8 +574,7 @@ struct v4l2_captureparm
 #define V4L2_MODE_HIGHQUALITY   0x0001  /*  High quality imaging mode */
 #define V4L2_CAP_TIMEPERFRAME   0x1000  /*  timeperframe field is supported */
 
-struct v4l2_outputparm
-{
+struct v4l2_outputparm {
         __u32              capability;   /*  Supported modes */
         __u32              outputmode;   /*  Current mode */
         struct v4l2_fract  timeperframe; /*  Time per frame in seconds */
@@ -702,8 +691,7 @@ typedef __u64 v4l2_std_id;
 #define V4L2_STD_ALL            (V4L2_STD_525_60        |\
                                  V4L2_STD_625_50)
 
-struct v4l2_standard
-{
+struct v4l2_standard {
         __u32                index;
         v4l2_std_id          id;
         __u8                 name[24];
@@ -715,8 +703,7 @@ struct v4l2_standard
 /*
  *      V I D E O   I N P U T S
  */
-struct v4l2_input
-{
+struct v4l2_input {
         __u32        index;             /*  Which input */
         __u8         name[32];          /*  Label */
         __u32        type;              /*  Type of input */
@@ -753,8 +740,7 @@ struct v4l2_input
 /*
  *      V I D E O   O U T P U T S
  */
-struct v4l2_output
-{
+struct v4l2_output {
         __u32        index;             /*  Which output */
         __u8         name[32];          /*  Label */
         __u32        type;              /*  Type of output */
@@ -771,14 +757,12 @@ struct v4l2_output
 /*
  *      C O N T R O L S
  */
-struct v4l2_control
-{
+struct v4l2_control {
         __u32                id;
         __s32                value;
 };
 
-struct v4l2_ext_control
-{
+struct v4l2_ext_control {
         __u32 id;
         __u32 reserved2[2];
         union {
@@ -788,8 +772,7 @@ struct v4l2_ext_control
         };
 } __attribute__ ((packed));
 
-struct v4l2_ext_controls
-{
+struct v4l2_ext_controls {
         __u32 ctrl_class;
         __u32 count;
         __u32 error_idx;
@@ -807,8 +790,7 @@ struct v4l2_ext_controls
 #define V4L2_CTRL_DRIVER_PRIV(id) (((id) & 0xffff) >= 0x1000)
 
 /*  Used in the VIDIOC_QUERYCTRL ioctl for querying controls */
-struct v4l2_queryctrl
-{
+struct v4l2_queryctrl {
         __u32                id;
         enum v4l2_ctrl_type  type;
         __u8                 name[32];  /* Whatever */
@@ -821,8 +803,7 @@ struct v4l2_queryctrl
 };
 
 /*  Used in the VIDIOC_QUERYMENU ioctl for querying menu items */
-struct v4l2_querymenu
-{
+struct v4l2_querymenu {
         __u32           id;
         __u32           index;
         __u8            name[32];       /* Whatever */
@@ -1104,8 +1085,7 @@ enum  v4l2_exposure_auto_type {
 /*
  *      T U N I N G
  */
-struct v4l2_tuner
-{
+struct v4l2_tuner {
         __u32                   index;
         __u8                    name[32];
         enum v4l2_tuner_type    type;
@@ -1119,8 +1099,7 @@ struct v4l2_tuner
         __u32                   reserved[4];
 };
 
-struct v4l2_modulator
-{
+struct v4l2_modulator {
         __u32                   index;
         __u8                    name[32];
         __u32                   capability;
@@ -1153,8 +1132,7 @@ struct v4l2_modulator
 #define V4L2_TUNER_MODE_LANG1           0x0003
 #define V4L2_TUNER_MODE_LANG1_LANG2     0x0004
 
-struct v4l2_frequency
-{
+struct v4l2_frequency {
         __u32                 tuner;
         enum v4l2_tuner_type  type;
         __u32                 frequency;
@@ -1172,8 +1150,7 @@ struct v4l2_hw_freq_seek {
 /*
  *      A U D I O
  */
-struct v4l2_audio
-{
+struct v4l2_audio {
         __u32   index;
         __u8    name[32];
         __u32   capability;
@@ -1188,8 +1165,7 @@ struct v4l2_audio
 /*  Flags for the 'mode' field */
 #define V4L2_AUDMODE_AVL                0x00001
 
-struct v4l2_audioout
-{
+struct v4l2_audioout {
         __u32   index;
         __u8    name[32];
         __u32   capability;
@@ -1253,8 +1229,7 @@ struct v4l2_encoder_cmd {
  */
 
 /* Raw VBI */
-struct v4l2_vbi_format
-{
+struct v4l2_vbi_format {
         __u32   sampling_rate;          /* in 1 Hz */
         __u32   offset;
         __u32   samples_per_line;
@@ -1266,8 +1241,8 @@ struct v4l2_vbi_format
 };
 
 /*  VBI flags  */
-#define V4L2_VBI_UNSYNC         (1<< 0)
-#define V4L2_VBI_INTERLACED     (1<< 1)
+#define V4L2_VBI_UNSYNC         (1 << 0)
+#define V4L2_VBI_INTERLACED     (1 << 1)
 
 /* Sliced VBI
  *
@@ -1276,8 +1251,7 @@ struct v4l2_vbi_format
  * notice in the definitive implementation.
  */
 
-struct v4l2_sliced_vbi_format
-{
+struct v4l2_sliced_vbi_format {
         __u16   service_set;
         /* service_lines[0][...] specifies lines 0-23 (1-23 used) of the first field
            service_lines[1][...] specifies lines 0-23 (1-23 used) of the second field
@@ -1301,8 +1275,7 @@ struct v4l2_sliced_vbi_format
 #define V4L2_SLICED_VBI_525             (V4L2_SLICED_CAPTION_525)
 #define V4L2_SLICED_VBI_625             (V4L2_SLICED_TELETEXT_B | V4L2_SLICED_VPS | V4L2_SLICED_WSS_625)
 
-struct v4l2_sliced_vbi_cap
-{
+struct v4l2_sliced_vbi_cap {
         __u16   service_set;
         /* service_lines[0][...] specifies lines 0-23 (1-23 used) of the first field
            service_lines[1][...] specifies lines 0-23 (1-23 used) of the second field
@@ -1313,8 +1286,7 @@ struct v4l2_sliced_vbi_cap
         __u32   reserved[3];    /* must be 0 */
 };
 
-struct v4l2_sliced_vbi_data
-{
+struct v4l2_sliced_vbi_data {
         __u32   id;
         __u32   field;          /* 0: first field, 1: second field */
         __u32   line;           /* 1-23 */
@@ -1328,27 +1300,23 @@ struct v4l2_sliced_vbi_data
 
 /*      Stream data format
  */
-struct v4l2_format
-{
+struct v4l2_format {
         enum v4l2_buf_type type;
-        union
-        {
-                struct v4l2_pix_format          pix;     // V4L2_BUF_TYPE_VIDEO_CAPTURE
-                struct v4l2_window              win;     // V4L2_BUF_TYPE_VIDEO_OVERLAY
-                struct v4l2_vbi_format          vbi;     // V4L2_BUF_TYPE_VBI_CAPTURE
-                struct v4l2_sliced_vbi_format   sliced;  // V4L2_BUF_TYPE_SLICED_VBI_CAPTURE
-                __u8    raw_data[200];                   // user-defined
+        union {
+                struct v4l2_pix_format          pix;     /* V4L2_BUF_TYPE_VIDEO_CAPTURE */
+                struct v4l2_window              win;     /* V4L2_BUF_TYPE_VIDEO_OVERLAY */
+                struct v4l2_vbi_format          vbi;     /* V4L2_BUF_TYPE_VBI_CAPTURE */
+                struct v4l2_sliced_vbi_format   sliced;  /* V4L2_BUF_TYPE_SLICED_VBI_CAPTURE */
+                __u8    raw_data[200];                   /* user-defined */
         } fmt;
 };
 
 
 /*      Stream type-dependent parameters
  */
-struct v4l2_streamparm
-{
+struct v4l2_streamparm {
         enum v4l2_buf_type type;
-        union
-        {
+        union {
                 struct v4l2_captureparm capture;
                 struct v4l2_outputparm  output;
                 __u8    raw_data[200];  /* user-defined */
@@ -1386,92 +1354,86 @@ struct v4l2_chip_ident {
  *      I O C T L   C O D E S   F O R   V I D E O   D E V I C E S
  *
  */
-#define VIDIOC_QUERYCAP         _IOR  ('V',  0, struct v4l2_capability)
-#define VIDIOC_RESERVED         _IO   ('V',  1)
-#define VIDIOC_ENUM_FMT         _IOWR ('V',  2, struct v4l2_fmtdesc)
-#define VIDIOC_G_FMT            _IOWR ('V',  4, struct v4l2_format)
-#define VIDIOC_S_FMT            _IOWR ('V',  5, struct v4l2_format)
-#define VIDIOC_REQBUFS          _IOWR ('V',  8, struct v4l2_requestbuffers)
-#define VIDIOC_QUERYBUF         _IOWR ('V',  9, struct v4l2_buffer)
-#define VIDIOC_G_FBUF           _IOR  ('V', 10, struct v4l2_framebuffer)
-#define VIDIOC_S_FBUF           _IOW  ('V', 11, struct v4l2_framebuffer)
-#define VIDIOC_OVERLAY          _IOW  ('V', 14, int)
-#define VIDIOC_QBUF             _IOWR ('V', 15, struct v4l2_buffer)
-#define VIDIOC_DQBUF            _IOWR ('V', 17, struct v4l2_buffer)
-#define VIDIOC_STREAMON         _IOW  ('V', 18, int)
-#define VIDIOC_STREAMOFF        _IOW  ('V', 19, int)
-#define VIDIOC_G_PARM           _IOWR ('V', 21, struct v4l2_streamparm)
-#define VIDIOC_S_PARM           _IOWR ('V', 22, struct v4l2_streamparm)
-#define VIDIOC_G_STD            _IOR  ('V', 23, v4l2_std_id)
-#define VIDIOC_S_STD            _IOW  ('V', 24, v4l2_std_id)
-#define VIDIOC_ENUMSTD          _IOWR ('V', 25, struct v4l2_standard)
-#define VIDIOC_ENUMINPUT        _IOWR ('V', 26, struct v4l2_input)
-#define VIDIOC_G_CTRL           _IOWR ('V', 27, struct v4l2_control)
-#define VIDIOC_S_CTRL           _IOWR ('V', 28, struct v4l2_control)
-#define VIDIOC_G_TUNER          _IOWR ('V', 29, struct v4l2_tuner)
-#define VIDIOC_S_TUNER          _IOW  ('V', 30, struct v4l2_tuner)
-#define VIDIOC_G_AUDIO          _IOR  ('V', 33, struct v4l2_audio)
-#define VIDIOC_S_AUDIO          _IOW  ('V', 34, struct v4l2_audio)
-#define VIDIOC_QUERYCTRL        _IOWR ('V', 36, struct v4l2_queryctrl)
-#define VIDIOC_QUERYMENU        _IOWR ('V', 37, struct v4l2_querymenu)
-#define VIDIOC_G_INPUT          _IOR  ('V', 38, int)
-#define VIDIOC_S_INPUT          _IOWR ('V', 39, int)
-#define VIDIOC_G_OUTPUT         _IOR  ('V', 46, int)
-#define VIDIOC_S_OUTPUT         _IOWR ('V', 47, int)
-#define VIDIOC_ENUMOUTPUT       _IOWR ('V', 48, struct v4l2_output)
-#define VIDIOC_G_AUDOUT         _IOR  ('V', 49, struct v4l2_audioout)
-#define VIDIOC_S_AUDOUT         _IOW  ('V', 50, struct v4l2_audioout)
-#define VIDIOC_G_MODULATOR      _IOWR ('V', 54, struct v4l2_modulator)
-#define VIDIOC_S_MODULATOR      _IOW  ('V', 55, struct v4l2_modulator)
-#define VIDIOC_G_FREQUENCY      _IOWR ('V', 56, struct v4l2_frequency)
-#define VIDIOC_S_FREQUENCY      _IOW  ('V', 57, struct v4l2_frequency)
-#define VIDIOC_CROPCAP          _IOWR ('V', 58, struct v4l2_cropcap)
-#define VIDIOC_G_CROP           _IOWR ('V', 59, struct v4l2_crop)
-#define VIDIOC_S_CROP           _IOW  ('V', 60, struct v4l2_crop)
-#define VIDIOC_G_JPEGCOMP       _IOR  ('V', 61, struct v4l2_jpegcompression)
-#define VIDIOC_S_JPEGCOMP       _IOW  ('V', 62, struct v4l2_jpegcompression)
-#define VIDIOC_QUERYSTD         _IOR  ('V', 63, v4l2_std_id)
-#define VIDIOC_TRY_FMT          _IOWR ('V', 64, struct v4l2_format)
-#define VIDIOC_ENUMAUDIO        _IOWR ('V', 65, struct v4l2_audio)
-#define VIDIOC_ENUMAUDOUT       _IOWR ('V', 66, struct v4l2_audioout)
-#define VIDIOC_G_PRIORITY       _IOR  ('V', 67, enum v4l2_priority)
-#define VIDIOC_S_PRIORITY       _IOW  ('V', 68, enum v4l2_priority)
-#define VIDIOC_G_SLICED_VBI_CAP _IOWR ('V', 69, struct v4l2_sliced_vbi_cap)
-#define VIDIOC_LOG_STATUS       _IO   ('V', 70)
-#define VIDIOC_G_EXT_CTRLS      _IOWR ('V', 71, struct v4l2_ext_controls)
-#define VIDIOC_S_EXT_CTRLS      _IOWR ('V', 72, struct v4l2_ext_controls)
-#define VIDIOC_TRY_EXT_CTRLS    _IOWR ('V', 73, struct v4l2_ext_controls)
+#define VIDIOC_QUERYCAP          _IOR('V',  0, struct v4l2_capability)
+#define VIDIOC_RESERVED           _IO('V',  1)
+#define VIDIOC_ENUM_FMT         _IOWR('V',  2, struct v4l2_fmtdesc)
+#define VIDIOC_G_FMT            _IOWR('V',  4, struct v4l2_format)
+#define VIDIOC_S_FMT            _IOWR('V',  5, struct v4l2_format)
+#define VIDIOC_REQBUFS          _IOWR('V',  8, struct v4l2_requestbuffers)
+#define VIDIOC_QUERYBUF         _IOWR('V',  9, struct v4l2_buffer)
+#define VIDIOC_G_FBUF            _IOR('V', 10, struct v4l2_framebuffer)
+#define VIDIOC_S_FBUF            _IOW('V', 11, struct v4l2_framebuffer)
+#define VIDIOC_OVERLAY           _IOW('V', 14, int)
+#define VIDIOC_QBUF             _IOWR('V', 15, struct v4l2_buffer)
+#define VIDIOC_DQBUF            _IOWR('V', 17, struct v4l2_buffer)
+#define VIDIOC_STREAMON          _IOW('V', 18, int)
+#define VIDIOC_STREAMOFF         _IOW('V', 19, int)
+#define VIDIOC_G_PARM           _IOWR('V', 21, struct v4l2_streamparm)
+#define VIDIOC_S_PARM           _IOWR('V', 22, struct v4l2_streamparm)
+#define VIDIOC_G_STD             _IOR('V', 23, v4l2_std_id)
+#define VIDIOC_S_STD             _IOW('V', 24, v4l2_std_id)
+#define VIDIOC_ENUMSTD          _IOWR('V', 25, struct v4l2_standard)
+#define VIDIOC_ENUMINPUT        _IOWR('V', 26, struct v4l2_input)
+#define VIDIOC_G_CTRL           _IOWR('V', 27, struct v4l2_control)
+#define VIDIOC_S_CTRL           _IOWR('V', 28, struct v4l2_control)
+#define VIDIOC_G_TUNER          _IOWR('V', 29, struct v4l2_tuner)
+#define VIDIOC_S_TUNER           _IOW('V', 30, struct v4l2_tuner)
+#define VIDIOC_G_AUDIO           _IOR('V', 33, struct v4l2_audio)
+#define VIDIOC_S_AUDIO           _IOW('V', 34, struct v4l2_audio)
+#define VIDIOC_QUERYCTRL        _IOWR('V', 36, struct v4l2_queryctrl)
+#define VIDIOC_QUERYMENU        _IOWR('V', 37, struct v4l2_querymenu)
+#define VIDIOC_G_INPUT           _IOR('V', 38, int)
+#define VIDIOC_S_INPUT          _IOWR('V', 39, int)
+#define VIDIOC_G_OUTPUT          _IOR('V', 46, int)
+#define VIDIOC_S_OUTPUT         _IOWR('V', 47, int)
+#define VIDIOC_ENUMOUTPUT       _IOWR('V', 48, struct v4l2_output)
+#define VIDIOC_G_AUDOUT          _IOR('V', 49, struct v4l2_audioout)
+#define VIDIOC_S_AUDOUT          _IOW('V', 50, struct v4l2_audioout)
+#define VIDIOC_G_MODULATOR      _IOWR('V', 54, struct v4l2_modulator)
+#define VIDIOC_S_MODULATOR       _IOW('V', 55, struct v4l2_modulator)
+#define VIDIOC_G_FREQUENCY      _IOWR('V', 56, struct v4l2_frequency)
+#define VIDIOC_S_FREQUENCY       _IOW('V', 57, struct v4l2_frequency)
+#define VIDIOC_CROPCAP          _IOWR('V', 58, struct v4l2_cropcap)
+#define VIDIOC_G_CROP           _IOWR('V', 59, struct v4l2_crop)
+#define VIDIOC_S_CROP            _IOW('V', 60, struct v4l2_crop)
+#define VIDIOC_G_JPEGCOMP        _IOR('V', 61, struct v4l2_jpegcompression)
+#define VIDIOC_S_JPEGCOMP        _IOW('V', 62, struct v4l2_jpegcompression)
+#define VIDIOC_QUERYSTD          _IOR('V', 63, v4l2_std_id)
+#define VIDIOC_TRY_FMT          _IOWR('V', 64, struct v4l2_format)
+#define VIDIOC_ENUMAUDIO        _IOWR('V', 65, struct v4l2_audio)
+#define VIDIOC_ENUMAUDOUT       _IOWR('V', 66, struct v4l2_audioout)
+#define VIDIOC_G_PRIORITY        _IOR('V', 67, enum v4l2_priority)
+#define VIDIOC_S_PRIORITY        _IOW('V', 68, enum v4l2_priority)
+#define VIDIOC_G_SLICED_VBI_CAP _IOWR('V', 69, struct v4l2_sliced_vbi_cap)
+#define VIDIOC_LOG_STATUS         _IO('V', 70)
+#define VIDIOC_G_EXT_CTRLS      _IOWR('V', 71, struct v4l2_ext_controls)
+#define VIDIOC_S_EXT_CTRLS      _IOWR('V', 72, struct v4l2_ext_controls)
+#define VIDIOC_TRY_EXT_CTRLS    _IOWR('V', 73, struct v4l2_ext_controls)
 #if 1
-#define VIDIOC_ENUM_FRAMESIZES  _IOWR ('V', 74, struct v4l2_frmsizeenum)
-#define VIDIOC_ENUM_FRAMEINTERVALS      _IOWR ('V', 75, struct v4l2_frmivalenum)
-#define VIDIOC_G_ENC_INDEX      _IOR  ('V', 76, struct v4l2_enc_idx)
-#define VIDIOC_ENCODER_CMD      _IOWR ('V', 77, struct v4l2_encoder_cmd)
-#define VIDIOC_TRY_ENCODER_CMD  _IOWR ('V', 78, struct v4l2_encoder_cmd)
+#define VIDIOC_ENUM_FRAMESIZES  _IOWR('V', 74, struct v4l2_frmsizeenum)
+#define VIDIOC_ENUM_FRAMEINTERVALS _IOWR('V', 75, struct v4l2_frmivalenum)
+#define VIDIOC_G_ENC_INDEX       _IOR('V', 76, struct v4l2_enc_idx)
+#define VIDIOC_ENCODER_CMD      _IOWR('V', 77, struct v4l2_encoder_cmd)
+#define VIDIOC_TRY_ENCODER_CMD  _IOWR('V', 78, struct v4l2_encoder_cmd)
 
 /* Experimental, only implemented if CONFIG_VIDEO_ADV_DEBUG is defined */
-#define VIDIOC_DBG_S_REGISTER   _IOW  ('V', 79, struct v4l2_register)
-#define VIDIOC_DBG_G_REGISTER   _IOWR ('V', 80, struct v4l2_register)
+#define VIDIOC_DBG_S_REGISTER    _IOW('V', 79, struct v4l2_register)
+#define VIDIOC_DBG_G_REGISTER   _IOWR('V', 80, struct v4l2_register)
 
-#define VIDIOC_G_CHIP_IDENT     _IOWR ('V', 81, struct v4l2_chip_ident)
+#define VIDIOC_G_CHIP_IDENT     _IOWR('V', 81, struct v4l2_chip_ident)
 #endif
-#define VIDIOC_S_HW_FREQ_SEEK   _IOW  ('V', 82, struct v4l2_hw_freq_seek)
+#define VIDIOC_S_HW_FREQ_SEEK    _IOW('V', 82, struct v4l2_hw_freq_seek)
 
 #ifdef __OLD_VIDIOC_
 /* for compatibility, will go away some day */
-#define VIDIOC_OVERLAY_OLD      _IOWR ('V', 14, int)
-#define VIDIOC_S_PARM_OLD       _IOW  ('V', 22, struct v4l2_streamparm)
-#define VIDIOC_S_CTRL_OLD       _IOW  ('V', 28, struct v4l2_control)
-#define VIDIOC_G_AUDIO_OLD      _IOWR ('V', 33, struct v4l2_audio)
-#define VIDIOC_G_AUDOUT_OLD     _IOWR ('V', 49, struct v4l2_audioout)
-#define VIDIOC_CROPCAP_OLD      _IOR  ('V', 58, struct v4l2_cropcap)
+#define VIDIOC_OVERLAY_OLD      _IOWR('V', 14, int)
+#define VIDIOC_S_PARM_OLD        _IOW('V', 22, struct v4l2_streamparm)
+#define VIDIOC_S_CTRL_OLD        _IOW('V', 28, struct v4l2_control)
+#define VIDIOC_G_AUDIO_OLD      _IOWR('V', 33, struct v4l2_audio)
+#define VIDIOC_G_AUDOUT_OLD     _IOWR('V', 49, struct v4l2_audioout)
+#define VIDIOC_CROPCAP_OLD       _IOR('V', 58, struct v4l2_cropcap)
 #endif
 
 #define BASE_VIDIOC_PRIVATE     192             /* 192-255 are private */
 
 #endif /* __LINUX_VIDEODEV2_H */
-
-/*
- * Local variables:
- * c-basic-offset: 8
- * End:
- */
diff --git a/include/linux/videotext.h b/include/linux/videotext.h
index 018f92047ff8..3e68c8d1c7f7 100644
--- a/include/linux/videotext.h
+++ b/include/linux/videotext.h
@@ -45,10 +45,10 @@
 #define VTXIOCCLRCACHE_OLD 0x710b  /* clear cache on VTX-interface (if avail.) */
 #define VTXIOCSETVIRT_OLD  0x710c  /* turn on virtual mode (this disables TV-display) */
 
-/* 
+/*
  *      Definitions for VTXIOCGETINFO
  */
- 
+
 #define SAA5243 0
 #define SAA5246 1
 #define SAA5249 2
@@ -57,10 +57,10 @@
 
 typedef struct {
         int version_major, version_minor;       /* version of driver; if version_major changes, driver */
-                                                /* is not backward compatible!!! CHECK THIS!!! */  
+                                                /* is not backward compatible!!! CHECK THIS!!! */
         int numpages;                           /* number of page-buffers of vtx-chipset */
         int cct_type;                           /* type of vtx-chipset (SAA5243, SAA5246, SAA5248 or
-                                                 * SAA5249) */
+                                                 * SAA5249) */
 }
 vtx_info_t;
 
@@ -81,7 +81,7 @@ vtx_info_t;
 #define PGMASK_HOUR (HR_TEN | HR_UNIT)
 #define PGMASK_MINUTE (MIN_TEN | MIN_UNIT)
 
-typedef struct 
+typedef struct
 {
         int page;       /* number of requested page (hexadecimal) */
         int hour;       /* requested hour (hexadecimal) */
@@ -98,11 +98,11 @@ vtx_pagereq_t;
 /*
  *      Definitions for VTXIOC{GETSTAT,PUTSTAT}
  */
- 
+
 #define VTX_PAGESIZE (40 * 24)
 #define VTX_VIRTUALSIZE (40 * 49)
 
-typedef struct 
+typedef struct
 {
         int pagenum;                    /* number of page (hexadecimal) */
         int hour;                       /* hour (hexadecimal) */
@@ -121,5 +121,5 @@ typedef struct
         unsigned hamming : 1;           /* hamming-error occurred */
 }
 vtx_pageinfo_t;
- 
+
 #endif /* _VTX_H */
diff --git a/include/linux/vmalloc.h b/include/linux/vmalloc.h
index 364789aae9f3..328eb4022727 100644
--- a/include/linux/vmalloc.h
+++ b/include/linux/vmalloc.h
@@ -4,9 +4,9 @@
 #include <linux/spinlock.h>
 #include <asm/page.h>           /* pgprot_t */
 
-struct vm_area_struct;
+struct vm_area_struct;          /* vma defining user mapping in mm_types.h */
 
-/* bits in vm_struct->flags */
+/* bits in flags of vmalloc's vm_struct below */
 #define VM_IOREMAP      0x00000001      /* ioremap() and friends */
 #define VM_ALLOC        0x00000002      /* vmalloc() */
 #define VM_MAP          0x00000004      /* vmap()ed pages */
diff --git a/include/linux/vt_kern.h b/include/linux/vt_kern.h
index 14c0e91be9b5..1cbd0a7db4e6 100644
--- a/include/linux/vt_kern.h
+++ b/include/linux/vt_kern.h
@@ -35,7 +35,6 @@ extern int fg_console, last_console, want_console;
 int vc_allocate(unsigned int console);
 int vc_cons_allocated(unsigned int console);
 int vc_resize(struct vc_data *vc, unsigned int cols, unsigned int lines);
-int vc_lock_resize(struct vc_data *vc, unsigned int cols, unsigned int lines);
 void vc_deallocate(unsigned int console);
 void reset_palette(struct vc_data *vc);
 void do_blank_screen(int entering_gfx);
@@ -74,7 +73,7 @@ void con_protect_unimap(struct vc_data *vc, int rdonly);
 int con_copy_unimap(struct vc_data *dst_vc, struct vc_data *src_vc);
 
 #define vc_translate(vc, c) ((vc)->vc_translate[(c) |                   \
-                                        (vc)->vc_toggle_meta ? 0x80 : 0])
+                                        ((vc)->vc_toggle_meta ? 0x80 : 0)])
 #else
 #define con_set_trans_old(arg) (0)
 #define con_get_trans_old(arg) (-EINVAL)
@@ -86,6 +85,7 @@ int con_copy_unimap(struct vc_data *dst_vc, struct vc_data *src_vc);
 #define con_copy_unimap(d, s) (0)
 #define con_get_unimap(vc, ct, uct, list) (-EINVAL)
 #define con_free_unimap(vc) do { ; } while (0)
+#define con_protect_unimap(vc, rdonly) do { ; } while (0)
 
 #define vc_translate(vc, c) (c)
 #endif