345 files changed, 6334 insertions, 2120 deletions

diff --git a/include/linux/Kbuild b/include/linux/Kbuild
index 01f636275057..619b5657af77 100644
--- a/include/linux/Kbuild
+++ b/include/linux/Kbuild
@@ -135,6 +135,7 @@ header-y += firewire-cdev.h
 header-y += firewire-constants.h
 header-y += flat.h
 header-y += fs.h
+header-y += fsl_hypervisor.h
 header-y += fuse.h
 header-y += futex.h
 header-y += gameport.h
diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index 1deb2a73c2da..6001b4da39dd 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -238,7 +238,6 @@ extern int acpi_paddr_to_node(u64 start_addr, u64 size);
 extern int pnpacpi_disabled;
 
 #define PXM_INVAL       (-1)
-#define NID_INVAL       (-1)
 
 int acpi_check_resource_conflict(const struct resource *res);
 
@@ -280,6 +279,8 @@ acpi_status acpi_run_osc(acpi_handle handle, struct acpi_osc_context *context);
 #define OSC_SB_CPUHP_OST_SUPPORT        8
 #define OSC_SB_APEI_SUPPORT             16
 
+extern bool osc_sb_apei_support_acked;
+
 /* PCI defined _OSC bits */
 /* _OSC DW1 Definition (OS Support Fields) */
 #define OSC_EXT_PCI_CONFIG_SUPPORT              1
diff --git a/include/linux/aer.h b/include/linux/aer.h
index 8414de22a779..544abdb2238c 100644
--- a/include/linux/aer.h
+++ b/include/linux/aer.h
@@ -51,5 +51,8 @@ static inline int pci_cleanup_aer_uncorrect_error_status(struct pci_dev *dev)
 
 extern void cper_print_aer(const char *prefix, int cper_severity,
                            struct aer_capability_regs *aer);
+extern int cper_severity_to_aer(int cper_severity);
+extern void aer_recover_queue(int domain, unsigned int bus, unsigned int devfn,
+                              int severity);
 #endif //_AER_H_
 
diff --git a/include/linux/aio.h b/include/linux/aio.h
index 7a8db4155281..2dcb72bff4b6 100644
--- a/include/linux/aio.h
+++ b/include/linux/aio.h
@@ -7,7 +7,7 @@
 #include <linux/uio.h>
 #include <linux/rcupdate.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 #define AIO_MAXSEGS             4
 #define AIO_KIOGRP_NR_ATOMIC    8
diff --git a/include/linux/amba/pl08x.h b/include/linux/amba/pl08x.h
index 3111385b8ca7..e6e28f37d8ec 100644
--- a/include/linux/amba/pl08x.h
+++ b/include/linux/amba/pl08x.h
@@ -172,8 +172,11 @@ struct pl08x_dma_chan {
         int phychan_hold;
         struct tasklet_struct tasklet;
         char *name;
-        struct pl08x_channel_data *cd;
-        dma_addr_t runtime_addr;
+        const struct pl08x_channel_data *cd;
+        dma_addr_t src_addr;
+        dma_addr_t dst_addr;
+        u32 src_cctl;
+        u32 dst_cctl;
         enum dma_data_direction runtime_direction;
         dma_cookie_t lc;
         struct list_head pend_list;
@@ -202,7 +205,7 @@ struct pl08x_dma_chan {
  * @mem_buses: buses which memory can be accessed from: PL08X_AHB1 | PL08X_AHB2
  */
 struct pl08x_platform_data {
-        struct pl08x_channel_data *slave_channels;
+        const struct pl08x_channel_data *slave_channels;
         unsigned int num_slave_channels;
         struct pl08x_channel_data memcpy_channel;
         int (*get_signal)(struct pl08x_dma_chan *);
diff --git a/include/linux/amba/serial.h b/include/linux/amba/serial.h
index 5479fdc849e9..514ed45c462e 100644
--- a/include/linux/amba/serial.h
+++ b/include/linux/amba/serial.h
@@ -201,6 +201,9 @@ struct amba_pl011_data {
         bool (*dma_filter)(struct dma_chan *chan, void *filter_param);
         void *dma_rx_param;
         void *dma_tx_param;
+        void (*init) (void);
+        void (*exit) (void);
+        void (*reset) (void);
 };
 #endif
 
diff --git a/include/linux/amd-iommu.h b/include/linux/amd-iommu.h
new file mode 100644
index 000000000000..a6863a2dec1f
--- /dev/null
+++ b/include/linux/amd-iommu.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2007-2010 Advanced Micro Devices, Inc.
+ * Author: Joerg Roedel <joerg.roedel@amd.com>
+ *         Leo Duran <leo.duran@amd.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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+
+#ifndef _ASM_X86_AMD_IOMMU_H
+#define _ASM_X86_AMD_IOMMU_H
+
+#include <linux/irqreturn.h>
+
+#ifdef CONFIG_AMD_IOMMU
+
+extern int amd_iommu_detect(void);
+
+#else
+
+static inline int amd_iommu_detect(void) { return -ENODEV; }
+
+#endif
+
+#endif /* _ASM_X86_AMD_IOMMU_H */
diff --git a/include/linux/anon_inodes.h b/include/linux/anon_inodes.h
index 69a21e0ebd33..8013a45242fe 100644
--- a/include/linux/anon_inodes.h
+++ b/include/linux/anon_inodes.h
@@ -8,6 +8,8 @@
 #ifndef _LINUX_ANON_INODES_H
 #define _LINUX_ANON_INODES_H
 
+struct file_operations;
+
 struct file *anon_inode_getfile(const char *name,
                                 const struct file_operations *fops,
                                 void *priv, int flags);
diff --git a/include/linux/arcdevice.h b/include/linux/arcdevice.h
index 7d650a0e3d8f..7216b0daf544 100644
--- a/include/linux/arcdevice.h
+++ b/include/linux/arcdevice.h
@@ -20,6 +20,7 @@
 #include <linux/if_arcnet.h>
 
 #ifdef __KERNEL__
+#include  <linux/irqreturn.h>
 
 #ifndef bool
 #define bool int
diff --git a/include/linux/ath9k_platform.h b/include/linux/ath9k_platform.h
index 60a7c49dcb49..6e3f54f37844 100644
--- a/include/linux/ath9k_platform.h
+++ b/include/linux/ath9k_platform.h
@@ -30,6 +30,8 @@ struct ath9k_platform_data {
         u32 gpio_val;
 
         bool is_clk_25mhz;
+        int (*get_mac_revision)(void);
+        int (*external_reset)(void);
 };
 
 #endif /* _LINUX_ATH9K_PLATFORM_H */
diff --git a/include/linux/atmdev.h b/include/linux/atmdev.h
index 381f4cec8260..49a83ca900ba 100644
--- a/include/linux/atmdev.h
+++ b/include/linux/atmdev.h
@@ -220,7 +220,7 @@ struct atm_cirange {
 #include <linux/skbuff.h> /* struct sk_buff */
 #include <linux/uio.h>
 #include <net/sock.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 #ifdef CONFIG_PROC_FS
 #include <linux/proc_fs.h>
diff --git a/include/linux/atomic.h b/include/linux/atomic.h
index ee456c79b0e6..42b77b5446d2 100644
--- a/include/linux/atomic.h
+++ b/include/linux/atomic.h
@@ -1,8 +1,32 @@
+/* Atomic operations usable in machine independent code */
 #ifndef _LINUX_ATOMIC_H
 #define _LINUX_ATOMIC_H
 #include <asm/atomic.h>
 
 /**
+ * atomic_add_unless - add unless the number is already a given value
+ * @v: pointer of type atomic_t
+ * @a: the amount to add to v...
+ * @u: ...unless v is equal to u.
+ *
+ * Atomically adds @a to @v, so long as @v was not already @u.
+ * Returns non-zero if @v was not @u, and zero otherwise.
+ */
+static inline int atomic_add_unless(atomic_t *v, int a, int u)
+{
+        return __atomic_add_unless(v, a, u) != u;
+}
+
+/**
+ * atomic_inc_not_zero - increment unless the number is zero
+ * @v: pointer of type atomic_t
+ *
+ * Atomically increments @v by 1, so long as @v is non-zero.
+ * Returns non-zero if @v was non-zero, and zero otherwise.
+ */
+#define atomic_inc_not_zero(v)          atomic_add_unless((v), 1, 0)
+
+/**
  * atomic_inc_not_zero_hint - increment if not null
  * @v: pointer of type atomic_t
  * @hint: probable value of the atomic before the increment
@@ -34,6 +58,32 @@ static inline int atomic_inc_not_zero_hint(atomic_t *v, int hint)
 }
 #endif
 
+#ifndef atomic_inc_unless_negative
+static inline int atomic_inc_unless_negative(atomic_t *p)
+{
+        int v, v1;
+        for (v = 0; v >= 0; v = v1) {
+                v1 = atomic_cmpxchg(p, v, v + 1);
+                if (likely(v1 == v))
+                        return 1;
+        }
+        return 0;
+}
+#endif
+
+#ifndef atomic_dec_unless_positive
+static inline int atomic_dec_unless_positive(atomic_t *p)
+{
+        int v, v1;
+        for (v = 0; v <= 0; v = v1) {
+                v1 = atomic_cmpxchg(p, v, v - 1);
+                if (likely(v1 == v))
+                        return 1;
+        }
+        return 0;
+}
+#endif
+
 #ifndef CONFIG_ARCH_HAS_ATOMIC_OR
 static inline void atomic_or(int i, atomic_t *v)
 {
@@ -47,4 +97,8 @@ static inline void atomic_or(int i, atomic_t *v)
 }
 #endif /* #ifndef CONFIG_ARCH_HAS_ATOMIC_OR */
 
+#include <asm-generic/atomic-long.h>
+#ifdef CONFIG_GENERIC_ATOMIC64
+#include <asm-generic/atomic64.h>
+#endif
 #endif /* _LINUX_ATOMIC_H */
diff --git a/include/linux/audit.h b/include/linux/audit.h
index 9d339eb27881..0c8006129fb2 100644
--- a/include/linux/audit.h
+++ b/include/linux/audit.h
@@ -613,6 +613,12 @@ extern void		    audit_log_d_path(struct audit_buffer *ab,
 extern void                 audit_log_key(struct audit_buffer *ab,
                                           char *key);
 extern void                 audit_log_lost(const char *message);
+#ifdef CONFIG_SECURITY
+extern void                 audit_log_secctx(struct audit_buffer *ab, u32 secid);
+#else
+#define audit_log_secctx(b,s) do { ; } while (0)
+#endif
+
 extern int                  audit_update_lsm_rules(void);
 
                                 /* Private API (for audit.c only) */
@@ -635,6 +641,7 @@ extern int audit_enabled;
 #define audit_log_untrustedstring(a,s) do { ; } while (0)
 #define audit_log_d_path(b, p, d) do { ; } while (0)
 #define audit_log_key(b, k) do { ; } while (0)
+#define audit_log_secctx(b,s) do { ; } while (0)
 #define audit_enabled 0
 #endif
 #endif
diff --git a/include/linux/backing-dev.h b/include/linux/backing-dev.h
index 96f4094b706d..3b2f9cb82986 100644
--- a/include/linux/backing-dev.h
+++ b/include/linux/backing-dev.h
@@ -16,7 +16,7 @@
 #include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/writeback.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 struct page;
 struct device;
@@ -40,6 +40,7 @@ typedef int (congested_fn)(void *, int);
 enum bdi_stat_item {
         BDI_RECLAIMABLE,
         BDI_WRITEBACK,
+        BDI_WRITTEN,
         NR_BDI_STAT_ITEMS
 };
 
@@ -57,6 +58,7 @@ struct bdi_writeback {
         struct list_head b_dirty;       /* dirty inodes */
         struct list_head b_io;          /* parked for writeback */
         struct list_head b_more_io;     /* parked for more writeback */
+        spinlock_t list_lock;           /* protects the b_* lists */
 };
 
 struct backing_dev_info {
@@ -71,6 +73,11 @@ struct backing_dev_info {
 
         struct percpu_counter bdi_stat[NR_BDI_STAT_ITEMS];
 
+        unsigned long bw_time_stamp;    /* last time write bw is updated */
+        unsigned long written_stamp;    /* pages written at bw_time_stamp */
+        unsigned long write_bandwidth;  /* the estimated write bandwidth */
+        unsigned long avg_write_bandwidth; /* further smoothed write bw */
+
         struct prop_local_percpu completions;
         int dirty_exceeded;
 
@@ -106,6 +113,7 @@ int bdi_writeback_thread(void *data);
 int bdi_has_dirty_io(struct backing_dev_info *bdi);
 void bdi_arm_supers_timer(void);
 void bdi_wakeup_thread_delayed(struct backing_dev_info *bdi);
+void bdi_lock_two(struct bdi_writeback *wb1, struct bdi_writeback *wb2);
 
 extern spinlock_t bdi_lock;
 extern struct list_head bdi_list;
diff --git a/include/linux/basic_mmio_gpio.h b/include/linux/basic_mmio_gpio.h
index 1ae12710d732..98999cf107ce 100644
--- a/include/linux/basic_mmio_gpio.h
+++ b/include/linux/basic_mmio_gpio.h
@@ -16,6 +16,7 @@
 #include <linux/gpio.h>
 #include <linux/types.h>
 #include <linux/compiler.h>
+#include <linux/spinlock_types.h>
 
 struct bgpio_pdata {
         int base;
diff --git a/include/linux/bcma/bcma.h b/include/linux/bcma/bcma.h
index 08763e4e848f..8c96654bef16 100644
--- a/include/linux/bcma/bcma.h
+++ b/include/linux/bcma/bcma.h
@@ -6,6 +6,7 @@
 
 #include <linux/bcma/bcma_driver_chipcommon.h>
 #include <linux/bcma/bcma_driver_pci.h>
+#include <linux/ssb/ssb.h> /* SPROM sharing */
 
 #include "bcma_regs.h"
 
@@ -24,6 +25,11 @@ struct bcma_chipinfo {
         u8 pkg;
 };
 
+enum bcma_clkmode {
+        BCMA_CLKMODE_FAST,
+        BCMA_CLKMODE_DYNAMIC,
+};
+
 struct bcma_host_ops {
         u8 (*read8)(struct bcma_device *core, u16 offset);
         u16 (*read16)(struct bcma_device *core, u16 offset);
@@ -31,6 +37,12 @@ struct bcma_host_ops {
         void (*write8)(struct bcma_device *core, u16 offset, u8 value);
         void (*write16)(struct bcma_device *core, u16 offset, u16 value);
         void (*write32)(struct bcma_device *core, u16 offset, u32 value);
+#ifdef CONFIG_BCMA_BLOCKIO
+        void (*block_read)(struct bcma_device *core, void *buffer,
+                           size_t count, u16 offset, u8 reg_width);
+        void (*block_write)(struct bcma_device *core, const void *buffer,
+                            size_t count, u16 offset, u8 reg_width);
+#endif
         /* Agent ops */
         u32 (*aread32)(struct bcma_device *core, u16 offset);
         void (*awrite32)(struct bcma_device *core, u16 offset, u32 value);
@@ -117,6 +129,8 @@ struct bcma_device {
         struct bcma_device_id id;
 
         struct device dev;
+        struct device *dma_dev;
+        unsigned int irq;
         bool dev_registered;
 
         u8 core_index;
@@ -179,6 +193,10 @@ struct bcma_bus {
 
         struct bcma_drv_cc drv_cc;
         struct bcma_drv_pci drv_pci;
+
+        /* We decided to share SPROM struct with SSB as long as we do not need
+         * any hacks for BCMA. This simplifies drivers code. */
+        struct ssb_sprom sprom;
 };
 
 extern inline u32 bcma_read8(struct bcma_device *core, u16 offset)
@@ -208,6 +226,18 @@ void bcma_write32(struct bcma_device *core, u16 offset, u32 value)
 {
         core->bus->ops->write32(core, offset, value);
 }
+#ifdef CONFIG_BCMA_BLOCKIO
+extern inline void bcma_block_read(struct bcma_device *core, void *buffer,
+                                   size_t count, u16 offset, u8 reg_width)
+{
+        core->bus->ops->block_read(core, buffer, count, offset, reg_width);
+}
+extern inline void bcma_block_write(struct bcma_device *core, const void *buffer,
+                                    size_t count, u16 offset, u8 reg_width)
+{
+        core->bus->ops->block_write(core, buffer, count, offset, reg_width);
+}
+#endif
 extern inline u32 bcma_aread32(struct bcma_device *core, u16 offset)
 {
         return core->bus->ops->aread32(core, offset);
@@ -218,7 +248,24 @@ void bcma_awrite32(struct bcma_device *core, u16 offset, u32 value)
         core->bus->ops->awrite32(core, offset, value);
 }
 
+#define bcma_mask32(cc, offset, mask) \
+        bcma_write32(cc, offset, bcma_read32(cc, offset) & (mask))
+#define bcma_set32(cc, offset, set) \
+        bcma_write32(cc, offset, bcma_read32(cc, offset) | (set))
+#define bcma_maskset32(cc, offset, mask, set) \
+        bcma_write32(cc, offset, (bcma_read32(cc, offset) & (mask)) | (set))
+
 extern bool bcma_core_is_enabled(struct bcma_device *core);
+extern void bcma_core_disable(struct bcma_device *core, u32 flags);
 extern int bcma_core_enable(struct bcma_device *core, u32 flags);
+extern void bcma_core_set_clockmode(struct bcma_device *core,
+                                    enum bcma_clkmode clkmode);
+extern void bcma_core_pll_ctl(struct bcma_device *core, u32 req, u32 status,
+                              bool on);
+#define BCMA_DMA_TRANSLATION_MASK       0xC0000000
+#define  BCMA_DMA_TRANSLATION_NONE      0x00000000
+#define  BCMA_DMA_TRANSLATION_DMA32_CMT 0x40000000 /* Client Mode Translation for 32-bit DMA */
+#define  BCMA_DMA_TRANSLATION_DMA64_CMT 0x80000000 /* Client Mode Translation for 64-bit DMA */
+extern u32 bcma_core_dma_translation(struct bcma_device *core);
 
 #endif /* LINUX_BCMA_H_ */
diff --git a/include/linux/bcma/bcma_driver_chipcommon.h b/include/linux/bcma/bcma_driver_chipcommon.h
index 083c3b6cd5ce..a0f684615ae5 100644
--- a/include/linux/bcma/bcma_driver_chipcommon.h
+++ b/include/linux/bcma/bcma_driver_chipcommon.h
@@ -179,15 +179,7 @@
 #define BCMA_CC_PROG_WAITCNT            0x0124
 #define BCMA_CC_FLASH_CFG               0x0128
 #define BCMA_CC_FLASH_WAITCNT           0x012C
-#define BCMA_CC_CLKCTLST                0x01E0 /* Clock control and status (rev >= 20) */
-#define  BCMA_CC_CLKCTLST_FORCEALP      0x00000001 /* Force ALP request */
-#define  BCMA_CC_CLKCTLST_FORCEHT       0x00000002 /* Force HT request */
-#define  BCMA_CC_CLKCTLST_FORCEILP      0x00000004 /* Force ILP request */
-#define  BCMA_CC_CLKCTLST_HAVEALPREQ    0x00000008 /* ALP available request */
-#define  BCMA_CC_CLKCTLST_HAVEHTREQ     0x00000010 /* HT available request */
-#define  BCMA_CC_CLKCTLST_HWCROFF       0x00000020 /* Force HW clock request off */
-#define  BCMA_CC_CLKCTLST_HAVEHT        0x00010000 /* HT available */
-#define  BCMA_CC_CLKCTLST_HAVEALP       0x00020000 /* APL available */
+/* 0x1E0 is defined as shared BCMA_CLKCTLST */
 #define BCMA_CC_HW_WORKAROUND           0x01E4 /* Hardware workaround (rev >= 20) */
 #define BCMA_CC_UART0_DATA              0x0300
 #define BCMA_CC_UART0_IMR               0x0304
@@ -244,6 +236,8 @@
 #define BCMA_CC_REGCTL_DATA             0x065C
 #define BCMA_CC_PLLCTL_ADDR             0x0660
 #define BCMA_CC_PLLCTL_DATA             0x0664
+#define BCMA_CC_SPROM                   0x0800 /* SPROM beginning */
+#define BCMA_CC_SPROM_PCIE6             0x0830 /* SPROM beginning on PCIe rev >= 6 */
 
 /* Data for the PMU, if available.
  * Check availability with ((struct bcma_chipcommon)->capabilities & BCMA_CC_CAP_PMU)
diff --git a/include/linux/bcma/bcma_driver_pci.h b/include/linux/bcma/bcma_driver_pci.h
index b7e191cf00ec..3871b668caf9 100644
--- a/include/linux/bcma/bcma_driver_pci.h
+++ b/include/linux/bcma/bcma_driver_pci.h
@@ -85,5 +85,7 @@ struct bcma_drv_pci {
 #define pcicore_write32(pc, offset, val)        bcma_write32((pc)->core, offset, val)
 
 extern void bcma_core_pci_init(struct bcma_drv_pci *pc);
+extern int bcma_core_pci_irq_ctl(struct bcma_drv_pci *pc,
+                                 struct bcma_device *core, bool enable);
 
 #endif /* LINUX_BCMA_DRIVER_PCI_H_ */
diff --git a/include/linux/bcma/bcma_regs.h b/include/linux/bcma/bcma_regs.h
index f82d88a960ce..9faae2ae02e8 100644
--- a/include/linux/bcma/bcma_regs.h
+++ b/include/linux/bcma/bcma_regs.h
@@ -1,13 +1,38 @@
 #ifndef LINUX_BCMA_REGS_H_
 #define LINUX_BCMA_REGS_H_
 
+/* Some single registers are shared between many cores */
+/* BCMA_CLKCTLST: ChipCommon (rev >= 20), PCIe, 80211 */
+#define BCMA_CLKCTLST                   0x01E0 /* Clock control and status */
+#define  BCMA_CLKCTLST_FORCEALP         0x00000001 /* Force ALP request */
+#define  BCMA_CLKCTLST_FORCEHT          0x00000002 /* Force HT request */
+#define  BCMA_CLKCTLST_FORCEILP         0x00000004 /* Force ILP request */
+#define  BCMA_CLKCTLST_HAVEALPREQ       0x00000008 /* ALP available request */
+#define  BCMA_CLKCTLST_HAVEHTREQ        0x00000010 /* HT available request */
+#define  BCMA_CLKCTLST_HWCROFF          0x00000020 /* Force HW clock request off */
+#define  BCMA_CLKCTLST_EXTRESREQ        0x00000700 /* Mask of external resource requests */
+#define  BCMA_CLKCTLST_HAVEALP          0x00010000 /* ALP available */
+#define  BCMA_CLKCTLST_HAVEHT           0x00020000 /* HT available */
+#define  BCMA_CLKCTLST_BP_ON_ALP        0x00040000 /* RO: running on ALP clock */
+#define  BCMA_CLKCTLST_BP_ON_HT         0x00080000 /* RO: running on HT clock */
+#define  BCMA_CLKCTLST_EXTRESST         0x07000000 /* Mask of external resource status */
+/* Is there any BCM4328 on BCMA bus? */
+#define  BCMA_CLKCTLST_4328A0_HAVEHT    0x00010000 /* 4328a0 has reversed bits */
+#define  BCMA_CLKCTLST_4328A0_HAVEALP   0x00020000 /* 4328a0 has reversed bits */
+
 /* Agent registers (common for every core) */
-#define BCMA_IOCTL                      0x0408
+#define BCMA_IOCTL                      0x0408 /* IO control */
 #define  BCMA_IOCTL_CLK                 0x0001
 #define  BCMA_IOCTL_FGC                 0x0002
 #define  BCMA_IOCTL_CORE_BITS           0x3FFC
 #define  BCMA_IOCTL_PME_EN              0x4000
 #define  BCMA_IOCTL_BIST_EN             0x8000
+#define BCMA_IOST                       0x0500 /* IO status */
+#define  BCMA_IOST_CORE_BITS            0x0FFF
+#define  BCMA_IOST_DMA64                0x1000
+#define  BCMA_IOST_GATED_CLK            0x2000
+#define  BCMA_IOST_BIST_ERROR           0x4000
+#define  BCMA_IOST_BIST_DONE            0x8000
 #define BCMA_RESET_CTL                  0x0800
 #define  BCMA_RESET_CTL_RESET           0x0001
 
diff --git a/include/linux/binfmts.h b/include/linux/binfmts.h
index 8845613fd7e3..fd88a3945aa1 100644
--- a/include/linux/binfmts.h
+++ b/include/linux/binfmts.h
@@ -111,6 +111,7 @@ extern int __must_check remove_arg_zero(struct linux_binprm *);
 extern int search_binary_handler(struct linux_binprm *, struct pt_regs *);
 extern int flush_old_exec(struct linux_binprm * bprm);
 extern void setup_new_exec(struct linux_binprm * bprm);
+extern void would_dump(struct linux_binprm *, struct file *);
 
 extern int suid_dumpable;
 #define SUID_DUMP_DISABLE       0       /* No setuid dumping */
diff --git a/include/linux/bit_spinlock.h b/include/linux/bit_spinlock.h
index b4326bfa684f..ac4d9f8b52e9 100644
--- a/include/linux/bit_spinlock.h
+++ b/include/linux/bit_spinlock.h
@@ -3,7 +3,7 @@
 
 #include <linux/kernel.h>
 #include <linux/preempt.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 /*
  *  bit-based spin_lock()
@@ -88,7 +88,7 @@ static inline int bit_spin_is_locked(int bitnum, unsigned long *addr)
 {
 #if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
         return test_bit(bitnum, addr);
-#elif defined CONFIG_PREEMPT
+#elif defined CONFIG_PREEMPT_COUNT
         return preempt_count();
 #else
         return 1;
diff --git a/include/linux/bitmap.h b/include/linux/bitmap.h
index dcafe0bf0005..7ad634501e48 100644
--- a/include/linux/bitmap.h
+++ b/include/linux/bitmap.h
@@ -144,7 +144,9 @@ extern int bitmap_find_free_region(unsigned long *bitmap, int bits, int order);
 extern void bitmap_release_region(unsigned long *bitmap, int pos, int order);
 extern int bitmap_allocate_region(unsigned long *bitmap, int pos, int order);
 extern void bitmap_copy_le(void *dst, const unsigned long *src, int nbits);
+extern int bitmap_ord_to_pos(const unsigned long *bitmap, int n, int bits);
 
+#define BITMAP_FIRST_WORD_MASK(start) (~0UL << ((start) % BITS_PER_LONG))
 #define BITMAP_LAST_WORD_MASK(nbits)                                    \
 (                                                                       \
         ((nbits) % BITS_PER_LONG) ?                                     \
diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h
index 2a7cea53ca0d..6395692b2e7a 100644
--- a/include/linux/blk_types.h
+++ b/include/linux/blk_types.h
@@ -167,7 +167,7 @@ enum rq_flag_bits {
         (REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER)
 #define REQ_COMMON_MASK \
         (REQ_WRITE | REQ_FAILFAST_MASK | REQ_SYNC | REQ_META | REQ_DISCARD | \
-         REQ_NOIDLE | REQ_FLUSH | REQ_FUA)
+         REQ_NOIDLE | REQ_FLUSH | REQ_FUA | REQ_SECURE)
 #define REQ_CLONE_MASK          REQ_COMMON_MASK
 
 #define REQ_RAHEAD              (1 << __REQ_RAHEAD)
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index ae9091a68480..0e67c45b3bc9 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -73,7 +73,7 @@ enum rq_cmd_type_bits {
 
 /*
  * try to put the fields that are referenced together in the same cacheline.
- * if you modify this structure, be sure to check block/blk-core.c:rq_init()
+ * if you modify this structure, be sure to check block/blk-core.c:blk_rq_init()
  * as well!
  */
 struct request {
@@ -260,8 +260,7 @@ struct queue_limits {
         unsigned char           discard_zeroes_data;
 };
 
-struct request_queue
-{
+struct request_queue {
         /*
          * Together with queue_head for cacheline sharing
          */
@@ -304,14 +303,14 @@ struct request_queue
         void                    *queuedata;
 
         /*
-         * queue needs bounce pages for pages above this limit
+         * various queue flags, see QUEUE_* below
          */
-        gfp_t                   bounce_gfp;
+        unsigned long           queue_flags;
 
         /*
-         * various queue flags, see QUEUE_* below
+         * queue needs bounce pages for pages above this limit
          */
-        unsigned long           queue_flags;
+        gfp_t                   bounce_gfp;
 
         /*
          * protects queue structures from reentrancy. ->__queue_lock should
@@ -334,8 +333,8 @@ struct request_queue
         unsigned int            nr_congestion_off;
         unsigned int            nr_batching;
 
-        void                    *dma_drain_buffer;
         unsigned int            dma_drain_size;
+        void                    *dma_drain_buffer;
         unsigned int            dma_pad_mask;
         unsigned int            dma_alignment;
 
@@ -393,7 +392,7 @@ struct request_queue
 #define QUEUE_FLAG_ELVSWITCH    6       /* don't use elevator, just do FIFO */
 #define QUEUE_FLAG_BIDI         7       /* queue supports bidi requests */
 #define QUEUE_FLAG_NOMERGES     8       /* disable merge attempts */
-#define QUEUE_FLAG_SAME_COMP    9       /* force complete on same CPU */
+#define QUEUE_FLAG_SAME_COMP    9       /* complete on same CPU-group */
 #define QUEUE_FLAG_FAIL_IO     10       /* fake timeout */
 #define QUEUE_FLAG_STACKABLE   11       /* supports request stacking */
 #define QUEUE_FLAG_NONROT      12       /* non-rotational device (SSD) */
@@ -403,6 +402,7 @@ struct request_queue
 #define QUEUE_FLAG_NOXMERGES   15       /* No extended merges */
 #define QUEUE_FLAG_ADD_RANDOM  16       /* Contributes to random pool */
 #define QUEUE_FLAG_SECDISCARD  17       /* supports SECDISCARD */
+#define QUEUE_FLAG_SAME_FORCE  18       /* force complete on same CPU */
 
 #define QUEUE_FLAG_DEFAULT      ((1 << QUEUE_FLAG_IO_STAT) |            \
                                  (1 << QUEUE_FLAG_STACKABLE)    |       \
@@ -857,12 +857,21 @@ struct request_queue *blk_alloc_queue(gfp_t);
 struct request_queue *blk_alloc_queue_node(gfp_t, int);
 extern void blk_put_queue(struct request_queue *);
 
+/*
+ * Note: Code in between changing the blk_plug list/cb_list or element of such
+ * lists is preemptable, but such code can't do sleep (or be very careful),
+ * otherwise data is corrupted. For details, please check schedule() where
+ * blk_schedule_flush_plug() is called.
+ */
 struct blk_plug {
         unsigned long magic;
         struct list_head list;
         struct list_head cb_list;
         unsigned int should_sort;
+        unsigned int count;
 };
+#define BLK_MAX_REQUEST_COUNT 16
+
 struct blk_plug_cb {
         struct list_head list;
         void (*callback)(struct blk_plug_cb *);
@@ -1282,8 +1291,8 @@ queue_max_integrity_segments(struct request_queue *q)
 #define blk_get_integrity(a)                    (0)
 #define blk_integrity_compare(a, b)             (0)
 #define blk_integrity_register(a, b)            (0)
-#define blk_integrity_unregister(a)             do { } while (0);
-#define blk_queue_max_integrity_segments(a, b)  do { } while (0);
+#define blk_integrity_unregister(a)             do { } while (0)
+#define blk_queue_max_integrity_segments(a, b)  do { } while (0)
 #define queue_max_integrity_segments(a)         (0)
 #define blk_integrity_merge_rq(a, b, c)         (0)
 #define blk_integrity_merge_bio(a, b, c)        (0)
diff --git a/include/linux/blktrace_api.h b/include/linux/blktrace_api.h
index b22fb0d3db0f..8c7c2de7631a 100644
--- a/include/linux/blktrace_api.h
+++ b/include/linux/blktrace_api.h
@@ -169,7 +169,8 @@ extern void blk_trace_shutdown(struct request_queue *);
 extern int do_blk_trace_setup(struct request_queue *q, char *name,
                               dev_t dev, struct block_device *bdev,
                               struct blk_user_trace_setup *buts);
-extern void __trace_note_message(struct blk_trace *, const char *fmt, ...);
+extern __attribute__((format(printf, 2, 3)))
+void __trace_note_message(struct blk_trace *, const char *fmt, ...);
 
 /**
  * blk_add_trace_msg - Add a (simple) message to the blktrace stream
diff --git a/include/linux/buffer_head.h b/include/linux/buffer_head.h
index 503c8a6b3079..458f497738a4 100644
--- a/include/linux/buffer_head.h
+++ b/include/linux/buffer_head.h
@@ -12,7 +12,7 @@
 #include <linux/linkage.h>
 #include <linux/pagemap.h>
 #include <linux/wait.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 #ifdef CONFIG_BLOCK
 
diff --git a/include/linux/ceph/libceph.h b/include/linux/ceph/libceph.h
index 6365f041745b..563755181c1e 100644
--- a/include/linux/ceph/libceph.h
+++ b/include/linux/ceph/libceph.h
@@ -35,7 +35,7 @@
 #define CEPH_OPT_MYIP             (1<<2) /* specified my ip */
 #define CEPH_OPT_NOCRC            (1<<3) /* no data crc on writes */
 
-#define CEPH_OPT_DEFAULT   (0);
+#define CEPH_OPT_DEFAULT   (0)
 
 #define ceph_set_opt(client, opt) \
         (client)->options->flags |= CEPH_OPT_##opt;
diff --git a/include/linux/ceph/messenger.h b/include/linux/ceph/messenger.h
index 31d91a64838b..d7adf151d335 100644
--- a/include/linux/ceph/messenger.h
+++ b/include/linux/ceph/messenger.h
@@ -94,6 +94,7 @@ struct ceph_msg {
         bool more_to_follow;
         bool needs_out_seq;
         int front_max;
+        unsigned long ack_stamp;        /* tx: when we were acked */
 
         struct ceph_msgpool *pool;
 };
diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h
index ab4ac0ccb857..da7e4bc34e8c 100644
--- a/include/linux/cgroup.h
+++ b/include/linux/cgroup.h
@@ -539,7 +539,6 @@ static inline struct cgroup_subsys_state *cgroup_subsys_state(
  */
 #define task_subsys_state_check(task, subsys_id, __c)                   \
         rcu_dereference_check(task->cgroups->subsys[subsys_id],         \
-                              rcu_read_lock_held() ||                   \
                               lockdep_is_held(&task->alloc_lock) ||     \
                               cgroup_lock_is_held() || (__c))
 
diff --git a/include/linux/clocksource.h b/include/linux/clocksource.h
index d4646b48dc4a..139c4db55f17 100644
--- a/include/linux/clocksource.h
+++ b/include/linux/clocksource.h
@@ -22,6 +22,10 @@
 typedef u64 cycle_t;
 struct clocksource;
 
+#ifdef CONFIG_ARCH_CLOCKSOURCE_DATA
+#include <asm/clocksource.h>
+#endif
+
 /**
  * struct cyclecounter - hardware abstraction for a free running counter
  *      Provides completely state-free accessors to the underlying hardware.
@@ -153,7 +157,7 @@ extern u64 timecounter_cyc2time(struct timecounter *tc,
  * @shift:              cycle to nanosecond divisor (power of two)
  * @max_idle_ns:        max idle time permitted by the clocksource (nsecs)
  * @flags:              flags describing special properties
- * @vread:              vsyscall based read
+ * @archdata:           arch-specific data
  * @suspend:            suspend function for the clocksource, if necessary
  * @resume:             resume function for the clocksource, if necessary
  */
@@ -169,16 +173,13 @@ struct clocksource {
         u32 shift;
         u64 max_idle_ns;
 
-#ifdef CONFIG_IA64
-        void *fsys_mmio;        /* used by fsyscall asm code */
-#define CLKSRC_FSYS_MMIO_SET(mmio, addr)      ((mmio) = (addr))
-#else
-#define CLKSRC_FSYS_MMIO_SET(mmio, addr)      do { } while (0)
+#ifdef CONFIG_ARCH_CLOCKSOURCE_DATA
+        struct arch_clocksource_data archdata;
 #endif
+
         const char *name;
         struct list_head list;
         int rating;
-        cycle_t (*vread)(void);
         int (*enable)(struct clocksource *cs);
         void (*disable)(struct clocksource *cs);
         unsigned long flags;
@@ -188,6 +189,7 @@ struct clocksource {
 #ifdef CONFIG_CLOCKSOURCE_WATCHDOG
         /* Watchdog related data, used by the framework */
         struct list_head wd_list;
+        cycle_t cs_last;
         cycle_t wd_last;
 #endif
 } ____cacheline_aligned;
diff --git a/include/linux/cn_proc.h b/include/linux/cn_proc.h
index 47dac5ea8d3a..12c517b51ca2 100644
--- a/include/linux/cn_proc.h
+++ b/include/linux/cn_proc.h
@@ -53,6 +53,7 @@ struct proc_event {
                 PROC_EVENT_UID  = 0x00000004,
                 PROC_EVENT_GID  = 0x00000040,
                 PROC_EVENT_SID  = 0x00000080,
+                PROC_EVENT_PTRACE = 0x00000100,
                 /* "next" should be 0x00000400 */
                 /* "last" is the last process event: exit */
                 PROC_EVENT_EXIT = 0x80000000
@@ -95,6 +96,13 @@ struct proc_event {
                         __kernel_pid_t process_tgid;
                 } sid;
 
+                struct ptrace_proc_event {
+                        __kernel_pid_t process_pid;
+                        __kernel_pid_t process_tgid;
+                        __kernel_pid_t tracer_pid;
+                        __kernel_pid_t tracer_tgid;
+                } ptrace;
+
                 struct exit_proc_event {
                         __kernel_pid_t process_pid;
                         __kernel_pid_t process_tgid;
@@ -109,6 +117,7 @@ void proc_fork_connector(struct task_struct *task);
 void proc_exec_connector(struct task_struct *task);
 void proc_id_connector(struct task_struct *task, int which_id);
 void proc_sid_connector(struct task_struct *task);
+void proc_ptrace_connector(struct task_struct *task, int which_id);
 void proc_exit_connector(struct task_struct *task);
 #else
 static inline void proc_fork_connector(struct task_struct *task)
@@ -124,6 +133,10 @@ static inline void proc_id_connector(struct task_struct *task,
 static inline void proc_sid_connector(struct task_struct *task)
 {}
 
+static inline void proc_ptrace_connector(struct task_struct *task,
+                                         int ptrace_id)
+{}
+
 static inline void proc_exit_connector(struct task_struct *task)
 {}
 #endif  /* CONFIG_PROC_EVENTS */
diff --git a/include/linux/compat.h b/include/linux/compat.h
index ddcb7db38e67..8779405e15a8 100644
--- a/include/linux/compat.h
+++ b/include/linux/compat.h
@@ -438,16 +438,7 @@ asmlinkage long compat_sys_ppoll(struct pollfd __user *ufds,
                                  struct compat_timespec __user *tsp,
                                  const compat_sigset_t __user *sigmask,
                                  compat_size_t sigsetsize);
-#if (defined(CONFIG_NFSD) || defined(CONFIG_NFSD_MODULE)) && \
-        !defined(CONFIG_NFSD_DEPRECATED)
-union compat_nfsctl_res;
-struct compat_nfsctl_arg;
-asmlinkage long compat_sys_nfsservctl(int cmd,
-                                      struct compat_nfsctl_arg __user *arg,
-                                      union compat_nfsctl_res __user *res);
-#else
 asmlinkage long compat_sys_nfsservctl(int cmd, void *notused, void *notused2);
-#endif
 asmlinkage long compat_sys_signalfd4(int ufd,
                                      const compat_sigset_t __user *sigmask,
                                      compat_size_t sigsetsize, int flags);
@@ -467,6 +458,8 @@ asmlinkage long compat_sys_setsockopt(int fd, int level, int optname,
                                       char __user *optval, unsigned int optlen);
 asmlinkage long compat_sys_sendmsg(int fd, struct compat_msghdr __user *msg,
                                    unsigned flags);
+asmlinkage long compat_sys_sendmmsg(int fd, struct compat_mmsghdr __user *mmsg,
+                                    unsigned vlen, unsigned int flags);
 asmlinkage long compat_sys_recvmsg(int fd, struct compat_msghdr __user *msg,
                                    unsigned int flags);
 asmlinkage long compat_sys_recv(int fd, void __user *buf, size_t len,
diff --git a/include/linux/configfs.h b/include/linux/configfs.h
index 645778ad899b..3081c58d696e 100644
--- a/include/linux/configfs.h
+++ b/include/linux/configfs.h
@@ -42,7 +42,7 @@
 #include <linux/mutex.h>
 #include <linux/err.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 #define CONFIGFS_ITEM_NAME_LEN  20
 
diff --git a/include/linux/connector.h b/include/linux/connector.h
index 7c60d0942adb..0c69ad825b39 100644
--- a/include/linux/connector.h
+++ b/include/linux/connector.h
@@ -44,7 +44,7 @@
 #define CN_VAL_DRBD                     0x1
 #define CN_KVP_IDX                      0x9     /* HyperV KVP */
 
-#define CN_NETLINK_USERS                9
+#define CN_NETLINK_USERS                10      /* Highest index + 1 */
 
 /*
  * Maximum connector's message size.
@@ -75,7 +75,7 @@ struct cn_msg {
 
 #ifdef __KERNEL__
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 #include <linux/list.h>
 #include <linux/workqueue.h>
diff --git a/include/linux/cordic.h b/include/linux/cordic.h
new file mode 100644
index 000000000000..f932093e20c2
--- /dev/null
+++ b/include/linux/cordic.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2011 Broadcom Corporation
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+#ifndef __CORDIC_H_
+#define __CORDIC_H_
+
+#include <linux/types.h>
+
+/**
+ * struct cordic_iq - i/q coordinate.
+ *
+ * @i: real part of coordinate (in phase).
+ * @q: imaginary part of coordinate (quadrature).
+ */
+struct cordic_iq {
+        s32 i;
+        s32 q;
+};
+
+/**
+ * cordic_calc_iq() - calculates the i/q coordinate for given angle.
+ *
+ * @theta: angle in degrees for which i/q coordinate is to be calculated.
+ * @coord: function output parameter holding the i/q coordinate.
+ *
+ * The function calculates the i/q coordinate for a given angle using
+ * cordic algorithm. The coordinate consists of a real (i) and an
+ * imaginary (q) part. The real part is essentially the cosine of the
+ * angle and the imaginary part is the sine of the angle. The returned
+ * values are scaled by 2^16 for precision. The range for theta is
+ * for -180 degrees to +180 degrees. Passed values outside this range are
+ * converted before doing the actual calculation.
+ */
+struct cordic_iq cordic_calc_iq(s32 theta);
+
+#endif /* __CORDIC_H_ */
diff --git a/include/linux/cpu.h b/include/linux/cpu.h
index 5f09323ee880..b1a635acf72a 100644
--- a/include/linux/cpu.h
+++ b/include/linux/cpu.h
@@ -70,6 +70,39 @@ enum {
         CPU_PRI_WORKQUEUE       = 5,
 };
 
+#define CPU_ONLINE              0x0002 /* CPU (unsigned)v is up */
+#define CPU_UP_PREPARE          0x0003 /* CPU (unsigned)v coming up */
+#define CPU_UP_CANCELED         0x0004 /* CPU (unsigned)v NOT coming up */
+#define CPU_DOWN_PREPARE        0x0005 /* CPU (unsigned)v going down */
+#define CPU_DOWN_FAILED         0x0006 /* CPU (unsigned)v NOT going down */
+#define CPU_DEAD                0x0007 /* CPU (unsigned)v dead */
+#define CPU_DYING               0x0008 /* CPU (unsigned)v not running any task,
+                                        * not handling interrupts, soon dead.
+                                        * Called on the dying cpu, interrupts
+                                        * are already disabled. Must not
+                                        * sleep, must not fail */
+#define CPU_POST_DEAD           0x0009 /* CPU (unsigned)v dead, cpu_hotplug
+                                        * lock is dropped */
+#define CPU_STARTING            0x000A /* CPU (unsigned)v soon running.
+                                        * Called on the new cpu, just before
+                                        * enabling interrupts. Must not sleep,
+                                        * must not fail */
+
+/* Used for CPU hotplug events occurring while tasks are frozen due to a suspend
+ * operation in progress
+ */
+#define CPU_TASKS_FROZEN        0x0010
+
+#define CPU_ONLINE_FROZEN       (CPU_ONLINE | CPU_TASKS_FROZEN)
+#define CPU_UP_PREPARE_FROZEN   (CPU_UP_PREPARE | CPU_TASKS_FROZEN)
+#define CPU_UP_CANCELED_FROZEN  (CPU_UP_CANCELED | CPU_TASKS_FROZEN)
+#define CPU_DOWN_PREPARE_FROZEN (CPU_DOWN_PREPARE | CPU_TASKS_FROZEN)
+#define CPU_DOWN_FAILED_FROZEN  (CPU_DOWN_FAILED | CPU_TASKS_FROZEN)
+#define CPU_DEAD_FROZEN         (CPU_DEAD | CPU_TASKS_FROZEN)
+#define CPU_DYING_FROZEN        (CPU_DYING | CPU_TASKS_FROZEN)
+#define CPU_STARTING_FROZEN     (CPU_STARTING | CPU_TASKS_FROZEN)
+
+
 #ifdef CONFIG_SMP
 /* Need to know about CPUs going up/down? */
 #if defined(CONFIG_HOTPLUG_CPU) || !defined(MODULE)
diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h
index 11be48e0d168..6216115c7789 100644
--- a/include/linux/cpufreq.h
+++ b/include/linux/cpufreq.h
@@ -324,11 +324,16 @@ static inline unsigned int cpufreq_get(unsigned int cpu)
 /* query the last known CPU freq (in kHz). If zero, cpufreq couldn't detect it */
 #ifdef CONFIG_CPU_FREQ
 unsigned int cpufreq_quick_get(unsigned int cpu);
+unsigned int cpufreq_quick_get_max(unsigned int cpu);
 #else
 static inline unsigned int cpufreq_quick_get(unsigned int cpu)
 {
         return 0;
 }
+static inline unsigned int cpufreq_quick_get_max(unsigned int cpu)
+{
+        return 0;
+}
 #endif
 
 
diff --git a/include/linux/cpuidle.h b/include/linux/cpuidle.h
index 36719ead50e8..b51629e15cfc 100644
--- a/include/linux/cpuidle.h
+++ b/include/linux/cpuidle.h
@@ -122,6 +122,8 @@ struct cpuidle_driver {
 };
 
 #ifdef CONFIG_CPU_IDLE
+extern void disable_cpuidle(void);
+extern int cpuidle_idle_call(void);
 
 extern int cpuidle_register_driver(struct cpuidle_driver *drv);
 struct cpuidle_driver *cpuidle_get_driver(void);
@@ -135,6 +137,8 @@ extern int cpuidle_enable_device(struct cpuidle_device *dev);
 extern void cpuidle_disable_device(struct cpuidle_device *dev);
 
 #else
+static inline void disable_cpuidle(void) { }
+static inline int cpuidle_idle_call(void) { return -ENODEV; }
 
 static inline int cpuidle_register_driver(struct cpuidle_driver *drv)
 {return -ENODEV; }
diff --git a/include/linux/cpumask.h b/include/linux/cpumask.h
index b24ac56477b4..4f7a63237471 100644
--- a/include/linux/cpumask.h
+++ b/include/linux/cpumask.h
@@ -617,6 +617,20 @@ static inline size_t cpumask_size(void)
  *        ... use 'tmpmask' like a normal struct cpumask * ...
  *
  *      free_cpumask_var(tmpmask);
+ *
+ *
+ * However, one notable exception is there. alloc_cpumask_var() allocates
+ * only nr_cpumask_bits bits (in the other hand, real cpumask_t always has
+ * NR_CPUS bits). Therefore you don't have to dereference cpumask_var_t.
+ *
+ *      cpumask_var_t tmpmask;
+ *      if (!alloc_cpumask_var(&tmpmask, GFP_KERNEL))
+ *              return -ENOMEM;
+ *
+ *      var = *tmpmask;
+ *
+ * This code makes NR_CPUS length memcopy and brings to a memory corruption.
+ * cpumask_copy() provide safe copy functionality.
  */
 #ifdef CONFIG_CPUMASK_OFFSTACK
 typedef struct cpumask *cpumask_var_t;
diff --git a/include/linux/crc8.h b/include/linux/crc8.h
new file mode 100644
index 000000000000..13c8dabb0441
--- /dev/null
+++ b/include/linux/crc8.h
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2011 Broadcom Corporation
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+#ifndef __CRC8_H_
+#define __CRC8_H_
+
+#include <linux/types.h>
+
+/* see usage of this value in crc8() description */
+#define CRC8_INIT_VALUE         0xFF
+
+/*
+ * Return value of crc8() indicating valid message+crc. This is true
+ * if a CRC is inverted before transmission. The CRC computed over the
+ * whole received bitstream is _table[x], where x is the bit pattern
+ * of the modification (almost always 0xff).
+ */
+#define CRC8_GOOD_VALUE(_table) (_table[0xFF])
+
+/* required table size for crc8 algorithm */
+#define CRC8_TABLE_SIZE                 256
+
+/* helper macro assuring right table size is used */
+#define DECLARE_CRC8_TABLE(_table) \
+        static u8 _table[CRC8_TABLE_SIZE]
+
+/**
+ * crc8_populate_lsb - fill crc table for given polynomial in regular bit order.
+ *
+ * @table:      table to be filled.
+ * @polynomial: polynomial for which table is to be filled.
+ *
+ * This function fills the provided table according the polynomial provided for
+ * regular bit order (lsb first). Polynomials in CRC algorithms are typically
+ * represented as shown below.
+ *
+ *      poly = x^8 + x^7 + x^6 + x^4 + x^2 + 1
+ *
+ * For lsb first direction x^7 maps to the lsb. So the polynomial is as below.
+ *
+ * - lsb first: poly = 10101011(1) = 0xAB
+ */
+void crc8_populate_lsb(u8 table[CRC8_TABLE_SIZE], u8 polynomial);
+
+/**
+ * crc8_populate_msb - fill crc table for given polynomial in reverse bit order.
+ *
+ * @table:      table to be filled.
+ * @polynomial: polynomial for which table is to be filled.
+ *
+ * This function fills the provided table according the polynomial provided for
+ * reverse bit order (msb first). Polynomials in CRC algorithms are typically
+ * represented as shown below.
+ *
+ *      poly = x^8 + x^7 + x^6 + x^4 + x^2 + 1
+ *
+ * For msb first direction x^7 maps to the msb. So the polynomial is as below.
+ *
+ * - msb first: poly = (1)11010101 = 0xD5
+ */
+void crc8_populate_msb(u8 table[CRC8_TABLE_SIZE], u8 polynomial);
+
+/**
+ * crc8() - calculate a crc8 over the given input data.
+ *
+ * @table:      crc table used for calculation.
+ * @pdata:      pointer to data buffer.
+ * @nbytes:     number of bytes in data buffer.
+ * @crc:        previous returned crc8 value.
+ *
+ * The CRC8 is calculated using the polynomial given in crc8_populate_msb()
+ * or crc8_populate_lsb().
+ *
+ * The caller provides the initial value (either %CRC8_INIT_VALUE
+ * or the previous returned value) to allow for processing of
+ * discontiguous blocks of data.  When generating the CRC the
+ * caller is responsible for complementing the final return value
+ * and inserting it into the byte stream.  When validating a byte
+ * stream (including CRC8), a final return value of %CRC8_GOOD_VALUE
+ * indicates the byte stream data can be considered valid.
+ *
+ * Reference:
+ * "A Painless Guide to CRC Error Detection Algorithms", ver 3, Aug 1993
+ * Williams, Ross N., ross<at>ross.net
+ * (see URL http://www.ross.net/crc/download/crc_v3.txt).
+ */
+u8 crc8(const u8 table[CRC8_TABLE_SIZE], u8 *pdata, size_t nbytes, u8 crc);
+
+#endif /* __CRC8_H_ */
diff --git a/include/linux/cred.h b/include/linux/cred.h
index 82607992f308..98f46efbe2d2 100644
--- a/include/linux/cred.h
+++ b/include/linux/cred.h
@@ -16,7 +16,7 @@
 #include <linux/init.h>
 #include <linux/key.h>
 #include <linux/selinux.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 struct user_struct;
 struct cred;
@@ -265,10 +265,11 @@ static inline void put_cred(const struct cred *_cred)
 /**
  * current_cred - Access the current task's subjective credentials
  *
- * Access the subjective credentials of the current task.
+ * Access the subjective credentials of the current task.  RCU-safe,
+ * since nobody else can modify it.
  */
 #define current_cred() \
-        (current->cred)
+        (*(__force struct cred **)&current->cred)
 
 /**
  * __task_cred - Access a task's objective credentials
@@ -284,7 +285,6 @@ static inline void put_cred(const struct cred *_cred)
         ({                                                              \
                 const struct task_struct *__t = (task);                 \
                 rcu_dereference_check(__t->real_cred,                   \
-                                      rcu_read_lock_held() ||           \
                                       task_is_dead(__t));               \
         })
 
@@ -308,7 +308,7 @@ static inline void put_cred(const struct cred *_cred)
 ({                                                      \
         struct user_struct *__u;                        \
         struct cred *__cred;                            \
-        __cred = (struct cred *) current_cred();        \
+        __cred = current_cred();                        \
         __u = get_uid(__cred->user);                    \
         __u;                                            \
 })
@@ -323,7 +323,7 @@ static inline void put_cred(const struct cred *_cred)
 ({                                                      \
         struct group_info *__groups;                    \
         struct cred *__cred;                            \
-        __cred = (struct cred *) current_cred();        \
+        __cred = current_cred();                        \
         __groups = get_group_info(__cred->group_info);  \
         __groups;                                       \
 })
@@ -342,7 +342,7 @@ static inline void put_cred(const struct cred *_cred)
 
 #define current_cred_xxx(xxx)                   \
 ({                                              \
-        current->cred->xxx;                     \
+        current_cred()->xxx;                    \
 })
 
 #define current_uid()           (current_cred_xxx(uid))
diff --git a/include/linux/crypto.h b/include/linux/crypto.h
index a6a7a1c83f54..e5e468e9133d 100644
--- a/include/linux/crypto.h
+++ b/include/linux/crypto.h
@@ -17,7 +17,7 @@
 #ifndef _LINUX_CRYPTO_H
 #define _LINUX_CRYPTO_H
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/list.h>
diff --git a/include/linux/cryptohash.h b/include/linux/cryptohash.h
index ec78a4bbe1d5..2cd9f1cf9fa3 100644
--- a/include/linux/cryptohash.h
+++ b/include/linux/cryptohash.h
@@ -3,11 +3,16 @@
 
 #define SHA_DIGEST_WORDS 5
 #define SHA_MESSAGE_BYTES (512 /*bits*/ / 8)
-#define SHA_WORKSPACE_WORDS 80
+#define SHA_WORKSPACE_WORDS 16
 
 void sha_init(__u32 *buf);
 void sha_transform(__u32 *digest, const char *data, __u32 *W);
 
+#define MD5_DIGEST_WORDS 4
+#define MD5_MESSAGE_BYTES 64
+
+void md5_transform(__u32 *hash, __u32 const *in);
+
 __u32 half_md4_transform(__u32 buf[4], __u32 const in[8]);
 
 #endif
diff --git a/include/linux/cs5535.h b/include/linux/cs5535.h
index 6fe2114f8ad2..c077aec3a6ff 100644
--- a/include/linux/cs5535.h
+++ b/include/linux/cs5535.h
@@ -11,6 +11,8 @@
 #ifndef _CS5535_H
 #define _CS5535_H
 
+#include <asm/msr.h>
+
 /* MSRs */
 #define MSR_GLIU_P2D_RO0        0x10000029
 
@@ -38,17 +40,75 @@
 #define MSR_MFGPT_NR            0x51400029
 #define MSR_MFGPT_SETUP         0x5140002B
 
+#define MSR_RTC_DOMA_OFFSET     0x51400055
+#define MSR_RTC_MONA_OFFSET     0x51400056
+#define MSR_RTC_CEN_OFFSET      0x51400057
+
 #define MSR_LX_SPARE_MSR        0x80000011      /* DC-specific */
 
 #define MSR_GX_GLD_MSR_CONFIG   0xC0002001
 #define MSR_GX_MSR_PADSEL       0xC0002011
 
+static inline int cs5535_pic_unreqz_select_high(unsigned int group,
+                                                unsigned int irq)
+{
+        uint32_t lo, hi;
+
+        rdmsr(MSR_PIC_ZSEL_HIGH, lo, hi);
+        lo &= ~(0xF << (group * 4));
+        lo |= (irq & 0xF) << (group * 4);
+        wrmsr(MSR_PIC_ZSEL_HIGH, lo, hi);
+        return 0;
+}
+
+/* PIC registers */
+#define CS5536_PIC_INT_SEL1     0x4d0
+#define CS5536_PIC_INT_SEL2     0x4d1
+
 /* resource sizes */
 #define LBAR_GPIO_SIZE          0xFF
 #define LBAR_MFGPT_SIZE         0x40
 #define LBAR_ACPI_SIZE          0x40
 #define LBAR_PMS_SIZE           0x80
 
+/*
+ * PMC registers (PMS block)
+ * It is only safe to access these registers as dword accesses.
+ * See CS5536 Specification Update erratas 17 & 18
+ */
+#define CS5536_PM_SCLK          0x10
+#define CS5536_PM_IN_SLPCTL     0x20
+#define CS5536_PM_WKXD          0x34
+#define CS5536_PM_WKD           0x30
+#define CS5536_PM_SSC           0x54
+
+/*
+ * PM registers (ACPI block)
+ * It is only safe to access these registers as dword accesses.
+ * See CS5536 Specification Update erratas 17 & 18
+ */
+#define CS5536_PM1_STS          0x00
+#define CS5536_PM1_EN           0x02
+#define CS5536_PM1_CNT          0x08
+#define CS5536_PM_GPE0_STS      0x18
+#define CS5536_PM_GPE0_EN       0x1c
+
+/* CS5536_PM1_STS bits */
+#define CS5536_WAK_FLAG         (1 << 15)
+#define CS5536_PWRBTN_FLAG      (1 << 8)
+
+/* CS5536_PM1_EN bits */
+#define CS5536_PM_PWRBTN        (1 << 8)
+#define CS5536_PM_RTC           (1 << 10)
+
+/* CS5536_PM_GPE0_STS bits */
+#define CS5536_GPIOM7_PME_FLAG  (1 << 31)
+#define CS5536_GPIOM6_PME_FLAG  (1 << 30)
+
+/* CS5536_PM_GPE0_EN bits */
+#define CS5536_GPIOM7_PME_EN    (1 << 31)
+#define CS5536_GPIOM6_PME_EN    (1 << 30)
+
 /* VSA2 magic values */
 #define VSA_VRC_INDEX           0xAC1C
 #define VSA_VRC_DATA            0xAC1E
diff --git a/include/linux/ctype.h b/include/linux/ctype.h
index a3d6ee0044f9..8acfe312f947 100644
--- a/include/linux/ctype.h
+++ b/include/linux/ctype.h
@@ -52,4 +52,13 @@ static inline unsigned char __toupper(unsigned char c)
 #define tolower(c) __tolower(c)
 #define toupper(c) __toupper(c)
 
+/*
+ * Fast implementation of tolower() for internal usage. Do not use in your
+ * code.
+ */
+static inline char _tolower(const char c)
+{
+        return c | 0x20;
+}
+
 #endif
diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index 19d90a55541d..62157c03caf7 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -1,7 +1,7 @@
 #ifndef __LINUX_DCACHE_H
 #define __LINUX_DCACHE_H
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <linux/list.h>
 #include <linux/rculist.h>
 #include <linux/rculist_bl.h>
@@ -180,12 +180,12 @@ struct dentry_operations {
  */
 
 /* d_flags entries */
-#define DCACHE_AUTOFS_PENDING 0x0001    /* autofs: "under construction" */
-#define DCACHE_NFSFS_RENAMED  0x0002
-     /* this dentry has been "silly renamed" and has to be deleted on the last
-      * dput() */
+#define DCACHE_OP_HASH          0x0001
+#define DCACHE_OP_COMPARE       0x0002
+#define DCACHE_OP_REVALIDATE    0x0004
+#define DCACHE_OP_DELETE        0x0008
 
-#define DCACHE_DISCONNECTED     0x0004
+#define DCACHE_DISCONNECTED     0x0010
      /* This dentry is possibly not currently connected to the dcache tree, in
       * which case its parent will either be itself, or will have this flag as
       * well.  nfsd will not use a dentry with this bit set, but will first
@@ -196,26 +196,23 @@ struct dentry_operations {
       * dentry into place and return that dentry rather than the passed one,
       * typically using d_splice_alias. */
 
-#define DCACHE_REFERENCED       0x0008  /* Recently used, don't discard. */
-#define DCACHE_RCUACCESS        0x0010  /* Entry has ever been RCU-visible */
-#define DCACHE_INOTIFY_PARENT_WATCHED 0x0020
-     /* Parent inode is watched by inotify */
-
-#define DCACHE_COOKIE           0x0040  /* For use by dcookie subsystem */
-#define DCACHE_FSNOTIFY_PARENT_WATCHED 0x0080
-     /* Parent inode is watched by some fsnotify listener */
+#define DCACHE_REFERENCED       0x0020  /* Recently used, don't discard. */
+#define DCACHE_RCUACCESS        0x0040  /* Entry has ever been RCU-visible */
 
 #define DCACHE_CANT_MOUNT       0x0100
 #define DCACHE_GENOCIDE         0x0200
 
-#define DCACHE_OP_HASH          0x1000
-#define DCACHE_OP_COMPARE       0x2000
-#define DCACHE_OP_REVALIDATE    0x4000
-#define DCACHE_OP_DELETE        0x8000
+#define DCACHE_NFSFS_RENAMED    0x1000
+     /* this dentry has been "silly renamed" and has to be deleted on the last
+      * dput() */
+#define DCACHE_COOKIE           0x2000  /* For use by dcookie subsystem */
+#define DCACHE_FSNOTIFY_PARENT_WATCHED 0x4000
+     /* Parent inode is watched by some fsnotify listener */
 
 #define DCACHE_MOUNTED          0x10000 /* is a mountpoint */
 #define DCACHE_NEED_AUTOMOUNT   0x20000 /* handle automount on this dir */
 #define DCACHE_MANAGE_TRANSIT   0x40000 /* manage transit from this dirent */
+#define DCACHE_NEED_LOOKUP      0x80000 /* dentry requires i_op->lookup */
 #define DCACHE_MANAGED_DENTRY \
         (DCACHE_MOUNTED|DCACHE_NEED_AUTOMOUNT|DCACHE_MANAGE_TRANSIT)
 
@@ -416,7 +413,12 @@ static inline bool d_mountpoint(struct dentry *dentry)
         return dentry->d_flags & DCACHE_MOUNTED;
 }
 
-extern struct dentry *lookup_create(struct nameidata *nd, int is_dir);
+static inline bool d_need_lookup(struct dentry *dentry)
+{
+        return dentry->d_flags & DCACHE_NEED_LOOKUP;
+}
+
+extern void d_clear_need_lookup(struct dentry *dentry);
 
 extern int sysctl_vfs_cache_pressure;
 
diff --git a/include/linux/dcbnl.h b/include/linux/dcbnl.h
index c52280047e2c..65a2562f66b4 100644
--- a/include/linux/dcbnl.h
+++ b/include/linux/dcbnl.h
@@ -203,6 +203,7 @@ struct dcbmsg {
  * @DCB_CMD_GFEATCFG: get DCBX features flags
  * @DCB_CMD_SFEATCFG: set DCBX features negotiation flags
  * @DCB_CMD_CEE_GET: get CEE aggregated configuration
+ * @DCB_CMD_IEEE_DEL: delete IEEE 802.1Qaz configuration
  */
 enum dcbnl_commands {
         DCB_CMD_UNDEFINED,
@@ -246,6 +247,7 @@ enum dcbnl_commands {
         DCB_CMD_SFEATCFG,
 
         DCB_CMD_CEE_GET,
+        DCB_CMD_IEEE_DEL,
 
         __DCB_CMD_ENUM_MAX,
         DCB_CMD_MAX = __DCB_CMD_ENUM_MAX - 1,
@@ -331,18 +333,30 @@ enum ieee_attrs_app {
 #define DCB_ATTR_IEEE_APP_MAX (__DCB_ATTR_IEEE_APP_MAX - 1)
 
 /**
- * enum cee_attrs - CEE DCBX get attributes
+ * enum cee_attrs - CEE DCBX get attributes.
  *
  * @DCB_ATTR_CEE_UNSPEC: unspecified
  * @DCB_ATTR_CEE_PEER_PG: peer PG configuration - get only
  * @DCB_ATTR_CEE_PEER_PFC: peer PFC configuration - get only
- * @DCB_ATTR_CEE_PEER_APP: peer APP tlv - get only
+ * @DCB_ATTR_CEE_PEER_APP_TABLE: peer APP tlv - get only
+ * @DCB_ATTR_CEE_TX_PG: TX PG configuration (DCB_CMD_PGTX_GCFG)
+ * @DCB_ATTR_CEE_RX_PG: RX PG configuration (DCB_CMD_PGRX_GCFG)
+ * @DCB_ATTR_CEE_PFC: PFC configuration (DCB_CMD_PFC_GCFG)
+ * @DCB_ATTR_CEE_APP_TABLE: APP configuration (multi DCB_CMD_GAPP)
+ * @DCB_ATTR_CEE_FEAT: DCBX features flags (DCB_CMD_GFEATCFG)
+ *
+ * An aggregated collection of the cee std negotiated parameters.
  */
 enum cee_attrs {
         DCB_ATTR_CEE_UNSPEC,
         DCB_ATTR_CEE_PEER_PG,
         DCB_ATTR_CEE_PEER_PFC,
         DCB_ATTR_CEE_PEER_APP_TABLE,
+        DCB_ATTR_CEE_TX_PG,
+        DCB_ATTR_CEE_RX_PG,
+        DCB_ATTR_CEE_PFC,
+        DCB_ATTR_CEE_APP_TABLE,
+        DCB_ATTR_CEE_FEAT,
         __DCB_ATTR_CEE_MAX
 };
 #define DCB_ATTR_CEE_MAX (__DCB_ATTR_CEE_MAX - 1)
@@ -355,6 +369,13 @@ enum peer_app_attr {
 };
 #define DCB_ATTR_CEE_PEER_APP_MAX (__DCB_ATTR_CEE_PEER_APP_MAX - 1)
 
+enum cee_attrs_app {
+        DCB_ATTR_CEE_APP_UNSPEC,
+        DCB_ATTR_CEE_APP,
+        __DCB_ATTR_CEE_APP_MAX
+};
+#define DCB_ATTR_CEE_APP_MAX (__DCB_ATTR_CEE_APP_MAX - 1)
+
 /**
  * enum dcbnl_pfc_attrs - DCB Priority Flow Control user priority nested attrs
  *
diff --git a/include/linux/dccp.h b/include/linux/dccp.h
index d638e85dc501..710c04302a15 100644
--- a/include/linux/dccp.h
+++ b/include/linux/dccp.h
@@ -236,6 +236,7 @@ enum dccp_packet_dequeueing_policy {
 #ifdef __KERNEL__
 
 #include <linux/in.h>
+#include <linux/interrupt.h>
 #include <linux/ktime.h>
 #include <linux/list.h>
 #include <linux/uio.h>
diff --git a/include/linux/debug_locks.h b/include/linux/debug_locks.h
index 2833452ea01c..5033fb88c107 100644
--- a/include/linux/debug_locks.h
+++ b/include/linux/debug_locks.h
@@ -2,7 +2,7 @@
 #define __LINUX_DEBUG_LOCKING_H
 
 #include <linux/kernel.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <asm/system.h>
 
 struct task_struct;
diff --git a/include/linux/device-mapper.h b/include/linux/device-mapper.h
index 4427e0454051..3fa1f3d90ce0 100644
--- a/include/linux/device-mapper.h
+++ b/include/linux/device-mapper.h
@@ -208,6 +208,49 @@ struct dm_target_callbacks {
 int dm_register_target(struct target_type *t);
 void dm_unregister_target(struct target_type *t);
 
+/*
+ * Target argument parsing.
+ */
+struct dm_arg_set {
+        unsigned argc;
+        char **argv;
+};
+
+/*
+ * The minimum and maximum value of a numeric argument, together with
+ * the error message to use if the number is found to be outside that range.
+ */
+struct dm_arg {
+        unsigned min;
+        unsigned max;
+        char *error;
+};
+
+/*
+ * Validate the next argument, either returning it as *value or, if invalid,
+ * returning -EINVAL and setting *error.
+ */
+int dm_read_arg(struct dm_arg *arg, struct dm_arg_set *arg_set,
+                unsigned *value, char **error);
+
+/*
+ * Process the next argument as the start of a group containing between
+ * arg->min and arg->max further arguments. Either return the size as
+ * *num_args or, if invalid, return -EINVAL and set *error.
+ */
+int dm_read_arg_group(struct dm_arg *arg, struct dm_arg_set *arg_set,
+                      unsigned *num_args, char **error);
+
+/*
+ * Return the current argument and shift to the next.
+ */
+const char *dm_shift_arg(struct dm_arg_set *as);
+
+/*
+ * Move through num_args arguments.
+ */
+void dm_consume_args(struct dm_arg_set *as, unsigned num_args);
+
 /*-----------------------------------------------------------------
  * Functions for creating and manipulating mapped devices.
  * Drop the reference with dm_put when you finish with the object.
diff --git a/include/linux/device.h b/include/linux/device.h
index c66111affca9..c20dfbfc49b4 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -22,7 +22,7 @@
 #include <linux/types.h>
 #include <linux/module.h>
 #include <linux/pm.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <asm/device.h>
 
 struct device;
@@ -516,7 +516,7 @@ struct device_dma_parameters {
  *              minimizes board-specific #ifdefs in drivers.
  * @power:      For device power management.
  *              See Documentation/power/devices.txt for details.
- * @pwr_domain: Provide callbacks that are executed during system suspend,
+ * @pm_domain:  Provide callbacks that are executed during system suspend,
  *              hibernation, system resume and during runtime PM transitions
  *              along with subsystem-level and driver-level callbacks.
  * @numa_node:  NUMA node this device is close to.
@@ -530,7 +530,6 @@ struct device_dma_parameters {
  * @dma_mem:    Internal for coherent mem override.
  * @archdata:   For arch-specific additions.
  * @of_node:    Associated device tree node.
- * @of_match:   Matching of_device_id from driver.
  * @devt:       For creating the sysfs "dev".
  * @devres_lock: Spinlock to protect the resource of the device.
  * @devres_head: The resources list of the device.
@@ -568,7 +567,7 @@ struct device {
         void            *platform_data; /* Platform specific data, device
                                            core doesn't touch it */
         struct dev_pm_info      power;
-        struct dev_power_domain *pwr_domain;
+        struct dev_pm_domain    *pm_domain;
 
 #ifdef CONFIG_NUMA
         int             numa_node;      /* NUMA node this device is close to */
@@ -654,13 +653,13 @@ static inline int device_is_registered(struct device *dev)
 
 static inline void device_enable_async_suspend(struct device *dev)
 {
-        if (!dev->power.in_suspend)
+        if (!dev->power.is_prepared)
                 dev->power.async_suspend = true;
 }
 
 static inline void device_disable_async_suspend(struct device *dev)
 {
-        if (!dev->power.in_suspend)
+        if (!dev->power.is_prepared)
                 dev->power.async_suspend = false;
 }
 
diff --git a/include/linux/device_cgroup.h b/include/linux/device_cgroup.h
index 0b0d9c39ed67..7aad1f440867 100644
--- a/include/linux/device_cgroup.h
+++ b/include/linux/device_cgroup.h
@@ -2,8 +2,16 @@
 #include <linux/fs.h>
 
 #ifdef CONFIG_CGROUP_DEVICE
-extern int devcgroup_inode_permission(struct inode *inode, int mask);
+extern int __devcgroup_inode_permission(struct inode *inode, int mask);
 extern int devcgroup_inode_mknod(int mode, dev_t dev);
+static inline int devcgroup_inode_permission(struct inode *inode, int mask)
+{
+        if (likely(!inode->i_rdev))
+                return 0;
+        if (!S_ISBLK(inode->i_mode) && !S_ISCHR(inode->i_mode))
+                return 0;
+        return __devcgroup_inode_permission(inode, mask);
+}
 #else
 static inline int devcgroup_inode_permission(struct inode *inode, int mask)
 { return 0; }
diff --git a/include/linux/dio.h b/include/linux/dio.h
index b2dd31ca1710..2cc0fd00463f 100644
--- a/include/linux/dio.h
+++ b/include/linux/dio.h
@@ -254,7 +254,7 @@ static inline struct dio_driver *dio_dev_driver(const struct dio_dev *d)
 
 #define dio_resource_start(d) ((d)->resource.start)
 #define dio_resource_end(d)   ((d)->resource.end)
-#define dio_resource_len(d)   ((d)->resource.end-(d)->resource.start+1)
+#define dio_resource_len(d)   (resource_size(&(d)->resource))
 #define dio_resource_flags(d) ((d)->resource.flags)
 
 #define dio_request_device(d, name) \
diff --git a/include/linux/dm-ioctl.h b/include/linux/dm-ioctl.h
index 3708455ee6c3..0cb8eff76bd6 100644
--- a/include/linux/dm-ioctl.h
+++ b/include/linux/dm-ioctl.h
@@ -267,9 +267,9 @@ enum {
 #define DM_DEV_SET_GEOMETRY     _IOWR(DM_IOCTL, DM_DEV_SET_GEOMETRY_CMD, struct dm_ioctl)
 
 #define DM_VERSION_MAJOR        4
-#define DM_VERSION_MINOR        20
+#define DM_VERSION_MINOR        21
 #define DM_VERSION_PATCHLEVEL   0
-#define DM_VERSION_EXTRA        "-ioctl (2011-02-02)"
+#define DM_VERSION_EXTRA        "-ioctl (2011-07-06)"
 
 /* Status bits */
 #define DM_READONLY_FLAG        (1 << 0) /* In/Out */
diff --git a/include/linux/dm-kcopyd.h b/include/linux/dm-kcopyd.h
index 298d587e349b..5e54458e920f 100644
--- a/include/linux/dm-kcopyd.h
+++ b/include/linux/dm-kcopyd.h
@@ -42,5 +42,20 @@ int dm_kcopyd_copy(struct dm_kcopyd_client *kc, struct dm_io_region *from,
                    unsigned num_dests, struct dm_io_region *dests,
                    unsigned flags, dm_kcopyd_notify_fn fn, void *context);
 
+/*
+ * Prepare a callback and submit it via the kcopyd thread.
+ *
+ * dm_kcopyd_prepare_callback allocates a callback structure and returns it.
+ * It must not be called from interrupt context.
+ * The returned value should be passed into dm_kcopyd_do_callback.
+ *
+ * dm_kcopyd_do_callback submits the callback.
+ * It may be called from interrupt context.
+ * The callback is issued from the kcopyd thread.
+ */
+void *dm_kcopyd_prepare_callback(struct dm_kcopyd_client *kc,
+                                 dm_kcopyd_notify_fn fn, void *context);
+void dm_kcopyd_do_callback(void *job, int read_err, unsigned long write_err);
+
 #endif  /* __KERNEL__ */
 #endif  /* _LINUX_DM_KCOPYD_H */
diff --git a/include/linux/dma-direction.h b/include/linux/dma-direction.h
new file mode 100644
index 000000000000..95b6a82f5951
--- /dev/null
+++ b/include/linux/dma-direction.h
@@ -0,0 +1,13 @@
+#ifndef _LINUX_DMA_DIRECTION_H
+#define _LINUX_DMA_DIRECTION_H
+/*
+ * These definitions mirror those in pci.h, so they can be used
+ * interchangeably with their PCI_ counterparts.
+ */
+enum dma_data_direction {
+        DMA_BIDIRECTIONAL = 0,
+        DMA_TO_DEVICE = 1,
+        DMA_FROM_DEVICE = 2,
+        DMA_NONE = 3,
+};
+#endif
diff --git a/include/linux/dma-mapping.h b/include/linux/dma-mapping.h
index ba8319ae5fcc..347fdc32177a 100644
--- a/include/linux/dma-mapping.h
+++ b/include/linux/dma-mapping.h
@@ -4,17 +4,9 @@
 #include <linux/device.h>
 #include <linux/err.h>
 #include <linux/dma-attrs.h>
+#include <linux/dma-direction.h>
 #include <linux/scatterlist.h>
 
-/* These definitions mirror those in pci.h, so they can be used
- * interchangeably with their PCI_ counterparts */
-enum dma_data_direction {
-        DMA_BIDIRECTIONAL = 0,
-        DMA_TO_DEVICE = 1,
-        DMA_FROM_DEVICE = 2,
-        DMA_NONE = 3,
-};
-
 struct dma_map_ops {
         void* (*alloc_coherent)(struct device *dev, size_t size,
                                 dma_addr_t *dma_handle, gfp_t gfp);
@@ -54,27 +46,6 @@ struct dma_map_ops {
 
 #define DMA_BIT_MASK(n) (((n) == 64) ? ~0ULL : ((1ULL<<(n))-1))
 
-typedef u64 DMA_nnBIT_MASK __deprecated;
-
-/*
- * NOTE: do not use the below macros in new code and do not add new definitions
- * here.
- *
- * Instead, just open-code DMA_BIT_MASK(n) within your driver
- */
-#define DMA_64BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(64)
-#define DMA_48BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(48)
-#define DMA_47BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(47)
-#define DMA_40BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(40)
-#define DMA_39BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(39)
-#define DMA_35BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(35)
-#define DMA_32BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(32)
-#define DMA_31BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(31)
-#define DMA_30BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(30)
-#define DMA_29BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(29)
-#define DMA_28BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(28)
-#define DMA_24BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(24)
-
 #define DMA_MASK_NONE   0x0ULL
 
 static inline int valid_dma_direction(int dma_direction)
diff --git a/include/linux/dma_remapping.h b/include/linux/dma_remapping.h
index 5619f8522738..bbd8661b3473 100644
--- a/include/linux/dma_remapping.h
+++ b/include/linux/dma_remapping.h
@@ -9,8 +9,12 @@
 #define VTD_PAGE_MASK           (((u64)-1) << VTD_PAGE_SHIFT)
 #define VTD_PAGE_ALIGN(addr)    (((addr) + VTD_PAGE_SIZE - 1) & VTD_PAGE_MASK)
 
+#define VTD_STRIDE_SHIFT        (9)
+#define VTD_STRIDE_MASK         (((u64)-1) << VTD_STRIDE_SHIFT)
+
 #define DMA_PTE_READ (1)
 #define DMA_PTE_WRITE (2)
+#define DMA_PTE_LARGE_PAGE (1 << 7)
 #define DMA_PTE_SNP (1 << 11)
 
 #define CONTEXT_TT_MULTI_LEVEL  0
diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h
index eee7addec282..8fbf40e0713c 100644
--- a/include/linux/dmaengine.h
+++ b/include/linux/dmaengine.h
@@ -23,7 +23,9 @@
 
 #include <linux/device.h>
 #include <linux/uio.h>
-#include <linux/dma-mapping.h>
+#include <linux/dma-direction.h>
+
+struct scatterlist;
 
 /**
  * typedef dma_cookie_t - an opaque DMA cookie
diff --git a/include/linux/drbd_limits.h b/include/linux/drbd_limits.h
index 246f576c981d..447c36752385 100644
--- a/include/linux/drbd_limits.h
+++ b/include/linux/drbd_limits.h
@@ -117,10 +117,10 @@
 /* drbdsetup XY resize -d Z
  * you are free to reduce the device size to nothing, if you want to.
  * the upper limit with 64bit kernel, enough ram and flexible meta data
- * is 16 TB, currently. */
+ * is 1 PiB, currently. */
 /* DRBD_MAX_SECTORS */
 #define DRBD_DISK_SIZE_SECT_MIN  0
-#define DRBD_DISK_SIZE_SECT_MAX  (16 * (2LLU << 30))
+#define DRBD_DISK_SIZE_SECT_MAX  (1 * (2LLU << 40))
 #define DRBD_DISK_SIZE_SECT_DEF  0 /* = disabled = no user size... */
 
 #define DRBD_ON_IO_ERROR_DEF EP_PASS_ON
diff --git a/include/linux/dvb/audio.h b/include/linux/dvb/audio.h
index fec66bd24f22..d47bccd604e4 100644
--- a/include/linux/dvb/audio.h
+++ b/include/linux/dvb/audio.h
@@ -67,7 +67,7 @@ typedef struct audio_status {
 
 
 typedef
-struct audio_karaoke{  /* if Vocal1 or Vocal2 are non-zero, they get mixed  */
+struct audio_karaoke {  /* if Vocal1 or Vocal2 are non-zero, they get mixed  */
         int vocal1;    /* into left and right t at 70% each */
         int vocal2;    /* if both, Vocal1 and Vocal2 are non-zero, Vocal1 gets*/
         int melody;    /* mixed into the left channel and */
diff --git a/include/linux/dw_apb_timer.h b/include/linux/dw_apb_timer.h
new file mode 100644
index 000000000000..49638ea3b776
--- /dev/null
+++ b/include/linux/dw_apb_timer.h
@@ -0,0 +1,56 @@
+/*
+ * (C) Copyright 2009 Intel Corporation
+ * Author: Jacob Pan (jacob.jun.pan@intel.com)
+ *
+ * Shared with ARM platforms, Jamie Iles, Picochip 2011
+ *
+ * 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.
+ *
+ * Support for the Synopsys DesignWare APB Timers.
+ */
+#ifndef __DW_APB_TIMER_H__
+#define __DW_APB_TIMER_H__
+
+#include <linux/clockchips.h>
+#include <linux/clocksource.h>
+#include <linux/interrupt.h>
+
+#define APBTMRS_REG_SIZE       0x14
+
+struct dw_apb_timer {
+        void __iomem                            *base;
+        unsigned long                           freq;
+        int                                     irq;
+};
+
+struct dw_apb_clock_event_device {
+        struct clock_event_device               ced;
+        struct dw_apb_timer                     timer;
+        struct irqaction                        irqaction;
+        void                                    (*eoi)(struct dw_apb_timer *);
+};
+
+struct dw_apb_clocksource {
+        struct dw_apb_timer                     timer;
+        struct clocksource                      cs;
+};
+
+void dw_apb_clockevent_register(struct dw_apb_clock_event_device *dw_ced);
+void dw_apb_clockevent_pause(struct dw_apb_clock_event_device *dw_ced);
+void dw_apb_clockevent_resume(struct dw_apb_clock_event_device *dw_ced);
+void dw_apb_clockevent_stop(struct dw_apb_clock_event_device *dw_ced);
+
+struct dw_apb_clock_event_device *
+dw_apb_clockevent_init(int cpu, const char *name, unsigned rating,
+                       void __iomem *base, int irq, unsigned long freq);
+struct dw_apb_clocksource *
+dw_apb_clocksource_init(unsigned rating, char *name, void __iomem *base,
+                        unsigned long freq);
+void dw_apb_clocksource_register(struct dw_apb_clocksource *dw_cs);
+void dw_apb_clocksource_start(struct dw_apb_clocksource *dw_cs);
+cycle_t dw_apb_clocksource_read(struct dw_apb_clocksource *dw_cs);
+void dw_apb_clocksource_unregister(struct dw_apb_clocksource *dw_cs);
+
+#endif /* __DW_APB_TIMER_H__ */
diff --git a/include/linux/ecryptfs.h b/include/linux/ecryptfs.h
new file mode 100644
index 000000000000..2224a8c0cb64
--- /dev/null
+++ b/include/linux/ecryptfs.h
@@ -0,0 +1,113 @@
+#ifndef _LINUX_ECRYPTFS_H
+#define _LINUX_ECRYPTFS_H
+
+/* Version verification for shared data structures w/ userspace */
+#define ECRYPTFS_VERSION_MAJOR 0x00
+#define ECRYPTFS_VERSION_MINOR 0x04
+#define ECRYPTFS_SUPPORTED_FILE_VERSION 0x03
+/* These flags indicate which features are supported by the kernel
+ * module; userspace tools such as the mount helper read
+ * ECRYPTFS_VERSIONING_MASK from a sysfs handle in order to determine
+ * how to behave. */
+#define ECRYPTFS_VERSIONING_PASSPHRASE            0x00000001
+#define ECRYPTFS_VERSIONING_PUBKEY                0x00000002
+#define ECRYPTFS_VERSIONING_PLAINTEXT_PASSTHROUGH 0x00000004
+#define ECRYPTFS_VERSIONING_POLICY                0x00000008
+#define ECRYPTFS_VERSIONING_XATTR                 0x00000010
+#define ECRYPTFS_VERSIONING_MULTKEY               0x00000020
+#define ECRYPTFS_VERSIONING_DEVMISC               0x00000040
+#define ECRYPTFS_VERSIONING_HMAC                  0x00000080
+#define ECRYPTFS_VERSIONING_FILENAME_ENCRYPTION   0x00000100
+#define ECRYPTFS_VERSIONING_GCM                   0x00000200
+#define ECRYPTFS_VERSIONING_MASK (ECRYPTFS_VERSIONING_PASSPHRASE \
+                                  | ECRYPTFS_VERSIONING_PLAINTEXT_PASSTHROUGH \
+                                  | ECRYPTFS_VERSIONING_PUBKEY \
+                                  | ECRYPTFS_VERSIONING_XATTR \
+                                  | ECRYPTFS_VERSIONING_MULTKEY \
+                                  | ECRYPTFS_VERSIONING_DEVMISC \
+                                  | ECRYPTFS_VERSIONING_FILENAME_ENCRYPTION)
+#define ECRYPTFS_MAX_PASSWORD_LENGTH 64
+#define ECRYPTFS_MAX_PASSPHRASE_BYTES ECRYPTFS_MAX_PASSWORD_LENGTH
+#define ECRYPTFS_SALT_SIZE 8
+#define ECRYPTFS_SALT_SIZE_HEX (ECRYPTFS_SALT_SIZE*2)
+/* The original signature size is only for what is stored on disk; all
+ * in-memory representations are expanded hex, so it better adapted to
+ * be passed around or referenced on the command line */
+#define ECRYPTFS_SIG_SIZE 8
+#define ECRYPTFS_SIG_SIZE_HEX (ECRYPTFS_SIG_SIZE*2)
+#define ECRYPTFS_PASSWORD_SIG_SIZE ECRYPTFS_SIG_SIZE_HEX
+#define ECRYPTFS_MAX_KEY_BYTES 64
+#define ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES 512
+#define ECRYPTFS_FILE_VERSION 0x03
+#define ECRYPTFS_MAX_PKI_NAME_BYTES 16
+
+#define RFC2440_CIPHER_DES3_EDE 0x02
+#define RFC2440_CIPHER_CAST_5 0x03
+#define RFC2440_CIPHER_BLOWFISH 0x04
+#define RFC2440_CIPHER_AES_128 0x07
+#define RFC2440_CIPHER_AES_192 0x08
+#define RFC2440_CIPHER_AES_256 0x09
+#define RFC2440_CIPHER_TWOFISH 0x0a
+#define RFC2440_CIPHER_CAST_6 0x0b
+
+#define RFC2440_CIPHER_RSA 0x01
+
+/**
+ * For convenience, we may need to pass around the encrypted session
+ * key between kernel and userspace because the authentication token
+ * may not be extractable.  For example, the TPM may not release the
+ * private key, instead requiring the encrypted data and returning the
+ * decrypted data.
+ */
+struct ecryptfs_session_key {
+#define ECRYPTFS_USERSPACE_SHOULD_TRY_TO_DECRYPT 0x00000001
+#define ECRYPTFS_USERSPACE_SHOULD_TRY_TO_ENCRYPT 0x00000002
+#define ECRYPTFS_CONTAINS_DECRYPTED_KEY 0x00000004
+#define ECRYPTFS_CONTAINS_ENCRYPTED_KEY 0x00000008
+        u32 flags;
+        u32 encrypted_key_size;
+        u32 decrypted_key_size;
+        u8 encrypted_key[ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES];
+        u8 decrypted_key[ECRYPTFS_MAX_KEY_BYTES];
+};
+
+struct ecryptfs_password {
+        u32 password_bytes;
+        s32 hash_algo;
+        u32 hash_iterations;
+        u32 session_key_encryption_key_bytes;
+#define ECRYPTFS_PERSISTENT_PASSWORD 0x01
+#define ECRYPTFS_SESSION_KEY_ENCRYPTION_KEY_SET 0x02
+        u32 flags;
+        /* Iterated-hash concatenation of salt and passphrase */
+        u8 session_key_encryption_key[ECRYPTFS_MAX_KEY_BYTES];
+        u8 signature[ECRYPTFS_PASSWORD_SIG_SIZE + 1];
+        /* Always in expanded hex */
+        u8 salt[ECRYPTFS_SALT_SIZE];
+};
+
+enum ecryptfs_token_types {ECRYPTFS_PASSWORD, ECRYPTFS_PRIVATE_KEY};
+
+struct ecryptfs_private_key {
+        u32 key_size;
+        u32 data_len;
+        u8 signature[ECRYPTFS_PASSWORD_SIG_SIZE + 1];
+        char pki_type[ECRYPTFS_MAX_PKI_NAME_BYTES + 1];
+        u8 data[];
+};
+
+/* May be a password or a private key */
+struct ecryptfs_auth_tok {
+        u16 version; /* 8-bit major and 8-bit minor */
+        u16 token_type;
+#define ECRYPTFS_ENCRYPT_ONLY 0x00000001
+        u32 flags;
+        struct ecryptfs_session_key session_key;
+        u8 reserved[32];
+        union {
+                struct ecryptfs_password password;
+                struct ecryptfs_private_key private_key;
+        } token;
+} __attribute__ ((packed));
+
+#endif /* _LINUX_ECRYPTFS_H */
diff --git a/include/linux/edac.h b/include/linux/edac.h
index 36c66443bdfd..4a73257b47d0 100644
--- a/include/linux/edac.h
+++ b/include/linux/edac.h
@@ -12,7 +12,7 @@
 #ifndef _LINUX_EDAC_H_
 #define _LINUX_EDAC_H_
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <linux/sysdev.h>
 
 #define EDAC_OPSTATE_INVAL      -1
diff --git a/include/linux/eeprom_93xx46.h b/include/linux/eeprom_93xx46.h
new file mode 100644
index 000000000000..06791811e49d
--- /dev/null
+++ b/include/linux/eeprom_93xx46.h
@@ -0,0 +1,18 @@
+/*
+ * Module: eeprom_93xx46
+ * platform description for 93xx46 EEPROMs.
+ */
+
+struct eeprom_93xx46_platform_data {
+        unsigned char   flags;
+#define EE_ADDR8        0x01            /*  8 bit addr. cfg */
+#define EE_ADDR16       0x02            /* 16 bit addr. cfg */
+#define EE_READONLY     0x08            /* forbid writing */
+
+        /*
+         * optional hooks to control additional logic
+         * before and after spi transfer.
+         */
+        void (*prepare)(void *);
+        void (*finish)(void *);
+};
diff --git a/include/linux/efi.h b/include/linux/efi.h
index e376270cd26e..2362a0bc7f0d 100644
--- a/include/linux/efi.h
+++ b/include/linux/efi.h
@@ -19,6 +19,7 @@
 #include <linux/rtc.h>
 #include <linux/ioport.h>
 #include <linux/pfn.h>
+#include <linux/pstore.h>
 
 #include <asm/page.h>
 #include <asm/system.h>
@@ -101,6 +102,13 @@ typedef struct {
         u64 attribute;
 } efi_memory_desc_t;
 
+typedef struct {
+        efi_guid_t guid;
+        u32 headersize;
+        u32 flags;
+        u32 imagesize;
+} efi_capsule_header_t;
+
 typedef int (*efi_freemem_callback_t) (u64 start, u64 end, void *arg);
 
 /*
@@ -156,6 +164,9 @@ typedef struct {
         unsigned long set_variable;
         unsigned long get_next_high_mono_count;
         unsigned long reset_system;
+        unsigned long update_capsule;
+        unsigned long query_capsule_caps;
+        unsigned long query_variable_info;
 } efi_runtime_services_t;
 
 typedef efi_status_t efi_get_time_t (efi_time_t *tm, efi_time_cap_t *tc);
@@ -168,7 +179,7 @@ typedef efi_status_t efi_get_variable_t (efi_char16_t *name, efi_guid_t *vendor,
 typedef efi_status_t efi_get_next_variable_t (unsigned long *name_size, efi_char16_t *name,
                                               efi_guid_t *vendor);
 typedef efi_status_t efi_set_variable_t (efi_char16_t *name, efi_guid_t *vendor, 
-                                         unsigned long attr, unsigned long data_size, 
+                                         u32 attr, unsigned long data_size,
                                          void *data);
 typedef efi_status_t efi_get_next_high_mono_count_t (u32 *count);
 typedef void efi_reset_system_t (int reset_type, efi_status_t status,
@@ -177,6 +188,17 @@ typedef efi_status_t efi_set_virtual_address_map_t (unsigned long memory_map_siz
                                                 unsigned long descriptor_size,
                                                 u32 descriptor_version,
                                                 efi_memory_desc_t *virtual_map);
+typedef efi_status_t efi_query_variable_info_t(u32 attr,
+                                               u64 *storage_space,
+                                               u64 *remaining_space,
+                                               u64 *max_variable_size);
+typedef efi_status_t efi_update_capsule_t(efi_capsule_header_t **capsules,
+                                          unsigned long count,
+                                          unsigned long sg_list);
+typedef efi_status_t efi_query_capsule_caps_t(efi_capsule_header_t **capsules,
+                                              unsigned long count,
+                                              u64 *max_size,
+                                              int *reset_type);
 
 /*
  *  EFI Configuration Table and GUID definitions
@@ -211,6 +233,9 @@ typedef efi_status_t efi_set_virtual_address_map_t (unsigned long memory_map_siz
 #define UV_SYSTEM_TABLE_GUID \
     EFI_GUID(  0x3b13a7d4, 0x633e, 0x11dd, 0x93, 0xec, 0xda, 0x25, 0x56, 0xd8, 0x95, 0x93 )
 
+#define LINUX_EFI_CRASH_GUID \
+    EFI_GUID(  0xcfc8fc79, 0xbe2e, 0x4ddc, 0x97, 0xf0, 0x9f, 0x98, 0xbf, 0xe2, 0x98, 0xa0 )
+
 typedef struct {
         efi_guid_t guid;
         unsigned long table;
@@ -218,6 +243,13 @@ typedef struct {
 
 #define EFI_SYSTEM_TABLE_SIGNATURE ((u64)0x5453595320494249ULL)
 
+#define EFI_2_30_SYSTEM_TABLE_REVISION  ((2 << 16) | (30))
+#define EFI_2_20_SYSTEM_TABLE_REVISION  ((2 << 16) | (20))
+#define EFI_2_10_SYSTEM_TABLE_REVISION  ((2 << 16) | (10))
+#define EFI_2_00_SYSTEM_TABLE_REVISION  ((2 << 16) | (00))
+#define EFI_1_10_SYSTEM_TABLE_REVISION  ((1 << 16) | (10))
+#define EFI_1_02_SYSTEM_TABLE_REVISION  ((1 << 16) | (02))
+
 typedef struct {
         efi_table_hdr_t hdr;
         unsigned long fw_vendor;        /* physical addr of CHAR16 vendor string */
@@ -250,6 +282,7 @@ struct efi_memory_map {
  */
 extern struct efi {
         efi_system_table_t *systab;     /* EFI system table */
+        unsigned int runtime_version;   /* Runtime services version */
         unsigned long mps;              /* MPS table */
         unsigned long acpi;             /* ACPI table  (IA64 ext 0.71) */
         unsigned long acpi20;           /* ACPI table  (ACPI 2.0) */
@@ -266,6 +299,9 @@ extern struct efi {
         efi_get_variable_t *get_variable;
         efi_get_next_variable_t *get_next_variable;
         efi_set_variable_t *set_variable;
+        efi_query_variable_info_t *query_variable_info;
+        efi_update_capsule_t *update_capsule;
+        efi_query_capsule_caps_t *query_capsule_caps;
         efi_get_next_high_mono_count_t *get_next_high_mono_count;
         efi_reset_system_t *reset_system;
         efi_set_virtual_address_map_t *set_virtual_address_map;
@@ -426,6 +462,8 @@ struct efivars {
         struct kset *kset;
         struct bin_attribute *new_var, *del_var;
         const struct efivar_operations *ops;
+        struct efivar_entry *walk_entry;
+        struct pstore_info efi_pstore_info;
 };
 
 int register_efivars(struct efivars *efivars,
diff --git a/include/linux/elevator.h b/include/linux/elevator.h
index 21a8ebf2dc3a..d800d5142184 100644
--- a/include/linux/elevator.h
+++ b/include/linux/elevator.h
@@ -146,7 +146,7 @@ extern struct request *elv_rb_latter_request(struct request_queue *, struct requ
 /*
  * rb support functions.
  */
-extern struct request *elv_rb_add(struct rb_root *, struct request *);
+extern void elv_rb_add(struct rb_root *, struct request *);
 extern void elv_rb_del(struct rb_root *, struct request *);
 extern struct request *elv_rb_find(struct rb_root *, sector_t);
 
diff --git a/include/linux/etherdevice.h b/include/linux/etherdevice.h
index ab68f785fd19..05955cf09937 100644
--- a/include/linux/etherdevice.h
+++ b/include/linux/etherdevice.h
@@ -38,7 +38,7 @@ extern int eth_header(struct sk_buff *skb, struct net_device *dev,
                       const void *daddr, const void *saddr, unsigned len);
 extern int eth_rebuild_header(struct sk_buff *skb);
 extern int eth_header_parse(const struct sk_buff *skb, unsigned char *haddr);
-extern int eth_header_cache(const struct neighbour *neigh, struct hh_cache *hh);
+extern int eth_header_cache(const struct neighbour *neigh, struct hh_cache *hh, __be16 type);
 extern void eth_header_cache_update(struct hh_cache *hh,
                                     const struct net_device *dev,
                                     const unsigned char *haddr);
diff --git a/include/linux/ethtool.h b/include/linux/ethtool.h
index c6a850ab2ec5..c6e427ab65fe 100644
--- a/include/linux/ethtool.h
+++ b/include/linux/ethtool.h
@@ -268,7 +268,7 @@ struct ethtool_pauseparam {
         __u32   cmd;    /* ETHTOOL_{G,S}PAUSEPARAM */
 
         /* If the link is being auto-negotiated (via ethtool_cmd.autoneg
-         * being true) the user may set 'autonet' here non-zero to have the
+         * being true) the user may set 'autoneg' here non-zero to have the
          * pause parameters be auto-negotiated too.  In such a case, the
          * {rx,tx}_pause values below determine what capabilities are
          * advertised.
@@ -287,7 +287,7 @@ enum ethtool_stringset {
         ETH_SS_TEST             = 0,
         ETH_SS_STATS,
         ETH_SS_PRIV_FLAGS,
-        ETH_SS_NTUPLE_FILTERS,
+        ETH_SS_NTUPLE_FILTERS,  /* Do not use, GRXNTUPLE is now deprecated */
         ETH_SS_FEATURES,
 };
 
@@ -310,9 +310,21 @@ struct ethtool_sset_info {
                                    __u32's, etc. */
 };
 
+/**
+ * enum ethtool_test_flags - flags definition of ethtool_test
+ * @ETH_TEST_FL_OFFLINE: if set perform online and offline tests, otherwise
+ *      only online tests.
+ * @ETH_TEST_FL_FAILED: Driver set this flag if test fails.
+ * @ETH_TEST_FL_EXTERNAL_LB: Application request to perform external loopback
+ *      test.
+ * @ETH_TEST_FL_EXTERNAL_LB_DONE: Driver performed the external loopback test
+ */
+
 enum ethtool_test_flags {
-        ETH_TEST_FL_OFFLINE     = (1 << 0),     /* online / offline */
-        ETH_TEST_FL_FAILED      = (1 << 1),     /* test passed / failed */
+        ETH_TEST_FL_OFFLINE     = (1 << 0),
+        ETH_TEST_FL_FAILED      = (1 << 1),
+        ETH_TEST_FL_EXTERNAL_LB = (1 << 2),
+        ETH_TEST_FL_EXTERNAL_LB_DONE    = (1 << 3),
 };
 
 /* for requesting NIC test and getting results*/
@@ -714,18 +726,6 @@ enum ethtool_sfeatures_retval_bits {
 /* needed by dev_disable_lro() */
 extern int __ethtool_set_flags(struct net_device *dev, u32 flags);
 
-struct ethtool_rx_ntuple_flow_spec_container {
-        struct ethtool_rx_ntuple_flow_spec fs;
-        struct list_head list;
-};
-
-struct ethtool_rx_ntuple_list {
-#define ETHTOOL_MAX_NTUPLE_LIST_ENTRY 1024
-#define ETHTOOL_MAX_NTUPLE_STRING_PER_ENTRY 14
-        struct list_head        list;
-        unsigned int            count;
-};
-
 /**
  * enum ethtool_phys_id_state - indicator state for physical identification
  * @ETHTOOL_ID_INACTIVE: Physical ID indicator should be deactivated
@@ -758,7 +758,6 @@ u32 ethtool_op_get_ufo(struct net_device *dev);
 int ethtool_op_set_ufo(struct net_device *dev, u32 data);
 u32 ethtool_op_get_flags(struct net_device *dev);
 int ethtool_op_set_flags(struct net_device *dev, u32 data, u32 supported);
-void ethtool_ntuple_flush(struct net_device *dev);
 bool ethtool_invalid_flags(struct net_device *dev, u32 data, u32 supported);
 
 /**
@@ -811,7 +810,7 @@ bool ethtool_invalid_flags(struct net_device *dev, u32 data, u32 supported);
  * @get_tx_csum: Deprecated as redundant. Report whether transmit checksums
  *      are turned on or off.
  * @set_tx_csum: Deprecated in favour of generic netdev features.  Turn
- *      transmit checksums on or off.  Returns a egative error code or zero.
+ *      transmit checksums on or off.  Returns a negative error code or zero.
  * @get_sg: Deprecated as redundant.  Report whether scatter-gather is
  *      enabled.  
  * @set_sg: Deprecated in favour of generic netdev features.  Turn
@@ -865,7 +864,6 @@ bool ethtool_invalid_flags(struct net_device *dev, u32 data, u32 supported);
  *      error code or zero.
  * @set_rx_ntuple: Set an RX n-tuple rule.  Returns a negative error code
  *      or zero.
- * @get_rx_ntuple: Deprecated.
  * @get_rxfh_indir: Get the contents of the RX flow hash indirection table.
  *      Returns a negative error code or zero.
  * @set_rxfh_indir: Set the contents of the RX flow hash indirection table.
@@ -944,7 +942,6 @@ struct ethtool_ops {
         int     (*reset)(struct net_device *, u32 *);
         int     (*set_rx_ntuple)(struct net_device *,
                                  struct ethtool_rx_ntuple *);
-        int     (*get_rx_ntuple)(struct net_device *, u32 stringset, void *);
         int     (*get_rxfh_indir)(struct net_device *,
                                   struct ethtool_rxfh_indir *);
         int     (*set_rxfh_indir)(struct net_device *,
@@ -1017,7 +1014,7 @@ struct ethtool_ops {
 #define ETHTOOL_FLASHDEV        0x00000033 /* Flash firmware to device */
 #define ETHTOOL_RESET           0x00000034 /* Reset hardware */
 #define ETHTOOL_SRXNTUPLE       0x00000035 /* Add an n-tuple filter to device */
-#define ETHTOOL_GRXNTUPLE       0x00000036 /* Get n-tuple filters from device */
+#define ETHTOOL_GRXNTUPLE       0x00000036 /* deprecated */
 #define ETHTOOL_GSSET_INFO      0x00000037 /* Get string set info */
 #define ETHTOOL_GRXFHINDIR      0x00000038 /* Get RX flow hash indir'n table */
 #define ETHTOOL_SRXFHINDIR      0x00000039 /* Set RX flow hash indir'n table */
@@ -1087,7 +1084,7 @@ struct ethtool_ops {
 /* The following are all involved in forcing a particular link
  * mode for the device for setting things.  When getting the
  * devices settings, these indicate the current mode and whether
- * it was foced up into this mode or autonegotiated.
+ * it was forced up into this mode or autonegotiated.
  */
 
 /* The forced speed, 10Mb, 100Mb, gigabit, 2.5Gb, 10GbE. */
diff --git a/include/linux/ext2_fs.h b/include/linux/ext2_fs.h
index 2dfa7076e8b6..53792bf36c71 100644
--- a/include/linux/ext2_fs.h
+++ b/include/linux/ext2_fs.h
@@ -18,6 +18,7 @@
 
 #include <linux/types.h>
 #include <linux/magic.h>
+#include <linux/fs.h>
 
 /*
  * The second extended filesystem constants/structures
diff --git a/include/linux/ext3_fs.h b/include/linux/ext3_fs.h
index 5e06acf95d0f..67a803aee619 100644
--- a/include/linux/ext3_fs.h
+++ b/include/linux/ext3_fs.h
@@ -418,12 +418,11 @@ struct ext3_inode {
 #define EXT2_MOUNT_DATA_FLAGS           EXT3_MOUNT_DATA_FLAGS
 #endif
 
-#define ext3_set_bit                    __test_and_set_bit_le
+#define ext3_set_bit                    __set_bit_le
 #define ext3_set_bit_atomic             ext2_set_bit_atomic
-#define ext3_clear_bit                  __test_and_clear_bit_le
+#define ext3_clear_bit                  __clear_bit_le
 #define ext3_clear_bit_atomic           ext2_clear_bit_atomic
 #define ext3_test_bit                   test_bit_le
-#define ext3_find_first_zero_bit        find_first_zero_bit_le
 #define ext3_find_next_zero_bit         find_next_zero_bit_le
 
 /*
@@ -877,7 +876,7 @@ extern int ext3_htree_store_dirent(struct file *dir_file, __u32 hash,
 extern void ext3_htree_free_dir_info(struct dir_private_info *p);
 
 /* fsync.c */
-extern int ext3_sync_file(struct file *, int);
+extern int ext3_sync_file(struct file *, loff_t, loff_t, int);
 
 /* hash.c */
 extern int ext3fs_dirhash(const char *name, int len, struct
@@ -913,7 +912,7 @@ extern void ext3_dirty_inode(struct inode *, int);
 extern int ext3_change_inode_journal_flag(struct inode *, int);
 extern int ext3_get_inode_loc(struct inode *, struct ext3_iloc *);
 extern int ext3_can_truncate(struct inode *inode);
-extern void ext3_truncate (struct inode *);
+extern void ext3_truncate(struct inode *inode);
 extern void ext3_set_inode_flags(struct inode *);
 extern void ext3_get_inode_flags(struct ext3_inode_info *);
 extern void ext3_set_aops(struct inode *inode);
diff --git a/include/linux/fault-inject.h b/include/linux/fault-inject.h
index 7b64ad40e4ce..c6f996f2abb6 100644
--- a/include/linux/fault-inject.h
+++ b/include/linux/fault-inject.h
@@ -5,7 +5,7 @@
 
 #include <linux/types.h>
 #include <linux/debugfs.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 /*
  * For explanation of the elements of this struct, see
@@ -25,26 +25,6 @@ struct fault_attr {
         unsigned long reject_end;
 
         unsigned long count;
-
-#ifdef CONFIG_FAULT_INJECTION_DEBUG_FS
-
-        struct {
-                struct dentry *dir;
-
-                struct dentry *probability_file;
-                struct dentry *interval_file;
-                struct dentry *times_file;
-                struct dentry *space_file;
-                struct dentry *verbose_file;
-                struct dentry *task_filter_file;
-                struct dentry *stacktrace_depth_file;
-                struct dentry *require_start_file;
-                struct dentry *require_end_file;
-                struct dentry *reject_start_file;
-                struct dentry *reject_end_file;
-        } dentries;
-
-#endif
 };
 
 #define FAULT_ATTR_INITIALIZER {                                \
@@ -57,24 +37,19 @@ struct fault_attr {
 
 #define DECLARE_FAULT_ATTR(name) struct fault_attr name = FAULT_ATTR_INITIALIZER
 int setup_fault_attr(struct fault_attr *attr, char *str);
-void should_fail_srandom(unsigned long entropy);
 bool should_fail(struct fault_attr *attr, ssize_t size);
 
 #ifdef CONFIG_FAULT_INJECTION_DEBUG_FS
 
-int init_fault_attr_dentries(struct fault_attr *attr, const char *name);
-void cleanup_fault_attr_dentries(struct fault_attr *attr);
+struct dentry *fault_create_debugfs_attr(const char *name,
+                        struct dentry *parent, struct fault_attr *attr);
 
 #else /* CONFIG_FAULT_INJECTION_DEBUG_FS */
 
-static inline int init_fault_attr_dentries(struct fault_attr *attr,
-                                          const char *name)
-{
-        return -ENODEV;
-}
-
-static inline void cleanup_fault_attr_dentries(struct fault_attr *attr)
+static inline struct dentry *fault_create_debugfs_attr(const char *name,
+                        struct dentry *parent, struct fault_attr *attr)
 {
+        return ERR_PTR(-ENODEV);
 }
 
 #endif /* CONFIG_FAULT_INJECTION_DEBUG_FS */
diff --git a/include/linux/fb.h b/include/linux/fb.h
index 6a8274877171..1d6836c498dd 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -1043,7 +1043,8 @@ extern void fb_deferred_io_open(struct fb_info *info,
                                 struct inode *inode,
                                 struct file *file);
 extern void fb_deferred_io_cleanup(struct fb_info *info);
-extern int fb_deferred_io_fsync(struct file *file, int datasync);
+extern int fb_deferred_io_fsync(struct file *file, loff_t start,
+                                loff_t end, int datasync);
 
 static inline bool fb_be_math(struct fb_info *info)
 {
diff --git a/include/linux/fd.h b/include/linux/fd.h
index f5d194af07a8..72202b1b9a6a 100644
--- a/include/linux/fd.h
+++ b/include/linux/fd.h
@@ -377,4 +377,26 @@ struct floppy_raw_cmd {
 #define FDEJECT _IO(2, 0x5a)
 /* eject the disk */
 
+
+#ifdef __KERNEL__
+#ifdef CONFIG_COMPAT
+#include <linux/compat.h>
+
+struct compat_floppy_struct {
+        compat_uint_t   size;
+        compat_uint_t   sect;
+        compat_uint_t   head;
+        compat_uint_t   track;
+        compat_uint_t   stretch;
+        unsigned char   gap;
+        unsigned char   rate;
+        unsigned char   spec1;
+        unsigned char   fmt_gap;
+        const compat_caddr_t name;
+};
+
+#define FDGETPRM32 _IOR(2, 0x04, struct compat_floppy_struct)
+#endif
+#endif
+
 #endif
diff --git a/include/linux/fdtable.h b/include/linux/fdtable.h
index 133c0ba25e30..82163c4b32c9 100644
--- a/include/linux/fdtable.h
+++ b/include/linux/fdtable.h
@@ -13,7 +13,7 @@
 #include <linux/init.h>
 #include <linux/fs.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 /*
  * The default fd array needs to be at least BITS_PER_LONG,
@@ -60,7 +60,6 @@ struct files_struct {
 
 #define rcu_dereference_check_fdtable(files, fdtfd) \
         (rcu_dereference_check((fdtfd), \
-                               rcu_read_lock_held() || \
                                lockdep_is_held(&(files)->file_lock) || \
                                atomic_read(&(files)->count) == 1 || \
                                rcu_my_thread_group_empty()))
diff --git a/include/linux/filter.h b/include/linux/filter.h
index 9ee3f9fb0b4a..741956fa5bfd 100644
--- a/include/linux/filter.h
+++ b/include/linux/filter.h
@@ -9,7 +9,7 @@
 #include <linux/types.h>
 
 #ifdef __KERNEL__
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #endif
 
 /*
diff --git a/include/linux/firewire-cdev.h b/include/linux/firewire-cdev.h
index 4ff09889c5c0..357dbfc2829e 100644
--- a/include/linux/firewire-cdev.h
+++ b/include/linux/firewire-cdev.h
@@ -30,10 +30,13 @@
 #include <linux/types.h>
 #include <linux/firewire-constants.h>
 
+/* available since kernel version 2.6.22 */
 #define FW_CDEV_EVENT_BUS_RESET                         0x00
 #define FW_CDEV_EVENT_RESPONSE                          0x01
 #define FW_CDEV_EVENT_REQUEST                           0x02
 #define FW_CDEV_EVENT_ISO_INTERRUPT                     0x03
+
+/* available since kernel version 2.6.30 */
 #define FW_CDEV_EVENT_ISO_RESOURCE_ALLOCATED            0x04
 #define FW_CDEV_EVENT_ISO_RESOURCE_DEALLOCATED          0x05
 
@@ -120,24 +123,11 @@ struct fw_cdev_event_response {
 
 /**
  * struct fw_cdev_event_request - Old version of &fw_cdev_event_request2
- * @closure:    See &fw_cdev_event_common; set by %FW_CDEV_IOC_ALLOCATE ioctl
  * @type:       See &fw_cdev_event_common; always %FW_CDEV_EVENT_REQUEST
- * @tcode:      See &fw_cdev_event_request2
- * @offset:     See &fw_cdev_event_request2
- * @handle:     See &fw_cdev_event_request2
- * @length:     See &fw_cdev_event_request2
- * @data:       See &fw_cdev_event_request2
  *
  * This event is sent instead of &fw_cdev_event_request2 if the kernel or
- * the client implements ABI version <= 3.
- *
- * Unlike &fw_cdev_event_request2, the sender identity cannot be established,
- * broadcast write requests cannot be distinguished from unicast writes, and
- * @tcode of lock requests is %TCODE_LOCK_REQUEST.
- *
- * Requests to the FCP_REQUEST or FCP_RESPONSE register are responded to as
- * with &fw_cdev_event_request2, except in kernel 2.6.32 and older which send
- * the response packet of the client's %FW_CDEV_IOC_SEND_RESPONSE ioctl.
+ * the client implements ABI version <= 3.  &fw_cdev_event_request lacks
+ * essential information; use &fw_cdev_event_request2 instead.
  */
 struct fw_cdev_event_request {
         __u64 closure;
@@ -452,29 +442,31 @@ union fw_cdev_event {
  *                 %FW_CDEV_ISO_CONTEXT_RECEIVE_MULTICHANNEL, and
  *                 %FW_CDEV_IOC_SET_ISO_CHANNELS
  */
-#define FW_CDEV_VERSION 3 /* Meaningless; don't use this macro. */
 
 /**
  * struct fw_cdev_get_info - General purpose information ioctl
  * @version:    The version field is just a running serial number.  Both an
  *              input parameter (ABI version implemented by the client) and
  *              output parameter (ABI version implemented by the kernel).
- *              A client must not fill in an %FW_CDEV_VERSION defined from an
- *              included kernel header file but the actual version for which
- *              the client was implemented.  This is necessary for forward
- *              compatibility.  We never break backwards compatibility, but
- *              may add more structs, events, and ioctls in later revisions.
- * @rom_length: If @rom is non-zero, at most rom_length bytes of configuration
+ *              A client shall fill in the ABI @version for which the client
+ *              was implemented.  This is necessary for forward compatibility.
+ * @rom_length: If @rom is non-zero, up to @rom_length bytes of Configuration
  *              ROM will be copied into that user space address.  In either
  *              case, @rom_length is updated with the actual length of the
- *              configuration ROM.
+ *              Configuration ROM.
  * @rom:        If non-zero, address of a buffer to be filled by a copy of the
- *              device's configuration ROM
+ *              device's Configuration ROM
  * @bus_reset:  If non-zero, address of a buffer to be filled by a
  *              &struct fw_cdev_event_bus_reset with the current state
  *              of the bus.  This does not cause a bus reset to happen.
  * @bus_reset_closure: Value of &closure in this and subsequent bus reset events
  * @card:       The index of the card this device belongs to
+ *
+ * The %FW_CDEV_IOC_GET_INFO ioctl is usually the very first one which a client
+ * performs right after it opened a /dev/fw* file.
+ *
+ * As a side effect, reception of %FW_CDEV_EVENT_BUS_RESET events to be read(2)
+ * is started by this ioctl.
  */
 struct fw_cdev_get_info {
         __u32 version;
@@ -612,7 +604,7 @@ struct fw_cdev_initiate_bus_reset {
  * @handle:     Handle to the descriptor, written by the kernel
  *
  * Add a descriptor block and optionally a preceding immediate key to the local
- * node's configuration ROM.
+ * node's Configuration ROM.
  *
  * The @key field specifies the upper 8 bits of the descriptor root directory
  * pointer and the @data and @length fields specify the contents. The @key
@@ -627,9 +619,9 @@ struct fw_cdev_initiate_bus_reset {
  * If successful, the kernel adds the descriptor and writes back a @handle to
  * the kernel-side object to be used for later removal of the descriptor block
  * and immediate key.  The kernel will also generate a bus reset to signal the
- * change of the configuration ROM to other nodes.
+ * change of the Configuration ROM to other nodes.
  *
- * This ioctl affects the configuration ROMs of all local nodes.
+ * This ioctl affects the Configuration ROMs of all local nodes.
  * The ioctl only succeeds on device files which represent a local node.
  */
 struct fw_cdev_add_descriptor {
@@ -641,13 +633,13 @@ struct fw_cdev_add_descriptor {
 };
 
 /**
- * struct fw_cdev_remove_descriptor - Remove contents from the configuration ROM
+ * struct fw_cdev_remove_descriptor - Remove contents from the Configuration ROM
  * @handle:     Handle to the descriptor, as returned by the kernel when the
  *              descriptor was added
  *
  * Remove a descriptor block and accompanying immediate key from the local
- * nodes' configuration ROMs.  The kernel will also generate a bus reset to
- * signal the change of the configuration ROM to other nodes.
+ * nodes' Configuration ROMs.  The kernel will also generate a bus reset to
+ * signal the change of the Configuration ROM to other nodes.
  */
 struct fw_cdev_remove_descriptor {
         __u32 handle;
@@ -863,13 +855,8 @@ struct fw_cdev_stop_iso {
  * @local_time:   system time, in microseconds since the Epoch
  * @cycle_timer:  Cycle Time register contents
  *
- * The %FW_CDEV_IOC_GET_CYCLE_TIMER ioctl reads the isochronous cycle timer
- * and also the system clock (%CLOCK_REALTIME).  This allows to express the
- * receive time of an isochronous packet as a system time.
- *
- * @cycle_timer consists of 7 bits cycleSeconds, 13 bits cycleCount, and
- * 12 bits cycleOffset, in host byte order.  Cf. the Cycle Time register
- * per IEEE 1394 or Isochronous Cycle Timer register per OHCI-1394.
+ * Same as %FW_CDEV_IOC_GET_CYCLE_TIMER2, but fixed to use %CLOCK_REALTIME
+ * and only with microseconds resolution.
  *
  * In version 1 and 2 of the ABI, this ioctl returned unreliable (non-
  * monotonic) @cycle_timer values on certain controllers.
@@ -886,10 +873,17 @@ struct fw_cdev_get_cycle_timer {
  * @clk_id:       input parameter, clock from which to get the system time
  * @cycle_timer:  Cycle Time register contents
  *
- * The %FW_CDEV_IOC_GET_CYCLE_TIMER2 works like
- * %FW_CDEV_IOC_GET_CYCLE_TIMER but lets you choose a clock like with POSIX'
- * clock_gettime function.  Supported @clk_id values are POSIX' %CLOCK_REALTIME
- * and %CLOCK_MONOTONIC and Linux' %CLOCK_MONOTONIC_RAW.
+ * The %FW_CDEV_IOC_GET_CYCLE_TIMER2 ioctl reads the isochronous cycle timer
+ * and also the system clock.  This allows to correlate reception time of
+ * isochronous packets with system time.
+ *
+ * @clk_id lets you choose a clock like with POSIX' clock_gettime function.
+ * Supported @clk_id values are POSIX' %CLOCK_REALTIME and %CLOCK_MONOTONIC
+ * and Linux' %CLOCK_MONOTONIC_RAW.
+ *
+ * @cycle_timer consists of 7 bits cycleSeconds, 13 bits cycleCount, and
+ * 12 bits cycleOffset, in host byte order.  Cf. the Cycle Time register
+ * per IEEE 1394 or Isochronous Cycle Timer register per OHCI-1394.
  */
 struct fw_cdev_get_cycle_timer2 {
         __s64 tv_sec;
@@ -1011,4 +1005,6 @@ struct fw_cdev_receive_phy_packets {
         __u64 closure;
 };
 
+#define FW_CDEV_VERSION 3 /* Meaningless legacy macro; don't use it. */
+
 #endif /* _LINUX_FIREWIRE_CDEV_H */
diff --git a/include/linux/firewire.h b/include/linux/firewire.h
index 5e6f42789afe..84ccf8e04fa6 100644
--- a/include/linux/firewire.h
+++ b/include/linux/firewire.h
@@ -14,7 +14,7 @@
 #include <linux/types.h>
 #include <linux/workqueue.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <asm/byteorder.h>
 
 #define fw_notify(s, args...) printk(KERN_NOTICE KBUILD_MODNAME ": " s, ## args)
diff --git a/include/linux/fs.h b/include/linux/fs.h
index c55d6b7cd5d6..178cdb4f1d4a 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -32,7 +32,9 @@
 #define SEEK_SET        0       /* seek relative to beginning of file */
 #define SEEK_CUR        1       /* seek relative to current file position */
 #define SEEK_END        2       /* seek relative to end of file */
-#define SEEK_MAX        SEEK_END
+#define SEEK_DATA       3       /* seek to the next data */
+#define SEEK_HOLE       4       /* seek to the next hole */
+#define SEEK_MAX        SEEK_HOLE
 
 struct fstrim_range {
         __u64 start;
@@ -63,6 +65,7 @@ struct inodes_stat_t {
 #define MAY_ACCESS 16
 #define MAY_OPEN 32
 #define MAY_CHDIR 64
+#define MAY_NOT_BLOCK 128       /* called from RCU mode, don't block */
 
 /*
  * flags in file.f_mode.  Note that FMODE_READ and FMODE_WRITE must correspond
@@ -208,6 +211,7 @@ struct inodes_stat_t {
 #define MS_KERNMOUNT    (1<<22) /* this is a kern_mount call */
 #define MS_I_VERSION    (1<<23) /* Update inode I_version field */
 #define MS_STRICTATIME  (1<<24) /* Always perform atime updates */
+#define MS_NOSEC        (1<<28)
 #define MS_BORN         (1<<29)
 #define MS_ACTIVE       (1<<30)
 #define MS_NOUSER       (1<<31)
@@ -375,7 +379,6 @@ struct inodes_stat_t {
 
 #include <linux/linkage.h>
 #include <linux/wait.h>
-#include <linux/types.h>
 #include <linux/kdev_t.h>
 #include <linux/dcache.h>
 #include <linux/path.h>
@@ -391,8 +394,9 @@ struct inodes_stat_t {
 #include <linux/semaphore.h>
 #include <linux/fiemap.h>
 #include <linux/rculist_bl.h>
+#include <linux/shrinker.h>
+#include <linux/atomic.h>
 
-#include <asm/atomic.h>
 #include <asm/byteorder.h>
 
 struct export_operations;
@@ -638,6 +642,7 @@ struct address_space {
         struct prio_tree_root   i_mmap;         /* tree of private and shared mappings */
         struct list_head        i_mmap_nonlinear;/*list VM_NONLINEAR mappings */
         struct mutex            i_mmap_mutex;   /* protect tree, count, list */
+        /* Protected by tree_lock together with the radix tree */
         unsigned long           nrpages;        /* number of total pages */
         pgoff_t                 writeback_index;/* writeback starts here */
         const struct address_space_operations *a_ops;   /* methods */
@@ -733,19 +738,55 @@ static inline int mapping_writably_mapped(struct address_space *mapping)
 struct posix_acl;
 #define ACL_NOT_CACHED ((void *)(-1))
 
+#define IOP_FASTPERM    0x0001
+#define IOP_LOOKUP      0x0002
+#define IOP_NOFOLLOW    0x0004
+
+/*
+ * Keep mostly read-only and often accessed (especially for
+ * the RCU path lookup and 'stat' data) fields at the beginning
+ * of the 'struct inode'
+ */
 struct inode {
-        /* RCU path lookup touches following: */
         umode_t                 i_mode;
+        unsigned short          i_opflags;
         uid_t                   i_uid;
         gid_t                   i_gid;
+        unsigned int            i_flags;
+
+#ifdef CONFIG_FS_POSIX_ACL
+        struct posix_acl        *i_acl;
+        struct posix_acl        *i_default_acl;
+#endif
+
         const struct inode_operations   *i_op;
         struct super_block      *i_sb;
+        struct address_space    *i_mapping;
+
+#ifdef CONFIG_SECURITY
+        void                    *i_security;
+#endif
 
+        /* Stat data, not accessed from path walking */
+        unsigned long           i_ino;
+        unsigned int            i_nlink;
+        dev_t                   i_rdev;
+        loff_t                  i_size;
+        struct timespec         i_atime;
+        struct timespec         i_mtime;
+        struct timespec         i_ctime;
+        unsigned int            i_blkbits;
+        blkcnt_t                i_blocks;
+
+#ifdef __NEED_I_SIZE_ORDERED
+        seqcount_t              i_size_seqcount;
+#endif
+
+        /* Misc */
+        unsigned long           i_state;
         spinlock_t              i_lock; /* i_blocks, i_bytes, maybe i_size */
-        unsigned int            i_flags;
         struct mutex            i_mutex;
 
-        unsigned long           i_state;
         unsigned long           dirtied_when;   /* jiffies of first dirtying */
 
         struct hlist_node       i_hash;
@@ -756,25 +797,12 @@ struct inode {
                 struct list_head        i_dentry;
                 struct rcu_head         i_rcu;
         };
-        unsigned long           i_ino;
         atomic_t                i_count;
-        unsigned int            i_nlink;
-        dev_t                   i_rdev;
-        unsigned int            i_blkbits;
         u64                     i_version;
-        loff_t                  i_size;
-#ifdef __NEED_I_SIZE_ORDERED
-        seqcount_t              i_size_seqcount;
-#endif
-        struct timespec         i_atime;
-        struct timespec         i_mtime;
-        struct timespec         i_ctime;
-        blkcnt_t                i_blocks;
         unsigned short          i_bytes;
-        struct rw_semaphore     i_alloc_sem;
+        atomic_t                i_dio_count;
         const struct file_operations    *i_fop; /* former ->i_op->default_file_ops */
         struct file_lock        *i_flock;
-        struct address_space    *i_mapping;
         struct address_space    i_data;
 #ifdef CONFIG_QUOTA
         struct dquot            *i_dquot[MAXQUOTAS];
@@ -797,13 +825,6 @@ struct inode {
         atomic_t                i_readcount; /* struct files open RO */
 #endif
         atomic_t                i_writecount;
-#ifdef CONFIG_SECURITY
-        void                    *i_security;
-#endif
-#ifdef CONFIG_FS_POSIX_ACL
-        struct posix_acl        *i_acl;
-        struct posix_acl        *i_default_acl;
-#endif
         void                    *i_private; /* fs or device private pointer */
 };
 
@@ -1066,12 +1087,12 @@ struct file_lock_operations {
 };
 
 struct lock_manager_operations {
-        int (*fl_compare_owner)(struct file_lock *, struct file_lock *);
-        void (*fl_notify)(struct file_lock *);  /* unblock callback */
-        int (*fl_grant)(struct file_lock *, struct file_lock *, int);
-        void (*fl_release_private)(struct file_lock *);
-        void (*fl_break)(struct file_lock *);
-        int (*fl_change)(struct file_lock **, int);
+        int (*lm_compare_owner)(struct file_lock *, struct file_lock *);
+        void (*lm_notify)(struct file_lock *);  /* unblock callback */
+        int (*lm_grant)(struct file_lock *, struct file_lock *, int);
+        void (*lm_release_private)(struct file_lock *);
+        void (*lm_break)(struct file_lock *);
+        int (*lm_change)(struct file_lock **, int);
 };
 
 struct lock_manager {
@@ -1393,6 +1414,11 @@ struct super_block {
         struct list_head        s_dentry_lru;   /* unused dentry lru */
         int                     s_nr_dentry_unused;     /* # of dentry on lru */
 
+        /* s_inode_lru_lock protects s_inode_lru and s_nr_inodes_unused */
+        spinlock_t              s_inode_lru_lock ____cacheline_aligned_in_smp;
+        struct list_head        s_inode_lru;            /* unused inode lru */
+        int                     s_nr_inodes_unused;     /* # of inodes on lru */
+
         struct block_device     *s_bdev;
         struct backing_dev_info *s_bdi;
         struct mtd_info         *s_mtd;
@@ -1435,8 +1461,14 @@ struct super_block {
          * Saved pool identifier for cleancache (-1 means none)
          */
         int cleancache_poolid;
+
+        struct shrinker s_shrink;       /* per-sb shrinker handle */
 };
 
+/* superblock cache pruning functions */
+extern void prune_icache_sb(struct super_block *sb, int nr_to_scan);
+extern void prune_dcache_sb(struct super_block *sb, int nr_to_scan);
+
 extern struct timespec current_fs_time(struct super_block *sb);
 
 /*
@@ -1451,10 +1483,6 @@ enum {
 #define vfs_check_frozen(sb, level) \
         wait_event((sb)->s_wait_unfrozen, ((sb)->s_frozen < (level)))
 
-#define get_fs_excl() atomic_inc(&current->fs_excl)
-#define put_fs_excl() atomic_dec(&current->fs_excl)
-#define has_fs_excl() atomic_read(&current->fs_excl)
-
 /*
  * until VFS tracks user namespaces for inodes, just make all files
  * belong to init_user_ns
@@ -1487,7 +1515,6 @@ extern void dentry_unhash(struct dentry *dentry);
 /*
  * VFS file helper functions.
  */
-extern int file_permission(struct file *, int);
 extern void inode_init_owner(struct inode *inode, const struct inode *dir,
                         mode_t mode);
 /*
@@ -1535,11 +1562,6 @@ struct block_device_operations;
 #define HAVE_COMPAT_IOCTL 1
 #define HAVE_UNLOCKED_IOCTL 1
 
-/*
- * NOTE:
- * all file operations except setlease can be called without
- * the big kernel lock held in all filesystems.
- */
 struct file_operations {
         struct module *owner;
         loff_t (*llseek) (struct file *, loff_t, int);
@@ -1555,7 +1577,7 @@ struct file_operations {
         int (*open) (struct inode *, struct file *);
         int (*flush) (struct file *, fl_owner_t id);
         int (*release) (struct inode *, struct file *);
-        int (*fsync) (struct file *, int datasync);
+        int (*fsync) (struct file *, loff_t, loff_t, int datasync);
         int (*aio_fsync) (struct kiocb *, int datasync);
         int (*fasync) (int, struct file *, int);
         int (*lock) (struct file *, int, struct file_lock *);
@@ -1570,13 +1592,11 @@ struct file_operations {
                           loff_t len);
 };
 
-#define IPERM_FLAG_RCU  0x0001
-
 struct inode_operations {
         struct dentry * (*lookup) (struct inode *,struct dentry *, struct nameidata *);
         void * (*follow_link) (struct dentry *, struct nameidata *);
-        int (*permission) (struct inode *, int, unsigned int);
-        int (*check_acl)(struct inode *, int, unsigned int);
+        int (*permission) (struct inode *, int);
+        struct posix_acl * (*get_acl)(struct inode *, int);
 
         int (*readlink) (struct dentry *, char __user *,int);
         void (*put_link) (struct dentry *, struct nameidata *, void *);
@@ -1642,6 +1662,8 @@ struct super_operations {
         ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
 #endif
         int (*bdev_try_to_free_page)(struct super_block*, struct page*, gfp_t);
+        int (*nr_cached_objects)(struct super_block *);
+        void (*free_cached_objects)(struct super_block *, int);
 };
 
 /*
@@ -1690,6 +1712,10 @@ struct super_operations {
  *                      set during data writeback, and cleared with a wakeup
  *                      on the bit address once it is done.
  *
+ * I_REFERENCED         Marks the inode as recently references on the LRU list.
+ *
+ * I_DIO_WAKEUP         Never set.  Only used as a key for wait_on_bit().
+ *
  * Q: What is the difference between I_WILL_FREE and I_FREEING?
  */
 #define I_DIRTY_SYNC            (1 << 0)
@@ -1703,6 +1729,8 @@ struct super_operations {
 #define __I_SYNC                7
 #define I_SYNC                  (1 << __I_SYNC)
 #define I_REFERENCED            (1 << 8)
+#define __I_DIO_WAKEUP          9
+#define I_DIO_WAKEUP            (1 << I_DIO_WAKEUP)
 
 #define I_DIRTY (I_DIRTY_SYNC | I_DIRTY_DATASYNC | I_DIRTY_PAGES)
 
@@ -1813,7 +1841,6 @@ struct file_system_type {
         struct lock_class_key i_lock_key;
         struct lock_class_key i_mutex_key;
         struct lock_class_key i_mutex_dir_key;
-        struct lock_class_key i_alloc_sem_key;
 };
 
 extern struct dentry *mount_ns(struct file_system_type *fs_type, int flags,
@@ -1834,6 +1861,8 @@ void kill_litter_super(struct super_block *sb);
 void deactivate_super(struct super_block *sb);
 void deactivate_locked_super(struct super_block *sb);
 int set_anon_super(struct super_block *s, void *data);
+int get_anon_bdev(dev_t *);
+void free_anon_bdev(dev_t);
 struct super_block *sget(struct file_system_type *type,
                         int (*test)(struct super_block *,void *),
                         int (*set)(struct super_block *,void *),
@@ -1866,6 +1895,7 @@ extern int register_filesystem(struct file_system_type *);
 extern int unregister_filesystem(struct file_system_type *);
 extern struct vfsmount *kern_mount_data(struct file_system_type *, void *data);
 #define kern_mount(type) kern_mount_data(type, NULL)
+extern void kern_unmount(struct vfsmount *mnt);
 extern int may_umount_tree(struct vfsmount *);
 extern int may_umount(struct vfsmount *);
 extern long do_mount(char *, char *, char *, unsigned long, void *);
@@ -2185,16 +2215,38 @@ extern sector_t bmap(struct inode *, sector_t);
 #endif
 extern int notify_change(struct dentry *, struct iattr *);
 extern int inode_permission(struct inode *, int);
-extern int generic_permission(struct inode *, int, unsigned int,
-                int (*check_acl)(struct inode *, int, unsigned int));
+extern int generic_permission(struct inode *, int);
 
 static inline bool execute_ok(struct inode *inode)
 {
         return (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode);
 }
 
-extern int get_write_access(struct inode *);
-extern int deny_write_access(struct file *);
+/*
+ * get_write_access() gets write permission for a file.
+ * put_write_access() releases this write permission.
+ * This is used for regular files.
+ * We cannot support write (and maybe mmap read-write shared) accesses and
+ * MAP_DENYWRITE mmappings simultaneously. The i_writecount field of an inode
+ * can have the following values:
+ * 0: no writers, no VM_DENYWRITE mappings
+ * < 0: (-i_writecount) vm_area_structs with VM_DENYWRITE set exist
+ * > 0: (i_writecount) users are writing to the file.
+ *
+ * Normally we operate on that counter with atomic_{inc,dec} and it's safe
+ * except for the cases where we don't hold i_writecount yet. Then we need to
+ * use {get,deny}_write_access() - these functions check the sign and refuse
+ * to do the change if sign is wrong.
+ */
+static inline int get_write_access(struct inode *inode)
+{
+        return atomic_inc_unless_negative(&inode->i_writecount) ? 0 : -ETXTBSY;
+}
+static inline int deny_write_access(struct file *file)
+{
+        struct inode *inode = file->f_path.dentry->d_inode;
+        return atomic_dec_unless_positive(&inode->i_writecount) ? 0 : -ETXTBSY;
+}
 static inline void put_write_access(struct inode * inode)
 {
         atomic_dec(&inode->i_writecount);
@@ -2273,17 +2325,25 @@ extern void __iget(struct inode * inode);
 extern void iget_failed(struct inode *);
 extern void end_writeback(struct inode *);
 extern void __destroy_inode(struct inode *);
-extern struct inode *new_inode(struct super_block *);
+extern struct inode *new_inode_pseudo(struct super_block *sb);
+extern struct inode *new_inode(struct super_block *sb);
 extern void free_inode_nonrcu(struct inode *inode);
 extern int should_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 *);
 static inline void insert_inode_hash(struct inode *inode)
 {
         __insert_inode_hash(inode, inode->i_ino);
 }
+
+extern void __remove_inode_hash(struct inode *);
+static inline void remove_inode_hash(struct inode *inode)
+{
+        if (!inode_unhashed(inode))
+                __remove_inode_hash(inode);
+}
+
 extern void inode_sb_list_add(struct inode *inode);
 
 #ifdef CONFIG_BLOCK
@@ -2314,7 +2374,8 @@ extern int generic_segment_checks(const struct iovec *iov,
 /* fs/block_dev.c */
 extern ssize_t blkdev_aio_write(struct kiocb *iocb, const struct iovec *iov,
                                 unsigned long nr_segs, loff_t pos);
-extern int blkdev_fsync(struct file *filp, int datasync);
+extern int blkdev_fsync(struct file *filp, loff_t start, loff_t end,
+                        int datasync);
 
 /* fs/splice.c */
 extern ssize_t generic_file_splice_read(struct file *, loff_t *,
@@ -2365,6 +2426,8 @@ enum {
 };
 
 void dio_end_io(struct bio *bio, int error);
+void inode_dio_wait(struct inode *inode);
+void inode_dio_done(struct inode *inode);
 
 ssize_t __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
         struct block_device *bdev, const struct iovec *iov, loff_t offset,
@@ -2372,14 +2435,17 @@ ssize_t __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
         dio_submit_t submit_io, int flags);
 
 static inline ssize_t blockdev_direct_IO(int rw, struct kiocb *iocb,
-        struct inode *inode, struct block_device *bdev, const struct iovec *iov,
-        loff_t offset, unsigned long nr_segs, get_block_t get_block,
-        dio_iodone_t end_io)
+                struct inode *inode, const struct iovec *iov, loff_t offset,
+                unsigned long nr_segs, get_block_t get_block)
 {
-        return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
-                                    nr_segs, get_block, end_io, NULL,
+        return __blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
+                                    offset, nr_segs, get_block, NULL, NULL,
                                     DIO_LOCKING | DIO_SKIP_HOLES);
 }
+#else
+static inline void inode_dio_wait(struct inode *inode)
+{
+}
 #endif
 
 extern const struct file_operations generic_ro_fops;
@@ -2429,6 +2495,8 @@ extern struct super_block *get_active_super(struct block_device *bdev);
 extern struct super_block *user_get_super(dev_t);
 extern void drop_super(struct super_block *sb);
 extern void iterate_supers(void (*)(struct super_block *, void *), void *);
+extern void iterate_supers_type(struct file_system_type *,
+                                void (*)(struct super_block *, void *), void *);
 
 extern int dcache_dir_open(struct inode *, struct file *);
 extern int dcache_dir_close(struct inode *, struct file *);
@@ -2441,7 +2509,7 @@ extern int simple_link(struct dentry *, struct inode *, struct dentry *);
 extern int simple_unlink(struct inode *, struct dentry *);
 extern int simple_rmdir(struct inode *, struct dentry *);
 extern int simple_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
-extern int noop_fsync(struct file *, int);
+extern int noop_fsync(struct file *, loff_t, loff_t, int);
 extern int simple_empty(struct dentry *);
 extern int simple_readpage(struct file *file, struct page *page);
 extern int simple_write_begin(struct file *file, struct address_space *mapping,
@@ -2466,7 +2534,7 @@ extern ssize_t simple_read_from_buffer(void __user *to, size_t count,
 extern ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos,
                 const void __user *from, size_t count);
 
-extern int generic_file_fsync(struct file *, int);
+extern int generic_file_fsync(struct file *, loff_t, loff_t, int);
 
 extern int generic_check_addressable(unsigned, u64);
 
@@ -2591,7 +2659,7 @@ static inline int is_sxid(mode_t mode)
 
 static inline void inode_has_no_xattr(struct inode *inode)
 {
-        if (!is_sxid(inode->i_mode))
+        if (!is_sxid(inode->i_mode) && (inode->i_sb->s_flags & MS_NOSEC))
                 inode->i_flags |= S_NOSEC;
 }
 
diff --git a/include/linux/fscache.h b/include/linux/fscache.h
index 7c4d72f5581f..9ec20dec3353 100644
--- a/include/linux/fscache.h
+++ b/include/linux/fscache.h
@@ -204,6 +204,8 @@ extern bool __fscache_check_page_write(struct fscache_cookie *, struct page *);
 extern void __fscache_wait_on_page_write(struct fscache_cookie *, struct page *);
 extern bool __fscache_maybe_release_page(struct fscache_cookie *, struct page *,
                                          gfp_t);
+extern void __fscache_uncache_all_inode_pages(struct fscache_cookie *,
+                                              struct inode *);
 
 /**
  * fscache_register_netfs - Register a filesystem as desiring caching services
@@ -643,4 +645,23 @@ bool fscache_maybe_release_page(struct fscache_cookie *cookie,
         return false;
 }
 
+/**
+ * fscache_uncache_all_inode_pages - Uncache all an inode's pages
+ * @cookie: The cookie representing the inode's cache object.
+ * @inode: The inode to uncache pages from.
+ *
+ * Uncache all the pages in an inode that are marked PG_fscache, assuming them
+ * to be associated with the given cookie.
+ *
+ * This function may sleep.  It will wait for pages that are being written out
+ * and will wait whilst the PG_fscache mark is removed by the cache.
+ */
+static inline
+void fscache_uncache_all_inode_pages(struct fscache_cookie *cookie,
+                                     struct inode *inode)
+{
+        if (fscache_cookie_valid(cookie))
+                __fscache_uncache_all_inode_pages(cookie, inode);
+}
+
 #endif /* _LINUX_FSCACHE_H */
diff --git a/include/linux/fsl-diu-fb.h b/include/linux/fsl-diu-fb.h
index 781d4671415f..daa9952d2174 100644
--- a/include/linux/fsl-diu-fb.h
+++ b/include/linux/fsl-diu-fb.h
@@ -24,12 +24,6 @@
  * See mpc8610fb_set_par(), map_video_memory(), and unmap_video_memory()
  */
 #define MEM_ALLOC_THRESHOLD (1024*768*4+32)
-/* Minimum value that the pixel clock can be set to in pico seconds
- * This is determined by platform clock/3 where the minimum platform
- * clock is 533MHz. This gives 5629 pico seconds.
- */
-#define MIN_PIX_CLK 5629
-#define MAX_PIX_CLK 96096
 
 #include <linux/types.h>
 
diff --git a/include/linux/fsl_hypervisor.h b/include/linux/fsl_hypervisor.h
new file mode 100644
index 000000000000..1cebaeeeef57
--- /dev/null
+++ b/include/linux/fsl_hypervisor.h
@@ -0,0 +1,241 @@
+/*
+ * Freescale hypervisor ioctl and kernel interface
+ *
+ * Copyright (C) 2008-2011 Freescale Semiconductor, Inc.
+ * Author: Timur Tabi <timur@freescale.com>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Freescale Semiconductor nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ *
+ * ALTERNATIVELY, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") as published by the Free Software
+ * Foundation, either version 2 of that License or (at your option) any
+ * later version.
+ *
+ * This software is provided by Freescale Semiconductor "as is" and any
+ * express or implied warranties, including, but not limited to, the implied
+ * warranties of merchantability and fitness for a particular purpose are
+ * disclaimed. In no event shall Freescale Semiconductor be liable for any
+ * direct, indirect, incidental, special, exemplary, or consequential damages
+ * (including, but not limited to, procurement of substitute goods or services;
+ * loss of use, data, or profits; or business interruption) however caused and
+ * on any theory of liability, whether in contract, strict liability, or tort
+ * (including negligence or otherwise) arising in any way out of the use of this
+ * software, even if advised of the possibility of such damage.
+ *
+ * This file is used by the Freescale hypervisor management driver.  It can
+ * also be included by applications that need to communicate with the driver
+ * via the ioctl interface.
+ */
+
+#ifndef FSL_HYPERVISOR_H
+#define FSL_HYPERVISOR_H
+
+#include <linux/types.h>
+
+/**
+ * struct fsl_hv_ioctl_restart - restart a partition
+ * @ret: return error code from the hypervisor
+ * @partition: the ID of the partition to restart, or -1 for the
+ *             calling partition
+ *
+ * Used by FSL_HV_IOCTL_PARTITION_RESTART
+ */
+struct fsl_hv_ioctl_restart {
+        __u32 ret;
+        __u32 partition;
+};
+
+/**
+ * struct fsl_hv_ioctl_status - get a partition's status
+ * @ret: return error code from the hypervisor
+ * @partition: the ID of the partition to query, or -1 for the
+ *             calling partition
+ * @status: The returned status of the partition
+ *
+ * Used by FSL_HV_IOCTL_PARTITION_GET_STATUS
+ *
+ * Values of 'status':
+ *    0 = Stopped
+ *    1 = Running
+ *    2 = Starting
+ *    3 = Stopping
+ */
+struct fsl_hv_ioctl_status {
+        __u32 ret;
+        __u32 partition;
+        __u32 status;
+};
+
+/**
+ * struct fsl_hv_ioctl_start - start a partition
+ * @ret: return error code from the hypervisor
+ * @partition: the ID of the partition to control
+ * @entry_point: The offset within the guest IMA to start execution
+ * @load: If non-zero, reload the partition's images before starting
+ *
+ * Used by FSL_HV_IOCTL_PARTITION_START
+ */
+struct fsl_hv_ioctl_start {
+        __u32 ret;
+        __u32 partition;
+        __u32 entry_point;
+        __u32 load;
+};
+
+/**
+ * struct fsl_hv_ioctl_stop - stop a partition
+ * @ret: return error code from the hypervisor
+ * @partition: the ID of the partition to stop, or -1 for the calling
+ *             partition
+ *
+ * Used by FSL_HV_IOCTL_PARTITION_STOP
+ */
+struct fsl_hv_ioctl_stop {
+        __u32 ret;
+        __u32 partition;
+};
+
+/**
+ * struct fsl_hv_ioctl_memcpy - copy memory between partitions
+ * @ret: return error code from the hypervisor
+ * @source: the partition ID of the source partition, or -1 for this
+ *          partition
+ * @target: the partition ID of the target partition, or -1 for this
+ *          partition
+ * @reserved: reserved, must be set to 0
+ * @local_addr: user-space virtual address of a buffer in the local
+ *              partition
+ * @remote_addr: guest physical address of a buffer in the
+ *           remote partition
+ * @count: the number of bytes to copy.  Both the local and remote
+ *         buffers must be at least 'count' bytes long
+ *
+ * Used by FSL_HV_IOCTL_MEMCPY
+ *
+ * The 'local' partition is the partition that calls this ioctl.  The
+ * 'remote' partition is a different partition.  The data is copied from
+ * the 'source' paritition' to the 'target' partition.
+ *
+ * The buffer in the remote partition must be guest physically
+ * contiguous.
+ *
+ * This ioctl does not support copying memory between two remote
+ * partitions or within the same partition, so either 'source' or
+ * 'target' (but not both) must be -1.  In other words, either
+ *
+ *      source == local and target == remote
+ * or
+ *      source == remote and target == local
+ */
+struct fsl_hv_ioctl_memcpy {
+        __u32 ret;
+        __u32 source;
+        __u32 target;
+        __u32 reserved; /* padding to ensure local_vaddr is aligned */
+        __u64 local_vaddr;
+        __u64 remote_paddr;
+        __u64 count;
+};
+
+/**
+ * struct fsl_hv_ioctl_doorbell - ring a doorbell
+ * @ret: return error code from the hypervisor
+ * @doorbell: the handle of the doorbell to ring doorbell
+ *
+ * Used by FSL_HV_IOCTL_DOORBELL
+ */
+struct fsl_hv_ioctl_doorbell {
+        __u32 ret;
+        __u32 doorbell;
+};
+
+/**
+ * struct fsl_hv_ioctl_prop - get/set a device tree property
+ * @ret: return error code from the hypervisor
+ * @handle: handle of partition whose tree to access
+ * @path: virtual address of path name of node to access
+ * @propname: virtual address of name of property to access
+ * @propval: virtual address of property data buffer
+ * @proplen: Size of property data buffer
+ * @reserved: reserved, must be set to 0
+ *
+ * Used by FSL_HV_IOCTL_DOORBELL
+ */
+struct fsl_hv_ioctl_prop {
+        __u32 ret;
+        __u32 handle;
+        __u64 path;
+        __u64 propname;
+        __u64 propval;
+        __u32 proplen;
+        __u32 reserved; /* padding to ensure structure is aligned */
+};
+
+/* The ioctl type, documented in ioctl-number.txt */
+#define FSL_HV_IOCTL_TYPE       0xAF
+
+/* Restart another partition */
+#define FSL_HV_IOCTL_PARTITION_RESTART \
+        _IOWR(FSL_HV_IOCTL_TYPE, 1, struct fsl_hv_ioctl_restart)
+
+/* Get a partition's status */
+#define FSL_HV_IOCTL_PARTITION_GET_STATUS \
+        _IOWR(FSL_HV_IOCTL_TYPE, 2, struct fsl_hv_ioctl_status)
+
+/* Boot another partition */
+#define FSL_HV_IOCTL_PARTITION_START \
+        _IOWR(FSL_HV_IOCTL_TYPE, 3, struct fsl_hv_ioctl_start)
+
+/* Stop this or another partition */
+#define FSL_HV_IOCTL_PARTITION_STOP \
+        _IOWR(FSL_HV_IOCTL_TYPE, 4, struct fsl_hv_ioctl_stop)
+
+/* Copy data from one partition to another */
+#define FSL_HV_IOCTL_MEMCPY \
+        _IOWR(FSL_HV_IOCTL_TYPE, 5, struct fsl_hv_ioctl_memcpy)
+
+/* Ring a doorbell */
+#define FSL_HV_IOCTL_DOORBELL \
+        _IOWR(FSL_HV_IOCTL_TYPE, 6, struct fsl_hv_ioctl_doorbell)
+
+/* Get a property from another guest's device tree */
+#define FSL_HV_IOCTL_GETPROP \
+        _IOWR(FSL_HV_IOCTL_TYPE, 7, struct fsl_hv_ioctl_prop)
+
+/* Set a property in another guest's device tree */
+#define FSL_HV_IOCTL_SETPROP \
+        _IOWR(FSL_HV_IOCTL_TYPE, 8, struct fsl_hv_ioctl_prop)
+
+#ifdef __KERNEL__
+
+/**
+ * fsl_hv_event_register() - register a callback for failover events
+ * @nb: pointer to caller-supplied notifier_block structure
+ *
+ * This function is called by device drivers to register their callback
+ * functions for fail-over events.
+ *
+ * The caller should allocate a notifier_block object and initialize the
+ * 'priority' and 'notifier_call' fields.
+ */
+int fsl_hv_failover_register(struct notifier_block *nb);
+
+/**
+ * fsl_hv_event_unregister() - unregister a callback for failover events
+ * @nb: the same 'nb' used in previous fsl_hv_failover_register call
+ */
+int fsl_hv_failover_unregister(struct notifier_block *nb);
+
+#endif
+
+#endif
diff --git a/include/linux/fsnotify_backend.h b/include/linux/fsnotify_backend.h
index 69ad89b50489..91d0e0a34ef3 100644
--- a/include/linux/fsnotify_backend.h
+++ b/include/linux/fsnotify_backend.h
@@ -16,7 +16,7 @@
 #include <linux/spinlock.h>
 #include <linux/types.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 /*
  * IN_* from inotfy.h lines up EXACTLY with FS_*, this is so we can easily
diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h
index 9d88e1cb5dbb..f0c0e8a47ae6 100644
--- a/include/linux/ftrace.h
+++ b/include/linux/ftrace.h
@@ -19,6 +19,8 @@
 
 #include <asm/ftrace.h>
 
+struct ftrace_hash;
+
 #ifdef CONFIG_FUNCTION_TRACER
 
 extern int ftrace_enabled;
@@ -29,8 +31,6 @@ ftrace_enable_sysctl(struct ctl_table *table, int write,
 
 typedef void (*ftrace_func_t)(unsigned long ip, unsigned long parent_ip);
 
-struct ftrace_hash;
-
 enum {
         FTRACE_OPS_FL_ENABLED           = 1 << 0,
         FTRACE_OPS_FL_GLOBAL            = 1 << 1,
@@ -123,7 +123,8 @@ stack_trace_sysctl(struct ctl_table *table, int write,
 struct ftrace_func_command {
         struct list_head        list;
         char                    *name;
-        int                     (*func)(char *func, char *cmd,
+        int                     (*func)(struct ftrace_hash *hash,
+                                        char *func, char *cmd,
                                         char *params, int enable);
 };
 
diff --git a/include/linux/ftrace_event.h b/include/linux/ftrace_event.h
index 59d3ef100eb9..96efa6794ea5 100644
--- a/include/linux/ftrace_event.h
+++ b/include/linux/ftrace_event.h
@@ -76,6 +76,7 @@ struct trace_iterator {
         struct trace_entry      *ent;
         unsigned long           lost_events;
         int                     leftover;
+        int                     ent_size;
         int                     cpu;
         u64                     ts;
 
@@ -129,6 +130,10 @@ void trace_current_buffer_unlock_commit(struct ring_buffer *buffer,
 void trace_nowake_buffer_unlock_commit(struct ring_buffer *buffer,
                                        struct ring_buffer_event *event,
                                         unsigned long flags, int pc);
+void trace_nowake_buffer_unlock_commit_regs(struct ring_buffer *buffer,
+                                            struct ring_buffer_event *event,
+                                            unsigned long flags, int pc,
+                                            struct pt_regs *regs);
 void trace_current_buffer_discard_commit(struct ring_buffer *buffer,
                                          struct ring_buffer_event *event);
 
diff --git a/include/linux/genalloc.h b/include/linux/genalloc.h
index 5bbebda78b02..5e98eeb2af3b 100644
--- a/include/linux/genalloc.h
+++ b/include/linux/genalloc.h
@@ -1,8 +1,26 @@
 /*
- * Basic general purpose allocator for managing special purpose memory
- * not managed by the regular kmalloc/kfree interface.
- * Uses for this includes on-device special memory, uncached memory
- * etc.
+ * Basic general purpose allocator for managing special purpose
+ * memory, for example, memory that is not managed by the regular
+ * kmalloc/kfree interface.  Uses for this includes on-device special
+ * memory, uncached memory etc.
+ *
+ * It is safe to use the allocator in NMI handlers and other special
+ * unblockable contexts that could otherwise deadlock on locks.  This
+ * is implemented by using atomic operations and retries on any
+ * conflicts.  The disadvantage is that there may be livelocks in
+ * extreme cases.  For better scalability, one allocator can be used
+ * for each CPU.
+ *
+ * The lockless operation only works if there is enough memory
+ * available.  If new memory is added to the pool a lock has to be
+ * still taken.  So any user relying on locklessness has to ensure
+ * that sufficient memory is preallocated.
+ *
+ * The basic atomic operation of this allocator is cmpxchg on long.
+ * On architectures that don't have NMI-safe cmpxchg implementation,
+ * the allocator can NOT be used in NMI handler.  So code uses the
+ * allocator in NMI handler should depend on
+ * CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG.
  *
  * This source code is licensed under the GNU General Public License,
  * Version 2.  See the file COPYING for more details.
@@ -15,7 +33,7 @@
  *  General purpose special memory pool descriptor.
  */
 struct gen_pool {
-        rwlock_t lock;
+        spinlock_t lock;
         struct list_head chunks;        /* list of chunks in this pool */
         int min_alloc_order;            /* minimum allocation order */
 };
@@ -24,8 +42,8 @@ struct gen_pool {
  *  General purpose special memory pool chunk descriptor.
  */
 struct gen_pool_chunk {
-        spinlock_t lock;
         struct list_head next_chunk;    /* next chunk in pool */
+        atomic_t avail;
         phys_addr_t phys_addr;          /* physical starting address of memory chunk */
         unsigned long start_addr;       /* starting address of memory chunk */
         unsigned long end_addr;         /* ending address of memory chunk */
@@ -56,4 +74,8 @@ static inline int gen_pool_add(struct gen_pool *pool, unsigned long addr,
 extern void gen_pool_destroy(struct gen_pool *);
 extern unsigned long gen_pool_alloc(struct gen_pool *, size_t);
 extern void gen_pool_free(struct gen_pool *, unsigned long, size_t);
+extern void gen_pool_for_each_chunk(struct gen_pool *,
+        void (*)(struct gen_pool *, struct gen_pool_chunk *, void *), void *);
+extern size_t gen_pool_avail(struct gen_pool *);
+extern size_t gen_pool_size(struct gen_pool *);
 #endif /* __GENALLOC_H__ */
diff --git a/include/linux/generic_acl.h b/include/linux/generic_acl.h
index 0437e377b555..b6d657544ef1 100644
--- a/include/linux/generic_acl.h
+++ b/include/linux/generic_acl.h
@@ -10,6 +10,5 @@ extern const struct xattr_handler generic_acl_default_handler;
 
 int generic_acl_init(struct inode *, struct inode *);
 int generic_acl_chmod(struct inode *);
-int generic_check_acl(struct inode *inode, int mask, unsigned int flags);
 
 #endif /* LINUX_GENERIC_ACL_H */
diff --git a/include/linux/genhd.h b/include/linux/genhd.h
index b78956b3c2e7..02fa4697a0e5 100644
--- a/include/linux/genhd.h
+++ b/include/linux/genhd.h
@@ -100,6 +100,7 @@ struct hd_struct {
         sector_t start_sect;
         sector_t nr_sects;
         sector_t alignment_offset;
+        unsigned int discard_alignment;
         struct device __dev;
         struct kobject *holder_dir;
         int policy, partno;
@@ -419,7 +420,7 @@ static inline int get_disk_ro(struct gendisk *disk)
 
 extern void disk_block_events(struct gendisk *disk);
 extern void disk_unblock_events(struct gendisk *disk);
-extern void disk_check_events(struct gendisk *disk);
+extern void disk_flush_events(struct gendisk *disk, unsigned int mask);
 extern unsigned int disk_clear_events(struct gendisk *disk, unsigned int mask);
 
 /* drivers/char/random.c */
diff --git a/include/linux/gfp.h b/include/linux/gfp.h
index cb4089254f01..3a76faf6a3ee 100644
--- a/include/linux/gfp.h
+++ b/include/linux/gfp.h
@@ -92,7 +92,7 @@ struct vm_area_struct;
  */
 #define __GFP_NOTRACK_FALSE_POSITIVE (__GFP_NOTRACK)
 
-#define __GFP_BITS_SHIFT 23     /* Room for 23 __GFP_FOO bits */
+#define __GFP_BITS_SHIFT 24     /* Room for N __GFP_FOO bits */
 #define __GFP_BITS_MASK ((__force gfp_t)((1 << __GFP_BITS_SHIFT) - 1))
 
 /* This equals 0, but use constants in case they ever change */
diff --git a/include/linux/gpio.h b/include/linux/gpio.h
index 32d47e710661..17b5a0d80e42 100644
--- a/include/linux/gpio.h
+++ b/include/linux/gpio.h
@@ -3,6 +3,17 @@
 
 /* see Documentation/gpio.txt */
 
+/* make these flag values available regardless of GPIO kconfig options */
+#define GPIOF_DIR_OUT   (0 << 0)
+#define GPIOF_DIR_IN    (1 << 0)
+
+#define GPIOF_INIT_LOW  (0 << 1)
+#define GPIOF_INIT_HIGH (1 << 1)
+
+#define GPIOF_IN                (GPIOF_DIR_IN)
+#define GPIOF_OUT_INIT_LOW      (GPIOF_DIR_OUT | GPIOF_INIT_LOW)
+#define GPIOF_OUT_INIT_HIGH     (GPIOF_DIR_OUT | GPIOF_INIT_HIGH)
+
 #ifdef CONFIG_GENERIC_GPIO
 #include <asm/gpio.h>
 
diff --git a/include/linux/gsmmux.h b/include/linux/gsmmux.h
index 378de4195caf..c25e9477f7c3 100644
--- a/include/linux/gsmmux.h
+++ b/include/linux/gsmmux.h
@@ -21,5 +21,16 @@ struct gsm_config
 #define GSMIOC_GETCONF          _IOR('G', 0, struct gsm_config)
 #define GSMIOC_SETCONF          _IOW('G', 1, struct gsm_config)
 
+struct gsm_netconfig {
+        unsigned int adaption;  /* Adaption to use in network mode */
+        unsigned short protocol;/* Protocol to use - only ETH_P_IP supported */
+        unsigned short unused2;
+        char if_name[IFNAMSIZ]; /* interface name format string */
+        __u8 unused[28];        /* For future use */
+};
+
+#define GSMIOC_ENABLE_NET      _IOW('G', 2, struct gsm_netconfig)
+#define GSMIOC_DISABLE_NET     _IO('G', 3)
+
 
 #endif
diff --git a/include/linux/hardirq.h b/include/linux/hardirq.h
index ba362171e8ae..f743883f769e 100644
--- a/include/linux/hardirq.h
+++ b/include/linux/hardirq.h
@@ -93,7 +93,7 @@
  */
 #define in_nmi()        (preempt_count() & NMI_MASK)
 
-#if defined(CONFIG_PREEMPT)
+#if defined(CONFIG_PREEMPT_COUNT)
 # define PREEMPT_CHECK_OFFSET 1
 #else
 # define PREEMPT_CHECK_OFFSET 0
@@ -115,7 +115,7 @@
 #define in_atomic_preempt_off() \
                 ((preempt_count() & ~PREEMPT_ACTIVE) != PREEMPT_CHECK_OFFSET)
 
-#ifdef CONFIG_PREEMPT
+#ifdef CONFIG_PREEMPT_COUNT
 # define preemptible()  (preempt_count() == 0 && !irqs_disabled())
 # define IRQ_EXIT_OFFSET (HARDIRQ_OFFSET-1)
 #else
diff --git a/include/linux/hid.h b/include/linux/hid.h
index 42f7e2fb501f..9cf8e7ae7450 100644
--- a/include/linux/hid.h
+++ b/include/linux/hid.h
@@ -453,7 +453,8 @@ struct hid_input {
 
 enum hid_type {
         HID_TYPE_OTHER = 0,
-        HID_TYPE_USBMOUSE
+        HID_TYPE_USBMOUSE,
+        HID_TYPE_USBNONE
 };
 
 struct hid_driver;
diff --git a/include/linux/hrtimer.h b/include/linux/hrtimer.h
index 51932e5acf7c..fd0dc30c9f15 100644
--- a/include/linux/hrtimer.h
+++ b/include/linux/hrtimer.h
@@ -135,6 +135,7 @@ struct hrtimer_sleeper {
  * @cpu_base:           per cpu clock base
  * @index:              clock type index for per_cpu support when moving a
  *                      timer to a base on another cpu.
+ * @clockid:            clock id for per_cpu support
  * @active:             red black tree root node for the active timers
  * @resolution:         the resolution of the clock, in nanoseconds
  * @get_time:           function to retrieve the current time of the clock
diff --git a/include/linux/hugetlb.h b/include/linux/hugetlb.h
index 59225ef27d15..19644e0016bd 100644
--- a/include/linux/hugetlb.h
+++ b/include/linux/hugetlb.h
@@ -231,6 +231,9 @@ struct hstate {
 struct huge_bootmem_page {
         struct list_head list;
         struct hstate *hstate;
+#ifdef CONFIG_HIGHMEM
+        phys_addr_t phys;
+#endif
 };
 
 struct page *alloc_huge_page_node(struct hstate *h, int nid);
diff --git a/include/linux/hw_breakpoint.h b/include/linux/hw_breakpoint.h
index d1e55fed2c7d..6ae9c631a1be 100644
--- a/include/linux/hw_breakpoint.h
+++ b/include/linux/hw_breakpoint.h
@@ -73,6 +73,7 @@ static inline unsigned long hw_breakpoint_len(struct perf_event *bp)
 extern struct perf_event *
 register_user_hw_breakpoint(struct perf_event_attr *attr,
                             perf_overflow_handler_t triggered,
+                            void *context,
                             struct task_struct *tsk);
 
 /* FIXME: only change from the attr, and don't unregister */
@@ -85,11 +86,13 @@ modify_user_hw_breakpoint(struct perf_event *bp, struct perf_event_attr *attr);
 extern struct perf_event *
 register_wide_hw_breakpoint_cpu(struct perf_event_attr *attr,
                                 perf_overflow_handler_t triggered,
+                                void *context,
                                 int cpu);
 
 extern struct perf_event * __percpu *
 register_wide_hw_breakpoint(struct perf_event_attr *attr,
-                            perf_overflow_handler_t triggered);
+                            perf_overflow_handler_t triggered,
+                            void *context);
 
 extern int register_perf_hw_breakpoint(struct perf_event *bp);
 extern int __register_perf_hw_breakpoint(struct perf_event *bp);
@@ -115,6 +118,7 @@ static inline int __init init_hw_breakpoint(void) { return 0; }
 static inline struct perf_event *
 register_user_hw_breakpoint(struct perf_event_attr *attr,
                             perf_overflow_handler_t triggered,
+                            void *context,
                             struct task_struct *tsk)    { return NULL; }
 static inline int
 modify_user_hw_breakpoint(struct perf_event *bp,
@@ -122,10 +126,12 @@ modify_user_hw_breakpoint(struct perf_event *bp,
 static inline struct perf_event *
 register_wide_hw_breakpoint_cpu(struct perf_event_attr *attr,
                                 perf_overflow_handler_t  triggered,
+                                void *context,
                                 int cpu)                { return NULL; }
 static inline struct perf_event * __percpu *
 register_wide_hw_breakpoint(struct perf_event_attr *attr,
-                            perf_overflow_handler_t triggered)  { return NULL; }
+                            perf_overflow_handler_t triggered,
+                            void *context)              { return NULL; }
 static inline int
 register_perf_hw_breakpoint(struct perf_event *bp)      { return -ENOSYS; }
 static inline int
diff --git a/include/linux/hw_random.h b/include/linux/hw_random.h
index 9bede7633f74..b4b0eef5fddf 100644
--- a/include/linux/hw_random.h
+++ b/include/linux/hw_random.h
@@ -25,7 +25,7 @@
  *                      there is always data available.  *OBSOLETE*
  * @data_read:          Read data from the RNG device.
  *                      Returns the number of lower random bytes in "data".
- *                      Must not be NULL.    *OSOLETE*
+ *                      Must not be NULL.    *OBSOLETE*
  * @read:               New API. drivers can fill up to max bytes of data
  *                      into the buffer. The buffer is aligned for any type.
  * @priv:               Private data, for use by the RNG driver.
diff --git a/include/linux/i2c-omap.h b/include/linux/i2c-omap.h
index 7472449cbb74..0aa0cbd676f7 100644
--- a/include/linux/i2c-omap.h
+++ b/include/linux/i2c-omap.h
@@ -3,6 +3,33 @@
 
 #include <linux/platform_device.h>
 
+/*
+ * Version 2 of the I2C peripheral unit has a different register
+ * layout and extra registers.  The ID register in the V2 peripheral
+ * unit on the OMAP4430 reports the same ID as the V1 peripheral
+ * unit on the OMAP3530, so we must inform the driver which IP
+ * version we know it is running on from platform / cpu-specific
+ * code using these constants in the hwmod class definition.
+ */
+
+#define OMAP_I2C_IP_VERSION_1 1
+#define OMAP_I2C_IP_VERSION_2 2
+
+/* struct omap_i2c_bus_platform_data .flags meanings */
+
+#define OMAP_I2C_FLAG_NO_FIFO                   BIT(0)
+#define OMAP_I2C_FLAG_SIMPLE_CLOCK              BIT(1)
+#define OMAP_I2C_FLAG_16BIT_DATA_REG            BIT(2)
+#define OMAP_I2C_FLAG_RESET_REGS_POSTIDLE       BIT(3)
+#define OMAP_I2C_FLAG_APPLY_ERRATA_I207 BIT(4)
+#define OMAP_I2C_FLAG_ALWAYS_ARMXOR_CLK BIT(5)
+#define OMAP_I2C_FLAG_FORCE_19200_INT_CLK       BIT(6)
+/* how the CPU address bus must be translated for I2C unit access */
+#define OMAP_I2C_FLAG_BUS_SHIFT_NONE 0
+#define OMAP_I2C_FLAG_BUS_SHIFT_1               BIT(7)
+#define OMAP_I2C_FLAG_BUS_SHIFT_2               BIT(8)
+#define OMAP_I2C_FLAG_BUS_SHIFT__SHIFT 7
+
 struct omap_i2c_bus_platform_data {
         u32             clkrate;
         void            (*set_mpu_wkup_lat)(struct device *dev, long set);
diff --git a/include/linux/i2c/adp8870.h b/include/linux/i2c/adp8870.h
new file mode 100644
index 000000000000..624dceccbd5b
--- /dev/null
+++ b/include/linux/i2c/adp8870.h
@@ -0,0 +1,153 @@
+/*
+ * Definitions and platform data for Analog Devices
+ * Backlight drivers ADP8870
+ *
+ * Copyright 2009-2010 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2 or later.
+ */
+
+#ifndef __LINUX_I2C_ADP8870_H
+#define __LINUX_I2C_ADP8870_H
+
+#define ID_ADP8870              8870
+
+#define ADP8870_MAX_BRIGHTNESS  0x7F
+#define FLAG_OFFT_SHIFT 8
+
+/*
+ * LEDs subdevice platform data
+ */
+
+#define ADP8870_LED_DIS_BLINK   (0 << FLAG_OFFT_SHIFT)
+#define ADP8870_LED_OFFT_600ms  (1 << FLAG_OFFT_SHIFT)
+#define ADP8870_LED_OFFT_1200ms (2 << FLAG_OFFT_SHIFT)
+#define ADP8870_LED_OFFT_1800ms (3 << FLAG_OFFT_SHIFT)
+
+#define ADP8870_LED_ONT_200ms   0
+#define ADP8870_LED_ONT_600ms   1
+#define ADP8870_LED_ONT_800ms   2
+#define ADP8870_LED_ONT_1200ms  3
+
+#define ADP8870_LED_D7          (7)
+#define ADP8870_LED_D6          (6)
+#define ADP8870_LED_D5          (5)
+#define ADP8870_LED_D4          (4)
+#define ADP8870_LED_D3          (3)
+#define ADP8870_LED_D2          (2)
+#define ADP8870_LED_D1          (1)
+
+/*
+ * Backlight subdevice platform data
+ */
+
+#define ADP8870_BL_D7           (1 << 6)
+#define ADP8870_BL_D6           (1 << 5)
+#define ADP8870_BL_D5           (1 << 4)
+#define ADP8870_BL_D4           (1 << 3)
+#define ADP8870_BL_D3           (1 << 2)
+#define ADP8870_BL_D2           (1 << 1)
+#define ADP8870_BL_D1           (1 << 0)
+
+#define ADP8870_FADE_T_DIS      0       /* Fade Timer Disabled */
+#define ADP8870_FADE_T_300ms    1       /* 0.3 Sec */
+#define ADP8870_FADE_T_600ms    2
+#define ADP8870_FADE_T_900ms    3
+#define ADP8870_FADE_T_1200ms   4
+#define ADP8870_FADE_T_1500ms   5
+#define ADP8870_FADE_T_1800ms   6
+#define ADP8870_FADE_T_2100ms   7
+#define ADP8870_FADE_T_2400ms   8
+#define ADP8870_FADE_T_2700ms   9
+#define ADP8870_FADE_T_3000ms   10
+#define ADP8870_FADE_T_3500ms   11
+#define ADP8870_FADE_T_4000ms   12
+#define ADP8870_FADE_T_4500ms   13
+#define ADP8870_FADE_T_5000ms   14
+#define ADP8870_FADE_T_5500ms   15      /* 5.5 Sec */
+
+#define ADP8870_FADE_LAW_LINEAR 0
+#define ADP8870_FADE_LAW_SQUARE 1
+#define ADP8870_FADE_LAW_CUBIC1 2
+#define ADP8870_FADE_LAW_CUBIC2 3
+
+#define ADP8870_BL_AMBL_FILT_80ms       0       /* Light sensor filter time */
+#define ADP8870_BL_AMBL_FILT_160ms      1
+#define ADP8870_BL_AMBL_FILT_320ms      2
+#define ADP8870_BL_AMBL_FILT_640ms      3
+#define ADP8870_BL_AMBL_FILT_1280ms     4
+#define ADP8870_BL_AMBL_FILT_2560ms     5
+#define ADP8870_BL_AMBL_FILT_5120ms     6
+#define ADP8870_BL_AMBL_FILT_10240ms    7       /* 10.24 sec */
+
+/*
+ * Blacklight current 0..30mA
+ */
+#define ADP8870_BL_CUR_mA(I)            ((I * 127) / 30)
+
+/*
+ * L2 comparator current 0..1106uA
+ */
+#define ADP8870_L2_COMP_CURR_uA(I)      ((I * 255) / 1106)
+
+/*
+ * L3 comparator current 0..551uA
+ */
+#define ADP8870_L3_COMP_CURR_uA(I)      ((I * 255) / 551)
+
+/*
+ * L4 comparator current 0..275uA
+ */
+#define ADP8870_L4_COMP_CURR_uA(I)      ((I * 255) / 275)
+
+/*
+ * L5 comparator current 0..138uA
+ */
+#define ADP8870_L5_COMP_CURR_uA(I)      ((I * 255) / 138)
+
+struct adp8870_backlight_platform_data {
+        u8 bl_led_assign;       /* 1 = Backlight 0 = Individual LED */
+        u8 pwm_assign;          /* 1 = Enables PWM mode */
+
+        u8 bl_fade_in;          /* Backlight Fade-In Timer */
+        u8 bl_fade_out;         /* Backlight Fade-Out Timer */
+        u8 bl_fade_law;         /* fade-on/fade-off transfer characteristic */
+
+        u8 en_ambl_sens;        /* 1 = enable ambient light sensor */
+        u8 abml_filt;           /* Light sensor filter time */
+
+        u8 l1_daylight_max;     /* use BL_CUR_mA(I) 0 <= I <= 30 mA */
+        u8 l1_daylight_dim;     /* typ = 0, use BL_CUR_mA(I) 0 <= I <= 30 mA */
+        u8 l2_bright_max;       /* use BL_CUR_mA(I) 0 <= I <= 30 mA */
+        u8 l2_bright_dim;       /* typ = 0, use BL_CUR_mA(I) 0 <= I <= 30 mA */
+        u8 l3_office_max;       /* use BL_CUR_mA(I) 0 <= I <= 30 mA */
+        u8 l3_office_dim;       /* typ = 0, use BL_CUR_mA(I) 0 <= I <= 30 mA */
+        u8 l4_indoor_max;       /* use BL_CUR_mA(I) 0 <= I <= 30 mA */
+        u8 l4_indor_dim;        /* typ = 0, use BL_CUR_mA(I) 0 <= I <= 30 mA */
+        u8 l5_dark_max;         /* use BL_CUR_mA(I) 0 <= I <= 30 mA */
+        u8 l5_dark_dim;         /* typ = 0, use BL_CUR_mA(I) 0 <= I <= 30 mA */
+
+        u8 l2_trip;             /* use L2_COMP_CURR_uA(I) 0 <= I <= 1106 uA */
+        u8 l2_hyst;             /* use L2_COMP_CURR_uA(I) 0 <= I <= 1106 uA */
+        u8 l3_trip;             /* use L3_COMP_CURR_uA(I) 0 <= I <= 551 uA */
+        u8 l3_hyst;             /* use L3_COMP_CURR_uA(I) 0 <= I <= 551 uA */
+        u8 l4_trip;             /* use L4_COMP_CURR_uA(I) 0 <= I <= 275 uA */
+        u8 l4_hyst;             /* use L4_COMP_CURR_uA(I) 0 <= I <= 275 uA */
+        u8 l5_trip;             /* use L5_COMP_CURR_uA(I) 0 <= I <= 138 uA */
+        u8 l5_hyst;             /* use L6_COMP_CURR_uA(I) 0 <= I <= 138 uA */
+
+        /**
+         * Independent Current Sinks / LEDS
+         * Sinks not assigned to the Backlight can be exposed to
+         * user space using the LEDS CLASS interface
+         */
+
+        int num_leds;
+        struct led_info *leds;
+        u8 led_fade_in;         /* LED Fade-In Timer */
+        u8 led_fade_out;        /* LED Fade-Out Timer */
+        u8 led_fade_law;        /* fade-on/fade-off transfer characteristic */
+        u8 led_on_time;
+};
+
+#endif /* __LINUX_I2C_ADP8870_H */
diff --git a/include/linux/i2c/twl.h b/include/linux/i2c/twl.h
index ba4f88624fcd..114c0f6fc63d 100644
--- a/include/linux/i2c/twl.h
+++ b/include/linux/i2c/twl.h
@@ -657,28 +657,41 @@ struct twl4030_power_data {
 extern void twl4030_power_init(struct twl4030_power_data *triton2_scripts);
 extern int twl4030_remove_script(u8 flags);
 
-struct twl4030_codec_audio_data {
+struct twl4030_codec_data {
         unsigned int digimic_delay; /* in ms */
         unsigned int ramp_delay_value;
         unsigned int offset_cncl_path;
         unsigned int check_defaults:1;
         unsigned int reset_registers:1;
         unsigned int hs_extmute:1;
+        u16 hs_left_step;
+        u16 hs_right_step;
+        u16 hf_left_step;
+        u16 hf_right_step;
         void (*set_hs_extmute)(int mute);
 };
 
-struct twl4030_codec_vibra_data {
+struct twl4030_vibra_data {
         unsigned int    coexist;
+
+        /* twl6040 */
+        unsigned int vibldrv_res;       /* left driver resistance */
+        unsigned int vibrdrv_res;       /* right driver resistance */
+        unsigned int viblmotor_res;     /* left motor resistance */
+        unsigned int vibrmotor_res;     /* right motor resistance */
+        int vddvibl_uV;                 /* VDDVIBL volt, set 0 for fixed reg */
+        int vddvibr_uV;                 /* VDDVIBR volt, set 0 for fixed reg */
 };
 
-struct twl4030_codec_data {
+struct twl4030_audio_data {
         unsigned int    audio_mclk;
-        struct twl4030_codec_audio_data         *audio;
-        struct twl4030_codec_vibra_data         *vibra;
+        struct twl4030_codec_data *codec;
+        struct twl4030_vibra_data *vibra;
 
         /* twl6040 */
         int audpwron_gpio;      /* audio power-on gpio */
         int naudint_irq;        /* audio interrupt */
+        unsigned int irq_base;
 };
 
 struct twl4030_platform_data {
@@ -690,7 +703,7 @@ struct twl4030_platform_data {
         struct twl4030_keypad_data              *keypad;
         struct twl4030_usb_data                 *usb;
         struct twl4030_power_data               *power;
-        struct twl4030_codec_data               *codec;
+        struct twl4030_audio_data               *audio;
 
         /* Common LDO regulators for TWL4030/TWL6030 */
         struct regulator_init_data              *vdac;
diff --git a/include/linux/i8253.h b/include/linux/i8253.h
new file mode 100644
index 000000000000..e6bb36a97519
--- /dev/null
+++ b/include/linux/i8253.h
@@ -0,0 +1,29 @@
+/*
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ *  Machine specific IO port address definition for generic.
+ *  Written by Osamu Tomita <tomita@cinet.co.jp>
+ */
+#ifndef __LINUX_I8253_H
+#define __LINUX_I8253_H
+
+#include <linux/param.h>
+#include <linux/spinlock.h>
+#include <linux/timex.h>
+
+/* i8253A PIT registers */
+#define PIT_MODE        0x43
+#define PIT_CH0         0x40
+#define PIT_CH2         0x42
+
+#define PIT_LATCH       ((PIT_TICK_RATE + HZ/2) / HZ)
+
+extern raw_spinlock_t i8253_lock;
+extern struct clock_event_device i8253_clockevent;
+extern void clockevent_i8253_init(bool oneshot);
+
+extern void setup_pit_timer(void);
+
+#endif /* __LINUX_I8253_H */
diff --git a/include/linux/idr.h b/include/linux/idr.h
index 13a801f3d028..255491cf522e 100644
--- a/include/linux/idr.h
+++ b/include/linux/idr.h
@@ -146,6 +146,10 @@ void ida_remove(struct ida *ida, int id);
 void ida_destroy(struct ida *ida);
 void ida_init(struct ida *ida);
 
+int ida_simple_get(struct ida *ida, unsigned int start, unsigned int end,
+                   gfp_t gfp_mask);
+void ida_simple_remove(struct ida *ida, unsigned int id);
+
 void __init idr_init_cache(void);
 
 #endif /* __IDR_H__ */
diff --git a/include/linux/ieee80211.h b/include/linux/ieee80211.h
index b2eee5879883..54c878960872 100644
--- a/include/linux/ieee80211.h
+++ b/include/linux/ieee80211.h
@@ -117,8 +117,19 @@
 #define IEEE80211_MAX_MESH_ID_LEN       32
 
 #define IEEE80211_QOS_CTL_LEN           2
-#define IEEE80211_QOS_CTL_TID_MASK      0x000F
-#define IEEE80211_QOS_CTL_TAG1D_MASK    0x0007
+/* 1d tag mask */
+#define IEEE80211_QOS_CTL_TAG1D_MASK            0x0007
+/* TID mask */
+#define IEEE80211_QOS_CTL_TID_MASK              0x000f
+/* EOSP */
+#define IEEE80211_QOS_CTL_EOSP                  0x0010
+/* ACK policy */
+#define IEEE80211_QOS_CTL_ACK_POLICY_NORMAL     0x0000
+#define IEEE80211_QOS_CTL_ACK_POLICY_NOACK      0x0020
+#define IEEE80211_QOS_CTL_ACK_POLICY_NO_EXPL    0x0040
+#define IEEE80211_QOS_CTL_ACK_POLICY_BLOCKACK   0x0060
+/* A-MSDU 802.11n */
+#define IEEE80211_QOS_CTL_A_MSDU_PRESENT        0x0080
 
 /* U-APSD queue for WMM IEs sent by AP */
 #define IEEE80211_WMM_IE_AP_QOSINFO_UAPSD       (1<<7)
@@ -1003,8 +1014,12 @@ struct ieee80211_ht_info {
 #define WLAN_CAPABILITY_ESS             (1<<0)
 #define WLAN_CAPABILITY_IBSS            (1<<1)
 
-/* A mesh STA sets the ESS and IBSS capability bits to zero */
-#define WLAN_CAPABILITY_IS_MBSS(cap)    \
+/*
+ * A mesh STA sets the ESS and IBSS capability bits to zero.
+ * however, this holds true for p2p probe responses (in the p2p_find
+ * phase) as well.
+ */
+#define WLAN_CAPABILITY_IS_STA_BSS(cap) \
         (!((cap) & (WLAN_CAPABILITY_ESS | WLAN_CAPABILITY_IBSS)))
 
 #define WLAN_CAPABILITY_CF_POLLABLE     (1<<2)
@@ -1419,9 +1434,6 @@ enum ieee80211_sa_query_action {
 };
 
 
-/* A-MSDU 802.11n */
-#define IEEE80211_QOS_CONTROL_A_MSDU_PRESENT 0x0080
-
 /* cipher suite selectors */
 #define WLAN_CIPHER_SUITE_USE_GROUP     0x000FAC00
 #define WLAN_CIPHER_SUITE_WEP40         0x000FAC01
@@ -1441,6 +1453,43 @@ enum ieee80211_sa_query_action {
 
 #define WLAN_PMKID_LEN                  16
 
+/*
+ * WMM/802.11e Tspec Element
+ */
+#define IEEE80211_WMM_IE_TSPEC_TID_MASK         0x0F
+#define IEEE80211_WMM_IE_TSPEC_TID_SHIFT        1
+
+enum ieee80211_tspec_status_code {
+        IEEE80211_TSPEC_STATUS_ADMISS_ACCEPTED = 0,
+        IEEE80211_TSPEC_STATUS_ADDTS_INVAL_PARAMS = 0x1,
+};
+
+struct ieee80211_tspec_ie {
+        u8 element_id;
+        u8 len;
+        u8 oui[3];
+        u8 oui_type;
+        u8 oui_subtype;
+        u8 version;
+        __le16 tsinfo;
+        u8 tsinfo_resvd;
+        __le16 nominal_msdu;
+        __le16 max_msdu;
+        __le32 min_service_int;
+        __le32 max_service_int;
+        __le32 inactivity_int;
+        __le32 suspension_int;
+        __le32 service_start_time;
+        __le32 min_data_rate;
+        __le32 mean_data_rate;
+        __le32 peak_data_rate;
+        __le32 max_burst_size;
+        __le32 delay_bound;
+        __le32 min_phy_rate;
+        __le16 sba;
+        __le16 medium_time;
+} __packed;
+
 /**
  * ieee80211_get_qos_ctl - get pointer to qos control bytes
  * @hdr: the frame
diff --git a/include/linux/if.h b/include/linux/if.h
index 3bc63e6a02f7..03489ca92ded 100644
--- a/include/linux/if.h
+++ b/include/linux/if.h
@@ -76,6 +76,8 @@
 #define IFF_BRIDGE_PORT 0x4000          /* device used as bridge port */
 #define IFF_OVS_DATAPATH        0x8000  /* device used as Open vSwitch
                                          * datapath port */
+#define IFF_TX_SKB_SHARING      0x10000 /* The interface supports sharing
+                                         * skbs on transmit */
 
 #define IF_GET_IFACE    0x0001          /* for querying only */
 #define IF_GET_PROTO    0x0002
diff --git a/include/linux/if_ether.h b/include/linux/if_ether.h
index 0065ffd3226b..a3d99ff6e3b5 100644
--- a/include/linux/if_ether.h
+++ b/include/linux/if_ether.h
@@ -78,10 +78,15 @@
                                          */
 #define ETH_P_PAE       0x888E          /* Port Access Entity (IEEE 802.1X) */
 #define ETH_P_AOE       0x88A2          /* ATA over Ethernet            */
+#define ETH_P_8021AD    0x88A8          /* 802.1ad Service VLAN         */
 #define ETH_P_TIPC      0x88CA          /* TIPC                         */
+#define ETH_P_8021AH    0x88E7          /* 802.1ah Backbone Service Tag */
 #define ETH_P_1588      0x88F7          /* IEEE 1588 Timesync */
 #define ETH_P_FCOE      0x8906          /* Fibre Channel over Ethernet  */
 #define ETH_P_FIP       0x8914          /* FCoE Initialization Protocol */
+#define ETH_P_QINQ1     0x9100          /* deprecated QinQ VLAN [ NOT AN OFFICIALLY REGISTERED ID ] */
+#define ETH_P_QINQ2     0x9200          /* deprecated QinQ VLAN [ NOT AN OFFICIALLY REGISTERED ID ] */
+#define ETH_P_QINQ3     0x9300          /* deprecated QinQ VLAN [ NOT AN OFFICIALLY REGISTERED ID ] */
 #define ETH_P_EDSA      0xDADA          /* Ethertype DSA [ NOT AN OFFICIALLY REGISTERED ID ] */
 
 /*
diff --git a/include/linux/if_packet.h b/include/linux/if_packet.h
index 72bfa5a034dd..c1486060f5ed 100644
--- a/include/linux/if_packet.h
+++ b/include/linux/if_packet.h
@@ -49,6 +49,12 @@ struct sockaddr_ll {
 #define PACKET_VNET_HDR                 15
 #define PACKET_TX_TIMESTAMP             16
 #define PACKET_TIMESTAMP                17
+#define PACKET_FANOUT                   18
+
+#define PACKET_FANOUT_HASH              0
+#define PACKET_FANOUT_LB                1
+#define PACKET_FANOUT_CPU               2
+#define PACKET_FANOUT_FLAG_DEFRAG       0x8000
 
 struct tpacket_stats {
         unsigned int    tp_packets;
@@ -62,6 +68,7 @@ struct tpacket_auxdata {
         __u16           tp_mac;
         __u16           tp_net;
         __u16           tp_vlan_tci;
+        __u16           tp_padding;
 };
 
 /* Rx ring - header status */
@@ -70,6 +77,7 @@ struct tpacket_auxdata {
 #define TP_STATUS_COPY          0x2
 #define TP_STATUS_LOSING        0x4
 #define TP_STATUS_CSUMNOTREADY  0x8
+#define TP_STATUS_VLAN_VALID   0x10 /* auxdata has valid tp_vlan_tci */
 
 /* Tx ring - header status */
 #define TP_STATUS_AVAILABLE     0x0
@@ -100,6 +108,7 @@ struct tpacket2_hdr {
         __u32           tp_sec;
         __u32           tp_nsec;
         __u16           tp_vlan_tci;
+        __u16           tp_padding;
 };
 
 #define TPACKET2_HDRLEN         (TPACKET_ALIGN(sizeof(struct tpacket2_hdr)) + sizeof(struct sockaddr_ll))
diff --git a/include/linux/if_vlan.h b/include/linux/if_vlan.h
index dc01681fbb42..44da4822bcab 100644
--- a/include/linux/if_vlan.h
+++ b/include/linux/if_vlan.h
@@ -91,25 +91,6 @@ struct vlan_group {
         struct rcu_head         rcu;
 };
 
-static inline struct net_device *vlan_group_get_device(struct vlan_group *vg,
-                                                       u16 vlan_id)
-{
-        struct net_device **array;
-        array = vg->vlan_devices_arrays[vlan_id / VLAN_GROUP_ARRAY_PART_LEN];
-        return array ? array[vlan_id % VLAN_GROUP_ARRAY_PART_LEN] : NULL;
-}
-
-static inline void vlan_group_set_device(struct vlan_group *vg,
-                                         u16 vlan_id,
-                                         struct net_device *dev)
-{
-        struct net_device **array;
-        if (!vg)
-                return;
-        array = vg->vlan_devices_arrays[vlan_id / VLAN_GROUP_ARRAY_PART_LEN];
-        array[vlan_id % VLAN_GROUP_ARRAY_PART_LEN] = dev;
-}
-
 static inline int is_vlan_dev(struct net_device *dev)
 {
         return dev->priv_flags & IFF_802_1Q_VLAN;
@@ -119,35 +100,18 @@ static inline int is_vlan_dev(struct net_device *dev)
 #define vlan_tx_tag_get(__skb)          ((__skb)->vlan_tci & ~VLAN_TAG_PRESENT)
 
 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
-/* Must be invoked with rcu_read_lock or with RTNL. */
-static inline struct net_device *vlan_find_dev(struct net_device *real_dev,
-                                               u16 vlan_id)
-{
-        struct vlan_group *grp = rcu_dereference_rtnl(real_dev->vlgrp);
-
-        if (grp)
-                return vlan_group_get_device(grp, vlan_id);
-
-        return NULL;
-}
 
+extern struct net_device *__vlan_find_dev_deep(struct net_device *real_dev,
+                                               u16 vlan_id);
 extern struct net_device *vlan_dev_real_dev(const struct net_device *dev);
 extern u16 vlan_dev_vlan_id(const struct net_device *dev);
 
-extern int __vlan_hwaccel_rx(struct sk_buff *skb, struct vlan_group *grp,
-                             u16 vlan_tci, int polling);
 extern bool vlan_do_receive(struct sk_buff **skb);
 extern struct sk_buff *vlan_untag(struct sk_buff *skb);
-extern gro_result_t
-vlan_gro_receive(struct napi_struct *napi, struct vlan_group *grp,
-                 unsigned int vlan_tci, struct sk_buff *skb);
-extern gro_result_t
-vlan_gro_frags(struct napi_struct *napi, struct vlan_group *grp,
-               unsigned int vlan_tci);
 
 #else
-static inline struct net_device *vlan_find_dev(struct net_device *real_dev,
-                                               u16 vlan_id)
+static inline struct net_device *
+__vlan_find_dev_deep(struct net_device *real_dev, u16 vlan_id)
 {
         return NULL;
 }
@@ -164,13 +128,6 @@ static inline u16 vlan_dev_vlan_id(const struct net_device *dev)
         return 0;
 }
 
-static inline int __vlan_hwaccel_rx(struct sk_buff *skb, struct vlan_group *grp,
-                                    u16 vlan_tci, int polling)
-{
-        BUG();
-        return NET_XMIT_SUCCESS;
-}
-
 static inline bool vlan_do_receive(struct sk_buff **skb)
 {
         if ((*skb)->vlan_tci & VLAN_VID_MASK)
@@ -182,50 +139,10 @@ static inline struct sk_buff *vlan_untag(struct sk_buff *skb)
 {
         return skb;
 }
-
-static inline gro_result_t
-vlan_gro_receive(struct napi_struct *napi, struct vlan_group *grp,
-                 unsigned int vlan_tci, struct sk_buff *skb)
-{
-        return GRO_DROP;
-}
-
-static inline gro_result_t
-vlan_gro_frags(struct napi_struct *napi, struct vlan_group *grp,
-               unsigned int vlan_tci)
-{
-        return GRO_DROP;
-}
 #endif
 
 /**
- * vlan_hwaccel_rx - netif_rx wrapper for VLAN RX acceleration
- * @skb: buffer
- * @grp: vlan group
- * @vlan_tci: VLAN TCI as received from the card
- */
-static inline int vlan_hwaccel_rx(struct sk_buff *skb,
-                                  struct vlan_group *grp,
-                                  u16 vlan_tci)
-{
-        return __vlan_hwaccel_rx(skb, grp, vlan_tci, 0);
-}
-
-/**
- * vlan_hwaccel_receive_skb - netif_receive_skb wrapper for VLAN RX acceleration
- * @skb: buffer
- * @grp: vlan group
- * @vlan_tci: VLAN TCI as received from the card
- */
-static inline int vlan_hwaccel_receive_skb(struct sk_buff *skb,
-                                           struct vlan_group *grp,
-                                           u16 vlan_tci)
-{
-        return __vlan_hwaccel_rx(skb, grp, vlan_tci, 1);
-}
-
-/**
- * __vlan_put_tag - regular VLAN tag inserting
+ * vlan_insert_tag - regular VLAN tag inserting
  * @skb: skbuff to tag
  * @vlan_tci: VLAN TCI to insert
  *
@@ -234,8 +151,10 @@ static inline int vlan_hwaccel_receive_skb(struct sk_buff *skb,
  *
  * Following the skb_unshare() example, in case of error, the calling function
  * doesn't have to worry about freeing the original skb.
+ *
+ * Does not change skb->protocol so this function can be used during receive.
  */
-static inline struct sk_buff *__vlan_put_tag(struct sk_buff *skb, u16 vlan_tci)
+static inline struct sk_buff *vlan_insert_tag(struct sk_buff *skb, u16 vlan_tci)
 {
         struct vlan_ethhdr *veth;
 
@@ -255,8 +174,25 @@ static inline struct sk_buff *__vlan_put_tag(struct sk_buff *skb, u16 vlan_tci)
         /* now, the TCI */
         veth->h_vlan_TCI = htons(vlan_tci);
 
-        skb->protocol = htons(ETH_P_8021Q);
+        return skb;
+}
 
+/**
+ * __vlan_put_tag - regular VLAN tag inserting
+ * @skb: skbuff to tag
+ * @vlan_tci: VLAN TCI to insert
+ *
+ * Inserts the VLAN tag into @skb as part of the payload
+ * Returns a VLAN tagged skb. If a new skb is created, @skb is freed.
+ *
+ * Following the skb_unshare() example, in case of error, the calling function
+ * doesn't have to worry about freeing the original skb.
+ */
+static inline struct sk_buff *__vlan_put_tag(struct sk_buff *skb, u16 vlan_tci)
+{
+        skb = vlan_insert_tag(skb, vlan_tci);
+        if (skb)
+                skb->protocol = htons(ETH_P_8021Q);
         return skb;
 }
 
diff --git a/include/linux/inet_lro.h b/include/linux/inet_lro.h
index c4335faebb63..2cf55afbcd4e 100644
--- a/include/linux/inet_lro.h
+++ b/include/linux/inet_lro.h
@@ -50,7 +50,6 @@ struct net_lro_desc {
         struct skb_frag_struct *next_frag;
         struct iphdr *iph;
         struct tcphdr *tcph;
-        struct vlan_group *vgrp;
         __wsum  data_csum;
         __be32 tcp_rcv_tsecr;
         __be32 tcp_rcv_tsval;
@@ -60,7 +59,6 @@ struct net_lro_desc {
         u16 ip_tot_len;
         u16 tcp_saw_tstamp;             /* timestamps enabled */
         __be16 tcp_window;
-        u16 vlan_tag;
         int pkt_aggr_cnt;               /* counts aggregated packets */
         int vlan_packet;
         int mss;
@@ -137,16 +135,6 @@ void lro_receive_skb(struct net_lro_mgr *lro_mgr,
                      void *priv);
 
 /*
- * Processes a SKB with VLAN HW acceleration support
- */
-
-void lro_vlan_hwaccel_receive_skb(struct net_lro_mgr *lro_mgr,
-                                  struct sk_buff *skb,
-                                  struct vlan_group *vgrp,
-                                  u16 vlan_tag,
-                                  void *priv);
-
-/*
  * Processes a fragment list
  *
  * This functions aggregate fragments and generate SKBs do pass
@@ -165,13 +153,6 @@ void lro_receive_frags(struct net_lro_mgr *lro_mgr,
                        struct skb_frag_struct *frags,
                        int len, int true_size, void *priv, __wsum sum);
 
-void lro_vlan_hwaccel_receive_frags(struct net_lro_mgr *lro_mgr,
-                                    struct skb_frag_struct *frags,
-                                    int len, int true_size,
-                                    struct vlan_group *vgrp,
-                                    u16 vlan_tag,
-                                    void *priv, __wsum sum);
-
 /*
  * Forward all aggregated SKBs held by lro_mgr to network stack
  */
diff --git a/include/linux/init_task.h b/include/linux/init_task.h
index 580f70c02391..d14e058aaeed 100644
--- a/include/linux/init_task.h
+++ b/include/linux/init_task.h
@@ -176,7 +176,6 @@ extern struct cred init_cred;
         .alloc_lock     = __SPIN_LOCK_UNLOCKED(tsk.alloc_lock),         \
         .journal_info   = NULL,                                         \
         .cpu_timers     = INIT_CPU_TIMERS(tsk.cpu_timers),              \
-        .fs_excl        = ATOMIC_INIT(0),                               \
         .pi_lock        = __RAW_SPIN_LOCK_UNLOCKED(tsk.pi_lock),        \
         .timer_slack_ns = 50000, /* 50 usec default slack */            \
         .pids = {                                                       \
diff --git a/include/linux/input.h b/include/linux/input.h
index 771d6d85667d..a637e7814334 100644
--- a/include/linux/input.h
+++ b/include/linux/input.h
@@ -119,9 +119,9 @@ struct input_keymap_entry {
 #define EVIOCGSND(len)          _IOC(_IOC_READ, 'E', 0x1a, len)         /* get all sounds status */
 #define EVIOCGSW(len)           _IOC(_IOC_READ, 'E', 0x1b, len)         /* get all switch states */
 
-#define EVIOCGBIT(ev,len)       _IOC(_IOC_READ, 'E', 0x20 + ev, len)    /* get event bits */
-#define EVIOCGABS(abs)          _IOR('E', 0x40 + abs, struct input_absinfo)     /* get abs value/limits */
-#define EVIOCSABS(abs)          _IOW('E', 0xc0 + abs, struct input_absinfo)     /* set abs value/limits */
+#define EVIOCGBIT(ev,len)       _IOC(_IOC_READ, 'E', 0x20 + (ev), len)  /* get event bits */
+#define EVIOCGABS(abs)          _IOR('E', 0x40 + (abs), struct input_absinfo)   /* get abs value/limits */
+#define EVIOCSABS(abs)          _IOW('E', 0xc0 + (abs), struct input_absinfo)   /* set abs value/limits */
 
 #define EVIOCSFF                _IOC(_IOC_WRITE, 'E', 0x80, sizeof(struct ff_effect))   /* send a force effect to a force feedback device */
 #define EVIOCRMFF               _IOW('E', 0x81, int)                    /* Erase a force effect */
@@ -438,6 +438,8 @@ struct input_keymap_entry {
 #define KEY_WIMAX               246
 #define KEY_RFKILL              247     /* Key that controls all radios */
 
+#define KEY_MICMUTE             248     /* Mute / unmute the microphone */
+
 /* Code 255 is reserved for special needs of AT keyboard driver */
 
 #define BTN_MISC                0x100
diff --git a/include/linux/input/kxtj9.h b/include/linux/input/kxtj9.h
new file mode 100644
index 000000000000..f6bac89537b8
--- /dev/null
+++ b/include/linux/input/kxtj9.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2011 Kionix, Inc.
+ * Written by Chris Hudson <chudson@kionix.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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ * 02111-1307, USA
+ */
+
+#ifndef __KXTJ9_H__
+#define __KXTJ9_H__
+
+#define KXTJ9_I2C_ADDR          0x0F
+
+struct kxtj9_platform_data {
+        unsigned int min_interval;      /* minimum poll interval (in milli-seconds) */
+
+        /*
+         * By default, x is axis 0, y is axis 1, z is axis 2; these can be
+         * changed to account for sensor orientation within the host device.
+         */
+        u8 axis_map_x;
+        u8 axis_map_y;
+        u8 axis_map_z;
+
+        /*
+         * Each axis can be negated to account for sensor orientation within
+         * the host device.
+         */
+        bool negate_x;
+        bool negate_y;
+        bool negate_z;
+
+        /* CTRL_REG1: set resolution, g-range, data ready enable */
+        /* Output resolution: 8-bit valid or 12-bit valid */
+        #define RES_8BIT                0
+        #define RES_12BIT               (1 << 6)
+        u8 res_12bit;
+        /* Output g-range: +/-2g, 4g, or 8g */
+        #define KXTJ9_G_2G              0
+        #define KXTJ9_G_4G              (1 << 3)
+        #define KXTJ9_G_8G              (1 << 4)
+        u8 g_range;
+
+        /* DATA_CTRL_REG: controls the output data rate of the part */
+        #define ODR12_5F                0
+        #define ODR25F                  1
+        #define ODR50F                  2
+        #define ODR100F                 3
+        #define ODR200F                 4
+        #define ODR400F                 5
+        #define ODR800F                 6
+        u8 data_odr_init;
+
+        int (*init)(void);
+        void (*exit)(void);
+        int (*power_on)(void);
+        int (*power_off)(void);
+};
+#endif  /* __KXTJ9_H__ */
diff --git a/include/linux/input/sh_keysc.h b/include/linux/input/sh_keysc.h
index 649dc7f12925..5d253cd93691 100644
--- a/include/linux/input/sh_keysc.h
+++ b/include/linux/input/sh_keysc.h
@@ -1,7 +1,7 @@
 #ifndef __SH_KEYSC_H__
 #define __SH_KEYSC_H__
 
-#define SH_KEYSC_MAXKEYS 49
+#define SH_KEYSC_MAXKEYS 64
 
 struct sh_keysc_info {
         enum { SH_KEYSC_MODE_1, SH_KEYSC_MODE_2, SH_KEYSC_MODE_3,
diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h
index 6c12989839d9..a103732b7588 100644
--- a/include/linux/interrupt.h
+++ b/include/linux/interrupt.h
@@ -17,7 +17,7 @@
 #include <linux/kref.h>
 #include <linux/workqueue.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <asm/ptrace.h>
 #include <asm/system.h>
 #include <trace/events/irq.h>
@@ -414,6 +414,7 @@ enum
         TASKLET_SOFTIRQ,
         SCHED_SOFTIRQ,
         HRTIMER_SOFTIRQ,
+        RCU_SOFTIRQ,    /* Preferable RCU should always be the last softirq */
 
         NR_SOFTIRQS
 };
diff --git a/include/linux/iocontext.h b/include/linux/iocontext.h
index b2eee896dcbc..5037a0ad2312 100644
--- a/include/linux/iocontext.h
+++ b/include/linux/iocontext.h
@@ -5,6 +5,14 @@
 #include <linux/rcupdate.h>
 
 struct cfq_queue;
+struct cfq_ttime {
+        unsigned long last_end_request;
+
+        unsigned long ttime_total;
+        unsigned long ttime_samples;
+        unsigned long ttime_mean;
+};
+
 struct cfq_io_context {
         void *key;
 
@@ -12,11 +20,7 @@ struct cfq_io_context {
 
         struct io_context *ioc;
 
-        unsigned long last_end_request;
-
-        unsigned long ttime_total;
-        unsigned long ttime_samples;
-        unsigned long ttime_mean;
+        struct cfq_ttime ttime;
 
         struct list_head queue_list;
         struct hlist_node cic_list;
diff --git a/include/linux/iommu.h b/include/linux/iommu.h
index 0a2ba4098996..9940319d6f9d 100644
--- a/include/linux/iommu.h
+++ b/include/linux/iommu.h
@@ -19,6 +19,8 @@
 #ifndef __LINUX_IOMMU_H
 #define __LINUX_IOMMU_H
 
+#include <linux/errno.h>
+
 #define IOMMU_READ      (1)
 #define IOMMU_WRITE     (2)
 #define IOMMU_CACHE     (4) /* DMA cache coherency */
diff --git a/include/linux/ioport.h b/include/linux/ioport.h
index e9bb22cba764..9d57a71775b5 100644
--- a/include/linux/ioport.h
+++ b/include/linux/ioport.h
@@ -109,6 +109,36 @@ struct resource_list {
 /* PCI control bits.  Shares IORESOURCE_BITS with above PCI ROM.  */
 #define IORESOURCE_PCI_FIXED            (1<<4)  /* Do not move resource */
 
+
+/* helpers to define resources */
+#define DEFINE_RES_NAMED(_start, _size, _name, _flags)                  \
+        {                                                               \
+                .start = (_start),                                      \
+                .end = (_start) + (_size) - 1,                          \
+                .name = (_name),                                        \
+                .flags = (_flags),                                      \
+        }
+
+#define DEFINE_RES_IO_NAMED(_start, _size, _name)                       \
+        DEFINE_RES_NAMED((_start), (_size), (_name), IORESOURCE_IO)
+#define DEFINE_RES_IO(_start, _size)                                    \
+        DEFINE_RES_IO_NAMED((_start), (_size), NULL)
+
+#define DEFINE_RES_MEM_NAMED(_start, _size, _name)                      \
+        DEFINE_RES_NAMED((_start), (_size), (_name), IORESOURCE_MEM)
+#define DEFINE_RES_MEM(_start, _size)                                   \
+        DEFINE_RES_MEM_NAMED((_start), (_size), NULL)
+
+#define DEFINE_RES_IRQ_NAMED(_irq, _name)                               \
+        DEFINE_RES_NAMED((_irq), 1, (_name), IORESOURCE_IRQ)
+#define DEFINE_RES_IRQ(_irq)                                            \
+        DEFINE_RES_IRQ_NAMED((_irq), NULL)
+
+#define DEFINE_RES_DMA_NAMED(_dma, _name)                               \
+        DEFINE_RES_NAMED((_dma), 1, (_name), IORESOURCE_DMA)
+#define DEFINE_RES_DMA(_dma)                                            \
+        DEFINE_RES_DMA_NAMED((_dma), NULL)
+
 /* PC/ISA/whatever - the normal PC address spaces: IO and memory */
 extern struct resource ioport_resource;
 extern struct resource iomem_resource;
@@ -132,6 +162,7 @@ extern int allocate_resource(struct resource *root, struct resource *new,
                                                        resource_size_t,
                                                        resource_size_t),
                              void *alignf_data);
+struct resource *lookup_resource(struct resource *root, resource_size_t start);
 int adjust_resource(struct resource *res, resource_size_t start,
                     resource_size_t size);
 resource_size_t resource_alignment(struct resource *res);
diff --git a/include/linux/ipc_namespace.h b/include/linux/ipc_namespace.h
index a6d1655f9607..8a297a5e794c 100644
--- a/include/linux/ipc_namespace.h
+++ b/include/linux/ipc_namespace.h
@@ -44,6 +44,11 @@ struct ipc_namespace {
         size_t          shm_ctlall;
         int             shm_ctlmni;
         int             shm_tot;
+        /*
+         * Defines whether IPC_RMID is forced for _all_ shm segments regardless
+         * of shmctl()
+         */
+        int             shm_rmid_forced;
 
         struct notifier_block ipcns_nb;
 
@@ -72,6 +77,7 @@ extern int register_ipcns_notifier(struct ipc_namespace *);
 extern int cond_register_ipcns_notifier(struct ipc_namespace *);
 extern void unregister_ipcns_notifier(struct ipc_namespace *);
 extern int ipcns_notify(unsigned long);
+extern void shm_destroy_orphaned(struct ipc_namespace *ns);
 #else /* CONFIG_SYSVIPC */
 static inline int register_ipcns_notifier(struct ipc_namespace *ns)
 { return 0; }
@@ -79,6 +85,7 @@ static inline int cond_register_ipcns_notifier(struct ipc_namespace *ns)
 { return 0; }
 static inline void unregister_ipcns_notifier(struct ipc_namespace *ns) { }
 static inline int ipcns_notify(unsigned long l) { return 0; }
+static inline void shm_destroy_orphaned(struct ipc_namespace *ns) {}
 #endif /* CONFIG_SYSVIPC */
 
 #ifdef CONFIG_POSIX_MQUEUE
diff --git a/include/linux/irq.h b/include/linux/irq.h
index 8b4538446636..87a06f345bd2 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -96,11 +96,6 @@ enum {
 
 #define IRQ_NO_BALANCING_MASK   (IRQ_PER_CPU | IRQ_NO_BALANCING)
 
-static inline __deprecated bool CHECK_IRQ_PER_CPU(unsigned int status)
-{
-        return status & IRQ_PER_CPU;
-}
-
 /*
  * Return value for chip->irq_set_affinity()
  *
@@ -113,14 +108,18 @@ enum {
 };
 
 struct msi_desc;
+struct irq_domain;
 
 /**
  * struct irq_data - per irq and irq chip data passed down to chip functions
  * @irq:                interrupt number
+ * @hwirq:              hardware interrupt number, local to the interrupt domain
  * @node:               node index useful for balancing
  * @state_use_accessors: status information for irq chip functions.
  *                      Use accessor functions to deal with it
  * @chip:               low level interrupt hardware access
+ * @domain:             Interrupt translation domain; responsible for mapping
+ *                      between hwirq number and linux irq number.
  * @handler_data:       per-IRQ data for the irq_chip methods
  * @chip_data:          platform-specific per-chip private data for the chip
  *                      methods, to allow shared chip implementations
@@ -133,9 +132,11 @@ struct msi_desc;
  */
 struct irq_data {
         unsigned int            irq;
+        unsigned long           hwirq;
         unsigned int            node;
         unsigned int            state_use_accessors;
         struct irq_chip         *chip;
+        struct irq_domain       *domain;
         void                    *handler_data;
         void                    *chip_data;
         struct msi_desc         *msi_desc;
@@ -676,7 +677,8 @@ void irq_gc_mask_disable_reg(struct irq_data *d);
 void irq_gc_mask_set_bit(struct irq_data *d);
 void irq_gc_mask_clr_bit(struct irq_data *d);
 void irq_gc_unmask_enable_reg(struct irq_data *d);
-void irq_gc_ack(struct irq_data *d);
+void irq_gc_ack_set_bit(struct irq_data *d);
+void irq_gc_ack_clr_bit(struct irq_data *d);
 void irq_gc_mask_disable_reg_and_ack(struct irq_data *d);
 void irq_gc_eoi(struct irq_data *d);
 int irq_gc_set_wake(struct irq_data *d, unsigned int on);
diff --git a/include/linux/irqdomain.h b/include/linux/irqdomain.h
new file mode 100644
index 000000000000..e807ad687a07
--- /dev/null
+++ b/include/linux/irqdomain.h
@@ -0,0 +1,91 @@
+/*
+ * irq_domain - IRQ translation domains
+ *
+ * Translation infrastructure between hw and linux irq numbers.  This is
+ * helpful for interrupt controllers to implement mapping between hardware
+ * irq numbers and the Linux irq number space.
+ *
+ * irq_domains also have a hook for translating device tree interrupt
+ * representation into a hardware irq number that can be mapped back to a
+ * Linux irq number without any extra platform support code.
+ *
+ * irq_domain is expected to be embedded in an interrupt controller's private
+ * data structure.
+ */
+#ifndef _LINUX_IRQDOMAIN_H
+#define _LINUX_IRQDOMAIN_H
+
+#include <linux/irq.h>
+#include <linux/mod_devicetable.h>
+
+#ifdef CONFIG_IRQ_DOMAIN
+struct device_node;
+struct irq_domain;
+
+/**
+ * struct irq_domain_ops - Methods for irq_domain objects
+ * @to_irq: (optional) given a local hardware irq number, return the linux
+ *          irq number.  If to_irq is not implemented, then the irq_domain
+ *          will use this translation: irq = (domain->irq_base + hwirq)
+ * @dt_translate: Given a device tree node and interrupt specifier, decode
+ *                the hardware irq number and linux irq type value.
+ */
+struct irq_domain_ops {
+        unsigned int (*to_irq)(struct irq_domain *d, unsigned long hwirq);
+
+#ifdef CONFIG_OF
+        int (*dt_translate)(struct irq_domain *d, struct device_node *node,
+                            const u32 *intspec, unsigned int intsize,
+                            unsigned long *out_hwirq, unsigned int *out_type);
+#endif /* CONFIG_OF */
+};
+
+/**
+ * struct irq_domain - Hardware interrupt number translation object
+ * @list: Element in global irq_domain list.
+ * @irq_base: Start of irq_desc range assigned to the irq_domain.  The creator
+ *            of the irq_domain is responsible for allocating the array of
+ *            irq_desc structures.
+ * @nr_irq: Number of irqs managed by the irq domain
+ * @ops: pointer to irq_domain methods
+ * @priv: private data pointer for use by owner.  Not touched by irq_domain
+ *        core code.
+ * @of_node: (optional) Pointer to device tree nodes associated with the
+ *           irq_domain.  Used when decoding device tree interrupt specifiers.
+ */
+struct irq_domain {
+        struct list_head list;
+        unsigned int irq_base;
+        unsigned int nr_irq;
+        const struct irq_domain_ops *ops;
+        void *priv;
+        struct device_node *of_node;
+};
+
+/**
+ * irq_domain_to_irq() - Translate from a hardware irq to a linux irq number
+ *
+ * Returns the linux irq number associated with a hardware irq.  By default,
+ * the mapping is irq == domain->irq_base + hwirq, but this mapping can
+ * be overridden if the irq_domain implements a .to_irq() hook.
+ */
+static inline unsigned int irq_domain_to_irq(struct irq_domain *d,
+                                             unsigned long hwirq)
+{
+        return d->ops->to_irq ? d->ops->to_irq(d, hwirq) : d->irq_base + hwirq;
+}
+
+extern void irq_domain_add(struct irq_domain *domain);
+extern void irq_domain_del(struct irq_domain *domain);
+#endif /* CONFIG_IRQ_DOMAIN */
+
+#if defined(CONFIG_IRQ_DOMAIN) && defined(CONFIG_OF_IRQ)
+extern void irq_domain_add_simple(struct device_node *controller, int irq_base);
+extern void irq_domain_generate_simple(const struct of_device_id *match,
+                                        u64 phys_base, unsigned int irq_start);
+#else /* CONFIG_IRQ_DOMAIN && CONFIG_OF_IRQ */
+static inline void irq_domain_generate_simple(const struct of_device_id *match,
+                                        u64 phys_base, unsigned int irq_start) { }
+#endif /* CONFIG_IRQ_DOMAIN && CONFIG_OF_IRQ */
+
+#endif /* _LINUX_IRQDOMAIN_H */
diff --git a/include/linux/irqreturn.h b/include/linux/irqreturn.h
index 819acaaac3f5..714ba08dc092 100644
--- a/include/linux/irqreturn.h
+++ b/include/linux/irqreturn.h
@@ -8,9 +8,9 @@
  * @IRQ_WAKE_THREAD     handler requests to wake the handler thread
  */
 enum irqreturn {
-        IRQ_NONE,
-        IRQ_HANDLED,
-        IRQ_WAKE_THREAD,
+        IRQ_NONE                = (0 << 0),
+        IRQ_HANDLED             = (1 << 0),
+        IRQ_WAKE_THREAD         = (1 << 1),
 };
 
 typedef enum irqreturn irqreturn_t;
diff --git a/include/linux/iscsi_boot_sysfs.h b/include/linux/iscsi_boot_sysfs.h
index f1e6c184f14f..f0a2f8b0aa13 100644
--- a/include/linux/iscsi_boot_sysfs.h
+++ b/include/linux/iscsi_boot_sysfs.h
@@ -92,6 +92,13 @@ struct iscsi_boot_kobj {
          * properties.
          */
         mode_t (*is_visible) (void *data, int type);
+
+        /*
+         * Driver specific release function.
+         *
+         * The function should free the data passed in.
+         */
+        void (*release) (void *data);
 };
 
 struct iscsi_boot_kset {
@@ -103,18 +110,21 @@ struct iscsi_boot_kobj *
 iscsi_boot_create_initiator(struct iscsi_boot_kset *boot_kset, int index,
                             void *data,
                             ssize_t (*show) (void *data, int type, char *buf),
-                            mode_t (*is_visible) (void *data, int type));
+                            mode_t (*is_visible) (void *data, int type),
+                            void (*release) (void *data));
 
 struct iscsi_boot_kobj *
 iscsi_boot_create_ethernet(struct iscsi_boot_kset *boot_kset, int index,
                            void *data,
                            ssize_t (*show) (void *data, int type, char *buf),
-                           mode_t (*is_visible) (void *data, int type));
+                           mode_t (*is_visible) (void *data, int type),
+                           void (*release) (void *data));
 struct iscsi_boot_kobj *
 iscsi_boot_create_target(struct iscsi_boot_kset *boot_kset, int index,
                          void *data,
                          ssize_t (*show) (void *data, int type, char *buf),
-                         mode_t (*is_visible) (void *data, int type));
+                         mode_t (*is_visible) (void *data, int type),
+                         void (*release) (void *data));
 
 struct iscsi_boot_kset *iscsi_boot_create_kset(const char *set_name);
 struct iscsi_boot_kset *iscsi_boot_create_host_kset(unsigned int hostno);
diff --git a/include/linux/jbd.h b/include/linux/jbd.h
index e06965081ba5..e6a5e34bed4f 100644
--- a/include/linux/jbd.h
+++ b/include/linux/jbd.h
@@ -940,7 +940,6 @@ extern int	   journal_force_commit(journal_t *);
  */
 struct journal_head *journal_add_journal_head(struct buffer_head *bh);
 struct journal_head *journal_grab_journal_head(struct buffer_head *bh);
-void journal_remove_journal_head(struct buffer_head *bh);
 void journal_put_journal_head(struct journal_head *jh);
 
 /*
diff --git a/include/linux/jbd2.h b/include/linux/jbd2.h
index 4ecb7b16b278..38f307b8c334 100644
--- a/include/linux/jbd2.h
+++ b/include/linux/jbd2.h
@@ -1024,7 +1024,6 @@ struct journal_s
 
 /* Filing buffers */
 extern void jbd2_journal_unfile_buffer(journal_t *, struct journal_head *);
-extern void __jbd2_journal_unfile_buffer(struct journal_head *);
 extern void __jbd2_journal_refile_buffer(struct journal_head *);
 extern void jbd2_journal_refile_buffer(journal_t *, struct journal_head *);
 extern void __jbd2_journal_file_buffer(struct journal_head *, transaction_t *, int);
@@ -1165,7 +1164,6 @@ extern void	   jbd2_journal_release_jbd_inode(journal_t *journal, struct jbd2_in
  */
 struct journal_head *jbd2_journal_add_journal_head(struct buffer_head *bh);
 struct journal_head *jbd2_journal_grab_journal_head(struct buffer_head *bh);
-void jbd2_journal_remove_journal_head(struct buffer_head *bh);
 void jbd2_journal_put_journal_head(struct journal_head *jh);
 
 /*
@@ -1331,12 +1329,6 @@ extern int jbd_blocks_per_page(struct inode *inode);
 #define BUFFER_TRACE2(bh, bh2, info)    do {} while (0)
 #define JBUFFER_TRACE(jh, info) do {} while (0)
 
-/* 
- * jbd2_dev_to_name is a utility function used by the jbd2 and ext4 
- * tracing infrastructure to map a dev_t to a device name.
- */
-extern const char *jbd2_dev_to_name(dev_t device);
-
 #endif  /* __KERNEL__ */
 
 #endif  /* _LINUX_JBD2_H */
diff --git a/include/linux/journal-head.h b/include/linux/journal-head.h
index 44e95d0a721f..423cb6d78ee0 100644
--- a/include/linux/journal-head.h
+++ b/include/linux/journal-head.h
@@ -45,7 +45,7 @@ struct journal_head {
          * has been cowed
          * [jbd_lock_bh_state()]
          */
-        unsigned b_cow_tid;
+        tid_t b_cow_tid;
 
         /*
          * Copy of the buffer data frozen for writing to the log.
diff --git a/include/linux/jump_label.h b/include/linux/jump_label.h
index 83e745f3ead7..66f23dc5e76a 100644
--- a/include/linux/jump_label.h
+++ b/include/linux/jump_label.h
@@ -54,7 +54,7 @@ extern void jump_label_apply_nops(struct module *mod);
 
 #else
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 #define JUMP_LABEL_INIT {ATOMIC_INIT(0)}
 
diff --git a/include/linux/kconfig.h b/include/linux/kconfig.h
new file mode 100644
index 000000000000..067eda0e4b32
--- /dev/null
+++ b/include/linux/kconfig.h
@@ -0,0 +1,32 @@
+#ifndef __LINUX_KCONFIG_H
+#define __LINUX_KCONFIG_H
+
+#include <generated/autoconf.h>
+
+/*
+ * Helper macros to use CONFIG_ options in C expressions. Note that
+ * these only work with boolean and tristate options.
+ */
+
+/*
+ * IS_ENABLED(CONFIG_FOO) evaluates to 1 if CONFIG_FOO is set to 'y' or 'm',
+ * 0 otherwise.
+ *
+ */
+#define IS_ENABLED(option) \
+        (__enabled_ ## option || __enabled_ ## option ## _MODULE)
+
+/*
+ * IS_BUILTIN(CONFIG_FOO) evaluates to 1 if CONFIG_FOO is set to 'y', 0
+ * otherwise. For boolean options, this is equivalent to
+ * IS_ENABLED(CONFIG_FOO).
+ */
+#define IS_BUILTIN(option) __enabled_ ## option
+
+/*
+ * IS_MODULE(CONFIG_FOO) evaluates to 1 if CONFIG_FOO is set to 'm', 0
+ * otherwise.
+ */
+#define IS_MODULE(option) __enabled_ ## option ## _MODULE
+
+#endif /* __LINUX_KCONFIG_H */
diff --git a/include/linux/kdb.h b/include/linux/kdb.h
index aadff7cc2b84..529d9a0c75a5 100644
--- a/include/linux/kdb.h
+++ b/include/linux/kdb.h
@@ -16,7 +16,7 @@
 #ifdef  CONFIG_KGDB_KDB
 #include <linux/init.h>
 #include <linux/sched.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 #define KDB_POLL_FUNC_MAX       5
 extern int kdb_poll_idx;
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index fb0e7329fee1..46ac9a50528d 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -56,6 +56,14 @@
 
 #define FIELD_SIZEOF(t, f) (sizeof(((t*)0)->f))
 #define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
+#define DIV_ROUND_UP_ULL(ll,d) \
+        ({ unsigned long long _tmp = (ll)+(d)-1; do_div(_tmp, d); _tmp; })
+
+#if BITS_PER_LONG == 32
+# define DIV_ROUND_UP_SECTOR_T(ll,d) DIV_ROUND_UP_ULL(ll, d)
+#else
+# define DIV_ROUND_UP_SECTOR_T(ll,d) DIV_ROUND_UP(ll,d)
+#endif
 
 /* The `const' in roundup() prevents gcc-3.3 from calling __divdi3 */
 #define roundup(x, y) (                                 \
@@ -121,7 +129,7 @@ extern int _cond_resched(void);
 # define might_resched() do { } while (0)
 #endif
 
-#ifdef CONFIG_DEBUG_SPINLOCK_SLEEP
+#ifdef CONFIG_DEBUG_ATOMIC_SLEEP
   void __might_sleep(const char *file, int line, int preempt_offset);
 /**
  * might_sleep - annotation for functions that can sleep
@@ -646,33 +654,10 @@ static inline void ftrace_dump(enum ftrace_dump_mode oops_dump_mode) { }
         const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
         (type *)( (char *)__mptr - offsetof(type,member) );})
 
-struct sysinfo;
-extern int do_sysinfo(struct sysinfo *info);
-
-#endif /* __KERNEL__ */
-
-#define SI_LOAD_SHIFT   16
-struct sysinfo {
-        long uptime;                    /* Seconds since boot */
-        unsigned long loads[3];         /* 1, 5, and 15 minute load averages */
-        unsigned long totalram;         /* Total usable main memory size */
-        unsigned long freeram;          /* Available memory size */
-        unsigned long sharedram;        /* Amount of shared memory */
-        unsigned long bufferram;        /* Memory used by buffers */
-        unsigned long totalswap;        /* Total swap space size */
-        unsigned long freeswap;         /* swap space still available */
-        unsigned short procs;           /* Number of current processes */
-        unsigned short pad;             /* explicit padding for m68k */
-        unsigned long totalhigh;        /* Total high memory size */
-        unsigned long freehigh;         /* Available high memory size */
-        unsigned int mem_unit;          /* Memory unit size in bytes */
-        char _f[20-2*sizeof(long)-sizeof(int)]; /* Padding: libc5 uses this.. */
-};
-
 #ifdef __CHECKER__
 #define BUILD_BUG_ON_NOT_POWER_OF_2(n)
-#define BUILD_BUG_ON_ZERO(e)
-#define BUILD_BUG_ON_NULL(e)
+#define BUILD_BUG_ON_ZERO(e) (0)
+#define BUILD_BUG_ON_NULL(e) ((void*)0)
 #define BUILD_BUG_ON(condition)
 #else /* __CHECKER__ */
 
@@ -736,4 +721,27 @@ extern int __build_bug_on_failed;
 # define REBUILD_DUE_TO_FTRACE_MCOUNT_RECORD
 #endif
 
+struct sysinfo;
+extern int do_sysinfo(struct sysinfo *info);
+
+#endif /* __KERNEL__ */
+
+#define SI_LOAD_SHIFT   16
+struct sysinfo {
+        long uptime;                    /* Seconds since boot */
+        unsigned long loads[3];         /* 1, 5, and 15 minute load averages */
+        unsigned long totalram;         /* Total usable main memory size */
+        unsigned long freeram;          /* Available memory size */
+        unsigned long sharedram;        /* Amount of shared memory */
+        unsigned long bufferram;        /* Memory used by buffers */
+        unsigned long totalswap;        /* Total swap space size */
+        unsigned long freeswap;         /* swap space still available */
+        unsigned short procs;           /* Number of current processes */
+        unsigned short pad;             /* explicit padding for m68k */
+        unsigned long totalhigh;        /* Total high memory size */
+        unsigned long freehigh;         /* Available high memory size */
+        unsigned int mem_unit;          /* Memory unit size in bytes */
+        char _f[20-2*sizeof(long)-sizeof(int)]; /* Padding: libc5 uses this.. */
+};
+
 #endif
diff --git a/include/linux/key.h b/include/linux/key.h
index 6ea4eebd3467..183a6af7715d 100644
--- a/include/linux/key.h
+++ b/include/linux/key.h
@@ -21,7 +21,7 @@
 #include <linux/rcupdate.h>
 #include <linux/sysctl.h>
 #include <linux/rwsem.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 #ifdef __KERNEL__
 
diff --git a/include/linux/kgdb.h b/include/linux/kgdb.h
index 10ca03d0a250..fa391835508d 100644
--- a/include/linux/kgdb.h
+++ b/include/linux/kgdb.h
@@ -16,7 +16,7 @@
 #include <linux/serial_8250.h>
 #include <linux/linkage.h>
 #include <linux/init.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #ifdef CONFIG_HAVE_ARCH_KGDB
 #include <asm/kgdb.h>
 #endif
diff --git a/include/linux/kmod.h b/include/linux/kmod.h
index d4a5c84c503d..0da38cf7db7b 100644
--- a/include/linux/kmod.h
+++ b/include/linux/kmod.h
@@ -45,7 +45,7 @@ static inline int request_module_nowait(const char *name, ...) { return -ENOSYS;
 #endif
 
 
-struct key;
+struct cred;
 struct file;
 
 enum umh_wait {
@@ -62,7 +62,7 @@ struct subprocess_info {
         char **envp;
         enum umh_wait wait;
         int retval;
-        int (*init)(struct subprocess_info *info);
+        int (*init)(struct subprocess_info *info, struct cred *new);
         void (*cleanup)(struct subprocess_info *info);
         void *data;
 };
@@ -73,7 +73,7 @@ struct subprocess_info *call_usermodehelper_setup(char *path, char **argv,
 
 /* Set various pieces of state into the subprocess_info structure */
 void call_usermodehelper_setfns(struct subprocess_info *info,
-                    int (*init)(struct subprocess_info *info),
+                    int (*init)(struct subprocess_info *info, struct cred *new),
                     void (*cleanup)(struct subprocess_info *info),
                     void *data);
 
@@ -87,7 +87,7 @@ void call_usermodehelper_freeinfo(struct subprocess_info *info);
 static inline int
 call_usermodehelper_fns(char *path, char **argv, char **envp,
                         enum umh_wait wait,
-                        int (*init)(struct subprocess_info *info),
+                        int (*init)(struct subprocess_info *info, struct cred *new),
                         void (*cleanup)(struct subprocess_info *), void *data)
 {
         struct subprocess_info *info;
diff --git a/include/linux/kmsg_dump.h b/include/linux/kmsg_dump.h
index 2a0d7d651dc3..ee0c952188de 100644
--- a/include/linux/kmsg_dump.h
+++ b/include/linux/kmsg_dump.h
@@ -12,6 +12,7 @@
 #ifndef _LINUX_KMSG_DUMP_H
 #define _LINUX_KMSG_DUMP_H
 
+#include <linux/errno.h>
 #include <linux/list.h>
 
 enum kmsg_dump_reason {
diff --git a/include/linux/kobject.h b/include/linux/kobject.h
index 9229b64ee3aa..668729cc0fe9 100644
--- a/include/linux/kobject.h
+++ b/include/linux/kobject.h
@@ -25,7 +25,7 @@
 #include <linux/kobject_ns.h>
 #include <linux/kernel.h>
 #include <linux/wait.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 #define UEVENT_HELPER_PATH_LEN          256
 #define UEVENT_NUM_ENVP                 32      /* number of env pointers */
diff --git a/include/linux/kobject_ns.h b/include/linux/kobject_ns.h
index 82cb5bf461fb..f66b065a8b5f 100644
--- a/include/linux/kobject_ns.h
+++ b/include/linux/kobject_ns.h
@@ -32,15 +32,17 @@ enum kobj_ns_type {
 
 /*
  * Callbacks so sysfs can determine namespaces
- *   @current_ns: return calling task's namespace
+ *   @grab_current_ns: return a new reference to calling task's namespace
  *   @netlink_ns: return namespace to which a sock belongs (right?)
  *   @initial_ns: return the initial namespace (i.e. init_net_ns)
+ *   @drop_ns: drops a reference to namespace
  */
 struct kobj_ns_type_operations {
         enum kobj_ns_type type;
-        const void *(*current_ns)(void);
+        void *(*grab_current_ns)(void);
         const void *(*netlink_ns)(struct sock *sk);
         const void *(*initial_ns)(void);
+        void (*drop_ns)(void *);
 };
 
 int kobj_ns_type_register(const struct kobj_ns_type_operations *ops);
@@ -48,9 +50,9 @@ int kobj_ns_type_registered(enum kobj_ns_type type);
 const struct kobj_ns_type_operations *kobj_child_ns_ops(struct kobject *parent);
 const struct kobj_ns_type_operations *kobj_ns_ops(struct kobject *kobj);
 
-const void *kobj_ns_current(enum kobj_ns_type type);
+void *kobj_ns_grab_current(enum kobj_ns_type type);
 const void *kobj_ns_netlink(enum kobj_ns_type type, struct sock *sk);
 const void *kobj_ns_initial(enum kobj_ns_type type);
-void kobj_ns_exit(enum kobj_ns_type type, const void *ns);
+void kobj_ns_drop(enum kobj_ns_type type, void *ns);
 
 #endif /* _LINUX_KOBJECT_NS_H */
diff --git a/include/linux/kvm.h b/include/linux/kvm.h
index 55ef181521ff..2c366b52f505 100644
--- a/include/linux/kvm.h
+++ b/include/linux/kvm.h
@@ -161,6 +161,7 @@ struct kvm_pit_config {
 #define KVM_EXIT_NMI              16
 #define KVM_EXIT_INTERNAL_ERROR   17
 #define KVM_EXIT_OSI              18
+#define KVM_EXIT_PAPR_HCALL       19
 
 /* For KVM_EXIT_INTERNAL_ERROR */
 #define KVM_INTERNAL_ERROR_EMULATION 1
@@ -264,6 +265,11 @@ struct kvm_run {
                 struct {
                         __u64 gprs[32];
                 } osi;
+                struct {
+                        __u64 nr;
+                        __u64 ret;
+                        __u64 args[9];
+                } papr_hcall;
                 /* Fix the size of the union. */
                 char padding[256];
         };
@@ -544,6 +550,9 @@ struct kvm_ppc_pvinfo {
 #define KVM_CAP_TSC_CONTROL 60
 #define KVM_CAP_GET_TSC_KHZ 61
 #define KVM_CAP_PPC_BOOKE_SREGS 62
+#define KVM_CAP_SPAPR_TCE 63
+#define KVM_CAP_PPC_SMT 64
+#define KVM_CAP_PPC_RMA 65
 
 #ifdef KVM_CAP_IRQ_ROUTING
 
@@ -746,6 +755,9 @@ struct kvm_clock_data {
 /* Available with KVM_CAP_XCRS */
 #define KVM_GET_XCRS              _IOR(KVMIO,  0xa6, struct kvm_xcrs)
 #define KVM_SET_XCRS              _IOW(KVMIO,  0xa7, struct kvm_xcrs)
+#define KVM_CREATE_SPAPR_TCE      _IOW(KVMIO,  0xa8, struct kvm_create_spapr_tce)
+/* Available with KVM_CAP_RMA */
+#define KVM_ALLOCATE_RMA          _IOR(KVMIO,  0xa9, struct kvm_allocate_rma)
 
 #define KVM_DEV_ASSIGN_ENABLE_IOMMU     (1 << 0)
 
@@ -773,20 +785,14 @@ struct kvm_assigned_pci_dev {
 
 struct kvm_assigned_irq {
         __u32 assigned_dev_id;
-        __u32 host_irq;
+        __u32 host_irq; /* ignored (legacy field) */
         __u32 guest_irq;
         __u32 flags;
         union {
-                struct {
-                        __u32 addr_lo;
-                        __u32 addr_hi;
-                        __u32 data;
-                } guest_msi;
                 __u32 reserved[12];
         };
 };
 
-
 struct kvm_assigned_msix_nr {
         __u32 assigned_dev_id;
         __u16 entry_nr;
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
index 31ebb59cbd2f..eabb21a30c34 100644
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@ -47,6 +47,7 @@
 #define KVM_REQ_DEACTIVATE_FPU    10
 #define KVM_REQ_EVENT             11
 #define KVM_REQ_APF_HALT          12
+#define KVM_REQ_STEAL_UPDATE      13
 
 #define KVM_USERSPACE_IRQ_SOURCE_ID     0
 
@@ -326,12 +327,17 @@ static inline struct kvm_memslots *kvm_memslots(struct kvm *kvm)
 static inline int is_error_hpa(hpa_t hpa) { return hpa >> HPA_MSB; }
 
 extern struct page *bad_page;
+extern struct page *fault_page;
+
 extern pfn_t bad_pfn;
+extern pfn_t fault_pfn;
 
 int is_error_page(struct page *page);
 int is_error_pfn(pfn_t pfn);
 int is_hwpoison_pfn(pfn_t pfn);
 int is_fault_pfn(pfn_t pfn);
+int is_noslot_pfn(pfn_t pfn);
+int is_invalid_pfn(pfn_t pfn);
 int kvm_is_error_hva(unsigned long addr);
 int kvm_set_memory_region(struct kvm *kvm,
                           struct kvm_userspace_memory_region *mem,
@@ -381,6 +387,8 @@ int kvm_read_guest_page(struct kvm *kvm, gfn_t gfn, void *data, int offset,
 int kvm_read_guest_atomic(struct kvm *kvm, gpa_t gpa, void *data,
                           unsigned long len);
 int kvm_read_guest(struct kvm *kvm, gpa_t gpa, void *data, unsigned long len);
+int kvm_read_guest_cached(struct kvm *kvm, struct gfn_to_hva_cache *ghc,
+                           void *data, unsigned long len);
 int kvm_write_guest_page(struct kvm *kvm, gfn_t gfn, const void *data,
                          int offset, int len);
 int kvm_write_guest(struct kvm *kvm, gpa_t gpa, const void *data,
diff --git a/include/linux/led-lm3530.h b/include/linux/led-lm3530.h
index 58592fa67d24..8eb12357a110 100644
--- a/include/linux/led-lm3530.h
+++ b/include/linux/led-lm3530.h
@@ -84,6 +84,8 @@ enum lm3530_als_mode {
  * @brt_ramp_rise: rate of rise of led current
  * @als1_resistor_sel: internal resistance from ALS1 input to ground
  * @als2_resistor_sel: internal resistance from ALS2 input to ground
+ * @als_vmin: als input voltage calibrated for max brightness in mV
+ * @als_vmax: als input voltage calibrated for min brightness in mV
  * @brt_val: brightness value (0-255)
  */
 struct lm3530_platform_data {
@@ -101,6 +103,9 @@ struct lm3530_platform_data {
         u8 als1_resistor_sel;
         u8 als2_resistor_sel;
 
+        u32 als_vmin;
+        u32 als_vmax;
+
         u8 brt_val;
 };
 
diff --git a/include/linux/lguest.h b/include/linux/lguest.h
index 2fb1dcbcb5aa..9962c6bb1311 100644
--- a/include/linux/lguest.h
+++ b/include/linux/lguest.h
@@ -59,8 +59,6 @@ struct lguest_data {
         unsigned long reserve_mem;
         /* KHz for the TSC clock. */
         u32 tsc_khz;
-        /* Page where the top-level pagetable is */
-        unsigned long pgdir;
 
 /* Fields initialized by the Guest at boot: */
         /* Instruction range to suppress interrupts even if enabled */
diff --git a/include/linux/libata.h b/include/linux/libata.h
index 5a9926b34072..efd6f9800762 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -74,6 +74,16 @@
 
 #define BPRINTK(fmt, args...) if (ap->flags & ATA_FLAG_DEBUGMSG) printk(KERN_ERR "%s: " fmt, __func__, ## args)
 
+#define ata_print_version_once(dev, version)                    \
+({                                                              \
+        static bool __print_once;                               \
+                                                                \
+        if (!__print_once) {                                    \
+                __print_once = true;                            \
+                ata_print_version(dev, version);                \
+        }                                                       \
+})
+
 /* NEW: debug levels */
 #define HAVE_LIBATA_MSG 1
 
@@ -1244,20 +1254,50 @@ static inline int sata_srst_pmp(struct ata_link *link)
 /*
  * printk helpers
  */
-#define ata_port_printk(ap, lv, fmt, args...) \
-        printk("%sata%u: "fmt, lv, (ap)->print_id , ##args)
-
-#define ata_link_printk(link, lv, fmt, args...) do { \
-        if (sata_pmp_attached((link)->ap) || (link)->ap->slave_link)    \
-                printk("%sata%u.%02u: "fmt, lv, (link)->ap->print_id,   \
-                       (link)->pmp , ##args); \
-        else \
-                printk("%sata%u: "fmt, lv, (link)->ap->print_id , ##args); \
-        } while(0)
-
-#define ata_dev_printk(dev, lv, fmt, args...) \
-        printk("%sata%u.%02u: "fmt, lv, (dev)->link->ap->print_id,      \
-               (dev)->link->pmp + (dev)->devno , ##args)
+__attribute__((format (printf, 3, 4)))
+int ata_port_printk(const struct ata_port *ap, const char *level,
+                    const char *fmt, ...);
+__attribute__((format (printf, 3, 4)))
+int ata_link_printk(const struct ata_link *link, const char *level,
+                    const char *fmt, ...);
+__attribute__((format (printf, 3, 4)))
+int ata_dev_printk(const struct ata_device *dev, const char *level,
+                   const char *fmt, ...);
+
+#define ata_port_err(ap, fmt, ...)                              \
+        ata_port_printk(ap, KERN_ERR, fmt, ##__VA_ARGS__)
+#define ata_port_warn(ap, fmt, ...)                             \
+        ata_port_printk(ap, KERN_WARNING, fmt, ##__VA_ARGS__)
+#define ata_port_notice(ap, fmt, ...)                           \
+        ata_port_printk(ap, KERN_NOTICE, fmt, ##__VA_ARGS__)
+#define ata_port_info(ap, fmt, ...)                             \
+        ata_port_printk(ap, KERN_INFO, fmt, ##__VA_ARGS__)
+#define ata_port_dbg(ap, fmt, ...)                              \
+        ata_port_printk(ap, KERN_DEBUG, fmt, ##__VA_ARGS__)
+
+#define ata_link_err(link, fmt, ...)                            \
+        ata_link_printk(link, KERN_ERR, fmt, ##__VA_ARGS__)
+#define ata_link_warn(link, fmt, ...)                           \
+        ata_link_printk(link, KERN_WARNING, fmt, ##__VA_ARGS__)
+#define ata_link_notice(link, fmt, ...)                         \
+        ata_link_printk(link, KERN_NOTICE, fmt, ##__VA_ARGS__)
+#define ata_link_info(link, fmt, ...)                           \
+        ata_link_printk(link, KERN_INFO, fmt, ##__VA_ARGS__)
+#define ata_link_dbg(link, fmt, ...)                            \
+        ata_link_printk(link, KERN_DEBUG, fmt, ##__VA_ARGS__)
+
+#define ata_dev_err(dev, fmt, ...)                              \
+        ata_dev_printk(dev, KERN_ERR, fmt, ##__VA_ARGS__)
+#define ata_dev_warn(dev, fmt, ...)                             \
+        ata_dev_printk(dev, KERN_WARNING, fmt, ##__VA_ARGS__)
+#define ata_dev_notice(dev, fmt, ...)                           \
+        ata_dev_printk(dev, KERN_NOTICE, fmt, ##__VA_ARGS__)
+#define ata_dev_info(dev, fmt, ...)                             \
+        ata_dev_printk(dev, KERN_INFO, fmt, ##__VA_ARGS__)
+#define ata_dev_dbg(dev, fmt, ...)                              \
+        ata_dev_printk(dev, KERN_DEBUG, fmt, ##__VA_ARGS__)
+
+void ata_print_version(const struct device *dev, const char *version);
 
 /*
  * ata_eh_info helpers
diff --git a/include/linux/llist.h b/include/linux/llist.h
new file mode 100644
index 000000000000..aa0c8b5b3cd0
--- /dev/null
+++ b/include/linux/llist.h
@@ -0,0 +1,126 @@
+#ifndef LLIST_H
+#define LLIST_H
+/*
+ * Lock-less NULL terminated single linked list
+ *
+ * If there are multiple producers and multiple consumers, llist_add
+ * can be used in producers and llist_del_all can be used in
+ * consumers.  They can work simultaneously without lock.  But
+ * llist_del_first can not be used here.  Because llist_del_first
+ * depends on list->first->next does not changed if list->first is not
+ * changed during its operation, but llist_del_first, llist_add,
+ * llist_add (or llist_del_all, llist_add, llist_add) sequence in
+ * another consumer may violate that.
+ *
+ * If there are multiple producers and one consumer, llist_add can be
+ * used in producers and llist_del_all or llist_del_first can be used
+ * in the consumer.
+ *
+ * This can be summarized as follow:
+ *
+ *           |   add    | del_first |  del_all
+ * add       |    -     |     -     |     -
+ * del_first |          |     L     |     L
+ * del_all   |          |           |     -
+ *
+ * Where "-" stands for no lock is needed, while "L" stands for lock
+ * is needed.
+ *
+ * The list entries deleted via llist_del_all can be traversed with
+ * traversing function such as llist_for_each etc.  But the list
+ * entries can not be traversed safely before deleted from the list.
+ * The order of deleted entries is from the newest to the oldest added
+ * one.  If you want to traverse from the oldest to the newest, you
+ * must reverse the order by yourself before traversing.
+ *
+ * The basic atomic operation of this list is cmpxchg on long.  On
+ * architectures that don't have NMI-safe cmpxchg implementation, the
+ * list can NOT be used in NMI handler.  So code uses the list in NMI
+ * handler should depend on CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG.
+ */
+
+struct llist_head {
+        struct llist_node *first;
+};
+
+struct llist_node {
+        struct llist_node *next;
+};
+
+#define LLIST_HEAD_INIT(name)   { NULL }
+#define LLIST_HEAD(name)        struct llist_head name = LLIST_HEAD_INIT(name)
+
+/**
+ * init_llist_head - initialize lock-less list head
+ * @head:       the head for your lock-less list
+ */
+static inline void init_llist_head(struct llist_head *list)
+{
+        list->first = NULL;
+}
+
+/**
+ * llist_entry - get the struct of this entry
+ * @ptr:        the &struct llist_node pointer.
+ * @type:       the type of the struct this is embedded in.
+ * @member:     the name of the llist_node within the struct.
+ */
+#define llist_entry(ptr, type, member)          \
+        container_of(ptr, type, member)
+
+/**
+ * llist_for_each - iterate over some deleted entries of a lock-less list
+ * @pos:        the &struct llist_node to use as a loop cursor
+ * @node:       the first entry of deleted list entries
+ *
+ * In general, some entries of the lock-less list can be traversed
+ * safely only after being deleted from list, so start with an entry
+ * instead of list head.
+ *
+ * If being used on entries deleted from lock-less list directly, the
+ * traverse order is from the newest to the oldest added entry.  If
+ * you want to traverse from the oldest to the newest, you must
+ * reverse the order by yourself before traversing.
+ */
+#define llist_for_each(pos, node)                       \
+        for ((pos) = (node); pos; (pos) = (pos)->next)
+
+/**
+ * llist_for_each_entry - iterate over some deleted entries of lock-less list of given type
+ * @pos:        the type * to use as a loop cursor.
+ * @node:       the fist entry of deleted list entries.
+ * @member:     the name of the llist_node with the struct.
+ *
+ * In general, some entries of the lock-less list can be traversed
+ * safely only after being removed from list, so start with an entry
+ * instead of list head.
+ *
+ * If being used on entries deleted from lock-less list directly, the
+ * traverse order is from the newest to the oldest added entry.  If
+ * you want to traverse from the oldest to the newest, you must
+ * reverse the order by yourself before traversing.
+ */
+#define llist_for_each_entry(pos, node, member)                         \
+        for ((pos) = llist_entry((node), typeof(*(pos)), member);       \
+             &(pos)->member != NULL;                                    \
+             (pos) = llist_entry((pos)->member.next, typeof(*(pos)), member))
+
+/**
+ * llist_empty - tests whether a lock-less list is empty
+ * @head:       the list to test
+ *
+ * Not guaranteed to be accurate or up to date.  Just a quick way to
+ * test whether the list is empty without deleting something from the
+ * list.
+ */
+static inline int llist_empty(const struct llist_head *head)
+{
+        return ACCESS_ONCE(head->first) == NULL;
+}
+
+void llist_add(struct llist_node *new, struct llist_head *head);
+void llist_add_batch(struct llist_node *new_first, struct llist_node *new_last,
+                     struct llist_head *head);
+struct llist_node *llist_del_first(struct llist_head *head);
+struct llist_node *llist_del_all(struct llist_head *head);
+#endif /* LLIST_H */
diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h
index 9724a38ee69d..3b535db00a94 100644
--- a/include/linux/memcontrol.h
+++ b/include/linux/memcontrol.h
@@ -39,6 +39,16 @@ extern unsigned long mem_cgroup_isolate_pages(unsigned long nr_to_scan,
                                         struct mem_cgroup *mem_cont,
                                         int active, int file);
 
+struct memcg_scanrecord {
+        struct mem_cgroup *mem; /* scanend memory cgroup */
+        struct mem_cgroup *root; /* scan target hierarchy root */
+        int context;            /* scanning context (see memcontrol.c) */
+        unsigned long nr_scanned[2]; /* the number of scanned pages */
+        unsigned long nr_rotated[2]; /* the number of rotated pages */
+        unsigned long nr_freed[2]; /* the number of freed pages */
+        unsigned long elapsed; /* nsec of time elapsed while scanning */
+};
+
 #ifdef CONFIG_CGROUP_MEM_RES_CTLR
 /*
  * All "charge" functions with gfp_mask should use GFP_KERNEL or
@@ -76,14 +86,13 @@ extern void mem_cgroup_uncharge_end(void);
 
 extern void mem_cgroup_uncharge_page(struct page *page);
 extern void mem_cgroup_uncharge_cache_page(struct page *page);
-extern int mem_cgroup_shmem_charge_fallback(struct page *page,
-                        struct mm_struct *mm, gfp_t gfp_mask);
 
 extern void mem_cgroup_out_of_memory(struct mem_cgroup *mem, gfp_t gfp_mask);
 int task_in_mem_cgroup(struct task_struct *task, const struct mem_cgroup *mem);
 
 extern struct mem_cgroup *try_get_mem_cgroup_from_page(struct page *page);
 extern struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p);
+extern struct mem_cgroup *try_get_mem_cgroup_from_mm(struct mm_struct *mm);
 
 static inline
 int mm_match_cgroup(const struct mm_struct *mm, const struct mem_cgroup *cgroup)
@@ -110,8 +119,7 @@ int mem_cgroup_inactive_anon_is_low(struct mem_cgroup *memcg);
 int mem_cgroup_inactive_file_is_low(struct mem_cgroup *memcg);
 int mem_cgroup_select_victim_node(struct mem_cgroup *memcg);
 unsigned long mem_cgroup_zone_nr_lru_pages(struct mem_cgroup *memcg,
-                                                struct zone *zone,
-                                                enum lru_list lru);
+                                        int nid, int zid, unsigned int lrumask);
 struct zone_reclaim_stat *mem_cgroup_get_reclaim_stat(struct mem_cgroup *memcg,
                                                       struct zone *zone);
 struct zone_reclaim_stat*
@@ -119,6 +127,15 @@ mem_cgroup_get_reclaim_stat_from_page(struct page *page);
 extern void mem_cgroup_print_oom_info(struct mem_cgroup *memcg,
                                         struct task_struct *p);
 
+extern unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *mem,
+                                                  gfp_t gfp_mask, bool noswap,
+                                                  struct memcg_scanrecord *rec);
+extern unsigned long mem_cgroup_shrink_node_zone(struct mem_cgroup *mem,
+                                                gfp_t gfp_mask, bool noswap,
+                                                struct zone *zone,
+                                                struct memcg_scanrecord *rec,
+                                                unsigned long *nr_scanned);
+
 #ifdef CONFIG_CGROUP_MEM_RES_CTLR_SWAP
 extern int do_swap_account;
 #endif
@@ -206,12 +223,6 @@ static inline void mem_cgroup_uncharge_cache_page(struct page *page)
 {
 }
 
-static inline int mem_cgroup_shmem_charge_fallback(struct page *page,
-                        struct mm_struct *mm, gfp_t gfp_mask)
-{
-        return 0;
-}
-
 static inline void mem_cgroup_add_lru_list(struct page *page, int lru)
 {
 }
@@ -246,6 +257,11 @@ static inline struct mem_cgroup *try_get_mem_cgroup_from_page(struct page *page)
         return NULL;
 }
 
+static inline struct mem_cgroup *try_get_mem_cgroup_from_mm(struct mm_struct *mm)
+{
+        return NULL;
+}
+
 static inline int mm_match_cgroup(struct mm_struct *mm, struct mem_cgroup *mem)
 {
         return 1;
@@ -307,8 +323,8 @@ mem_cgroup_inactive_file_is_low(struct mem_cgroup *memcg)
 }
 
 static inline unsigned long
-mem_cgroup_zone_nr_lru_pages(struct mem_cgroup *memcg, struct zone *zone,
-                             enum lru_list lru)
+mem_cgroup_zone_nr_lru_pages(struct mem_cgroup *memcg, int nid, int zid,
+                                unsigned int lru_mask)
 {
         return 0;
 }
diff --git a/include/linux/memory.h b/include/linux/memory.h
index e1e3b2b84f85..935699b30b7c 100644
--- a/include/linux/memory.h
+++ b/include/linux/memory.h
@@ -20,6 +20,8 @@
 #include <linux/compiler.h>
 #include <linux/mutex.h>
 
+#define MIN_MEMORY_BLOCK_SIZE     (1 << SECTION_SIZE_BITS)
+
 struct memory_block {
         unsigned long start_section_nr;
         unsigned long end_section_nr;
diff --git a/include/linux/memory_hotplug.h b/include/linux/memory_hotplug.h
index 8122018d3000..0b8e2a742600 100644
--- a/include/linux/memory_hotplug.h
+++ b/include/linux/memory_hotplug.h
@@ -68,12 +68,19 @@ static inline void zone_seqlock_init(struct zone *zone)
 extern int zone_grow_free_lists(struct zone *zone, unsigned long new_nr_pages);
 extern int zone_grow_waitqueues(struct zone *zone, unsigned long nr_pages);
 extern int add_one_highpage(struct page *page, int pfn, int bad_ppro);
-/* need some defines for these for archs that don't support it */
-extern void online_page(struct page *page);
 /* VM interface that may be used by firmware interface */
 extern int online_pages(unsigned long, unsigned long);
 extern void __offline_isolated_pages(unsigned long, unsigned long);
 
+typedef void (*online_page_callback_t)(struct page *page);
+
+extern int set_online_page_callback(online_page_callback_t callback);
+extern int restore_online_page_callback(online_page_callback_t callback);
+
+extern void __online_page_set_limits(struct page *page);
+extern void __online_page_increment_counters(struct page *page);
+extern void __online_page_free(struct page *page);
+
 #ifdef CONFIG_MEMORY_HOTREMOVE
 extern bool is_pageblock_removable_nolock(struct page *page);
 #endif /* CONFIG_MEMORY_HOTREMOVE */
diff --git a/include/linux/mfd/aat2870.h b/include/linux/mfd/aat2870.h
new file mode 100644
index 000000000000..f7316c29bdec
--- /dev/null
+++ b/include/linux/mfd/aat2870.h
@@ -0,0 +1,181 @@
+/*
+ * linux/include/linux/mfd/aat2870.h
+ *
+ * Copyright (c) 2011, NVIDIA Corporation.
+ * Author: Jin Park <jinyoungp@nvidia.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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ */
+
+#ifndef __LINUX_MFD_AAT2870_H
+#define __LINUX_MFD_AAT2870_H
+
+#include <linux/debugfs.h>
+#include <linux/i2c.h>
+
+/* Register offsets */
+#define AAT2870_BL_CH_EN        0x00
+#define AAT2870_BLM             0x01
+#define AAT2870_BLS             0x02
+#define AAT2870_BL1             0x03
+#define AAT2870_BL2             0x04
+#define AAT2870_BL3             0x05
+#define AAT2870_BL4             0x06
+#define AAT2870_BL5             0x07
+#define AAT2870_BL6             0x08
+#define AAT2870_BL7             0x09
+#define AAT2870_BL8             0x0A
+#define AAT2870_FLR             0x0B
+#define AAT2870_FM              0x0C
+#define AAT2870_FS              0x0D
+#define AAT2870_ALS_CFG0        0x0E
+#define AAT2870_ALS_CFG1        0x0F
+#define AAT2870_ALS_CFG2        0x10
+#define AAT2870_AMB             0x11
+#define AAT2870_ALS0            0x12
+#define AAT2870_ALS1            0x13
+#define AAT2870_ALS2            0x14
+#define AAT2870_ALS3            0x15
+#define AAT2870_ALS4            0x16
+#define AAT2870_ALS5            0x17
+#define AAT2870_ALS6            0x18
+#define AAT2870_ALS7            0x19
+#define AAT2870_ALS8            0x1A
+#define AAT2870_ALS9            0x1B
+#define AAT2870_ALSA            0x1C
+#define AAT2870_ALSB            0x1D
+#define AAT2870_ALSC            0x1E
+#define AAT2870_ALSD            0x1F
+#define AAT2870_ALSE            0x20
+#define AAT2870_ALSF            0x21
+#define AAT2870_SUB_SET         0x22
+#define AAT2870_SUB_CTRL        0x23
+#define AAT2870_LDO_AB          0x24
+#define AAT2870_LDO_CD          0x25
+#define AAT2870_LDO_EN          0x26
+#define AAT2870_REG_NUM         0x27
+
+/* Device IDs */
+enum aat2870_id {
+        AAT2870_ID_BL,
+        AAT2870_ID_LDOA,
+        AAT2870_ID_LDOB,
+        AAT2870_ID_LDOC,
+        AAT2870_ID_LDOD
+};
+
+/* Backlight channels */
+#define AAT2870_BL_CH1          0x01
+#define AAT2870_BL_CH2          0x02
+#define AAT2870_BL_CH3          0x04
+#define AAT2870_BL_CH4          0x08
+#define AAT2870_BL_CH5          0x10
+#define AAT2870_BL_CH6          0x20
+#define AAT2870_BL_CH7          0x40
+#define AAT2870_BL_CH8          0x80
+#define AAT2870_BL_CH_ALL       0xFF
+
+/* Backlight current magnitude (mA) */
+enum aat2870_current {
+        AAT2870_CURRENT_0_45 = 1,
+        AAT2870_CURRENT_0_90,
+        AAT2870_CURRENT_1_80,
+        AAT2870_CURRENT_2_70,
+        AAT2870_CURRENT_3_60,
+        AAT2870_CURRENT_4_50,
+        AAT2870_CURRENT_5_40,
+        AAT2870_CURRENT_6_30,
+        AAT2870_CURRENT_7_20,
+        AAT2870_CURRENT_8_10,
+        AAT2870_CURRENT_9_00,
+        AAT2870_CURRENT_9_90,
+        AAT2870_CURRENT_10_8,
+        AAT2870_CURRENT_11_7,
+        AAT2870_CURRENT_12_6,
+        AAT2870_CURRENT_13_5,
+        AAT2870_CURRENT_14_4,
+        AAT2870_CURRENT_15_3,
+        AAT2870_CURRENT_16_2,
+        AAT2870_CURRENT_17_1,
+        AAT2870_CURRENT_18_0,
+        AAT2870_CURRENT_18_9,
+        AAT2870_CURRENT_19_8,
+        AAT2870_CURRENT_20_7,
+        AAT2870_CURRENT_21_6,
+        AAT2870_CURRENT_22_5,
+        AAT2870_CURRENT_23_4,
+        AAT2870_CURRENT_24_3,
+        AAT2870_CURRENT_25_2,
+        AAT2870_CURRENT_26_1,
+        AAT2870_CURRENT_27_0,
+        AAT2870_CURRENT_27_9
+};
+
+struct aat2870_register {
+        bool readable;
+        bool writeable;
+        u8 value;
+};
+
+struct aat2870_data {
+        struct device *dev;
+        struct i2c_client *client;
+
+        struct mutex io_lock;
+        struct aat2870_register *reg_cache; /* register cache */
+        int en_pin; /* enable GPIO pin (if < 0, ignore this value) */
+        bool is_enable;
+
+        /* init and uninit for platform specified */
+        int (*init)(struct aat2870_data *aat2870);
+        void (*uninit)(struct aat2870_data *aat2870);
+
+        /* i2c io funcntions */
+        int (*read)(struct aat2870_data *aat2870, u8 addr, u8 *val);
+        int (*write)(struct aat2870_data *aat2870, u8 addr, u8 val);
+        int (*update)(struct aat2870_data *aat2870, u8 addr, u8 mask, u8 val);
+
+        /* for debugfs */
+        struct dentry *dentry_root;
+        struct dentry *dentry_reg;
+};
+
+struct aat2870_subdev_info {
+        int id;
+        const char *name;
+        void *platform_data;
+};
+
+struct aat2870_platform_data {
+        int en_pin; /* enable GPIO pin (if < 0, ignore this value) */
+
+        struct aat2870_subdev_info *subdevs;
+        int num_subdevs;
+
+        /* init and uninit for platform specified */
+        int (*init)(struct aat2870_data *aat2870);
+        void (*uninit)(struct aat2870_data *aat2870);
+};
+
+struct aat2870_bl_platform_data {
+        /* backlight channels, default is AAT2870_BL_CH_ALL */
+        int channels;
+        /* backlight current magnitude, default is AAT2870_CURRENT_27_9 */
+        int max_current;
+        /* maximum brightness, default is 255 */
+        int max_brightness;
+};
+
+#endif /* __LINUX_MFD_AAT2870_H */
diff --git a/include/linux/mfd/ab8500.h b/include/linux/mfd/ab8500.h
index b31843075198..838c6b487cc5 100644
--- a/include/linux/mfd/ab8500.h
+++ b/include/linux/mfd/ab8500.h
@@ -28,6 +28,7 @@
 #define AB8500_INTERRUPT        0xE
 #define AB8500_RTC              0xF
 #define AB8500_MISC             0x10
+#define AB8500_DEVELOPMENT      0x11
 #define AB8500_DEBUG            0x12
 #define AB8500_PROD_TEST        0x13
 #define AB8500_OTP_EMUL         0x15
@@ -74,13 +75,6 @@
 #define AB8500_INT_ACC_DETECT_21DB_F    37
 #define AB8500_INT_ACC_DETECT_21DB_R    38
 #define AB8500_INT_GP_SW_ADC_CONV_END   39
-#define AB8500_INT_ACC_DETECT_1DB_F     33
-#define AB8500_INT_ACC_DETECT_1DB_R     34
-#define AB8500_INT_ACC_DETECT_22DB_F    35
-#define AB8500_INT_ACC_DETECT_22DB_R    36
-#define AB8500_INT_ACC_DETECT_21DB_F    37
-#define AB8500_INT_ACC_DETECT_21DB_R    38
-#define AB8500_INT_GP_SW_ADC_CONV_END   39
 #define AB8500_INT_GPIO6R               40
 #define AB8500_INT_GPIO7R               41
 #define AB8500_INT_GPIO8R               42
diff --git a/include/linux/mfd/ds1wm.h b/include/linux/mfd/ds1wm.h
index be469a357cbb..38a372a0e285 100644
--- a/include/linux/mfd/ds1wm.h
+++ b/include/linux/mfd/ds1wm.h
@@ -3,4 +3,11 @@
 struct ds1wm_driver_data {
         int active_high;
         int clock_rate;
+        /* in milliseconds, the amount of time to */
+        /* sleep following a reset pulse. Zero    */
+        /* should work if your bus devices recover*/
+        /* time respects the 1-wire spec since the*/
+        /* ds1wm implements the precise timings of*/
+        /* a reset pulse/presence detect sequence.*/
+        unsigned int reset_recover_delay;
 };
diff --git a/include/linux/mfd/max8997.h b/include/linux/mfd/max8997.h
index 60931d089422..0bbd13dbe336 100644
--- a/include/linux/mfd/max8997.h
+++ b/include/linux/mfd/max8997.h
@@ -107,11 +107,16 @@ struct max8997_platform_data {
         unsigned int buck5_voltage[8];
         bool buck5_gpiodvs;
 
+        /* ---- Charger control ---- */
+        /* eoc stands for 'end of charge' */
+        int eoc_mA; /* 50 ~ 200mA by 10mA step */
+        /* charge Full Timeout */
+        int timeout; /* 0 (no timeout), 5, 6, 7 hours */
+
         /* MUIC: Not implemented */
         /* HAPTIC: Not implemented */
         /* RTC: Not implemented */
         /* Flash: Not implemented */
-        /* Charger control: Not implemented */
 };
 
 #endif /* __LINUX_MFD_MAX8998_H */
diff --git a/include/linux/mfd/max8998.h b/include/linux/mfd/max8998.h
index 61daa167b576..f4f0dfa4698a 100644
--- a/include/linux/mfd/max8998.h
+++ b/include/linux/mfd/max8998.h
@@ -87,6 +87,15 @@ struct max8998_regulator_data {
  * @wakeup: Allow to wake up from suspend
  * @rtc_delay: LP3974 RTC chip bug that requires delay after a register
  * write before reading it.
+ * @eoc: End of Charge Level in percent: 10% ~ 45% by 5% step
+ *   If it equals 0, leave it unchanged.
+ *   Otherwise, it is a invalid value.
+ * @restart: Restart Level in mV: 100, 150, 200, and -1 for disable.
+ *   If it equals 0, leave it unchanged.
+ *   Otherwise, it is a invalid value.
+ * @timeout: Full Timeout in hours: 5, 6, 7, and -1 for disable.
+ *   If it equals 0, leave it unchanged.
+ *   Otherwise, leave it unchanged.
  */
 struct max8998_platform_data {
         struct max8998_regulator_data   *regulators;
@@ -107,6 +116,9 @@ struct max8998_platform_data {
         int                             buck2_default_idx;
         bool                            wakeup;
         bool                            rtc_delay;
+        int                             eoc;
+        int                             restart;
+        int                             timeout;
 };
 
 #endif /*  __LINUX_MFD_MAX8998_H */
diff --git a/include/linux/mfd/pm8xxx/rtc.h b/include/linux/mfd/pm8xxx/rtc.h
new file mode 100644
index 000000000000..14f1983eaecc
--- /dev/null
+++ b/include/linux/mfd/pm8xxx/rtc.h
@@ -0,0 +1,25 @@
+/* Copyright (c) 2010-2011, Code Aurora Forum. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only 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 __RTC_PM8XXX_H__
+#define __RTC_PM8XXX_H__
+
+#define PM8XXX_RTC_DEV_NAME     "rtc-pm8xxx"
+/**
+ * struct pm8xxx_rtc_pdata - RTC driver platform data
+ * @rtc_write_enable: variable stating RTC write capability
+ */
+struct pm8xxx_rtc_platform_data {
+        bool rtc_write_enable;
+};
+
+#endif /* __RTC_PM8XXX_H__ */
diff --git a/include/linux/mfd/stmpe.h b/include/linux/mfd/stmpe.h
index e762c270d8d4..be1af7c42e57 100644
--- a/include/linux/mfd/stmpe.h
+++ b/include/linux/mfd/stmpe.h
@@ -57,6 +57,7 @@ struct stmpe_variant_info;
  * @irq_lock: IRQ bus lock
  * @dev: device, mostly for dev_dbg()
  * @i2c: i2c client
+ * @partnum: part number
  * @variant: the detected STMPE model number
  * @regs: list of addresses of registers which are at different addresses on
  *        different variants.  Indexed by one of STMPE_IDX_*.
@@ -121,6 +122,8 @@ struct stmpe_keypad_platform_data {
  * @norequest_mask: bitmask specifying which GPIOs should _not_ be
  *                  requestable due to different usage (e.g. touch, keypad)
  *                  STMPE_GPIO_NOREQ_* macros can be used here.
+ * @setup: board specific setup callback.
+ * @remove: board specific remove callback
  */
 struct stmpe_gpio_platform_data {
         int gpio_base;
diff --git a/include/linux/mfd/tmio.h b/include/linux/mfd/tmio.h
index 5a90266c3a5a..0dc98044d8b7 100644
--- a/include/linux/mfd/tmio.h
+++ b/include/linux/mfd/tmio.h
@@ -68,6 +68,11 @@
  * controller and report the event to the driver.
  */
 #define TMIO_MMC_HAS_COLD_CD            (1 << 3)
+/*
+ * Some controllers require waiting for the SD bus to become
+ * idle before writing to some registers.
+ */
+#define TMIO_MMC_HAS_IDLE_WAIT          (1 << 4)
 
 int tmio_core_mmc_enable(void __iomem *cnf, int shift, unsigned long base);
 int tmio_core_mmc_resume(void __iomem *cnf, int shift, unsigned long base);
@@ -80,6 +85,8 @@ struct tmio_mmc_dma {
         int alignment_shift;
 };
 
+struct tmio_mmc_host;
+
 /*
  * data for the MMC controller
  */
@@ -94,6 +101,7 @@ struct tmio_mmc_data {
         void (*set_pwr)(struct platform_device *host, int state);
         void (*set_clk_div)(struct platform_device *host, int state);
         int (*get_cd)(struct platform_device *host);
+        int (*write16_hook)(struct tmio_mmc_host *host, int addr);
 };
 
 static inline void tmio_mmc_cd_wakeup(struct tmio_mmc_data *pdata)
diff --git a/include/linux/mfd/tps65910.h b/include/linux/mfd/tps65910.h
index 8bb85b930c07..82b4c8801a4f 100644
--- a/include/linux/mfd/tps65910.h
+++ b/include/linux/mfd/tps65910.h
@@ -269,7 +269,7 @@
 #define LDO1_SEL_MASK                                   0xFC
 #define LDO3_SEL_MASK                                   0x7C
 #define LDO_MIN_VOLT                                    1000
-#define LDO_MAX_VOLT                                    3300;
+#define LDO_MAX_VOLT                                    3300
 
 
 /*Register VDIG1  (0x80) register.RegisterDescription */
@@ -791,6 +791,7 @@ int tps65910_clear_bits(struct tps65910 *tps65910, u8 reg, u8 mask);
 void tps65910_gpio_init(struct tps65910 *tps65910, int gpio_base);
 int tps65910_irq_init(struct tps65910 *tps65910, int irq,
                 struct tps65910_platform_data *pdata);
+int tps65910_irq_exit(struct tps65910 *tps65910);
 
 static inline int tps65910_chip_id(struct tps65910 *tps65910)
 {
diff --git a/include/linux/mfd/tps65912.h b/include/linux/mfd/tps65912.h
new file mode 100644
index 000000000000..aaceab402ec5
--- /dev/null
+++ b/include/linux/mfd/tps65912.h
@@ -0,0 +1,327 @@
+/*
+ * tps65912.h  --  TI TPS6591x
+ *
+ * Copyright 2011 Texas Instruments Inc.
+ *
+ * Author: Margarita Olaya <magi@slimlogic.co.uk>
+ *
+ *  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 __LINUX_MFD_TPS65912_H
+#define __LINUX_MFD_TPS65912_H
+
+/* TPS regulator type list */
+#define REGULATOR_LDO           0
+#define REGULATOR_DCDC          1
+
+/*
+ * List of registers for TPS65912
+ */
+
+#define TPS65912_DCDC1_CTRL             0x00
+#define TPS65912_DCDC2_CTRL             0x01
+#define TPS65912_DCDC3_CTRL             0x02
+#define TPS65912_DCDC4_CTRL             0x03
+#define TPS65912_DCDC1_OP               0x04
+#define TPS65912_DCDC1_AVS              0x05
+#define TPS65912_DCDC1_LIMIT            0x06
+#define TPS65912_DCDC2_OP               0x07
+#define TPS65912_DCDC2_AVS              0x08
+#define TPS65912_DCDC2_LIMIT            0x09
+#define TPS65912_DCDC3_OP               0x0A
+#define TPS65912_DCDC3_AVS              0x0B
+#define TPS65912_DCDC3_LIMIT            0x0C
+#define TPS65912_DCDC4_OP               0x0D
+#define TPS65912_DCDC4_AVS              0x0E
+#define TPS65912_DCDC4_LIMIT            0x0F
+#define TPS65912_LDO1_OP                0x10
+#define TPS65912_LDO1_AVS               0x11
+#define TPS65912_LDO1_LIMIT             0x12
+#define TPS65912_LDO2_OP                0x13
+#define TPS65912_LDO2_AVS               0x14
+#define TPS65912_LDO2_LIMIT             0x15
+#define TPS65912_LDO3_OP                0x16
+#define TPS65912_LDO3_AVS               0x17
+#define TPS65912_LDO3_LIMIT             0x18
+#define TPS65912_LDO4_OP                0x19
+#define TPS65912_LDO4_AVS               0x1A
+#define TPS65912_LDO4_LIMIT             0x1B
+#define TPS65912_LDO5                   0x1C
+#define TPS65912_LDO6                   0x1D
+#define TPS65912_LDO7                   0x1E
+#define TPS65912_LDO8                   0x1F
+#define TPS65912_LDO9                   0x20
+#define TPS65912_LDO10                  0x21
+#define TPS65912_THRM                   0x22
+#define TPS65912_CLK32OUT               0x23
+#define TPS65912_DEVCTRL                0x24
+#define TPS65912_DEVCTRL2               0x25
+#define TPS65912_I2C_SPI_CFG            0x26
+#define TPS65912_KEEP_ON                0x27
+#define TPS65912_KEEP_ON2               0x28
+#define TPS65912_SET_OFF1               0x29
+#define TPS65912_SET_OFF2               0x2A
+#define TPS65912_DEF_VOLT               0x2B
+#define TPS65912_DEF_VOLT_MAPPING       0x2C
+#define TPS65912_DISCHARGE              0x2D
+#define TPS65912_DISCHARGE2             0x2E
+#define TPS65912_EN1_SET1               0x2F
+#define TPS65912_EN1_SET2               0x30
+#define TPS65912_EN2_SET1               0x31
+#define TPS65912_EN2_SET2               0x32
+#define TPS65912_EN3_SET1               0x33
+#define TPS65912_EN3_SET2               0x34
+#define TPS65912_EN4_SET1               0x35
+#define TPS65912_EN4_SET2               0x36
+#define TPS65912_PGOOD                  0x37
+#define TPS65912_PGOOD2                 0x38
+#define TPS65912_INT_STS                0x39
+#define TPS65912_INT_MSK                0x3A
+#define TPS65912_INT_STS2               0x3B
+#define TPS65912_INT_MSK2               0x3C
+#define TPS65912_INT_STS3               0x3D
+#define TPS65912_INT_MSK3               0x3E
+#define TPS65912_INT_STS4               0x3F
+#define TPS65912_INT_MSK4               0x40
+#define TPS65912_GPIO1                  0x41
+#define TPS65912_GPIO2                  0x42
+#define TPS65912_GPIO3                  0x43
+#define TPS65912_GPIO4                  0x44
+#define TPS65912_GPIO5                  0x45
+#define TPS65912_VMON                   0x46
+#define TPS65912_LEDA_CTRL1             0x47
+#define TPS65912_LEDA_CTRL2             0x48
+#define TPS65912_LEDA_CTRL3             0x49
+#define TPS65912_LEDA_CTRL4             0x4A
+#define TPS65912_LEDA_CTRL5             0x4B
+#define TPS65912_LEDA_CTRL6             0x4C
+#define TPS65912_LEDA_CTRL7             0x4D
+#define TPS65912_LEDA_CTRL8             0x4E
+#define TPS65912_LEDB_CTRL1             0x4F
+#define TPS65912_LEDB_CTRL2             0x50
+#define TPS65912_LEDB_CTRL3             0x51
+#define TPS65912_LEDB_CTRL4             0x52
+#define TPS65912_LEDB_CTRL5             0x53
+#define TPS65912_LEDB_CTRL6             0x54
+#define TPS65912_LEDB_CTRL7             0x55
+#define TPS65912_LEDB_CTRL8             0x56
+#define TPS65912_LEDC_CTRL1             0x57
+#define TPS65912_LEDC_CTRL2             0x58
+#define TPS65912_LEDC_CTRL3             0x59
+#define TPS65912_LEDC_CTRL4             0x5A
+#define TPS65912_LEDC_CTRL5             0x5B
+#define TPS65912_LEDC_CTRL6             0x5C
+#define TPS65912_LEDC_CTRL7             0x5D
+#define TPS65912_LEDC_CTRL8             0x5E
+#define TPS65912_LED_RAMP_UP_TIME       0x5F
+#define TPS65912_LED_RAMP_DOWN_TIME     0x60
+#define TPS65912_LED_SEQ_EN             0x61
+#define TPS65912_LOADSWITCH             0x62
+#define TPS65912_SPARE                  0x63
+#define TPS65912_VERNUM                 0x64
+#define TPS6591X_MAX_REGISTER           0x64
+
+/* IRQ Definitions */
+#define TPS65912_IRQ_PWRHOLD_F          0
+#define TPS65912_IRQ_VMON               1
+#define TPS65912_IRQ_PWRON              2
+#define TPS65912_IRQ_PWRON_LP           3
+#define TPS65912_IRQ_PWRHOLD_R          4
+#define TPS65912_IRQ_HOTDIE             5
+#define TPS65912_IRQ_GPIO1_R            6
+#define TPS65912_IRQ_GPIO1_F            7
+#define TPS65912_IRQ_GPIO2_R            8
+#define TPS65912_IRQ_GPIO2_F            9
+#define TPS65912_IRQ_GPIO3_R            10
+#define TPS65912_IRQ_GPIO3_F            11
+#define TPS65912_IRQ_GPIO4_R            12
+#define TPS65912_IRQ_GPIO4_F            13
+#define TPS65912_IRQ_GPIO5_R            14
+#define TPS65912_IRQ_GPIO5_F            15
+#define TPS65912_IRQ_PGOOD_DCDC1        16
+#define TPS65912_IRQ_PGOOD_DCDC2        17
+#define TPS65912_IRQ_PGOOD_DCDC3        18
+#define TPS65912_IRQ_PGOOD_DCDC4        19
+#define TPS65912_IRQ_PGOOD_LDO1         20
+#define TPS65912_IRQ_PGOOD_LDO2         21
+#define TPS65912_IRQ_PGOOD_LDO3         22
+#define TPS65912_IRQ_PGOOD_LDO4         23
+#define TPS65912_IRQ_PGOOD_LDO5         24
+#define TPS65912_IRQ_PGOOD_LDO6         25
+#define TPS65912_IRQ_PGOOD_LDO7         26
+#define TPS65912_IRQ_PGOOD_LD08         27
+#define TPS65912_IRQ_PGOOD_LDO9         28
+#define TPS65912_IRQ_PGOOD_LDO10        29
+
+#define TPS65912_NUM_IRQ                30
+
+/* GPIO 1 and 2 Register Definitions */
+#define GPIO_SLEEP_MASK                 0x80
+#define GPIO_SLEEP_SHIFT                7
+#define GPIO_DEB_MASK                   0x10
+#define GPIO_DEB_SHIFT                  4
+#define GPIO_CFG_MASK                   0x04
+#define GPIO_CFG_SHIFT                  2
+#define GPIO_STS_MASK                   0x02
+#define GPIO_STS_SHIFT                  1
+#define GPIO_SET_MASK                   0x01
+#define GPIO_SET_SHIFT                  0
+
+/* GPIO 3 Register Definitions */
+#define GPIO3_SLEEP_MASK                0x80
+#define GPIO3_SLEEP_SHIFT               7
+#define GPIO3_SEL_MASK                  0x40
+#define GPIO3_SEL_SHIFT                 6
+#define GPIO3_ODEN_MASK                 0x20
+#define GPIO3_ODEN_SHIFT                5
+#define GPIO3_DEB_MASK                  0x10
+#define GPIO3_DEB_SHIFT                 4
+#define GPIO3_PDEN_MASK                 0x08
+#define GPIO3_PDEN_SHIFT                3
+#define GPIO3_CFG_MASK                  0x04
+#define GPIO3_CFG_SHIFT                 2
+#define GPIO3_STS_MASK                  0x02
+#define GPIO3_STS_SHIFT                 1
+#define GPIO3_SET_MASK                  0x01
+#define GPIO3_SET_SHIFT                 0
+
+/* GPIO 4 Register Definitions */
+#define GPIO4_SLEEP_MASK                0x80
+#define GPIO4_SLEEP_SHIFT               7
+#define GPIO4_SEL_MASK                  0x40
+#define GPIO4_SEL_SHIFT                 6
+#define GPIO4_ODEN_MASK                 0x20
+#define GPIO4_ODEN_SHIFT                5
+#define GPIO4_DEB_MASK                  0x10
+#define GPIO4_DEB_SHIFT                 4
+#define GPIO4_PDEN_MASK                 0x08
+#define GPIO4_PDEN_SHIFT                3
+#define GPIO4_CFG_MASK                  0x04
+#define GPIO4_CFG_SHIFT                 2
+#define GPIO4_STS_MASK                  0x02
+#define GPIO4_STS_SHIFT                 1
+#define GPIO4_SET_MASK                  0x01
+#define GPIO4_SET_SHIFT                 0
+
+/* Register THERM  (0x80) register.RegisterDescription */
+#define THERM_THERM_HD_MASK             0x20
+#define THERM_THERM_HD_SHIFT            5
+#define THERM_THERM_TS_MASK             0x10
+#define THERM_THERM_TS_SHIFT            4
+#define THERM_THERM_HDSEL_MASK          0x0C
+#define THERM_THERM_HDSEL_SHIFT         2
+#define THERM_RSVD1_MASK                0x02
+#define THERM_RSVD1_SHIFT               1
+#define THERM_THERM_STATE_MASK          0x01
+#define THERM_THERM_STATE_SHIFT         0
+
+/* Register DCDCCTRL1 register.RegisterDescription */
+#define DCDCCTRL_VCON_ENABLE_MASK       0x80
+#define DCDCCTRL_VCON_ENABLE_SHIFT      7
+#define DCDCCTRL_VCON_RANGE1_MASK       0x40
+#define DCDCCTRL_VCON_RANGE1_SHIFT      6
+#define DCDCCTRL_VCON_RANGE0_MASK       0x20
+#define DCDCCTRL_VCON_RANGE0_SHIFT      5
+#define DCDCCTRL_TSTEP2_MASK            0x10
+#define DCDCCTRL_TSTEP2_SHIFT           4
+#define DCDCCTRL_TSTEP1_MASK            0x08
+#define DCDCCTRL_TSTEP1_SHIFT           3
+#define DCDCCTRL_TSTEP0_MASK            0x04
+#define DCDCCTRL_TSTEP0_SHIFT           2
+#define DCDCCTRL_DCDC1_MODE_MASK        0x02
+#define DCDCCTRL_DCDC1_MODE_SHIFT       1
+
+/* Register DCDCCTRL2 and DCDCCTRL3 register.RegisterDescription */
+#define DCDCCTRL_TSTEP2_MASK            0x10
+#define DCDCCTRL_TSTEP2_SHIFT           4
+#define DCDCCTRL_TSTEP1_MASK            0x08
+#define DCDCCTRL_TSTEP1_SHIFT           3
+#define DCDCCTRL_TSTEP0_MASK            0x04
+#define DCDCCTRL_TSTEP0_SHIFT           2
+#define DCDCCTRL_DCDC_MODE_MASK         0x02
+#define DCDCCTRL_DCDC_MODE_SHIFT        1
+#define DCDCCTRL_RSVD0_MASK             0x01
+#define DCDCCTRL_RSVD0_SHIFT            0
+
+/* Register DCDCCTRL4 register.RegisterDescription */
+#define DCDCCTRL_RAMP_TIME_MASK         0x01
+#define DCDCCTRL_RAMP_TIME_SHIFT        0
+
+/* Register DCDCx_AVS */
+#define DCDC_AVS_ENABLE_MASK            0x80
+#define DCDC_AVS_ENABLE_SHIFT           7
+#define DCDC_AVS_ECO_MASK               0x40
+#define DCDC_AVS_ECO_SHIFT              6
+
+/* Register DCDCx_LIMIT */
+#define DCDC_LIMIT_RANGE_MASK           0xC0
+#define DCDC_LIMIT_RANGE_SHIFT          6
+#define DCDC_LIMIT_MAX_SEL_MASK         0x3F
+#define DCDC_LIMIT_MAX_SEL_SHIFT        0
+
+/**
+ * struct tps65912_board
+ * Board platform dat may be used to initialize regulators.
+ */
+struct tps65912_board {
+        int is_dcdc1_avs;
+        int is_dcdc2_avs;
+        int is_dcdc3_avs;
+        int is_dcdc4_avs;
+        int irq;
+        int irq_base;
+        int gpio_base;
+        struct regulator_init_data *tps65912_pmic_init_data;
+};
+
+/**
+ * struct tps65912 - tps65912 sub-driver chip access routines
+ */
+
+struct tps65912 {
+        struct device *dev;
+        /* for read/write acces */
+        struct mutex io_mutex;
+
+        /* For device IO interfaces: I2C or SPI */
+        void *control_data;
+
+        int (*read)(struct tps65912 *tps65912, u8 reg, int size, void *dest);
+        int (*write)(struct tps65912 *tps65912, u8 reg, int size, void *src);
+
+        /* Client devices */
+        struct tps65912_pmic *pmic;
+
+        /* GPIO Handling */
+        struct gpio_chip gpio;
+
+        /* IRQ Handling */
+        struct mutex irq_lock;
+        int chip_irq;
+        int irq_base;
+        int irq_num;
+        u32 irq_mask;
+};
+
+struct tps65912_platform_data {
+        int irq;
+        int irq_base;
+};
+
+unsigned int tps_chip(void);
+
+int tps65912_set_bits(struct tps65912 *tps65912, u8 reg, u8 mask);
+int tps65912_clear_bits(struct tps65912 *tps65912, u8 reg, u8 mask);
+int tps65912_reg_read(struct tps65912 *tps65912, u8 reg);
+int tps65912_reg_write(struct tps65912 *tps65912, u8 reg, u8 val);
+int tps65912_device_init(struct tps65912 *tps65912);
+void tps65912_device_exit(struct tps65912 *tps65912);
+int tps65912_irq_init(struct tps65912 *tps65912, int irq,
+                        struct tps65912_platform_data *pdata);
+
+#endif /*  __LINUX_MFD_TPS65912_H */
diff --git a/include/linux/mfd/twl4030-codec.h b/include/linux/mfd/twl4030-audio.h
index 5cc16bbd1da1..3d22b72df076 100644
--- a/include/linux/mfd/twl4030-codec.h
+++ b/include/linux/mfd/twl4030-audio.h
@@ -1,5 +1,5 @@
 /*
- * MFD driver for twl4030 codec submodule
+ * MFD driver for twl4030 audio submodule
  *
  * Author: Peter Ujfalusi <peter.ujfalusi@ti.com>
  *
@@ -259,14 +259,14 @@
 #define TWL4030_VIBRA_DIR_SEL           0x20
 
 /* TWL4030 codec resource IDs */
-enum twl4030_codec_res {
-        TWL4030_CODEC_RES_POWER = 0,
-        TWL4030_CODEC_RES_APLL,
-        TWL4030_CODEC_RES_MAX,
+enum twl4030_audio_res {
+        TWL4030_AUDIO_RES_POWER = 0,
+        TWL4030_AUDIO_RES_APLL,
+        TWL4030_AUDIO_RES_MAX,
 };
 
-int twl4030_codec_disable_resource(enum twl4030_codec_res id);
-int twl4030_codec_enable_resource(enum twl4030_codec_res id);
-unsigned int twl4030_codec_get_mclk(void);
+int twl4030_audio_disable_resource(enum twl4030_audio_res id);
+int twl4030_audio_enable_resource(enum twl4030_audio_res id);
+unsigned int twl4030_audio_get_mclk(void);
 
 #endif  /* End of __TWL4030_CODEC_H__ */
diff --git a/include/linux/mfd/twl6040.h b/include/linux/mfd/twl6040.h
new file mode 100644
index 000000000000..4c806f6d663e
--- /dev/null
+++ b/include/linux/mfd/twl6040.h
@@ -0,0 +1,228 @@
+/*
+ * MFD driver for twl6040
+ *
+ * Authors:     Jorge Eduardo Candelaria <jorge.candelaria@ti.com>
+ *              Misael Lopez Cruz <misael.lopez@ti.com>
+ *
+ * Copyright:   (C) 2011 Texas Instruments, Inc.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef __TWL6040_CODEC_H__
+#define __TWL6040_CODEC_H__
+
+#include <linux/interrupt.h>
+#include <linux/mfd/core.h>
+
+#define TWL6040_REG_ASICID              0x01
+#define TWL6040_REG_ASICREV             0x02
+#define TWL6040_REG_INTID               0x03
+#define TWL6040_REG_INTMR               0x04
+#define TWL6040_REG_NCPCTL              0x05
+#define TWL6040_REG_LDOCTL              0x06
+#define TWL6040_REG_HPPLLCTL            0x07
+#define TWL6040_REG_LPPLLCTL            0x08
+#define TWL6040_REG_LPPLLDIV            0x09
+#define TWL6040_REG_AMICBCTL            0x0A
+#define TWL6040_REG_DMICBCTL            0x0B
+#define TWL6040_REG_MICLCTL             0x0C
+#define TWL6040_REG_MICRCTL             0x0D
+#define TWL6040_REG_MICGAIN             0x0E
+#define TWL6040_REG_LINEGAIN            0x0F
+#define TWL6040_REG_HSLCTL              0x10
+#define TWL6040_REG_HSRCTL              0x11
+#define TWL6040_REG_HSGAIN              0x12
+#define TWL6040_REG_EARCTL              0x13
+#define TWL6040_REG_HFLCTL              0x14
+#define TWL6040_REG_HFLGAIN             0x15
+#define TWL6040_REG_HFRCTL              0x16
+#define TWL6040_REG_HFRGAIN             0x17
+#define TWL6040_REG_VIBCTLL             0x18
+#define TWL6040_REG_VIBDATL             0x19
+#define TWL6040_REG_VIBCTLR             0x1A
+#define TWL6040_REG_VIBDATR             0x1B
+#define TWL6040_REG_HKCTL1              0x1C
+#define TWL6040_REG_HKCTL2              0x1D
+#define TWL6040_REG_GPOCTL              0x1E
+#define TWL6040_REG_ALB                 0x1F
+#define TWL6040_REG_DLB                 0x20
+#define TWL6040_REG_TRIM1               0x28
+#define TWL6040_REG_TRIM2               0x29
+#define TWL6040_REG_TRIM3               0x2A
+#define TWL6040_REG_HSOTRIM             0x2B
+#define TWL6040_REG_HFOTRIM             0x2C
+#define TWL6040_REG_ACCCTL              0x2D
+#define TWL6040_REG_STATUS              0x2E
+
+#define TWL6040_CACHEREGNUM             (TWL6040_REG_STATUS + 1)
+
+#define TWL6040_VIOREGNUM               18
+#define TWL6040_VDDREGNUM               21
+
+/* INTID (0x03) fields */
+
+#define TWL6040_THINT                   0x01
+#define TWL6040_PLUGINT                 0x02
+#define TWL6040_UNPLUGINT               0x04
+#define TWL6040_HOOKINT                 0x08
+#define TWL6040_HFINT                   0x10
+#define TWL6040_VIBINT                  0x20
+#define TWL6040_READYINT                0x40
+
+/* INTMR (0x04) fields */
+
+#define TWL6040_THMSK                   0x01
+#define TWL6040_PLUGMSK                 0x02
+#define TWL6040_HOOKMSK                 0x08
+#define TWL6040_HFMSK                   0x10
+#define TWL6040_VIBMSK                  0x20
+#define TWL6040_READYMSK                0x40
+#define TWL6040_ALLINT_MSK              0x7B
+
+/* NCPCTL (0x05) fields */
+
+#define TWL6040_NCPENA                  0x01
+#define TWL6040_NCPOPEN                 0x40
+
+/* LDOCTL (0x06) fields */
+
+#define TWL6040_LSLDOENA                0x01
+#define TWL6040_HSLDOENA                0x04
+#define TWL6040_REFENA                  0x40
+#define TWL6040_OSCENA                  0x80
+
+/* HPPLLCTL (0x07) fields */
+
+#define TWL6040_HPLLENA                 0x01
+#define TWL6040_HPLLRST                 0x02
+#define TWL6040_HPLLBP                  0x04
+#define TWL6040_HPLLSQRENA              0x08
+#define TWL6040_MCLK_12000KHZ           (0 << 5)
+#define TWL6040_MCLK_19200KHZ           (1 << 5)
+#define TWL6040_MCLK_26000KHZ           (2 << 5)
+#define TWL6040_MCLK_38400KHZ           (3 << 5)
+#define TWL6040_MCLK_MSK                0x60
+
+/* LPPLLCTL (0x08) fields */
+
+#define TWL6040_LPLLENA                 0x01
+#define TWL6040_LPLLRST                 0x02
+#define TWL6040_LPLLSEL                 0x04
+#define TWL6040_LPLLFIN                 0x08
+#define TWL6040_HPLLSEL                 0x10
+
+/* HSLCTL (0x10) fields */
+
+#define TWL6040_HSDACMODEL              0x02
+#define TWL6040_HSDRVMODEL              0x08
+
+/* HSRCTL (0x11) fields */
+
+#define TWL6040_HSDACMODER              0x02
+#define TWL6040_HSDRVMODER              0x08
+
+/* VIBCTLL (0x18) fields */
+
+#define TWL6040_VIBENAL                 0x01
+#define TWL6040_VIBCTRLL                0x04
+#define TWL6040_VIBCTRLLP               0x08
+#define TWL6040_VIBCTRLLN               0x10
+
+/* VIBDATL (0x19) fields */
+
+#define TWL6040_VIBDAT_MAX              0x64
+
+/* VIBCTLR (0x1A) fields */
+
+#define TWL6040_VIBENAR                 0x01
+#define TWL6040_VIBCTRLR                0x04
+#define TWL6040_VIBCTRLRP               0x08
+#define TWL6040_VIBCTRLRN               0x10
+
+/* GPOCTL (0x1E) fields */
+
+#define TWL6040_GPO1                    0x01
+#define TWL6040_GPO2                    0x02
+#define TWL6040_GPO3                    0x03
+
+/* ACCCTL (0x2D) fields */
+
+#define TWL6040_I2CSEL                  0x01
+#define TWL6040_RESETSPLIT              0x04
+#define TWL6040_INTCLRMODE              0x08
+
+/* STATUS (0x2E) fields */
+
+#define TWL6040_PLUGCOMP                0x02
+#define TWL6040_VIBLOCDET               0x10
+#define TWL6040_VIBROCDET               0x20
+#define TWL6040_TSHUTDET                0x40
+
+#define TWL6040_CELLS                   2
+
+#define TWL6040_REV_ES1_0               0x00
+#define TWL6040_REV_ES1_1               0x01
+#define TWL6040_REV_ES1_2               0x02
+
+#define TWL6040_IRQ_TH                  0
+#define TWL6040_IRQ_PLUG                1
+#define TWL6040_IRQ_HOOK                2
+#define TWL6040_IRQ_HF                  3
+#define TWL6040_IRQ_VIB                 4
+#define TWL6040_IRQ_READY               5
+
+/* PLL selection */
+#define TWL6040_SYSCLK_SEL_LPPLL        0
+#define TWL6040_SYSCLK_SEL_HPPLL        1
+
+struct twl6040 {
+        struct device *dev;
+        struct mutex mutex;
+        struct mutex io_mutex;
+        struct mutex irq_mutex;
+        struct mfd_cell cells[TWL6040_CELLS];
+        struct completion ready;
+
+        int audpwron;
+        int power_count;
+        int rev;
+
+        int pll;
+        unsigned int sysclk;
+
+        unsigned int irq;
+        unsigned int irq_base;
+        u8 irq_masks_cur;
+        u8 irq_masks_cache;
+};
+
+int twl6040_reg_read(struct twl6040 *twl6040, unsigned int reg);
+int twl6040_reg_write(struct twl6040 *twl6040, unsigned int reg,
+                      u8 val);
+int twl6040_set_bits(struct twl6040 *twl6040, unsigned int reg,
+                     u8 mask);
+int twl6040_clear_bits(struct twl6040 *twl6040, unsigned int reg,
+                       u8 mask);
+int twl6040_power(struct twl6040 *twl6040, int on);
+int twl6040_set_pll(struct twl6040 *twl6040, int pll_id,
+                    unsigned int freq_in, unsigned int freq_out);
+int twl6040_get_pll(struct twl6040 *twl6040);
+unsigned int twl6040_get_sysclk(struct twl6040 *twl6040);
+int twl6040_irq_init(struct twl6040 *twl6040);
+void twl6040_irq_exit(struct twl6040 *twl6040);
+
+#endif  /* End of __TWL6040_CODEC_H__ */
diff --git a/include/linux/mfd/wm831x/core.h b/include/linux/mfd/wm831x/core.h
index 0d515ee1c247..8dda8ded5cda 100644
--- a/include/linux/mfd/wm831x/core.h
+++ b/include/linux/mfd/wm831x/core.h
@@ -17,6 +17,7 @@
 
 #include <linux/completion.h>
 #include <linux/interrupt.h>
+#include <linux/list.h>
 
 /*
  * Register values.
@@ -234,9 +235,111 @@
 #define WM831X_ON_PIN_TO_SHIFT                       0  /* ON_PIN_TO - [1:0] */
 #define WM831X_ON_PIN_TO_WIDTH                       2  /* ON_PIN_TO - [1:0] */
 
+/*
+ * R16528 (0x4090) - Clock Control 1
+ */
+#define WM831X_CLKOUT_ENA                       0x8000  /* CLKOUT_ENA */
+#define WM831X_CLKOUT_ENA_MASK                  0x8000  /* CLKOUT_ENA */
+#define WM831X_CLKOUT_ENA_SHIFT                     15  /* CLKOUT_ENA */
+#define WM831X_CLKOUT_ENA_WIDTH                      1  /* CLKOUT_ENA */
+#define WM831X_CLKOUT_OD                        0x2000  /* CLKOUT_OD */
+#define WM831X_CLKOUT_OD_MASK                   0x2000  /* CLKOUT_OD */
+#define WM831X_CLKOUT_OD_SHIFT                      13  /* CLKOUT_OD */
+#define WM831X_CLKOUT_OD_WIDTH                       1  /* CLKOUT_OD */
+#define WM831X_CLKOUT_SLOT_MASK                 0x0700  /* CLKOUT_SLOT - [10:8] */
+#define WM831X_CLKOUT_SLOT_SHIFT                     8  /* CLKOUT_SLOT - [10:8] */
+#define WM831X_CLKOUT_SLOT_WIDTH                     3  /* CLKOUT_SLOT - [10:8] */
+#define WM831X_CLKOUT_SLPSLOT_MASK              0x0070  /* CLKOUT_SLPSLOT - [6:4] */
+#define WM831X_CLKOUT_SLPSLOT_SHIFT                  4  /* CLKOUT_SLPSLOT - [6:4] */
+#define WM831X_CLKOUT_SLPSLOT_WIDTH                  3  /* CLKOUT_SLPSLOT - [6:4] */
+#define WM831X_CLKOUT_SRC                       0x0001  /* CLKOUT_SRC */
+#define WM831X_CLKOUT_SRC_MASK                  0x0001  /* CLKOUT_SRC */
+#define WM831X_CLKOUT_SRC_SHIFT                      0  /* CLKOUT_SRC */
+#define WM831X_CLKOUT_SRC_WIDTH                      1  /* CLKOUT_SRC */
+
+/*
+ * R16529 (0x4091) - Clock Control 2
+ */
+#define WM831X_XTAL_INH                         0x8000  /* XTAL_INH */
+#define WM831X_XTAL_INH_MASK                    0x8000  /* XTAL_INH */
+#define WM831X_XTAL_INH_SHIFT                       15  /* XTAL_INH */
+#define WM831X_XTAL_INH_WIDTH                        1  /* XTAL_INH */
+#define WM831X_XTAL_ENA                         0x2000  /* XTAL_ENA */
+#define WM831X_XTAL_ENA_MASK                    0x2000  /* XTAL_ENA */
+#define WM831X_XTAL_ENA_SHIFT                       13  /* XTAL_ENA */
+#define WM831X_XTAL_ENA_WIDTH                        1  /* XTAL_ENA */
+#define WM831X_XTAL_BKUPENA                     0x1000  /* XTAL_BKUPENA */
+#define WM831X_XTAL_BKUPENA_MASK                0x1000  /* XTAL_BKUPENA */
+#define WM831X_XTAL_BKUPENA_SHIFT                   12  /* XTAL_BKUPENA */
+#define WM831X_XTAL_BKUPENA_WIDTH                    1  /* XTAL_BKUPENA */
+#define WM831X_FLL_AUTO                         0x0080  /* FLL_AUTO */
+#define WM831X_FLL_AUTO_MASK                    0x0080  /* FLL_AUTO */
+#define WM831X_FLL_AUTO_SHIFT                        7  /* FLL_AUTO */
+#define WM831X_FLL_AUTO_WIDTH                        1  /* FLL_AUTO */
+#define WM831X_FLL_AUTO_FREQ_MASK               0x0007  /* FLL_AUTO_FREQ - [2:0] */
+#define WM831X_FLL_AUTO_FREQ_SHIFT                   0  /* FLL_AUTO_FREQ - [2:0] */
+#define WM831X_FLL_AUTO_FREQ_WIDTH                   3  /* FLL_AUTO_FREQ - [2:0] */
+
+/*
+ * R16530 (0x4092) - FLL Control 1
+ */
+#define WM831X_FLL_FRAC                         0x0004  /* FLL_FRAC */
+#define WM831X_FLL_FRAC_MASK                    0x0004  /* FLL_FRAC */
+#define WM831X_FLL_FRAC_SHIFT                        2  /* FLL_FRAC */
+#define WM831X_FLL_FRAC_WIDTH                        1  /* FLL_FRAC */
+#define WM831X_FLL_OSC_ENA                      0x0002  /* FLL_OSC_ENA */
+#define WM831X_FLL_OSC_ENA_MASK                 0x0002  /* FLL_OSC_ENA */
+#define WM831X_FLL_OSC_ENA_SHIFT                     1  /* FLL_OSC_ENA */
+#define WM831X_FLL_OSC_ENA_WIDTH                     1  /* FLL_OSC_ENA */
+#define WM831X_FLL_ENA                          0x0001  /* FLL_ENA */
+#define WM831X_FLL_ENA_MASK                     0x0001  /* FLL_ENA */
+#define WM831X_FLL_ENA_SHIFT                         0  /* FLL_ENA */
+#define WM831X_FLL_ENA_WIDTH                         1  /* FLL_ENA */
+
+/*
+ * R16531 (0x4093) - FLL Control 2
+ */
+#define WM831X_FLL_OUTDIV_MASK                  0x3F00  /* FLL_OUTDIV - [13:8] */
+#define WM831X_FLL_OUTDIV_SHIFT                      8  /* FLL_OUTDIV - [13:8] */
+#define WM831X_FLL_OUTDIV_WIDTH                      6  /* FLL_OUTDIV - [13:8] */
+#define WM831X_FLL_CTRL_RATE_MASK               0x0070  /* FLL_CTRL_RATE - [6:4] */
+#define WM831X_FLL_CTRL_RATE_SHIFT                   4  /* FLL_CTRL_RATE - [6:4] */
+#define WM831X_FLL_CTRL_RATE_WIDTH                   3  /* FLL_CTRL_RATE - [6:4] */
+#define WM831X_FLL_FRATIO_MASK                  0x0007  /* FLL_FRATIO - [2:0] */
+#define WM831X_FLL_FRATIO_SHIFT                      0  /* FLL_FRATIO - [2:0] */
+#define WM831X_FLL_FRATIO_WIDTH                      3  /* FLL_FRATIO - [2:0] */
+
+/*
+ * R16532 (0x4094) - FLL Control 3
+ */
+#define WM831X_FLL_K_MASK                       0xFFFF  /* FLL_K - [15:0] */
+#define WM831X_FLL_K_SHIFT                           0  /* FLL_K - [15:0] */
+#define WM831X_FLL_K_WIDTH                          16  /* FLL_K - [15:0] */
+
+/*
+ * R16533 (0x4095) - FLL Control 4
+ */
+#define WM831X_FLL_N_MASK                       0x7FE0  /* FLL_N - [14:5] */
+#define WM831X_FLL_N_SHIFT                           5  /* FLL_N - [14:5] */
+#define WM831X_FLL_N_WIDTH                          10  /* FLL_N - [14:5] */
+#define WM831X_FLL_GAIN_MASK                    0x000F  /* FLL_GAIN - [3:0] */
+#define WM831X_FLL_GAIN_SHIFT                        0  /* FLL_GAIN - [3:0] */
+#define WM831X_FLL_GAIN_WIDTH                        4  /* FLL_GAIN - [3:0] */
+
+/*
+ * R16534 (0x4096) - FLL Control 5
+ */
+#define WM831X_FLL_CLK_REF_DIV_MASK             0x0018  /* FLL_CLK_REF_DIV - [4:3] */
+#define WM831X_FLL_CLK_REF_DIV_SHIFT                 3  /* FLL_CLK_REF_DIV - [4:3] */
+#define WM831X_FLL_CLK_REF_DIV_WIDTH                 2  /* FLL_CLK_REF_DIV - [4:3] */
+#define WM831X_FLL_CLK_SRC_MASK                 0x0003  /* FLL_CLK_SRC - [1:0] */
+#define WM831X_FLL_CLK_SRC_SHIFT                     0  /* FLL_CLK_SRC - [1:0] */
+#define WM831X_FLL_CLK_SRC_WIDTH                     2  /* FLL_CLK_SRC - [1:0] */
+
 struct regulator_dev;
 
 #define WM831X_NUM_IRQ_REGS 5
+#define WM831X_NUM_GPIO_REGS 16
 
 enum wm831x_parent {
         WM8310 = 0x8310,
@@ -248,6 +351,12 @@ enum wm831x_parent {
         WM8326 = 0x8326,
 };
 
+struct wm831x;
+enum wm831x_auxadc;
+
+typedef int (*wm831x_auxadc_read_fn)(struct wm831x *wm831x,
+                                     enum wm831x_auxadc input);
+
 struct wm831x {
         struct mutex io_lock;
 
@@ -261,7 +370,7 @@ struct wm831x {
 
         int irq;  /* Our chip IRQ */
         struct mutex irq_lock;
-        unsigned int irq_base;
+        int irq_base;
         int irq_masks_cur[WM831X_NUM_IRQ_REGS];   /* Currently active value */
         int irq_masks_cache[WM831X_NUM_IRQ_REGS]; /* Cached hardware value */
 
@@ -272,8 +381,13 @@ struct wm831x {
 
         int num_gpio;
 
+        /* Used by the interrupt controller code to post writes */
+        int gpio_update[WM831X_NUM_GPIO_REGS];
+
         struct mutex auxadc_lock;
-        struct completion auxadc_done;
+        struct list_head auxadc_pending;
+        u16 auxadc_active;
+        wm831x_auxadc_read_fn auxadc_read;
 
         /* The WM831x has a security key blocking access to certain
          * registers.  The mutex is taken by the accessors for locking
@@ -300,5 +414,6 @@ void wm831x_device_exit(struct wm831x *wm831x);
 int wm831x_device_suspend(struct wm831x *wm831x);
 int wm831x_irq_init(struct wm831x *wm831x, int irq);
 void wm831x_irq_exit(struct wm831x *wm831x);
+void wm831x_auxadc_init(struct wm831x *wm831x);
 
 #endif
diff --git a/include/linux/mfd/wm831x/pdata.h b/include/linux/mfd/wm831x/pdata.h
index ff42d700293f..0ba24599fe51 100644
--- a/include/linux/mfd/wm831x/pdata.h
+++ b/include/linux/mfd/wm831x/pdata.h
@@ -120,6 +120,9 @@ struct wm831x_pdata {
         /** Put the /IRQ line into CMOS mode */
         bool irq_cmos;
 
+        /** Disable the touchscreen */
+        bool disable_touch;
+
         int irq_base;
         int gpio_base;
         int gpio_defaults[WM831X_GPIO_NUM];
diff --git a/include/linux/mii.h b/include/linux/mii.h
index 359fba880274..103113a2fd18 100644
--- a/include/linux/mii.h
+++ b/include/linux/mii.h
@@ -128,6 +128,8 @@
 /* 1000BASE-T Control register */
 #define ADVERTISE_1000FULL      0x0200  /* Advertise 1000BASE-T full duplex */
 #define ADVERTISE_1000HALF      0x0100  /* Advertise 1000BASE-T half duplex */
+#define CTL1000_AS_MASTER       0x0800
+#define CTL1000_ENABLE_MASTER   0x1000
 
 /* 1000BASE-T Status register */
 #define LPA_1000LOCALRXOK       0x2000  /* Link partner local receiver status */
diff --git a/include/linux/mlx4/cmd.h b/include/linux/mlx4/cmd.h
index 9a18667c13cc..b56e4587208d 100644
--- a/include/linux/mlx4/cmd.h
+++ b/include/linux/mlx4/cmd.h
@@ -123,6 +123,9 @@ enum {
         /* debug commands */
         MLX4_CMD_QUERY_DEBUG_MSG = 0x2a,
         MLX4_CMD_SET_DEBUG_MSG   = 0x2b,
+
+        /* statistics commands */
+        MLX4_CMD_QUERY_IF_STAT   = 0X54,
 };
 
 enum {
diff --git a/include/linux/mlx4/device.h b/include/linux/mlx4/device.h
index 8985768e2c0d..53ef894bfa05 100644
--- a/include/linux/mlx4/device.h
+++ b/include/linux/mlx4/device.h
@@ -37,7 +37,7 @@
 #include <linux/completion.h>
 #include <linux/radix-tree.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 #define MAX_MSIX_P_PORT         17
 #define MAX_MSIX                64
@@ -58,22 +58,28 @@ enum {
 };
 
 enum {
-        MLX4_DEV_CAP_FLAG_RC            = 1 <<  0,
-        MLX4_DEV_CAP_FLAG_UC            = 1 <<  1,
-        MLX4_DEV_CAP_FLAG_UD            = 1 <<  2,
-        MLX4_DEV_CAP_FLAG_SRQ           = 1 <<  6,
-        MLX4_DEV_CAP_FLAG_IPOIB_CSUM    = 1 <<  7,
-        MLX4_DEV_CAP_FLAG_BAD_PKEY_CNTR = 1 <<  8,
-        MLX4_DEV_CAP_FLAG_BAD_QKEY_CNTR = 1 <<  9,
-        MLX4_DEV_CAP_FLAG_DPDP          = 1 << 12,
-        MLX4_DEV_CAP_FLAG_BLH           = 1 << 15,
-        MLX4_DEV_CAP_FLAG_MEM_WINDOW    = 1 << 16,
-        MLX4_DEV_CAP_FLAG_APM           = 1 << 17,
-        MLX4_DEV_CAP_FLAG_ATOMIC        = 1 << 18,
-        MLX4_DEV_CAP_FLAG_RAW_MCAST     = 1 << 19,
-        MLX4_DEV_CAP_FLAG_UD_AV_PORT    = 1 << 20,
-        MLX4_DEV_CAP_FLAG_UD_MCAST      = 1 << 21,
-        MLX4_DEV_CAP_FLAG_IBOE          = 1 << 30
+        MLX4_DEV_CAP_FLAG_RC            = 1LL <<  0,
+        MLX4_DEV_CAP_FLAG_UC            = 1LL <<  1,
+        MLX4_DEV_CAP_FLAG_UD            = 1LL <<  2,
+        MLX4_DEV_CAP_FLAG_SRQ           = 1LL <<  6,
+        MLX4_DEV_CAP_FLAG_IPOIB_CSUM    = 1LL <<  7,
+        MLX4_DEV_CAP_FLAG_BAD_PKEY_CNTR = 1LL <<  8,
+        MLX4_DEV_CAP_FLAG_BAD_QKEY_CNTR = 1LL <<  9,
+        MLX4_DEV_CAP_FLAG_DPDP          = 1LL << 12,
+        MLX4_DEV_CAP_FLAG_BLH           = 1LL << 15,
+        MLX4_DEV_CAP_FLAG_MEM_WINDOW    = 1LL << 16,
+        MLX4_DEV_CAP_FLAG_APM           = 1LL << 17,
+        MLX4_DEV_CAP_FLAG_ATOMIC        = 1LL << 18,
+        MLX4_DEV_CAP_FLAG_RAW_MCAST     = 1LL << 19,
+        MLX4_DEV_CAP_FLAG_UD_AV_PORT    = 1LL << 20,
+        MLX4_DEV_CAP_FLAG_UD_MCAST      = 1LL << 21,
+        MLX4_DEV_CAP_FLAG_IBOE          = 1LL << 30,
+        MLX4_DEV_CAP_FLAG_UC_LOOPBACK   = 1LL << 32,
+        MLX4_DEV_CAP_FLAG_WOL           = 1LL << 38,
+        MLX4_DEV_CAP_FLAG_UDP_RSS       = 1LL << 40,
+        MLX4_DEV_CAP_FLAG_VEP_UC_STEER  = 1LL << 41,
+        MLX4_DEV_CAP_FLAG_VEP_MC_STEER  = 1LL << 42,
+        MLX4_DEV_CAP_FLAG_COUNTERS      = 1LL << 48
 };
 
 enum {
@@ -253,15 +259,10 @@ struct mlx4_caps {
         int                     mtt_entry_sz;
         u32                     max_msg_sz;
         u32                     page_size_cap;
-        u32                     flags;
+        u64                     flags;
         u32                     bmme_flags;
         u32                     reserved_lkey;
         u16                     stat_rate_support;
-        int                     udp_rss;
-        int                     loopback_support;
-        int                     vep_uc_steering;
-        int                     vep_mc_steering;
-        int                     wol;
         u8                      port_width_cap[MLX4_MAX_PORTS + 1];
         int                     max_gso_sz;
         int                     reserved_qps_cnt[MLX4_NUM_QP_REGION];
@@ -274,6 +275,7 @@ struct mlx4_caps {
         u8                      supported_type[MLX4_MAX_PORTS + 1];
         u32                     port_mask;
         enum mlx4_port_type     possible_type[MLX4_MAX_PORTS + 1];
+        u32                     max_counters;
 };
 
 struct mlx4_buf_list {
@@ -438,6 +440,17 @@ union mlx4_ext_av {
         struct mlx4_eth_av      eth;
 };
 
+struct mlx4_counter {
+        u8      reserved1[3];
+        u8      counter_mode;
+        __be32  num_ifc;
+        u32     reserved2[2];
+        __be64  rx_frames;
+        __be64  rx_bytes;
+        __be64  tx_frames;
+        __be64  tx_bytes;
+};
+
 struct mlx4_dev {
         struct pci_dev         *pdev;
         unsigned long           flags;
@@ -568,4 +581,7 @@ void mlx4_release_eq(struct mlx4_dev *dev, int vec);
 int mlx4_wol_read(struct mlx4_dev *dev, u64 *config, int port);
 int mlx4_wol_write(struct mlx4_dev *dev, u64 config, int port);
 
+int mlx4_counter_alloc(struct mlx4_dev *dev, u32 *idx);
+void mlx4_counter_free(struct mlx4_dev *dev, u32 idx);
+
 #endif /* MLX4_DEVICE_H */
diff --git a/include/linux/mlx4/qp.h b/include/linux/mlx4/qp.h
index 9e9eb21056ca..4001c8249dbb 100644
--- a/include/linux/mlx4/qp.h
+++ b/include/linux/mlx4/qp.h
@@ -54,7 +54,8 @@ enum mlx4_qp_optpar {
         MLX4_QP_OPTPAR_RETRY_COUNT              = 1 << 12,
         MLX4_QP_OPTPAR_RNR_RETRY                = 1 << 13,
         MLX4_QP_OPTPAR_ACK_TIMEOUT              = 1 << 14,
-        MLX4_QP_OPTPAR_SCHED_QUEUE              = 1 << 16
+        MLX4_QP_OPTPAR_SCHED_QUEUE              = 1 << 16,
+        MLX4_QP_OPTPAR_COUNTER_INDEX            = 1 << 20
 };
 
 enum mlx4_qp_state {
@@ -99,7 +100,7 @@ struct mlx4_qp_path {
         u8                      fl;
         u8                      reserved1[2];
         u8                      pkey_index;
-        u8                      reserved2;
+        u8                      counter_index;
         u8                      grh_mylmc;
         __be16                  rlid;
         u8                      ackto;
@@ -111,8 +112,7 @@ struct mlx4_qp_path {
         u8                      sched_queue;
         u8                      vlan_index;
         u8                      reserved3[2];
-        u8                      counter_index;
-        u8                      reserved4;
+        u8                      reserved4[2];
         u8                      dmac[6];
 };
 
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 9670f71d7be9..f2690cf49827 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -15,6 +15,7 @@
 #include <linux/range.h>
 #include <linux/pfn.h>
 #include <linux/bit_spinlock.h>
+#include <linux/shrinker.h>
 
 struct mempolicy;
 struct anon_vma;
@@ -636,7 +637,7 @@ static inline pte_t maybe_mkwrite(pte_t pte, struct vm_area_struct *vma)
 #define SECTIONS_MASK           ((1UL << SECTIONS_WIDTH) - 1)
 #define ZONEID_MASK             ((1UL << ZONEID_SHIFT) - 1)
 
-static inline enum zone_type page_zonenum(struct page *page)
+static inline enum zone_type page_zonenum(const struct page *page)
 {
         return (page->flags >> ZONES_PGSHIFT) & ZONES_MASK;
 }
@@ -664,15 +665,15 @@ static inline int zone_to_nid(struct zone *zone)
 }
 
 #ifdef NODE_NOT_IN_PAGE_FLAGS
-extern int page_to_nid(struct page *page);
+extern int page_to_nid(const struct page *page);
 #else
-static inline int page_to_nid(struct page *page)
+static inline int page_to_nid(const struct page *page)
 {
         return (page->flags >> NODES_PGSHIFT) & NODES_MASK;
 }
 #endif
 
-static inline struct zone *page_zone(struct page *page)
+static inline struct zone *page_zone(const struct page *page)
 {
         return &NODE_DATA(page_to_nid(page))->node_zones[page_zonenum(page)];
 }
@@ -717,9 +718,9 @@ static inline void set_page_links(struct page *page, enum zone_type zone,
  */
 #include <linux/vmstat.h>
 
-static __always_inline void *lowmem_page_address(struct page *page)
+static __always_inline void *lowmem_page_address(const struct page *page)
 {
-        return __va(PFN_PHYS(page_to_pfn(page)));
+        return __va(PFN_PHYS(page_to_pfn((struct page *)page)));
 }
 
 #if defined(CONFIG_HIGHMEM) && !defined(WANT_PAGE_VIRTUAL)
@@ -910,6 +911,8 @@ unsigned long unmap_vmas(struct mmu_gather *tlb,
  * @pte_entry: if set, called for each non-empty PTE (4th-level) entry
  * @pte_hole: if set, called for each hole at all levels
  * @hugetlb_entry: if set, called for each hugetlb entry
+ *                 *Caution*: The caller must hold mmap_sem() if @hugetlb_entry
+ *                            is used.
  *
  * (see walk_page_range for more details)
  */
@@ -985,6 +988,8 @@ int get_user_pages(struct task_struct *tsk, struct mm_struct *mm,
 int get_user_pages_fast(unsigned long start, int nr_pages, int write,
                         struct page **pages);
 struct page *get_dump_page(unsigned long addr);
+extern int fixup_user_fault(struct task_struct *tsk, struct mm_struct *mm,
+                            unsigned long address, unsigned int fault_flags);
 
 extern int try_to_release_page(struct page * page, gfp_t gfp_mask);
 extern void do_invalidatepage(struct page *page, unsigned long offset);
@@ -1121,44 +1126,6 @@ static inline void sync_mm_rss(struct task_struct *task, struct mm_struct *mm)
 }
 #endif
 
-/*
- * This struct is used to pass information from page reclaim to the shrinkers.
- * We consolidate the values for easier extention later.
- */
-struct shrink_control {
-        gfp_t gfp_mask;
-
-        /* How many slab objects shrinker() should scan and try to reclaim */
-        unsigned long nr_to_scan;
-};
-
-/*
- * A callback you can register to apply pressure to ageable caches.
- *
- * 'sc' is passed shrink_control which includes a count 'nr_to_scan'
- * and a 'gfpmask'.  It should look through the least-recently-used
- * 'nr_to_scan' entries and attempt to free them up.  It should return
- * the number of objects which remain in the cache.  If it returns -1, it means
- * it cannot do any scanning at this time (eg. there is a risk of deadlock).
- *
- * The 'gfpmask' refers to the allocation we are currently trying to
- * fulfil.
- *
- * Note that 'shrink' will be passed nr_to_scan == 0 when the VM is
- * querying the cache size, so a fastpath for that case is appropriate.
- */
-struct shrinker {
-        int (*shrink)(struct shrinker *, struct shrink_control *sc);
-        int seeks;      /* seeks to recreate an obj */
-
-        /* These are for internal use */
-        struct list_head list;
-        long nr;        /* objs pending delete */
-};
-#define DEFAULT_SEEKS 2 /* A good number if you don't know better. */
-extern void register_shrinker(struct shrinker *);
-extern void unregister_shrinker(struct shrinker *);
-
 int vma_wants_writenotify(struct vm_area_struct *vma);
 
 extern pte_t *__get_locked_pte(struct mm_struct *mm, unsigned long addr,
@@ -1313,6 +1280,7 @@ extern void remove_active_range(unsigned int nid, unsigned long start_pfn,
                                         unsigned long end_pfn);
 extern void remove_all_active_ranges(void);
 void sort_node_map(void);
+unsigned long node_map_pfn_alignment(void);
 unsigned long __absent_pages_in_range(int nid, unsigned long start_pfn,
                                                 unsigned long end_pfn);
 extern unsigned long absent_pages_in_range(unsigned long start_pfn,
@@ -1445,8 +1413,7 @@ extern int do_munmap(struct mm_struct *, unsigned long, size_t);
 
 extern unsigned long do_brk(unsigned long, unsigned long);
 
-/* filemap.c */
-extern unsigned long page_unuse(struct page *);
+/* truncate.c */
 extern void truncate_inode_pages(struct address_space *, loff_t);
 extern void truncate_inode_pages_range(struct address_space *,
                                        loff_t lstart, loff_t lend);
@@ -1633,6 +1600,7 @@ enum mf_flags {
 };
 extern void memory_failure(unsigned long pfn, int trapno);
 extern int __memory_failure(unsigned long pfn, int trapno, int flags);
+extern void memory_failure_queue(unsigned long pfn, int trapno, int flags);
 extern int unpoison_memory(unsigned long pfn);
 extern int sysctl_memory_failure_early_kill;
 extern int sysctl_memory_failure_recovery;
diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
index 027935c86c68..774b8952deb4 100644
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -30,23 +30,61 @@ struct address_space;
  * moment. Note that we have no way to track which tasks are using
  * a page, though if it is a pagecache page, rmap structures can tell us
  * who is mapping it.
+ *
+ * The objects in struct page are organized in double word blocks in
+ * order to allows us to use atomic double word operations on portions
+ * of struct page. That is currently only used by slub but the arrangement
+ * allows the use of atomic double word operations on the flags/mapping
+ * and lru list pointers also.
  */
 struct page {
+        /* First double word block */
         unsigned long flags;            /* Atomic flags, some possibly
                                          * updated asynchronously */
-        atomic_t _count;                /* Usage count, see below. */
-        union {
-                atomic_t _mapcount;     /* Count of ptes mapped in mms,
-                                         * to show when page is mapped
-                                         * & limit reverse map searches.
+        struct address_space *mapping;  /* If low bit clear, points to
+                                         * inode address_space, or NULL.
+                                         * If page mapped as anonymous
+                                         * memory, low bit is set, and
+                                         * it points to anon_vma object:
+                                         * see PAGE_MAPPING_ANON below.
                                          */
-                struct {                /* SLUB */
-                        u16 inuse;
-                        u16 objects;
+        /* Second double word */
+        struct {
+                union {
+                        pgoff_t index;          /* Our offset within mapping. */
+                        void *freelist;         /* slub first free object */
+                };
+
+                union {
+                        /* Used for cmpxchg_double in slub */
+                        unsigned long counters;
+
+                        struct {
+
+                                union {
+                                        atomic_t _mapcount;     /* Count of ptes mapped in mms,
+                                                         * to show when page is mapped
+                                                         * & limit reverse map searches.
+                                                         */
+
+                                        struct {
+                                                unsigned inuse:16;
+                                                unsigned objects:15;
+                                                unsigned frozen:1;
+                                        };
+                                };
+                                atomic_t _count;                /* Usage count, see below. */
+                        };
                 };
         };
+
+        /* Third double word block */
+        struct list_head lru;           /* Pageout list, eg. active_list
+                                         * protected by zone->lru_lock !
+                                         */
+
+        /* Remainder is not double word aligned */
         union {
-            struct {
                 unsigned long private;          /* Mapping-private opaque data:
                                                  * usually used for buffer_heads
                                                  * if PagePrivate set; used for
@@ -54,27 +92,13 @@ struct page {
                                                  * indicates order in the buddy
                                                  * system if PG_buddy is set.
                                                  */
-                struct address_space *mapping;  /* If low bit clear, points to
-                                                 * inode address_space, or NULL.
-                                                 * If page mapped as anonymous
-                                                 * memory, low bit is set, and
-                                                 * it points to anon_vma object:
-                                                 * see PAGE_MAPPING_ANON below.
-                                                 */
-            };
 #if USE_SPLIT_PTLOCKS
-            spinlock_t ptl;
+                spinlock_t ptl;
 #endif
-            struct kmem_cache *slab;    /* SLUB: Pointer to slab */
-            struct page *first_page;    /* Compound tail pages */
-        };
-        union {
-                pgoff_t index;          /* Our offset within mapping. */
-                void *freelist;         /* SLUB: freelist req. slab lock */
+                struct kmem_cache *slab;        /* SLUB: Pointer to slab */
+                struct page *first_page;        /* Compound tail pages */
         };
-        struct list_head lru;           /* Pageout list, eg. active_list
-                                         * protected by zone->lru_lock !
-                                         */
+
         /*
          * On machines where all RAM is mapped into kernel address space,
          * we can simply calculate the virtual address. On machines with
@@ -100,7 +124,16 @@ struct page {
          */
         void *shadow;
 #endif
-};
+}
+/*
+ * If another subsystem starts using the double word pairing for atomic
+ * operations on struct page then it must change the #if to ensure
+ * proper alignment of the page struct.
+ */
+#if defined(CONFIG_SLUB) && defined(CONFIG_CMPXCHG_LOCAL)
+        __attribute__((__aligned__(2*sizeof(unsigned long))))
+#endif
+;
 
 typedef unsigned long __nocast vm_flags_t;
 
diff --git a/include/linux/mman.h b/include/linux/mman.h
index 9872d6ca58ae..8b74e9b1d0ad 100644
--- a/include/linux/mman.h
+++ b/include/linux/mman.h
@@ -14,7 +14,7 @@
 #include <linux/mm.h>
 #include <linux/percpu_counter.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 extern int sysctl_overcommit_memory;
 extern int sysctl_overcommit_ratio;
diff --git a/include/linux/mmc/boot.h b/include/linux/mmc/boot.h
index 39d787c229cb..23acc3baa07d 100644
--- a/include/linux/mmc/boot.h
+++ b/include/linux/mmc/boot.h
@@ -1,7 +1,7 @@
-#ifndef MMC_BOOT_H
-#define MMC_BOOT_H
+#ifndef LINUX_MMC_BOOT_H
+#define LINUX_MMC_BOOT_H
 
 enum { MMC_PROGRESS_ENTER, MMC_PROGRESS_INIT,
        MMC_PROGRESS_LOAD, MMC_PROGRESS_DONE };
 
-#endif
+#endif /* LINUX_MMC_BOOT_H */
diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
index c6927a4d157f..b460fc2af8a1 100644
--- a/include/linux/mmc/card.h
+++ b/include/linux/mmc/card.h
@@ -64,6 +64,19 @@ struct mmc_ext_csd {
         unsigned long long      enhanced_area_offset;   /* Units: Byte */
         unsigned int            enhanced_area_size;     /* Units: KB */
         unsigned int            boot_size;              /* in bytes */
+        u8                      raw_partition_support;  /* 160 */
+        u8                      raw_erased_mem_count;   /* 181 */
+        u8                      raw_ext_csd_structure;  /* 194 */
+        u8                      raw_card_type;          /* 196 */
+        u8                      raw_s_a_timeout;                /* 217 */
+        u8                      raw_hc_erase_gap_size;  /* 221 */
+        u8                      raw_erase_timeout_mult; /* 223 */
+        u8                      raw_hc_erase_grp_size;  /* 224 */
+        u8                      raw_sec_trim_mult;      /* 229 */
+        u8                      raw_sec_erase_mult;     /* 230 */
+        u8                      raw_sec_feature_support;/* 231 */
+        u8                      raw_trim_mult;          /* 232 */
+        u8                      raw_sectors[4];         /* 212 - 4 bytes */
 };
 
 struct sd_scr {
@@ -390,4 +403,4 @@ extern void mmc_unregister_driver(struct mmc_driver *);
 extern void mmc_fixup_device(struct mmc_card *card,
                              const struct mmc_fixup *table);
 
-#endif
+#endif /* LINUX_MMC_CARD_H */
diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
index b6718e549a51..b8b1b7a311f1 100644
--- a/include/linux/mmc/core.h
+++ b/include/linux/mmc/core.h
@@ -117,6 +117,7 @@ struct mmc_data {
 
         unsigned int            sg_len;         /* size of scatter list */
         struct scatterlist      *sg;            /* I/O scatter list */
+        s32                     host_cookie;    /* host private data */
 };
 
 struct mmc_request {
@@ -125,13 +126,16 @@ struct mmc_request {
         struct mmc_data         *data;
         struct mmc_command      *stop;
 
-        void                    *done_data;     /* completion data */
+        struct completion       completion;
         void                    (*done)(struct mmc_request *);/* completion function */
 };
 
 struct mmc_host;
 struct mmc_card;
+struct mmc_async_req;
 
+extern struct mmc_async_req *mmc_start_req(struct mmc_host *,
+                                           struct mmc_async_req *, int *);
 extern void mmc_wait_for_req(struct mmc_host *, struct mmc_request *);
 extern int mmc_wait_for_cmd(struct mmc_host *, struct mmc_command *, int);
 extern int mmc_app_cmd(struct mmc_host *, struct mmc_card *);
@@ -155,6 +159,7 @@ extern int mmc_can_trim(struct mmc_card *card);
 extern int mmc_can_secure_erase_trim(struct mmc_card *card);
 extern int mmc_erase_group_aligned(struct mmc_card *card, unsigned int from,
                                    unsigned int nr);
+extern unsigned int mmc_calc_max_discard(struct mmc_card *card);
 
 extern int mmc_set_blocklen(struct mmc_card *card, unsigned int blocklen);
 
@@ -179,4 +184,4 @@ static inline void mmc_claim_host(struct mmc_host *host)
 
 extern u32 mmc_vddrange_to_ocrmask(int vdd_min, int vdd_max);
 
-#endif
+#endif /* LINUX_MMC_CORE_H */
diff --git a/include/linux/mmc/dw_mmc.h b/include/linux/mmc/dw_mmc.h
index bdd7ceeb99e4..6b46819705d1 100644
--- a/include/linux/mmc/dw_mmc.h
+++ b/include/linux/mmc/dw_mmc.h
@@ -11,8 +11,8 @@
  * (at your option) any later version.
  */
 
-#ifndef _LINUX_MMC_DW_MMC_H_
-#define _LINUX_MMC_DW_MMC_H_
+#ifndef LINUX_MMC_DW_MMC_H
+#define LINUX_MMC_DW_MMC_H
 
 #define MAX_MCI_SLOTS   2
 
@@ -48,6 +48,7 @@ struct mmc_data;
  * @data: The data currently being transferred, or NULL if no data
  *      transfer is in progress.
  * @use_dma: Whether DMA channel is initialized or not.
+ * @using_dma: Whether DMA is in use for the current transfer.
  * @sg_dma: Bus address of DMA buffer.
  * @sg_cpu: Virtual address of DMA buffer.
  * @dma_ops: Pointer to platform-specific DMA callbacks.
@@ -74,7 +75,11 @@ struct mmc_data;
  * @pdev: Platform device associated with the MMC controller.
  * @pdata: Platform data associated with the MMC controller.
  * @slot: Slots sharing this MMC controller.
+ * @fifo_depth: depth of FIFO.
  * @data_shift: log2 of FIFO item size.
+ * @part_buf_start: Start index in part_buf.
+ * @part_buf_count: Bytes of partial data in part_buf.
+ * @part_buf: Simple buffer for partial fifo reads/writes.
  * @push_data: Pointer to FIFO push function.
  * @pull_data: Pointer to FIFO pull function.
  * @quirks: Set of quirks that apply to specific versions of the IP.
@@ -117,6 +122,7 @@ struct dw_mci {
 
         /* DMA interface members*/
         int                     use_dma;
+        int                     using_dma;
 
         dma_addr_t              sg_dma;
         void                    *sg_cpu;
@@ -131,7 +137,7 @@ struct dw_mci {
         u32                     stop_cmdr;
         u32                     dir_status;
         struct tasklet_struct   tasklet;
-        struct tasklet_struct   card_tasklet;
+        struct work_struct      card_work;
         unsigned long           pending_events;
         unsigned long           completed_events;
         enum dw_mci_state       state;
@@ -146,7 +152,15 @@ struct dw_mci {
         struct dw_mci_slot      *slot[MAX_MCI_SLOTS];
 
         /* FIFO push and pull */
+        int                     fifo_depth;
         int                     data_shift;
+        u8                      part_buf_start;
+        u8                      part_buf_count;
+        union {
+                u16             part_buf16;
+                u32             part_buf32;
+                u64             part_buf;
+        };
         void (*push_data)(struct dw_mci *host, void *buf, int cnt);
         void (*pull_data)(struct dw_mci *host, void *buf, int cnt);
 
@@ -196,6 +210,12 @@ struct dw_mci_board {
         unsigned int bus_hz; /* Bus speed */
 
         unsigned int caps;      /* Capabilities */
+        /*
+         * Override fifo depth. If 0, autodetect it from the FIFOTH register,
+         * but note that this may not be reliable after a bootloader has used
+         * it.
+         */
+        unsigned int fifo_depth;
 
         /* delay in mS before detecting cards after interrupt */
         u32 detect_delay_ms;
@@ -219,4 +239,4 @@ struct dw_mci_board {
         struct block_settings *blk_settings;
 };
 
-#endif /* _LINUX_MMC_DW_MMC_H_ */
+#endif /* LINUX_MMC_DW_MMC_H */
diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h
index 1ee4424462eb..0f83858147a6 100644
--- a/include/linux/mmc/host.h
+++ b/include/linux/mmc/host.h
@@ -106,6 +106,15 @@ struct mmc_host_ops {
          */
         int (*enable)(struct mmc_host *host);
         int (*disable)(struct mmc_host *host, int lazy);
+        /*
+         * It is optional for the host to implement pre_req and post_req in
+         * order to support double buffering of requests (prepare one
+         * request while another request is active).
+         */
+        void    (*post_req)(struct mmc_host *host, struct mmc_request *req,
+                            int err);
+        void    (*pre_req)(struct mmc_host *host, struct mmc_request *req,
+                           bool is_first_req);
         void    (*request)(struct mmc_host *host, struct mmc_request *req);
         /*
          * Avoid calling these three functions too often or in a "fast path",
@@ -139,11 +148,22 @@ struct mmc_host_ops {
         int     (*start_signal_voltage_switch)(struct mmc_host *host, struct mmc_ios *ios);
         int     (*execute_tuning)(struct mmc_host *host);
         void    (*enable_preset_value)(struct mmc_host *host, bool enable);
+        int     (*select_drive_strength)(unsigned int max_dtr, int host_drv, int card_drv);
 };
 
 struct mmc_card;
 struct device;
 
+struct mmc_async_req {
+        /* active mmc request */
+        struct mmc_request      *mrq;
+        /*
+         * Check error status of completed mmc request.
+         * Returns 0 if success otherwise non zero.
+         */
+        int (*err_check) (struct mmc_card *, struct mmc_async_req *);
+};
+
 struct mmc_host {
         struct device           *parent;
         struct device           class_dev;
@@ -231,6 +251,7 @@ struct mmc_host {
         unsigned int            max_req_size;   /* maximum number of bytes in one req */
         unsigned int            max_blk_size;   /* maximum size of one mmc block */
         unsigned int            max_blk_count;  /* maximum number of blocks in one req */
+        unsigned int            max_discard_to; /* max. discard timeout in ms */
 
         /* private data */
         spinlock_t              lock;           /* lock for claim and bus ops */
@@ -281,6 +302,8 @@ struct mmc_host {
 
         struct dentry           *debugfs_root;
 
+        struct mmc_async_req    *areq;          /* active async req */
+
         unsigned long           private[0] ____cacheline_aligned;
 };
 
@@ -373,5 +396,4 @@ static inline int mmc_host_cmd23(struct mmc_host *host)
 {
         return host->caps & MMC_CAP_CMD23;
 }
-#endif
-
+#endif /* LINUX_MMC_HOST_H */
diff --git a/include/linux/mmc/ioctl.h b/include/linux/mmc/ioctl.h
index 5baf2983a12f..8fa5bc5f8059 100644
--- a/include/linux/mmc/ioctl.h
+++ b/include/linux/mmc/ioctl.h
@@ -51,4 +51,4 @@ struct mmc_ioc_cmd {
  * block device operations.
  */
 #define MMC_IOC_MAX_BYTES  (512L * 256)
-#endif  /* LINUX_MMC_IOCTL_H */
+#endif /* LINUX_MMC_IOCTL_H */
diff --git a/include/linux/mmc/mmc.h b/include/linux/mmc/mmc.h
index ac26a685cca8..5a794cb503ea 100644
--- a/include/linux/mmc/mmc.h
+++ b/include/linux/mmc/mmc.h
@@ -21,8 +21,8 @@
  *          15 May 2002
  */
 
-#ifndef MMC_MMC_H
-#define MMC_MMC_H
+#ifndef LINUX_MMC_MMC_H
+#define LINUX_MMC_MMC_H
 
 /* Standard MMC commands (4.1)           type  argument     response */
    /* class 1 */
@@ -140,6 +140,16 @@ static inline bool mmc_op_multi(u32 opcode)
 #define R1_SWITCH_ERROR         (1 << 7)        /* sx, c */
 #define R1_APP_CMD              (1 << 5)        /* sr, c */
 
+#define R1_STATE_IDLE   0
+#define R1_STATE_READY  1
+#define R1_STATE_IDENT  2
+#define R1_STATE_STBY   3
+#define R1_STATE_TRAN   4
+#define R1_STATE_DATA   5
+#define R1_STATE_RCV    6
+#define R1_STATE_PRG    7
+#define R1_STATE_DIS    8
+
 /*
  * MMC/SD in SPI mode reports R1 status always, and R2 for SEND_STATUS
  * R1 is the low order byte; R2 is the next highest byte, when present.
@@ -327,5 +337,4 @@ struct _mmc_csd {
 #define MMC_SWITCH_MODE_CLEAR_BITS      0x02    /* Clear bits which are 1 in value */
 #define MMC_SWITCH_MODE_WRITE_BYTE      0x03    /* Set target to value */
 
-#endif  /* MMC_MMC_PROTOCOL_H */
-
+#endif /* LINUX_MMC_MMC_H */
diff --git a/include/linux/mmc/pm.h b/include/linux/mmc/pm.h
index d37aac49cf9a..4a139204c20c 100644
--- a/include/linux/mmc/pm.h
+++ b/include/linux/mmc/pm.h
@@ -27,4 +27,4 @@ typedef unsigned int mmc_pm_flag_t;
 #define MMC_PM_KEEP_POWER       (1 << 0)        /* preserve card power during suspend */
 #define MMC_PM_WAKE_SDIO_IRQ    (1 << 1)        /* wake up host system on SDIO IRQ assertion */
 
-#endif
+#endif /* LINUX_MMC_PM_H */
diff --git a/include/linux/mmc/sd.h b/include/linux/mmc/sd.h
index 7d35d52c3df3..1ebcf9ba1256 100644
--- a/include/linux/mmc/sd.h
+++ b/include/linux/mmc/sd.h
@@ -9,8 +9,8 @@
  * your option) any later version.
  */
 
-#ifndef MMC_SD_H
-#define MMC_SD_H
+#ifndef LINUX_MMC_SD_H
+#define LINUX_MMC_SD_H
 
 /* SD commands                           type  argument     response */
   /* class 0 */
@@ -91,5 +91,4 @@
 #define SD_SWITCH_ACCESS_DEF    0
 #define SD_SWITCH_ACCESS_HS     1
 
-#endif
-
+#endif /* LINUX_MMC_SD_H */
diff --git a/include/linux/mmc/sdhci-pltfm.h b/include/linux/mmc/sdhci-pltfm.h
deleted file mode 100644
index 548d59d404cb..000000000000
--- a/include/linux/mmc/sdhci-pltfm.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Platform data declarations for the sdhci-pltfm driver.
- *
- * Copyright (c) 2010 MontaVista Software, LLC.
- *
- * Author: Anton Vorontsov <avorontsov@ru.mvista.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 _SDHCI_PLTFM_H
-#define _SDHCI_PLTFM_H
-
-struct sdhci_ops;
-struct sdhci_host;
-
-/**
- * struct sdhci_pltfm_data - SDHCI platform-specific information & hooks
- * @ops: optional pointer to the platform-provided SDHCI ops
- * @quirks: optional SDHCI quirks
- * @init: optional hook that is called during device probe, before the
- *        driver tries to access any SDHCI registers
- * @exit: optional hook that is called during device removal
- */
-struct sdhci_pltfm_data {
-        struct sdhci_ops *ops;
-        unsigned int quirks;
-        int (*init)(struct sdhci_host *host, struct sdhci_pltfm_data *pdata);
-        void (*exit)(struct sdhci_host *host);
-};
-
-#endif /* _SDHCI_PLTFM_H */
diff --git a/include/linux/mmc/sdhci-spear.h b/include/linux/mmc/sdhci-spear.h
index 9188c973f3e1..5cdc96da9dd5 100644
--- a/include/linux/mmc/sdhci-spear.h
+++ b/include/linux/mmc/sdhci-spear.h
@@ -11,8 +11,8 @@
  * warranty of any kind, whether express or implied.
  */
 
-#ifndef MMC_SDHCI_SPEAR_H
-#define MMC_SDHCI_SPEAR_H
+#ifndef LINUX_MMC_SDHCI_SPEAR_H
+#define LINUX_MMC_SDHCI_SPEAR_H
 
 #include <linux/platform_device.h>
 /*
@@ -39,4 +39,4 @@ sdhci_set_plat_data(struct platform_device *pdev, struct sdhci_plat_data *data)
         pdev->dev.platform_data = data;
 }
 
-#endif /* MMC_SDHCI_SPEAR_H */
+#endif /* LINUX_MMC_SDHCI_SPEAR_H */
diff --git a/include/linux/mmc/sdhci.h b/include/linux/mmc/sdhci.h
index 6a68c4eb4e44..5666f3abfab7 100644
--- a/include/linux/mmc/sdhci.h
+++ b/include/linux/mmc/sdhci.h
@@ -8,8 +8,8 @@
  * the Free Software Foundation; either version 2 of the License, or (at
  * your option) any later version.
  */
-#ifndef __SDHCI_H
-#define __SDHCI_H
+#ifndef LINUX_MMC_SDHCI_H
+#define LINUX_MMC_SDHCI_H
 
 #include <linux/scatterlist.h>
 #include <linux/compiler.h>
@@ -162,4 +162,4 @@ struct sdhci_host {
 
         unsigned long private[0] ____cacheline_aligned;
 };
-#endif /* __SDHCI_H */
+#endif /* LINUX_MMC_SDHCI_H */
diff --git a/include/linux/mmc/sdio.h b/include/linux/mmc/sdio.h
index 245cdacee544..2a2e9905a247 100644
--- a/include/linux/mmc/sdio.h
+++ b/include/linux/mmc/sdio.h
@@ -9,8 +9,8 @@
  * your option) any later version.
  */
 
-#ifndef MMC_SDIO_H
-#define MMC_SDIO_H
+#ifndef LINUX_MMC_SDIO_H
+#define LINUX_MMC_SDIO_H
 
 /* SDIO commands                         type  argument     response */
 #define SD_IO_SEND_OP_COND          5 /* bcr  [23:0] OCR         R4  */
@@ -161,5 +161,4 @@
 
 #define SDIO_FBR_BLKSIZE        0x10    /* block size (2 bytes) */
 
-#endif
-
+#endif /* LINUX_MMC_SDIO_H */
diff --git a/include/linux/mmc/sdio_func.h b/include/linux/mmc/sdio_func.h
index 31baaf82f458..50f0bc952328 100644
--- a/include/linux/mmc/sdio_func.h
+++ b/include/linux/mmc/sdio_func.h
@@ -9,8 +9,8 @@
  * your option) any later version.
  */
 
-#ifndef MMC_SDIO_FUNC_H
-#define MMC_SDIO_FUNC_H
+#ifndef LINUX_MMC_SDIO_FUNC_H
+#define LINUX_MMC_SDIO_FUNC_H
 
 #include <linux/device.h>
 #include <linux/mod_devicetable.h>
@@ -161,5 +161,4 @@ extern void sdio_f0_writeb(struct sdio_func *func, unsigned char b,
 extern mmc_pm_flag_t sdio_get_host_pm_caps(struct sdio_func *func);
 extern int sdio_set_host_pm_flags(struct sdio_func *func, mmc_pm_flag_t flags);
 
-#endif
-
+#endif /* LINUX_MMC_SDIO_FUNC_H */
diff --git a/include/linux/mmc/sdio_ids.h b/include/linux/mmc/sdio_ids.h
index a36ab3bc7b03..9f03feedc8e7 100644
--- a/include/linux/mmc/sdio_ids.h
+++ b/include/linux/mmc/sdio_ids.h
@@ -2,8 +2,8 @@
  * SDIO Classes, Interface Types, Manufacturer IDs, etc.
  */
 
-#ifndef MMC_SDIO_IDS_H
-#define MMC_SDIO_IDS_H
+#ifndef LINUX_MMC_SDIO_IDS_H
+#define LINUX_MMC_SDIO_IDS_H
 
 /*
  * Standard SDIO Function Interfaces
@@ -44,4 +44,4 @@
 #define SDIO_DEVICE_ID_SIANO_NOVA_A0            0x1100
 #define SDIO_DEVICE_ID_SIANO_STELLAR            0x5347
 
-#endif
+#endif /* LINUX_MMC_SDIO_IDS_H */
diff --git a/include/linux/mmc/sh_mmcif.h b/include/linux/mmc/sh_mmcif.h
index 9eb9b4b96f55..0222cd8ebe76 100644
--- a/include/linux/mmc/sh_mmcif.h
+++ b/include/linux/mmc/sh_mmcif.h
@@ -11,8 +11,8 @@
  *
  */
 
-#ifndef __SH_MMCIF_H__
-#define __SH_MMCIF_H__
+#ifndef LINUX_MMC_SH_MMCIF_H
+#define LINUX_MMC_SH_MMCIF_H
 
 #include <linux/io.h>
 #include <linux/platform_device.h>
@@ -220,4 +220,4 @@ static inline void sh_mmcif_boot_init(void __iomem *base)
         sh_mmcif_boot_cmd(base, 0x03400040, 0x00010000);
 }
 
-#endif /* __SH_MMCIF_H__ */
+#endif /* LINUX_MMC_SH_MMCIF_H */
diff --git a/include/linux/mmc/sh_mobile_sdhi.h b/include/linux/mmc/sh_mobile_sdhi.h
index faf32b6ec185..bd50b365167f 100644
--- a/include/linux/mmc/sh_mobile_sdhi.h
+++ b/include/linux/mmc/sh_mobile_sdhi.h
@@ -1,5 +1,5 @@
-#ifndef __SH_MOBILE_SDHI_H__
-#define __SH_MOBILE_SDHI_H__
+#ifndef LINUX_MMC_SH_MOBILE_SDHI_H
+#define LINUX_MMC_SH_MOBILE_SDHI_H
 
 #include <linux/types.h>
 
@@ -17,4 +17,4 @@ struct sh_mobile_sdhi_info {
         int (*get_cd)(struct platform_device *pdev);
 };
 
-#endif /* __SH_MOBILE_SDHI_H__ */
+#endif /* LINUX_MMC_SH_MOBILE_SDHI_H */
diff --git a/include/linux/mmc/tmio.h b/include/linux/mmc/tmio.h
index 19490b942db0..a1c1f321e519 100644
--- a/include/linux/mmc/tmio.h
+++ b/include/linux/mmc/tmio.h
@@ -12,8 +12,8 @@
  *
  * TC6393XB TC6391XB TC6387XB T7L66XB ASIC3
  */
-#ifndef _LINUX_MMC_TMIO_H_
-#define _LINUX_MMC_TMIO_H_
+#ifndef LINUX_MMC_TMIO_H
+#define LINUX_MMC_TMIO_H
 
 #define CTL_SD_CMD 0x00
 #define CTL_ARG_REG 0x04
@@ -21,6 +21,7 @@
 #define CTL_XFER_BLK_COUNT 0xa
 #define CTL_RESPONSE 0x0c
 #define CTL_STATUS 0x1c
+#define CTL_STATUS2 0x1e
 #define CTL_IRQ_MASK 0x20
 #define CTL_SD_CARD_CLK_CTL 0x24
 #define CTL_SD_XFER_LEN 0x26
@@ -30,6 +31,7 @@
 #define CTL_TRANSACTION_CTL 0x34
 #define CTL_SDIO_STATUS 0x36
 #define CTL_SDIO_IRQ_MASK 0x38
+#define CTL_DMA_ENABLE 0xd8
 #define CTL_RESET_SD 0xe0
 #define CTL_SDIO_REGS 0x100
 #define CTL_CLK_AND_WAIT_CTL 0x138
@@ -60,4 +62,4 @@
 
 #define TMIO_BBS                512             /* Boot block size */
 
-#endif /* _LINUX_MMC_TMIO_H_ */
+#endif /* LINUX_MMC_TMIO_H */
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index c928dac6cad0..be1ac8d7789b 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -16,7 +16,7 @@
 #include <linux/nodemask.h>
 #include <linux/pageblock-flags.h>
 #include <generated/bounds.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <asm/page.h>
 
 /* Free memory management - zoned buddy allocator.  */
@@ -158,6 +158,12 @@ static inline int is_unevictable_lru(enum lru_list l)
         return (l == LRU_UNEVICTABLE);
 }
 
+/* Mask used at gathering information at once (see memcontrol.c) */
+#define LRU_ALL_FILE (BIT(LRU_INACTIVE_FILE) | BIT(LRU_ACTIVE_FILE))
+#define LRU_ALL_ANON (BIT(LRU_INACTIVE_ANON) | BIT(LRU_ACTIVE_ANON))
+#define LRU_ALL_EVICTABLE (LRU_ALL_FILE | LRU_ALL_ANON)
+#define LRU_ALL      ((1 << NR_LRU_LISTS) - 1)
+
 enum zone_watermarks {
         WMARK_MIN,
         WMARK_LOW,
@@ -647,6 +653,13 @@ typedef struct pglist_data {
 #endif
 #define nid_page_nr(nid, pagenr)        pgdat_page_nr(NODE_DATA(nid),(pagenr))
 
+#define node_start_pfn(nid)     (NODE_DATA(nid)->node_start_pfn)
+
+#define node_end_pfn(nid) ({\
+        pg_data_t *__pgdat = NODE_DATA(nid);\
+        __pgdat->node_start_pfn + __pgdat->node_spanned_pages;\
+})
+
 #include <linux/memory_hotplug.h>
 
 extern struct mutex zonelists_mutex;
diff --git a/include/linux/mnt_namespace.h b/include/linux/mnt_namespace.h
index 0b89efc6f215..29304855652d 100644
--- a/include/linux/mnt_namespace.h
+++ b/include/linux/mnt_namespace.h
@@ -18,7 +18,6 @@ struct proc_mounts {
         struct seq_file m; /* must be the first element */
         struct mnt_namespace *ns;
         struct path root;
-        int event;
 };
 
 struct fs_struct;
diff --git a/include/linux/module.h b/include/linux/module.h
index d9ca2d5dc6d0..1c30087a2d81 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -48,10 +48,18 @@ struct modversion_info
 
 struct module;
 
+struct module_kobject {
+        struct kobject kobj;
+        struct module *mod;
+        struct kobject *drivers_dir;
+        struct module_param_attrs *mp;
+};
+
 struct module_attribute {
-        struct attribute attr;
-        ssize_t (*show)(struct module_attribute *, struct module *, char *);
-        ssize_t (*store)(struct module_attribute *, struct module *,
+        struct attribute attr;
+        ssize_t (*show)(struct module_attribute *, struct module_kobject *,
+                        char *);
+        ssize_t (*store)(struct module_attribute *, struct module_kobject *,
                          const char *, size_t count);
         void (*setup)(struct module *, const char *);
         int (*test)(struct module *);
@@ -65,15 +73,9 @@ struct module_version_attribute {
 } __attribute__ ((__aligned__(sizeof(void *))));
 
 extern ssize_t __modver_version_show(struct module_attribute *,
-                                     struct module *, char *);
+                                     struct module_kobject *, char *);
 
-struct module_kobject
-{
-        struct kobject kobj;
-        struct module *mod;
-        struct kobject *drivers_dir;
-        struct module_param_attrs *mp;
-};
+extern struct module_attribute module_uevent;
 
 /* These are either module local, or the kernel's dummy ones. */
 extern int init_module(void);
diff --git a/include/linux/moduleloader.h b/include/linux/moduleloader.h
index c1f40c2f7ffb..b2be02ebf453 100644
--- a/include/linux/moduleloader.h
+++ b/include/linux/moduleloader.h
@@ -5,7 +5,12 @@
 #include <linux/module.h>
 #include <linux/elf.h>
 
-/* These must be implemented by the specific architecture */
+/* These may be implemented by architectures that need to hook into the
+ * module loader code.  Architectures that don't need to do anything special
+ * can just rely on the 'weak' default hooks defined in kernel/module.c.
+ * Note, however, that at least one of apply_relocate or apply_relocate_add
+ * must be implemented by each architecture.
+ */
 
 /* Adjust arch-specific sections.  Return 0 on success.  */
 int module_frob_arch_sections(Elf_Ehdr *hdr,
diff --git a/include/linux/mount.h b/include/linux/mount.h
index 604f122a2326..33fe53d78110 100644
--- a/include/linux/mount.h
+++ b/include/linux/mount.h
@@ -14,7 +14,7 @@
 #include <linux/nodemask.h>
 #include <linux/spinlock.h>
 #include <linux/seqlock.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 struct super_block;
 struct vfsmount;
diff --git a/include/linux/mtd/physmap.h b/include/linux/mtd/physmap.h
index d40bfa1d9c91..e5f21d293c70 100644
--- a/include/linux/mtd/physmap.h
+++ b/include/linux/mtd/physmap.h
@@ -19,6 +19,7 @@
 #include <linux/mtd/partitions.h>
 
 struct map_info;
+struct platform_device;
 
 struct physmap_flash_data {
         unsigned int            width;
diff --git a/include/linux/mtd/ubi.h b/include/linux/mtd/ubi.h
index 15da0e99f48a..db4836bed514 100644
--- a/include/linux/mtd/ubi.h
+++ b/include/linux/mtd/ubi.h
@@ -155,12 +155,14 @@ struct ubi_device_info {
 };
 
 /*
- * enum - volume notification types.
- * @UBI_VOLUME_ADDED: volume has been added
- * @UBI_VOLUME_REMOVED: start volume volume
- * @UBI_VOLUME_RESIZED: volume size has been re-sized
- * @UBI_VOLUME_RENAMED: volume name has been re-named
- * @UBI_VOLUME_UPDATED: volume name has been updated
+ * Volume notification types.
+ * @UBI_VOLUME_ADDED: a volume has been added (an UBI device was attached or a
+ *                    volume was created)
+ * @UBI_VOLUME_REMOVED: a volume has been removed (an UBI device was detached
+ *                      or a volume was removed)
+ * @UBI_VOLUME_RESIZED: a volume has been re-sized
+ * @UBI_VOLUME_RENAMED: a volume has been re-named
+ * @UBI_VOLUME_UPDATED: data has been written to a volume
  *
  * These constants define which type of event has happened when a volume
  * notification function is invoked.
diff --git a/include/linux/mutex.h b/include/linux/mutex.h
index a940fe435aca..9121595a8ebf 100644
--- a/include/linux/mutex.h
+++ b/include/linux/mutex.h
@@ -15,7 +15,7 @@
 #include <linux/linkage.h>
 #include <linux/lockdep.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 /*
  * Simple, straightforward mutexes with strict semantics:
@@ -92,7 +92,7 @@ do {							\
                                                         \
         __mutex_init((mutex), #mutex, &__key);          \
 } while (0)
-# define mutex_destroy(mutex)                           do { } while (0)
+static inline void mutex_destroy(struct mutex *lock) {}
 #endif
 
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
diff --git a/include/linux/namei.h b/include/linux/namei.h
index eba45ea10298..76fe2c62ae71 100644
--- a/include/linux/namei.h
+++ b/include/linux/namei.h
@@ -48,7 +48,6 @@ enum {LAST_NORM, LAST_ROOT, LAST_DOT, LAST_DOTDOT, LAST_BIND};
  */
 #define LOOKUP_FOLLOW           0x0001
 #define LOOKUP_DIRECTORY        0x0002
-#define LOOKUP_CONTINUE         0x0004
 
 #define LOOKUP_PARENT           0x0010
 #define LOOKUP_REVAL            0x0020
@@ -75,9 +74,11 @@ extern int user_path_at(int, const char __user *, unsigned, struct path *);
 
 extern int kern_path(const char *, unsigned, struct path *);
 
+extern struct dentry *kern_path_create(int, const char *, struct path *, int);
+extern struct dentry *user_path_create(int, const char __user *, struct path *, int);
 extern int kern_path_parent(const char *, struct nameidata *);
 extern int vfs_path_lookup(struct dentry *, struct vfsmount *,
-                           const char *, unsigned int, struct nameidata *);
+                           const char *, unsigned int, struct path *);
 
 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 ca333e79e10f..ddee79bb8f15 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -34,8 +34,7 @@
 #include <linux/pm_qos_params.h>
 #include <linux/timer.h>
 #include <linux/delay.h>
-#include <linux/mm.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <asm/cache.h>
 #include <asm/byteorder.h>
 
@@ -61,11 +60,6 @@ struct wireless_dev;
 #define SET_ETHTOOL_OPS(netdev,ops) \
         ( (netdev)->ethtool_ops = (ops) )
 
-#define HAVE_ALLOC_NETDEV               /* feature macro: alloc_xxxdev
-                                           functions are available. */
-#define HAVE_FREE_NETDEV                /* free_netdev() */
-#define HAVE_NETDEV_PRIV                /* netdev_priv() */
-
 /* hardware address assignment types */
 #define NET_ADDR_PERM           0       /* address is permanent (default) */
 #define NET_ADDR_RANDOM         1       /* address is generated randomly */
@@ -258,21 +252,8 @@ struct netdev_hw_addr_list {
         netdev_hw_addr_list_for_each(ha, &(dev)->mc)
 
 struct hh_cache {
-        struct hh_cache *hh_next;       /* Next entry                        */
-        atomic_t        hh_refcnt;      /* number of users                   */
-/*
- * We want hh_output, hh_len, hh_lock and hh_data be a in a separate
- * cache line on SMP.
- * They are mostly read, but hh_refcnt may be changed quite frequently,
- * incurring cache line ping pongs.
- */
-        __be16          hh_type ____cacheline_aligned_in_smp;
-                                        /* protocol identifier, f.e ETH_P_IP
-                                         *  NOTE:  For VLANs, this will be the
-                                         *  encapuslated type. --BLG
-                                         */
-        u16             hh_len;         /* length of header */
-        int             (*hh_output)(struct sk_buff *skb);
+        u16             hh_len;
+        u16             __pad;
         seqlock_t       hh_lock;
 
         /* cached hardware header; allow for machine alignment needs.        */
@@ -284,12 +265,6 @@ struct hh_cache {
         unsigned long   hh_data[HH_DATA_ALIGN(LL_MAX_HEADER) / sizeof(long)];
 };
 
-static inline void hh_cache_put(struct hh_cache *hh)
-{
-        if (atomic_dec_and_test(&hh->hh_refcnt))
-                kfree(hh);
-}
-
 /* Reserve HH_DATA_MOD byte aligned hard_header_len, but at least that much.
  * Alternative is:
  *   dev->hard_header_len ? (dev->hard_header_len +
@@ -314,8 +289,7 @@ struct header_ops {
                            const void *saddr, unsigned len);
         int     (*parse)(const struct sk_buff *skb, unsigned char *haddr);
         int     (*rebuild)(struct sk_buff *skb);
-#define HAVE_HEADER_CACHE
-        int     (*cache)(const struct neighbour *neigh, struct hh_cache *hh);
+        int     (*cache)(const struct neighbour *neigh, struct hh_cache *hh, __be16 type);
         void    (*cache_update)(struct hh_cache *hh,
                                 const struct net_device *dev,
                                 const unsigned char *haddr);
@@ -556,7 +530,7 @@ struct netdev_queue {
         struct Qdisc            *qdisc;
         unsigned long           state;
         struct Qdisc            *qdisc_sleeping;
-#ifdef CONFIG_RPS
+#if defined(CONFIG_RPS) || defined(CONFIG_XPS)
         struct kobject          kobj;
 #endif
 #if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
@@ -794,12 +768,6 @@ struct netdev_tc_txq {
  *      3. Update dev->stats asynchronously and atomically, and define
  *         neither operation.
  *
- * void (*ndo_vlan_rx_register)(struct net_device *dev, struct vlan_group *grp);
- *      If device support VLAN receive acceleration
- *      (ie. dev->features & NETIF_F_HW_VLAN_RX), then this function is called
- *      when vlan groups for the device changes.  Note: grp is NULL
- *      if no vlan's groups are being used.
- *
  * void (*ndo_vlan_rx_add_vid)(struct net_device *dev, unsigned short vid);
  *      If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER)
  *      this function is called when a VLAN id is registered.
@@ -888,7 +856,6 @@ struct netdev_tc_txq {
  *      Must return >0 or -errno if it changed dev->features itself.
  *
  */
-#define HAVE_NET_DEVICE_OPS
 struct net_device_ops {
         int                     (*ndo_init)(struct net_device *dev);
         void                    (*ndo_uninit)(struct net_device *dev);
@@ -919,8 +886,6 @@ struct net_device_ops {
                                                      struct rtnl_link_stats64 *storage);
         struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
 
-        void                    (*ndo_vlan_rx_register)(struct net_device *dev,
-                                                        struct vlan_group *grp);
         void                    (*ndo_vlan_rx_add_vid)(struct net_device *dev,
                                                        unsigned short vid);
         void                    (*ndo_vlan_rx_kill_vid)(struct net_device *dev,
@@ -1097,12 +1062,6 @@ struct net_device {
 #define NETIF_F_ALL_FCOE        (NETIF_F_FCOE_CRC | NETIF_F_FCOE_MTU | \
                                  NETIF_F_FSO)
 
-#define NETIF_F_ALL_TX_OFFLOADS (NETIF_F_ALL_CSUM | NETIF_F_SG | \
-                                 NETIF_F_FRAGLIST | NETIF_F_ALL_TSO | \
-                                 NETIF_F_HIGHDMA | \
-                                 NETIF_F_SCTP_CSUM | \
-                                 NETIF_F_ALL_FCOE)
-
         /*
          * If one device supports one of these features, then enable them
          * for all in netdev_increment_features.
@@ -1173,7 +1132,7 @@ struct net_device {
         spinlock_t              addr_list_lock;
         struct netdev_hw_addr_list      uc;     /* Unicast mac addresses */
         struct netdev_hw_addr_list      mc;     /* Multicast mac addresses */
-        int                     uc_promisc;
+        bool                    uc_promisc;
         unsigned int            promiscuity;
         unsigned int            allmulti;
 
@@ -1220,7 +1179,7 @@ struct net_device {
 
         unsigned char           broadcast[MAX_ADDR_LEN];        /* hw bcast add */
 
-#ifdef CONFIG_RPS
+#if defined(CONFIG_RPS) || defined(CONFIG_XPS)
         struct kset             *queues_kset;
 
         struct netdev_rx_queue  *_rx;
@@ -1348,9 +1307,6 @@ struct net_device {
         /* max exchange id for FCoE LRO by ddp */
         unsigned int            fcoe_ddp_xid;
 #endif
-        /* n-tuple filter list attached to this device */
-        struct ethtool_rx_ntuple_list ethtool_ntuple_list;
-
         /* phy device may attach itself for hardware timestamping */
         struct phy_device *phydev;
 
@@ -1563,9 +1519,41 @@ struct packet_type {
         struct list_head        list;
 };
 
-#include <linux/interrupt.h>
 #include <linux/notifier.h>
 
+/* netdevice notifier chain. Please remember to update the rtnetlink
+ * notification exclusion list in rtnetlink_event() when adding new
+ * types.
+ */
+#define NETDEV_UP       0x0001  /* For now you can't veto a device up/down */
+#define NETDEV_DOWN     0x0002
+#define NETDEV_REBOOT   0x0003  /* Tell a protocol stack a network interface
+                                   detected a hardware crash and restarted
+                                   - we can use this eg to kick tcp sessions
+                                   once done */
+#define NETDEV_CHANGE   0x0004  /* Notify device state change */
+#define NETDEV_REGISTER 0x0005
+#define NETDEV_UNREGISTER       0x0006
+#define NETDEV_CHANGEMTU        0x0007
+#define NETDEV_CHANGEADDR       0x0008
+#define NETDEV_GOING_DOWN       0x0009
+#define NETDEV_CHANGENAME       0x000A
+#define NETDEV_FEAT_CHANGE      0x000B
+#define NETDEV_BONDING_FAILOVER 0x000C
+#define NETDEV_PRE_UP           0x000D
+#define NETDEV_PRE_TYPE_CHANGE  0x000E
+#define NETDEV_POST_TYPE_CHANGE 0x000F
+#define NETDEV_POST_INIT        0x0010
+#define NETDEV_UNREGISTER_BATCH 0x0011
+#define NETDEV_RELEASE          0x0012
+#define NETDEV_NOTIFY_PEERS     0x0013
+#define NETDEV_JOIN             0x0014
+
+extern int register_netdevice_notifier(struct notifier_block *nb);
+extern int unregister_netdevice_notifier(struct notifier_block *nb);
+extern int call_netdevice_notifiers(unsigned long val, struct net_device *dev);
+
+
 extern rwlock_t                         dev_base_lock;          /* Device list lock */
 
 
@@ -1648,12 +1636,9 @@ static inline void unregister_netdevice(struct net_device *dev)
 extern int              netdev_refcnt_read(const struct net_device *dev);
 extern void             free_netdev(struct net_device *dev);
 extern void             synchronize_net(void);
-extern int              register_netdevice_notifier(struct notifier_block *nb);
-extern int              unregister_netdevice_notifier(struct notifier_block *nb);
 extern int              init_dummy_netdev(struct net_device *dev);
 extern void             netdev_resync_ops(struct net_device *dev);
 
-extern int call_netdevice_notifiers(unsigned long val, struct net_device *dev);
 extern struct net_device        *dev_get_by_index(struct net *net, int ifindex);
 extern struct net_device        *__dev_get_by_index(struct net *net, int ifindex);
 extern struct net_device        *dev_get_by_index_rcu(struct net *net, int ifindex);
@@ -1694,9 +1679,12 @@ static inline int skb_gro_header_hard(struct sk_buff *skb, unsigned int hlen)
 static inline void *skb_gro_header_slow(struct sk_buff *skb, unsigned int hlen,
                                         unsigned int offset)
 {
+        if (!pskb_may_pull(skb, hlen))
+                return NULL;
+
         NAPI_GRO_CB(skb)->frag0 = NULL;
         NAPI_GRO_CB(skb)->frag0_len = 0;
-        return pskb_may_pull(skb, hlen) ? skb->data + offset : NULL;
+        return skb->data + offset;
 }
 
 static inline void *skb_gro_mac_header(struct sk_buff *skb)
@@ -1786,8 +1774,6 @@ static inline void input_queue_tail_incr_save(struct softnet_data *sd,
 
 DECLARE_PER_CPU_ALIGNED(struct softnet_data, softnet_data);
 
-#define HAVE_NETIF_QUEUE
-
 extern void __netif_schedule(struct Qdisc *q);
 
 static inline void netif_schedule_queue(struct netdev_queue *txq)
@@ -2063,10 +2049,8 @@ extern void dev_kfree_skb_irq(struct sk_buff *skb);
  */
 extern void dev_kfree_skb_any(struct sk_buff *skb);
 
-#define HAVE_NETIF_RX 1
 extern int              netif_rx(struct sk_buff *skb);
 extern int              netif_rx_ni(struct sk_buff *skb);
-#define HAVE_NETIF_RECEIVE_SKB 1
 extern int              netif_receive_skb(struct sk_buff *skb);
 extern gro_result_t     dev_gro_receive(struct napi_struct *napi,
                                         struct sk_buff *skb);
@@ -2246,7 +2230,6 @@ extern void netif_device_attach(struct net_device *dev);
 /*
  * Network interface message level settings
  */
-#define HAVE_NETIF_MSG 1
 
 enum {
         NETIF_MSG_DRV           = 0x0001,
@@ -2555,7 +2538,7 @@ extern void netdev_class_remove_file(struct class_attribute *class_attr);
 
 extern struct kobj_ns_type_operations net_ns_type_operations;
 
-extern char *netdev_drivername(const struct net_device *dev, char *buffer, int len);
+extern const char *netdev_drivername(const struct net_device *dev);
 
 extern void linkwatch_run_queue(void);
 
@@ -2564,7 +2547,6 @@ static inline u32 netdev_get_wanted_features(struct net_device *dev)
         return (dev->features & ~dev->hw_features) | dev->wanted_features;
 }
 u32 netdev_increment_features(u32 all, u32 one, u32 mask);
-u32 netdev_fix_features(struct net_device *dev, u32 features);
 int __netdev_update_features(struct net_device *dev);
 void netdev_update_features(struct net_device *dev);
 void netdev_change_features(struct net_device *dev);
diff --git a/include/linux/netfilter/ipset/ip_set.h b/include/linux/netfilter/ipset/ip_set.h
index 5a262e3ae715..3540c6e262f7 100644
--- a/include/linux/netfilter/ipset/ip_set.h
+++ b/include/linux/netfilter/ipset/ip_set.h
@@ -104,6 +104,8 @@ enum {
         IPSET_ATTR_NAMEREF,
         IPSET_ATTR_IP2,
         IPSET_ATTR_CIDR2,
+        IPSET_ATTR_IP2_TO,
+        IPSET_ATTR_IFACE,
         __IPSET_ATTR_ADT_MAX,
 };
 #define IPSET_ATTR_ADT_MAX      (__IPSET_ATTR_ADT_MAX - 1)
@@ -142,12 +144,18 @@ enum ipset_errno {
 enum ipset_cmd_flags {
         IPSET_FLAG_BIT_EXIST    = 0,
         IPSET_FLAG_EXIST        = (1 << IPSET_FLAG_BIT_EXIST),
+        IPSET_FLAG_BIT_LIST_SETNAME = 1,
+        IPSET_FLAG_LIST_SETNAME = (1 << IPSET_FLAG_BIT_LIST_SETNAME),
+        IPSET_FLAG_BIT_LIST_HEADER = 2,
+        IPSET_FLAG_LIST_HEADER  = (1 << IPSET_FLAG_BIT_LIST_HEADER),
 };
 
 /* Flags at CADT attribute level */
 enum ipset_cadt_flags {
         IPSET_FLAG_BIT_BEFORE   = 0,
         IPSET_FLAG_BEFORE       = (1 << IPSET_FLAG_BIT_BEFORE),
+        IPSET_FLAG_BIT_PHYSDEV  = 1,
+        IPSET_FLAG_PHYSDEV      = (1 << IPSET_FLAG_BIT_PHYSDEV),
 };
 
 /* Commands with settype-specific attributes */
@@ -165,6 +173,7 @@ enum ipset_adt {
 #include <linux/ipv6.h>
 #include <linux/netlink.h>
 #include <linux/netfilter.h>
+#include <linux/netfilter/x_tables.h>
 #include <linux/vmalloc.h>
 #include <net/netlink.h>
 
@@ -206,6 +215,8 @@ enum ip_set_feature {
         IPSET_TYPE_IP2 = (1 << IPSET_TYPE_IP2_FLAG),
         IPSET_TYPE_NAME_FLAG = 4,
         IPSET_TYPE_NAME = (1 << IPSET_TYPE_NAME_FLAG),
+        IPSET_TYPE_IFACE_FLAG = 5,
+        IPSET_TYPE_IFACE = (1 << IPSET_TYPE_IFACE_FLAG),
         /* Strictly speaking not a feature, but a flag for dumping:
          * this settype must be dumped last */
         IPSET_DUMP_LAST_FLAG = 7,
@@ -214,7 +225,17 @@ enum ip_set_feature {
 
 struct ip_set;
 
-typedef int (*ipset_adtfn)(struct ip_set *set, void *value, u32 timeout);
+typedef int (*ipset_adtfn)(struct ip_set *set, void *value,
+                           u32 timeout, u32 flags);
+
+/* Kernel API function options */
+struct ip_set_adt_opt {
+        u8 family;              /* Actual protocol family */
+        u8 dim;                 /* Dimension of match/target */
+        u8 flags;               /* Direction and negation flags */
+        u32 cmdflags;           /* Command-like flags */
+        u32 timeout;            /* Timeout value */
+};
 
 /* Set type, variant-specific part */
 struct ip_set_type_variant {
@@ -223,14 +244,15 @@ struct ip_set_type_variant {
          *                      zero for no match/success to add/delete
          *                      positive for matching element */
         int (*kadt)(struct ip_set *set, const struct sk_buff * skb,
-                    enum ipset_adt adt, u8 pf, u8 dim, u8 flags);
+                    const struct xt_action_param *par,
+                    enum ipset_adt adt, const struct ip_set_adt_opt *opt);
 
         /* Userspace: test/add/del entries
          *              returns negative error code,
          *                      zero for no match/success to add/delete
          *                      positive for matching element */
         int (*uadt)(struct ip_set *set, struct nlattr *tb[],
-                    enum ipset_adt adt, u32 *lineno, u32 flags);
+                    enum ipset_adt adt, u32 *lineno, u32 flags, bool retried);
 
         /* Low level add/del/test functions */
         ipset_adtfn adt[IPSET_ADT_MAX];
@@ -268,8 +290,8 @@ struct ip_set_type {
         u8 dimension;
         /* Supported family: may be AF_UNSPEC for both AF_INET/AF_INET6 */
         u8 family;
-        /* Type revision */
-        u8 revision;
+        /* Type revisions */
+        u8 revision_min, revision_max;
 
         /* Create set */
         int (*create)(struct ip_set *set, struct nlattr *tb[], u32 flags);
@@ -300,6 +322,8 @@ struct ip_set {
         const struct ip_set_type_variant *variant;
         /* The actual INET family of the set */
         u8 family;
+        /* The type revision */
+        u8 revision;
         /* The type specific data */
         void *data;
 };
@@ -307,21 +331,25 @@ struct ip_set {
 /* register and unregister set references */
 extern ip_set_id_t ip_set_get_byname(const char *name, struct ip_set **set);
 extern void ip_set_put_byindex(ip_set_id_t index);
-extern const char * ip_set_name_byindex(ip_set_id_t index);
+extern const char *ip_set_name_byindex(ip_set_id_t index);
 extern ip_set_id_t ip_set_nfnl_get(const char *name);
 extern ip_set_id_t ip_set_nfnl_get_byindex(ip_set_id_t index);
 extern void ip_set_nfnl_put(ip_set_id_t index);
 
 /* API for iptables set match, and SET target */
+
 extern int ip_set_add(ip_set_id_t id, const struct sk_buff *skb,
-                      u8 family, u8 dim, u8 flags);
+                      const struct xt_action_param *par,
+                      const struct ip_set_adt_opt *opt);
 extern int ip_set_del(ip_set_id_t id, const struct sk_buff *skb,
-                      u8 family, u8 dim, u8 flags);
+                      const struct xt_action_param *par,
+                      const struct ip_set_adt_opt *opt);
 extern int ip_set_test(ip_set_id_t id, const struct sk_buff *skb,
-                       u8 family, u8 dim, u8 flags);
+                       const struct xt_action_param *par,
+                       const struct ip_set_adt_opt *opt);
 
 /* Utility functions */
-extern void * ip_set_alloc(size_t size);
+extern void *ip_set_alloc(size_t size);
 extern void ip_set_free(void *members);
 extern int ip_set_get_ipaddr4(struct nlattr *nla,  __be32 *ipaddr);
 extern int ip_set_get_ipaddr6(struct nlattr *nla, union nf_inet_addr *ipaddr);
@@ -331,7 +359,7 @@ ip_set_get_hostipaddr4(struct nlattr *nla, u32 *ipaddr)
 {
         __be32 ip;
         int ret = ip_set_get_ipaddr4(nla, &ip);
-        
+
         if (ret)
                 return ret;
         *ipaddr = ntohl(ip);
diff --git a/include/linux/netfilter/ipset/ip_set_ahash.h b/include/linux/netfilter/ipset/ip_set_ahash.h
index ac3c822eb39a..b89fb79cb44f 100644
--- a/include/linux/netfilter/ipset/ip_set_ahash.h
+++ b/include/linux/netfilter/ipset/ip_set_ahash.h
@@ -5,6 +5,11 @@
 #include <linux/jhash.h>
 #include <linux/netfilter/ipset/ip_set_timeout.h>
 
+#define CONCAT(a, b, c)         a##b##c
+#define TOKEN(a, b, c)          CONCAT(a, b, c)
+
+#define type_pf_next            TOKEN(TYPE, PF, _elem)
+
 /* Hashing which uses arrays to resolve clashing. The hash table is resized
  * (doubled) when searching becomes too long.
  * Internally jhash is used with the assumption that the size of the
@@ -23,7 +28,32 @@
 /* Number of elements to store in an initial array block */
 #define AHASH_INIT_SIZE                 4
 /* Max number of elements to store in an array block */
-#define AHASH_MAX_SIZE                  (3*4)
+#define AHASH_MAX_SIZE                  (3*AHASH_INIT_SIZE)
+
+/* Max number of elements can be tuned */
+#ifdef IP_SET_HASH_WITH_MULTI
+#define AHASH_MAX(h)                    ((h)->ahash_max)
+
+static inline u8
+tune_ahash_max(u8 curr, u32 multi)
+{
+        u32 n;
+
+        if (multi < curr)
+                return curr;
+
+        n = curr + AHASH_INIT_SIZE;
+        /* Currently, at listing one hash bucket must fit into a message.
+         * Therefore we have a hard limit here.
+         */
+        return n > curr && n <= 64 ? n : curr;
+}
+#define TUNE_AHASH_MAX(h, multi)        \
+        ((h)->ahash_max = tune_ahash_max((h)->ahash_max, multi))
+#else
+#define AHASH_MAX(h)                    AHASH_MAX_SIZE
+#define TUNE_AHASH_MAX(h, multi)
+#endif
 
 /* A hash bucket */
 struct hbucket {
@@ -38,7 +68,7 @@ struct htable {
         struct hbucket bucket[0]; /* hashtable buckets */
 };
 
-#define hbucket(h, i)           &((h)->bucket[i])
+#define hbucket(h, i)           (&((h)->bucket[i]))
 
 /* Book-keeping of the prefixes added to the set */
 struct ip_set_hash_nets {
@@ -54,9 +84,16 @@ struct ip_set_hash {
         u32 initval;            /* random jhash init value */
         u32 timeout;            /* timeout value, if enabled */
         struct timer_list gc;   /* garbage collection when timeout enabled */
+        struct type_pf_next next; /* temporary storage for uadd */
+#ifdef IP_SET_HASH_WITH_MULTI
+        u8 ahash_max;           /* max elements in an array block */
+#endif
 #ifdef IP_SET_HASH_WITH_NETMASK
         u8 netmask;             /* netmask value for subnets to store */
 #endif
+#ifdef IP_SET_HASH_WITH_RBTREE
+        struct rb_root rbtree;
+#endif
 #ifdef IP_SET_HASH_WITH_NETS
         struct ip_set_hash_nets nets[0]; /* book-keeping of prefixes */
 #endif
@@ -194,17 +231,24 @@ ip_set_hash_destroy(struct ip_set *set)
                 del_timer_sync(&h->gc);
 
         ahash_destroy(h->table);
+#ifdef IP_SET_HASH_WITH_RBTREE
+        rbtree_destroy(&h->rbtree);
+#endif
         kfree(h);
 
         set->data = NULL;
 }
 
-#define HKEY(data, initval, htable_bits)                                 \
-(jhash2((u32 *)(data), sizeof(struct type_pf_elem)/sizeof(u32), initval) \
-        & jhash_mask(htable_bits))
-
 #endif /* _IP_SET_AHASH_H */
 
+#ifndef HKEY_DATALEN
+#define HKEY_DATALEN    sizeof(struct type_pf_elem)
+#endif
+
+#define HKEY(data, initval, htable_bits)                        \
+(jhash2((u32 *)(data), HKEY_DATALEN/sizeof(u32), initval)       \
+        & jhash_mask(htable_bits))
+
 #define CONCAT(a, b, c)         a##b##c
 #define TOKEN(a, b, c)          CONCAT(a, b, c)
 
@@ -217,6 +261,7 @@ ip_set_hash_destroy(struct ip_set *set)
 #define type_pf_data_netmask    TOKEN(TYPE, PF, _data_netmask)
 #define type_pf_data_list       TOKEN(TYPE, PF, _data_list)
 #define type_pf_data_tlist      TOKEN(TYPE, PF, _data_tlist)
+#define type_pf_data_next       TOKEN(TYPE, PF, _data_next)
 
 #define type_pf_elem            TOKEN(TYPE, PF, _elem)
 #define type_pf_telem           TOKEN(TYPE, PF, _telem)
@@ -262,12 +307,13 @@ ip_set_hash_destroy(struct ip_set *set)
 /* Add an element to the hash table when resizing the set:
  * we spare the maintenance of the internal counters. */
 static int
-type_pf_elem_add(struct hbucket *n, const struct type_pf_elem *value)
+type_pf_elem_add(struct hbucket *n, const struct type_pf_elem *value,
+                 u8 ahash_max)
 {
         if (n->pos >= n->size) {
                 void *tmp;
 
-                if (n->size >= AHASH_MAX_SIZE)
+                if (n->size >= ahash_max)
                         /* Trigger rehashing */
                         return -EAGAIN;
 
@@ -322,7 +368,7 @@ retry:
                 for (j = 0; j < n->pos; j++) {
                         data = ahash_data(n, j);
                         m = hbucket(t, HKEY(data, h->initval, htable_bits));
-                        ret = type_pf_elem_add(m, data);
+                        ret = type_pf_elem_add(m, data, AHASH_MAX(h));
                         if (ret < 0) {
                                 read_unlock_bh(&set->lock);
                                 ahash_destroy(t);
@@ -346,17 +392,20 @@ retry:
         return 0;
 }
 
+static inline void
+type_pf_data_next(struct ip_set_hash *h, const struct type_pf_elem *d);
+
 /* Add an element to a hash and update the internal counters when succeeded,
  * otherwise report the proper error code. */
 static int
-type_pf_add(struct ip_set *set, void *value, u32 timeout)
+type_pf_add(struct ip_set *set, void *value, u32 timeout, u32 flags)
 {
         struct ip_set_hash *h = set->data;
         struct htable *t;
         const struct type_pf_elem *d = value;
         struct hbucket *n;
         int i, ret = 0;
-        u32 key;
+        u32 key, multi = 0;
 
         if (h->elements >= h->maxelem)
                 return -IPSET_ERR_HASH_FULL;
@@ -366,14 +415,17 @@ type_pf_add(struct ip_set *set, void *value, u32 timeout)
         key = HKEY(value, h->initval, t->htable_bits);
         n = hbucket(t, key);
         for (i = 0; i < n->pos; i++)
-                if (type_pf_data_equal(ahash_data(n, i), d)) {
+                if (type_pf_data_equal(ahash_data(n, i), d, &multi)) {
                         ret = -IPSET_ERR_EXIST;
                         goto out;
                 }
-
-        ret = type_pf_elem_add(n, value);
-        if (ret != 0)
+        TUNE_AHASH_MAX(h, multi);
+        ret = type_pf_elem_add(n, value, AHASH_MAX(h));
+        if (ret != 0) {
+                if (ret == -EAGAIN)
+                        type_pf_data_next(h, d);
                 goto out;
+        }
 
 #ifdef IP_SET_HASH_WITH_NETS
         add_cidr(h, d->cidr, HOST_MASK);
@@ -388,7 +440,7 @@ out:
  * and free up space if possible.
  */
 static int
-type_pf_del(struct ip_set *set, void *value, u32 timeout)
+type_pf_del(struct ip_set *set, void *value, u32 timeout, u32 flags)
 {
         struct ip_set_hash *h = set->data;
         struct htable *t = h->table;
@@ -396,13 +448,13 @@ type_pf_del(struct ip_set *set, void *value, u32 timeout)
         struct hbucket *n;
         int i;
         struct type_pf_elem *data;
-        u32 key;
+        u32 key, multi = 0;
 
         key = HKEY(value, h->initval, t->htable_bits);
         n = hbucket(t, key);
         for (i = 0; i < n->pos; i++) {
                 data = ahash_data(n, i);
-                if (!type_pf_data_equal(data, d))
+                if (!type_pf_data_equal(data, d, &multi))
                         continue;
                 if (i != n->pos - 1)
                         /* Not last one */
@@ -443,17 +495,17 @@ type_pf_test_cidrs(struct ip_set *set, struct type_pf_elem *d, u32 timeout)
         struct hbucket *n;
         const struct type_pf_elem *data;
         int i, j = 0;
-        u32 key;
+        u32 key, multi = 0;
         u8 host_mask = SET_HOST_MASK(set->family);
 
         pr_debug("test by nets\n");
-        for (; j < host_mask && h->nets[j].cidr; j++) {
+        for (; j < host_mask && h->nets[j].cidr && !multi; j++) {
                 type_pf_data_netmask(d, h->nets[j].cidr);
                 key = HKEY(d, h->initval, t->htable_bits);
                 n = hbucket(t, key);
                 for (i = 0; i < n->pos; i++) {
                         data = ahash_data(n, i);
-                        if (type_pf_data_equal(data, d))
+                        if (type_pf_data_equal(data, d, &multi))
                                 return 1;
                 }
         }
@@ -463,7 +515,7 @@ type_pf_test_cidrs(struct ip_set *set, struct type_pf_elem *d, u32 timeout)
 
 /* Test whether the element is added to the set */
 static int
-type_pf_test(struct ip_set *set, void *value, u32 timeout)
+type_pf_test(struct ip_set *set, void *value, u32 timeout, u32 flags)
 {
         struct ip_set_hash *h = set->data;
         struct htable *t = h->table;
@@ -471,7 +523,7 @@ type_pf_test(struct ip_set *set, void *value, u32 timeout)
         struct hbucket *n;
         const struct type_pf_elem *data;
         int i;
-        u32 key;
+        u32 key, multi = 0;
 
 #ifdef IP_SET_HASH_WITH_NETS
         /* If we test an IP address and not a network address,
@@ -484,7 +536,7 @@ type_pf_test(struct ip_set *set, void *value, u32 timeout)
         n = hbucket(t, key);
         for (i = 0; i < n->pos; i++) {
                 data = ahash_data(n, i);
-                if (type_pf_data_equal(data, d))
+                if (type_pf_data_equal(data, d, &multi))
                         return 1;
         }
         return 0;
@@ -586,10 +638,11 @@ nla_put_failure:
 
 static int
 type_pf_kadt(struct ip_set *set, const struct sk_buff * skb,
-             enum ipset_adt adt, u8 pf, u8 dim, u8 flags);
+             const struct xt_action_param *par,
+             enum ipset_adt adt, const struct ip_set_adt_opt *opt);
 static int
 type_pf_uadt(struct ip_set *set, struct nlattr *tb[],
-             enum ipset_adt adt, u32 *lineno, u32 flags);
+             enum ipset_adt adt, u32 *lineno, u32 flags, bool retried);
 
 static const struct ip_set_type_variant type_pf_variant = {
         .kadt   = type_pf_kadt,
@@ -640,14 +693,14 @@ type_pf_data_timeout_set(struct type_pf_elem *data, u32 timeout)
 
 static int
 type_pf_elem_tadd(struct hbucket *n, const struct type_pf_elem *value,
-                  u32 timeout)
+                  u8 ahash_max, u32 timeout)
 {
         struct type_pf_elem *data;
 
         if (n->pos >= n->size) {
                 void *tmp;
 
-                if (n->size >= AHASH_MAX_SIZE)
+                if (n->size >= ahash_max)
                         /* Trigger rehashing */
                         return -EAGAIN;
 
@@ -752,7 +805,7 @@ retry:
                 for (j = 0; j < n->pos; j++) {
                         data = ahash_tdata(n, j);
                         m = hbucket(t, HKEY(data, h->initval, htable_bits));
-                        ret = type_pf_elem_tadd(m, data,
+                        ret = type_pf_elem_tadd(m, data, AHASH_MAX(h),
                                                 type_pf_data_timeout(data));
                         if (ret < 0) {
                                 read_unlock_bh(&set->lock);
@@ -776,15 +829,16 @@ retry:
 }
 
 static int
-type_pf_tadd(struct ip_set *set, void *value, u32 timeout)
+type_pf_tadd(struct ip_set *set, void *value, u32 timeout, u32 flags)
 {
         struct ip_set_hash *h = set->data;
         struct htable *t = h->table;
         const struct type_pf_elem *d = value;
         struct hbucket *n;
         struct type_pf_elem *data;
-        int ret = 0, i, j = AHASH_MAX_SIZE + 1;
-        u32 key;
+        int ret = 0, i, j = AHASH_MAX(h) + 1;
+        bool flag_exist = flags & IPSET_FLAG_EXIST;
+        u32 key, multi = 0;
 
         if (h->elements >= h->maxelem)
                 /* FIXME: when set is full, we slow down here */
@@ -798,18 +852,18 @@ type_pf_tadd(struct ip_set *set, void *value, u32 timeout)
         n = hbucket(t, key);
         for (i = 0; i < n->pos; i++) {
                 data = ahash_tdata(n, i);
-                if (type_pf_data_equal(data, d)) {
-                        if (type_pf_data_expired(data))
+                if (type_pf_data_equal(data, d, &multi)) {
+                        if (type_pf_data_expired(data) || flag_exist)
                                 j = i;
                         else {
                                 ret = -IPSET_ERR_EXIST;
                                 goto out;
                         }
-                } else if (j == AHASH_MAX_SIZE + 1 &&
+                } else if (j == AHASH_MAX(h) + 1 &&
                            type_pf_data_expired(data))
                         j = i;
         }
-        if (j != AHASH_MAX_SIZE + 1) {
+        if (j != AHASH_MAX(h) + 1) {
                 data = ahash_tdata(n, j);
 #ifdef IP_SET_HASH_WITH_NETS
                 del_cidr(h, data->cidr, HOST_MASK);
@@ -819,9 +873,13 @@ type_pf_tadd(struct ip_set *set, void *value, u32 timeout)
                 type_pf_data_timeout_set(data, timeout);
                 goto out;
         }
-        ret = type_pf_elem_tadd(n, d, timeout);
-        if (ret != 0)
+        TUNE_AHASH_MAX(h, multi);
+        ret = type_pf_elem_tadd(n, d, AHASH_MAX(h), timeout);
+        if (ret != 0) {
+                if (ret == -EAGAIN)
+                        type_pf_data_next(h, d);
                 goto out;
+        }
 
 #ifdef IP_SET_HASH_WITH_NETS
         add_cidr(h, d->cidr, HOST_MASK);
@@ -833,7 +891,7 @@ out:
 }
 
 static int
-type_pf_tdel(struct ip_set *set, void *value, u32 timeout)
+type_pf_tdel(struct ip_set *set, void *value, u32 timeout, u32 flags)
 {
         struct ip_set_hash *h = set->data;
         struct htable *t = h->table;
@@ -841,13 +899,13 @@ type_pf_tdel(struct ip_set *set, void *value, u32 timeout)
         struct hbucket *n;
         int i;
         struct type_pf_elem *data;
-        u32 key;
+        u32 key, multi = 0;
 
         key = HKEY(value, h->initval, t->htable_bits);
         n = hbucket(t, key);
         for (i = 0; i < n->pos; i++) {
                 data = ahash_tdata(n, i);
-                if (!type_pf_data_equal(data, d))
+                if (!type_pf_data_equal(data, d, &multi))
                         continue;
                 if (type_pf_data_expired(data))
                         return -IPSET_ERR_EXIST;
@@ -887,16 +945,16 @@ type_pf_ttest_cidrs(struct ip_set *set, struct type_pf_elem *d, u32 timeout)
         struct type_pf_elem *data;
         struct hbucket *n;
         int i, j = 0;
-        u32 key;
+        u32 key, multi = 0;
         u8 host_mask = SET_HOST_MASK(set->family);
 
-        for (; j < host_mask && h->nets[j].cidr; j++) {
+        for (; j < host_mask && h->nets[j].cidr && !multi; j++) {
                 type_pf_data_netmask(d, h->nets[j].cidr);
                 key = HKEY(d, h->initval, t->htable_bits);
                 n = hbucket(t, key);
                 for (i = 0; i < n->pos; i++) {
                         data = ahash_tdata(n, i);
-                        if (type_pf_data_equal(data, d))
+                        if (type_pf_data_equal(data, d, &multi))
                                 return !type_pf_data_expired(data);
                 }
         }
@@ -905,14 +963,14 @@ type_pf_ttest_cidrs(struct ip_set *set, struct type_pf_elem *d, u32 timeout)
 #endif
 
 static int
-type_pf_ttest(struct ip_set *set, void *value, u32 timeout)
+type_pf_ttest(struct ip_set *set, void *value, u32 timeout, u32 flags)
 {
         struct ip_set_hash *h = set->data;
         struct htable *t = h->table;
         struct type_pf_elem *data, *d = value;
         struct hbucket *n;
         int i;
-        u32 key;
+        u32 key, multi = 0;
 
 #ifdef IP_SET_HASH_WITH_NETS
         if (d->cidr == SET_HOST_MASK(set->family))
@@ -922,7 +980,7 @@ type_pf_ttest(struct ip_set *set, void *value, u32 timeout)
         n = hbucket(t, key);
         for (i = 0; i < n->pos; i++) {
                 data = ahash_tdata(n, i);
-                if (type_pf_data_equal(data, d))
+                if (type_pf_data_equal(data, d, &multi))
                         return !type_pf_data_expired(data);
         }
         return 0;
@@ -1030,6 +1088,8 @@ type_pf_gc_init(struct ip_set *set)
                  IPSET_GC_PERIOD(h->timeout));
 }
 
+#undef HKEY_DATALEN
+#undef HKEY
 #undef type_pf_data_equal
 #undef type_pf_data_isnull
 #undef type_pf_data_copy
diff --git a/include/linux/netfilter/ipset/ip_set_hash.h b/include/linux/netfilter/ipset/ip_set_hash.h
index b86f15c04524..e2a9fae767f6 100644
--- a/include/linux/netfilter/ipset/ip_set_hash.h
+++ b/include/linux/netfilter/ipset/ip_set_hash.h
@@ -11,6 +11,10 @@ enum {
         IPSET_ERR_INVALID_PROTO,
         /* Protocol missing but must be specified */
         IPSET_ERR_MISSING_PROTO,
+        /* Range not supported */
+        IPSET_ERR_HASH_RANGE_UNSUPPORTED,
+        /* Invalid range */
+        IPSET_ERR_HASH_RANGE,
 };
 
 #ifdef __KERNEL__
diff --git a/include/linux/netfilter/ipset/ip_set_timeout.h b/include/linux/netfilter/ipset/ip_set_timeout.h
index bcdd40ad39ed..47923205a4ad 100644
--- a/include/linux/netfilter/ipset/ip_set_timeout.h
+++ b/include/linux/netfilter/ipset/ip_set_timeout.h
@@ -22,6 +22,9 @@
 
 #define with_timeout(timeout)   ((timeout) != IPSET_NO_TIMEOUT)
 
+#define opt_timeout(opt, map)   \
+        (with_timeout((opt)->timeout) ? (opt)->timeout : (map)->timeout)
+
 static inline unsigned int
 ip_set_timeout_uget(struct nlattr *tb)
 {
@@ -75,7 +78,7 @@ ip_set_timeout_set(u32 timeout)
 static inline u32
 ip_set_timeout_get(unsigned long timeout)
 {
-        return timeout == IPSET_ELEM_PERMANENT ? 0 : 
+        return timeout == IPSET_ELEM_PERMANENT ? 0 :
                 jiffies_to_msecs(timeout - jiffies)/1000;
 }
 
diff --git a/include/linux/netfilter/ipset/pfxlen.h b/include/linux/netfilter/ipset/pfxlen.h
index 0e1fb50da562..199fd11fedc0 100644
--- a/include/linux/netfilter/ipset/pfxlen.h
+++ b/include/linux/netfilter/ipset/pfxlen.h
@@ -2,7 +2,8 @@
 #define _PFXLEN_H
 
 #include <asm/byteorder.h>
-#include <linux/netfilter.h> 
+#include <linux/netfilter.h>
+#include <net/tcp.h>
 
 /* Prefixlen maps, by Jan Engelhardt  */
 extern const union nf_inet_addr ip_set_netmask_map[];
@@ -32,4 +33,12 @@ ip_set_hostmask6(u8 pfxlen)
         return &ip_set_hostmask_map[pfxlen].ip6[0];
 }
 
+extern u32 ip_set_range_to_cidr(u32 from, u32 to, u8 *cidr);
+
+#define ip_set_mask_from_to(from, to, cidr)     \
+do {                                            \
+        from &= ip_set_hostmask(cidr);          \
+        to = from | ~ip_set_hostmask(cidr);     \
+} while (0)
+
 #endif /*_PFXLEN_H */
diff --git a/include/linux/netfilter/nf_conntrack_common.h b/include/linux/netfilter/nf_conntrack_common.h
index 50cdc2559a5a..0d3dd66322ec 100644
--- a/include/linux/netfilter/nf_conntrack_common.h
+++ b/include/linux/netfilter/nf_conntrack_common.h
@@ -18,6 +18,9 @@ enum ip_conntrack_info {
         /* >= this indicates reply direction */
         IP_CT_IS_REPLY,
 
+        IP_CT_ESTABLISHED_REPLY = IP_CT_ESTABLISHED + IP_CT_IS_REPLY,
+        IP_CT_RELATED_REPLY = IP_CT_RELATED + IP_CT_IS_REPLY,
+        IP_CT_NEW_REPLY = IP_CT_NEW + IP_CT_IS_REPLY,   
         /* Number of distinct IP_CT types (no NEW in reply dirn). */
         IP_CT_NUMBER = IP_CT_IS_REPLY * 2 - 1
 };
diff --git a/include/linux/netfilter/nfnetlink.h b/include/linux/netfilter/nfnetlink.h
index 2b11fc1a86be..74d33861473c 100644
--- a/include/linux/netfilter/nfnetlink.h
+++ b/include/linux/netfilter/nfnetlink.h
@@ -60,6 +60,9 @@ struct nfnl_callback {
         int (*call)(struct sock *nl, struct sk_buff *skb, 
                     const struct nlmsghdr *nlh,
                     const struct nlattr * const cda[]);
+        int (*call_rcu)(struct sock *nl, struct sk_buff *skb, 
+                    const struct nlmsghdr *nlh,
+                    const struct nlattr * const cda[]);
         const struct nla_policy *policy;        /* netlink attribute policy */
         const u_int16_t attr_count;             /* number of nlattr's */
 };
diff --git a/include/linux/netfilter/nfnetlink_queue.h b/include/linux/netfilter/nfnetlink_queue.h
index af94e0014ebd..24b32e6c009e 100644
--- a/include/linux/netfilter/nfnetlink_queue.h
+++ b/include/linux/netfilter/nfnetlink_queue.h
@@ -8,6 +8,7 @@ enum nfqnl_msg_types {
         NFQNL_MSG_PACKET,               /* packet from kernel to userspace */
         NFQNL_MSG_VERDICT,              /* verdict from userspace to kernel */
         NFQNL_MSG_CONFIG,               /* connect to a particular queue */
+        NFQNL_MSG_VERDICT_BATCH,        /* batchv from userspace to kernel */
 
         NFQNL_MSG_MAX
 };
diff --git a/include/linux/netfilter/xt_set.h b/include/linux/netfilter/xt_set.h
index 081f1ded2842..c0405ac92870 100644
--- a/include/linux/netfilter/xt_set.h
+++ b/include/linux/netfilter/xt_set.h
@@ -35,7 +35,7 @@ struct xt_set_info_target_v0 {
         struct xt_set_info_v0 del_set;
 };
 
-/* Revision 1: current interface to netfilter/iptables */
+/* Revision 1  match and target */
 
 struct xt_set_info {
         ip_set_id_t index;
@@ -44,13 +44,22 @@ struct xt_set_info {
 };
 
 /* match and target infos */
-struct xt_set_info_match {
+struct xt_set_info_match_v1 {
         struct xt_set_info match_set;
 };
 
-struct xt_set_info_target {
+struct xt_set_info_target_v1 {
         struct xt_set_info add_set;
         struct xt_set_info del_set;
 };
 
+/* Revision 2 target */
+
+struct xt_set_info_target_v2 {
+        struct xt_set_info add_set;
+        struct xt_set_info del_set;
+        u32 flags;
+        u32 timeout;
+};
+
 #endif /*_XT_SET_H*/
diff --git a/include/linux/netlink.h b/include/linux/netlink.h
index a9dd89552f9c..2e17c5dbdcb8 100644
--- a/include/linux/netlink.h
+++ b/include/linux/netlink.h
@@ -49,6 +49,7 @@ struct nlmsghdr {
 #define NLM_F_MULTI             2       /* Multipart message, terminated by NLMSG_DONE */
 #define NLM_F_ACK               4       /* Reply with ack, with zero or error code */
 #define NLM_F_ECHO              8       /* Echo this request            */
+#define NLM_F_DUMP_INTR         16      /* Dump was inconsistent due to sequence change */
 
 /* Modifiers to GET request */
 #define NLM_F_ROOT      0x100   /* specify tree root    */
@@ -221,7 +222,9 @@ struct netlink_callback {
         int                     (*dump)(struct sk_buff * skb,
                                         struct netlink_callback *cb);
         int                     (*done)(struct netlink_callback *cb);
-        int                     family;
+        u16                     family;
+        u16                     min_dump_alloc;
+        unsigned int            prev_seq, seq;
         long                    args[6];
 };
 
@@ -259,7 +262,8 @@ __nlmsg_put(struct sk_buff *skb, u32 pid, u32 seq, int type, int len, int flags)
 extern int netlink_dump_start(struct sock *ssk, struct sk_buff *skb,
                               const struct nlmsghdr *nlh,
                               int (*dump)(struct sk_buff *skb, struct netlink_callback*),
-                              int (*done)(struct netlink_callback*));
+                              int (*done)(struct netlink_callback*),
+                              u16 min_dump_alloc);
 
 
 #define NL_NONROOT_RECV 0x1
diff --git a/include/linux/netpoll.h b/include/linux/netpoll.h
index 79358bb712c6..5dfa091c3347 100644
--- a/include/linux/netpoll.h
+++ b/include/linux/netpoll.h
@@ -40,8 +40,6 @@ struct netpoll_info {
         struct netpoll *netpoll;
 };
 
-void netpoll_poll_dev(struct net_device *dev);
-void netpoll_poll(struct netpoll *np);
 void netpoll_send_udp(struct netpoll *np, const char *msg, int len);
 void netpoll_print_options(struct netpoll *np);
 int netpoll_parse_options(struct netpoll *np, char *opt);
diff --git a/include/linux/nfc.h b/include/linux/nfc.h
new file mode 100644
index 000000000000..330a4c5db588
--- /dev/null
+++ b/include/linux/nfc.h
@@ -0,0 +1,126 @@
+/*
+ * Copyright (C) 2011 Instituto Nokia de Tecnologia
+ *
+ * Authors:
+ *    Lauro Ramos Venancio <lauro.venancio@openbossa.org>
+ *    Aloisio Almeida Jr <aloisio.almeida@openbossa.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the
+ * Free Software Foundation, Inc.,
+ * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __LINUX_NFC_H
+#define __LINUX_NFC_H
+
+#include <linux/types.h>
+#include <linux/socket.h>
+
+#define NFC_GENL_NAME "nfc"
+#define NFC_GENL_VERSION 1
+
+#define NFC_GENL_MCAST_EVENT_NAME "events"
+
+/**
+ * enum nfc_commands - supported nfc commands
+ *
+ * @NFC_CMD_UNSPEC: unspecified command
+ *
+ * @NFC_CMD_GET_DEVICE: request information about a device (requires
+ *      %NFC_ATTR_DEVICE_INDEX) or dump request to get a list of all nfc devices
+ * @NFC_CMD_START_POLL: start polling for targets using the given protocols
+ *      (requires %NFC_ATTR_DEVICE_INDEX and %NFC_ATTR_PROTOCOLS)
+ * @NFC_CMD_STOP_POLL: stop polling for targets (requires
+ *      %NFC_ATTR_DEVICE_INDEX)
+ * @NFC_CMD_GET_TARGET: dump all targets found by the previous poll (requires
+ *      %NFC_ATTR_DEVICE_INDEX)
+ * @NFC_EVENT_TARGETS_FOUND: event emitted when a new target is found
+ *      (it sends %NFC_ATTR_DEVICE_INDEX)
+ * @NFC_EVENT_DEVICE_ADDED: event emitted when a new device is registred
+ *      (it sends %NFC_ATTR_DEVICE_NAME, %NFC_ATTR_DEVICE_INDEX and
+ *      %NFC_ATTR_PROTOCOLS)
+ * @NFC_EVENT_DEVICE_REMOVED: event emitted when a device is removed
+ *      (it sends %NFC_ATTR_DEVICE_INDEX)
+ */
+enum nfc_commands {
+        NFC_CMD_UNSPEC,
+        NFC_CMD_GET_DEVICE,
+        NFC_CMD_START_POLL,
+        NFC_CMD_STOP_POLL,
+        NFC_CMD_GET_TARGET,
+        NFC_EVENT_TARGETS_FOUND,
+        NFC_EVENT_DEVICE_ADDED,
+        NFC_EVENT_DEVICE_REMOVED,
+/* private: internal use only */
+        __NFC_CMD_AFTER_LAST
+};
+#define NFC_CMD_MAX (__NFC_CMD_AFTER_LAST - 1)
+
+/**
+ * enum nfc_attrs - supported nfc attributes
+ *
+ * @NFC_ATTR_UNSPEC: unspecified attribute
+ *
+ * @NFC_ATTR_DEVICE_INDEX: index of nfc device
+ * @NFC_ATTR_DEVICE_NAME: device name, max 8 chars
+ * @NFC_ATTR_PROTOCOLS: nfc protocols - bitwise or-ed combination from
+ *      NFC_PROTO_*_MASK constants
+ * @NFC_ATTR_TARGET_INDEX: index of the nfc target
+ * @NFC_ATTR_TARGET_SENS_RES: NFC-A targets extra information such as NFCID
+ * @NFC_ATTR_TARGET_SEL_RES: NFC-A targets extra information (useful if the
+ *      target is not NFC-Forum compliant)
+ */
+enum nfc_attrs {
+        NFC_ATTR_UNSPEC,
+        NFC_ATTR_DEVICE_INDEX,
+        NFC_ATTR_DEVICE_NAME,
+        NFC_ATTR_PROTOCOLS,
+        NFC_ATTR_TARGET_INDEX,
+        NFC_ATTR_TARGET_SENS_RES,
+        NFC_ATTR_TARGET_SEL_RES,
+/* private: internal use only */
+        __NFC_ATTR_AFTER_LAST
+};
+#define NFC_ATTR_MAX (__NFC_ATTR_AFTER_LAST - 1)
+
+#define NFC_DEVICE_NAME_MAXSIZE 8
+
+/* NFC protocols */
+#define NFC_PROTO_JEWEL         1
+#define NFC_PROTO_MIFARE        2
+#define NFC_PROTO_FELICA        3
+#define NFC_PROTO_ISO14443      4
+#define NFC_PROTO_NFC_DEP       5
+
+#define NFC_PROTO_MAX           6
+
+/* NFC protocols masks used in bitsets */
+#define NFC_PROTO_JEWEL_MASK    (1 << NFC_PROTO_JEWEL)
+#define NFC_PROTO_MIFARE_MASK   (1 << NFC_PROTO_MIFARE)
+#define NFC_PROTO_FELICA_MASK   (1 << NFC_PROTO_FELICA)
+#define NFC_PROTO_ISO14443_MASK (1 << NFC_PROTO_ISO14443)
+#define NFC_PROTO_NFC_DEP_MASK  (1 << NFC_PROTO_NFC_DEP)
+
+struct sockaddr_nfc {
+        sa_family_t sa_family;
+        __u32 dev_idx;
+        __u32 target_idx;
+        __u32 nfc_protocol;
+};
+
+/* NFC socket protocols */
+#define NFC_SOCKPROTO_RAW       0
+#define NFC_SOCKPROTO_MAX       1
+
+#endif /*__LINUX_NFC_H */
diff --git a/include/linux/nfs.h b/include/linux/nfs.h
index f387919bbc59..8c6ee44914cb 100644
--- a/include/linux/nfs.h
+++ b/include/linux/nfs.h
@@ -29,6 +29,8 @@
 #define NFS_MNT_VERSION         1
 #define NFS_MNT3_VERSION        3
 
+#define NFS_PIPE_DIRNAME "/nfs"
+
 /*
  * NFS stats. The good thing with these values is that NFSv3 errors are
  * a superset of NFSv2 errors (with the exception of NFSERR_WFLUSH which
diff --git a/include/linux/nfs4.h b/include/linux/nfs4.h
index 504b289ba680..76f99e8714f3 100644
--- a/include/linux/nfs4.h
+++ b/include/linux/nfs4.h
@@ -563,6 +563,10 @@ enum {
         NFSPROC4_CLNT_GETDEVICEINFO,
         NFSPROC4_CLNT_LAYOUTCOMMIT,
         NFSPROC4_CLNT_LAYOUTRETURN,
+        NFSPROC4_CLNT_SECINFO_NO_NAME,
+        NFSPROC4_CLNT_TEST_STATEID,
+        NFSPROC4_CLNT_FREE_STATEID,
+        NFSPROC4_CLNT_GETDEVICELIST,
 };
 
 /* nfs41 types */
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index 1b93b9c60e55..eaac770f886e 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -85,7 +85,7 @@ struct nfs_lock_context {
 struct nfs4_state;
 struct nfs_open_context {
         struct nfs_lock_context lock_context;
-        struct path path;
+        struct dentry *dentry;
         struct rpc_cred *cred;
         struct nfs4_state *state;
         fmode_t mode;
@@ -99,9 +99,10 @@ struct nfs_open_context {
 
 struct nfs_open_dir_context {
         struct rpc_cred *cred;
+        unsigned long attr_gencount;
         __u64 dir_cookie;
         __u64 dup_cookie;
-        int duped;
+        signed char duped;
 };
 
 /*
@@ -360,7 +361,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, unsigned int);
+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);
@@ -372,7 +373,7 @@ extern void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr);
 extern struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx);
 extern void put_nfs_open_context(struct nfs_open_context *ctx);
 extern struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, fmode_t mode);
-extern struct nfs_open_context *alloc_nfs_open_context(struct path *path, struct rpc_cred *cred, fmode_t f_mode);
+extern struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, struct rpc_cred *cred, fmode_t f_mode);
 extern void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx);
 extern struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx);
 extern void nfs_put_lock_context(struct nfs_lock_context *l_ctx);
@@ -568,12 +569,12 @@ extern struct posix_acl *nfs3_proc_getacl(struct inode *inode, int type);
 extern int nfs3_proc_setacl(struct inode *inode, int type,
                             struct posix_acl *acl);
 extern int nfs3_proc_set_default_acl(struct inode *dir, struct inode *inode,
-                mode_t mode);
+                umode_t mode);
 extern void nfs3_forget_cached_acls(struct inode *inode);
 #else
 static inline int nfs3_proc_set_default_acl(struct inode *dir,
                                             struct inode *inode,
-                                            mode_t mode)
+                                            umode_t mode)
 {
         return 0;
 }
diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h
index 87694ca86914..b5479df8378d 100644
--- a/include/linux/nfs_fs_sb.h
+++ b/include/linux/nfs_fs_sb.h
@@ -7,7 +7,7 @@
 #include <linux/nfs_xdr.h>
 #include <linux/sunrpc/xprt.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 struct nfs4_session;
 struct nfs_iostats;
@@ -16,6 +16,7 @@ struct nfs4_sequence_args;
 struct nfs4_sequence_res;
 struct nfs_server;
 struct nfs4_minor_version_ops;
+struct server_scope;
 
 /*
  * The nfs_client identifies our client state to the server.
@@ -77,12 +78,13 @@ struct nfs_client {
         /* The flags used for obtaining the clientid during EXCHANGE_ID */
         u32                     cl_exchange_flags;
         struct nfs4_session     *cl_session;    /* sharred session */
-        struct list_head        cl_layouts;
 #endif /* CONFIG_NFS_V4 */
 
 #ifdef CONFIG_NFS_FSCACHE
         struct fscache_cookie   *fscache;       /* client index cache cookie */
 #endif
+
+        struct server_scope     *server_scope;  /* from exchange_id */
 };
 
 /*
@@ -129,8 +131,9 @@ struct nfs_server {
         struct fscache_cookie   *fscache;       /* superblock cookie */
 #endif
 
+        u32                     pnfs_blksize;   /* layout_blksize attr */
 #ifdef CONFIG_NFS_V4
-        u32                     attr_bitmask[2];/* V4 bitmask representing the set
+        u32                     attr_bitmask[3];/* V4 bitmask representing the set
                                                    of attributes supported on this
                                                    filesystem */
         u32                     cache_consistency_bitmask[2];
@@ -143,12 +146,14 @@ struct nfs_server {
                                                    filesystem */
         struct pnfs_layoutdriver_type  *pnfs_curr_ld; /* Active layout driver */
         struct rpc_wait_queue   roc_rpcwaitq;
+        void                    *pnfs_ld_data;  /* per mount point data */
 
         /* the following fields are protected by nfs_client->cl_lock */
         struct rb_root          state_owners;
         struct rb_root          openowner_id;
         struct rb_root          lockowner_id;
 #endif
+        struct list_head        layouts;
         struct list_head        delegations;
         void (*destroy)(struct nfs_server *);
 
diff --git a/include/linux/nfs_page.h b/include/linux/nfs_page.h
index 3a34e80ae92f..e2791a27a901 100644
--- a/include/linux/nfs_page.h
+++ b/include/linux/nfs_page.h
@@ -55,20 +55,28 @@ struct nfs_page {
         struct nfs_writeverf    wb_verf;        /* Commit cookie */
 };
 
+struct nfs_pageio_descriptor;
+struct nfs_pageio_ops {
+        void    (*pg_init)(struct nfs_pageio_descriptor *, struct nfs_page *);
+        bool    (*pg_test)(struct nfs_pageio_descriptor *, struct nfs_page *, struct nfs_page *);
+        int     (*pg_doio)(struct nfs_pageio_descriptor *);
+};
+
 struct nfs_pageio_descriptor {
         struct list_head        pg_list;
         unsigned long           pg_bytes_written;
         size_t                  pg_count;
         size_t                  pg_bsize;
         unsigned int            pg_base;
-        char                    pg_moreio;
+        unsigned char           pg_moreio : 1,
+                                pg_recoalesce : 1;
 
         struct inode            *pg_inode;
-        int                     (*pg_doio)(struct nfs_pageio_descriptor *);
+        const struct nfs_pageio_ops *pg_ops;
         int                     pg_ioflags;
         int                     pg_error;
+        const struct rpc_call_ops *pg_rpc_callops;
         struct pnfs_layout_segment *pg_lseg;
-        bool                    (*pg_test)(struct nfs_pageio_descriptor *, struct nfs_page *, struct nfs_page *);
 };
 
 #define NFS_WBACK_BUSY(req)     (test_bit(PG_BUSY,&(req)->wb_flags))
@@ -85,19 +93,21 @@ extern	int nfs_scan_list(struct nfs_inode *nfsi, struct list_head *dst,
                           pgoff_t idx_start, unsigned int npages, int tag);
 extern  void nfs_pageio_init(struct nfs_pageio_descriptor *desc,
                              struct inode *inode,
-                             int (*doio)(struct nfs_pageio_descriptor *desc),
+                             const struct nfs_pageio_ops *pg_ops,
                              size_t bsize,
                              int how);
 extern  int nfs_pageio_add_request(struct nfs_pageio_descriptor *,
                                    struct nfs_page *);
 extern  void nfs_pageio_complete(struct nfs_pageio_descriptor *desc);
 extern  void nfs_pageio_cond_complete(struct nfs_pageio_descriptor *, pgoff_t);
+extern bool nfs_generic_pg_test(struct nfs_pageio_descriptor *desc,
+                                struct nfs_page *prev,
+                                struct nfs_page *req);
 extern  int nfs_wait_on_request(struct nfs_page *);
 extern  void nfs_unlock_request(struct nfs_page *req);
 extern  int nfs_set_page_tag_locked(struct nfs_page *req);
 extern  void nfs_clear_page_tag_locked(struct nfs_page *req);
 
-
 /*
  * Lock the page of an asynchronous request without getting a new reference
  */
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index 5e8444a11adf..abd615d74a29 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -122,6 +122,7 @@ struct nfs_fsinfo {
         struct timespec         time_delta; /* server time granularity */
         __u32                   lease_time; /* in seconds */
         __u32                   layouttype; /* supported pnfs layout driver */
+        __u32                   blksize; /* preferred pnfs io block size */
 };
 
 struct nfs_fsstat {
@@ -158,7 +159,6 @@ struct nfs_seqid;
 
 /* nfs41 sessions channel attributes */
 struct nfs4_channel_attrs {
-        u32                     headerpadsz;
         u32                     max_rqst_sz;
         u32                     max_resp_sz;
         u32                     max_resp_sz_cached;
@@ -236,6 +236,17 @@ struct nfs4_layoutget {
         gfp_t gfp_flags;
 };
 
+struct nfs4_getdevicelist_args {
+        const struct nfs_fh *fh;
+        u32 layoutclass;
+        struct nfs4_sequence_args seq_args;
+};
+
+struct nfs4_getdevicelist_res {
+        struct pnfs_devicelist *devlist;
+        struct nfs4_sequence_res seq_res;
+};
+
 struct nfs4_getdeviceinfo_args {
         struct pnfs_device *pdev;
         struct nfs4_sequence_args seq_args;
@@ -258,21 +269,23 @@ struct nfs4_layoutcommit_res {
         struct nfs_fattr *fattr;
         const struct nfs_server *server;
         struct nfs4_sequence_res seq_res;
+        int status;
 };
 
 struct nfs4_layoutcommit_data {
         struct rpc_task task;
         struct nfs_fattr fattr;
-        struct pnfs_layout_segment *lseg;
+        struct list_head lseg_list;
         struct rpc_cred *cred;
         struct nfs4_layoutcommit_args args;
         struct nfs4_layoutcommit_res res;
 };
 
 struct nfs4_layoutreturn_args {
-        __u32   layout_type;
+        struct pnfs_layout_hdr *layout;
         struct inode *inode;
         nfs4_stateid stateid;
+        __u32   layout_type;
         struct nfs4_sequence_args seq_args;
 };
 
@@ -760,6 +773,11 @@ struct nfs3_getaclres {
         struct posix_acl *      acl_default;
 };
 
+struct nfs4_string {
+        unsigned int len;
+        char *data;
+};
+
 #ifdef CONFIG_NFS_V4
 
 typedef u64 clientid4;
@@ -943,18 +961,13 @@ struct nfs4_server_caps_arg {
 };
 
 struct nfs4_server_caps_res {
-        u32                             attr_bitmask[2];
+        u32                             attr_bitmask[3];
         u32                             acl_bitmask;
         u32                             has_links;
         u32                             has_symlinks;
         struct nfs4_sequence_res        seq_res;
 };
 
-struct nfs4_string {
-        unsigned int len;
-        char *data;
-};
-
 #define NFS4_PATHNAME_MAXCOMPONENTS 512
 struct nfs4_pathname {
         unsigned int ncomponents;
@@ -1061,6 +1074,7 @@ struct server_scope {
 struct nfs41_exchange_id_res {
         struct nfs_client               *client;
         u32                             flags;
+        struct server_scope             *server_scope;
 };
 
 struct nfs41_create_session_args {
@@ -1084,6 +1098,34 @@ struct nfs41_reclaim_complete_args {
 struct nfs41_reclaim_complete_res {
         struct nfs4_sequence_res        seq_res;
 };
+
+#define SECINFO_STYLE_CURRENT_FH 0
+#define SECINFO_STYLE_PARENT 1
+struct nfs41_secinfo_no_name_args {
+        int                             style;
+        struct nfs4_sequence_args       seq_args;
+};
+
+struct nfs41_test_stateid_args {
+        nfs4_stateid                    *stateid;
+        struct nfs4_sequence_args       seq_args;
+};
+
+struct nfs41_test_stateid_res {
+        unsigned int                    status;
+        struct nfs4_sequence_res        seq_res;
+};
+
+struct nfs41_free_stateid_args {
+        nfs4_stateid                    *stateid;
+        struct nfs4_sequence_args       seq_args;
+};
+
+struct nfs41_free_stateid_res {
+        unsigned int                    status;
+        struct nfs4_sequence_res        seq_res;
+};
+
 #endif /* CONFIG_NFS_V4_1 */
 
 struct nfs_page;
@@ -1097,6 +1139,7 @@ struct nfs_read_data {
         struct rpc_cred         *cred;
         struct nfs_fattr        fattr;  /* fattr storage */
         struct list_head        pages;  /* Coalesced read requests */
+        struct list_head        list;   /* lists of struct nfs_read_data */
         struct nfs_page         *req;   /* multi ops per nfs_page */
         struct page             **pagevec;
         unsigned int            npages; /* Max length of pagevec */
@@ -1120,6 +1163,7 @@ struct nfs_write_data {
         struct nfs_fattr        fattr;
         struct nfs_writeverf    verf;
         struct list_head        pages;          /* Coalesced requests we wish to flush */
+        struct list_head        list;           /* lists of struct nfs_write_data */
         struct nfs_page         *req;           /* multi ops per nfs_page */
         struct page             **pagevec;
         unsigned int            npages;         /* Max length of pagevec */
diff --git a/include/linux/nfsd/export.h b/include/linux/nfsd/export.h
index 84058ec69390..8a31a20efe7e 100644
--- a/include/linux/nfsd/export.h
+++ b/include/linux/nfsd/export.h
@@ -133,8 +133,6 @@ __be32 check_nfsd_access(struct svc_export *exp, struct svc_rqst *rqstp);
 int                     nfsd_export_init(void);
 void                    nfsd_export_shutdown(void);
 void                    nfsd_export_flush(void);
-void                    exp_readlock(void);
-void                    exp_readunlock(void);
 struct svc_export *     rqst_exp_get_by_name(struct svc_rqst *,
                                              struct path *);
 struct svc_export *     rqst_exp_parent(struct svc_rqst *,
diff --git a/include/linux/nl80211.h b/include/linux/nl80211.h
index c7ccaae15af6..8ad70dcac3f9 100644
--- a/include/linux/nl80211.h
+++ b/include/linux/nl80211.h
@@ -6,7 +6,7 @@
  * Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net>
  * Copyright 2008 Michael Wu <flamingice@sourmilk.net>
  * Copyright 2008 Luis Carlos Cobo <luisca@cozybit.com>
- * Copyright 2008 Michael Buesch <mb@bu3sch.de>
+ * Copyright 2008 Michael Buesch <m@bues.ch>
  * Copyright 2008, 2009 Luis R. Rodriguez <lrodriguez@atheros.com>
  * Copyright 2008 Jouni Malinen <jouni.malinen@atheros.com>
  * Copyright 2008 Colin McCabe <colin@cozybit.com>
@@ -247,7 +247,8 @@
  *      passed, all channels allowed for the current regulatory domain
  *      are used.  Extra IEs can also be passed from the userspace by
  *      using the %NL80211_ATTR_IE attribute.
- * @NL80211_CMD_STOP_SCHED_SCAN: stop a scheduled scan
+ * @NL80211_CMD_STOP_SCHED_SCAN: stop a scheduled scan.  Returns -ENOENT
+ *      if scheduled scan is not running.
  * @NL80211_CMD_SCHED_SCAN_RESULTS: indicates that there are scheduled scan
  *      results available.
  * @NL80211_CMD_SCHED_SCAN_STOPPED: indicates that the scheduled scan has
@@ -483,6 +484,14 @@
  *      more background information, see
  *      http://wireless.kernel.org/en/users/Documentation/WoWLAN.
  *
+ * @NL80211_CMD_SET_REKEY_OFFLOAD: This command is used give the driver
+ *      the necessary information for supporting GTK rekey offload. This
+ *      feature is typically used during WoWLAN. The configuration data
+ *      is contained in %NL80211_ATTR_REKEY_DATA (which is nested and
+ *      contains the data in sub-attributes). After rekeying happened,
+ *      this command may also be sent by the driver as an MLME event to
+ *      inform userspace of the new replay counter.
+ *
  * @NL80211_CMD_MAX: highest used command number
  * @__NL80211_CMD_AFTER_LAST: internal use
  */
@@ -605,6 +614,8 @@ enum nl80211_commands {
         NL80211_CMD_SCHED_SCAN_RESULTS,
         NL80211_CMD_SCHED_SCAN_STOPPED,
 
+        NL80211_CMD_SET_REKEY_OFFLOAD,
+
         /* add new commands above here */
 
         /* used to define NL80211_CMD_MAX below */
@@ -745,8 +756,12 @@ enum nl80211_commands {
  *
  * @NL80211_ATTR_MAX_NUM_SCAN_SSIDS: number of SSIDs you can scan with
  *      a single scan request, a wiphy attribute.
+ * @NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS: number of SSIDs you can
+ *      scan with a single scheduled scan request, a wiphy attribute.
  * @NL80211_ATTR_MAX_SCAN_IE_LEN: maximum length of information elements
  *      that can be added to a scan request
+ * @NL80211_ATTR_MAX_SCHED_SCAN_IE_LEN: maximum length of information
+ *      elements that can be added to a scheduled scan request
  *
  * @NL80211_ATTR_SCAN_FREQUENCIES: nested attribute with frequencies (in MHz)
  * @NL80211_ATTR_SCAN_SSIDS: nested attribute with SSIDs, leave out for passive
@@ -978,8 +993,8 @@ enum nl80211_commands {
  *      driving the peer link management state machine.
  *      @NL80211_MESH_SETUP_USERSPACE_AMPE must be enabled.
  *
- * @NL80211_ATTR_WOWLAN_SUPPORTED: indicates, as part of the wiphy capabilities,
- *      the supported WoWLAN triggers
+ * @NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED: indicates, as part of the wiphy
+ *      capabilities, the supported WoWLAN triggers
  * @NL80211_ATTR_WOWLAN_TRIGGERS: used by %NL80211_CMD_SET_WOWLAN to
  *      indicate which WoW triggers should be enabled. This is also
  *      used by %NL80211_CMD_GET_WOWLAN to get the currently enabled WoWLAN
@@ -996,6 +1011,14 @@ enum nl80211_commands {
  *      are managed in software: interfaces of these types aren't subject to
  *      any restrictions in their number or combinations.
  *
+ * @%NL80211_ATTR_REKEY_DATA: nested attribute containing the information
+ *      necessary for GTK rekeying in the device, see &enum nl80211_rekey_data.
+ *
+ * @NL80211_ATTR_SCAN_SUPP_RATES: rates per to be advertised as supported in scan,
+ *      nested array attribute containing an entry for each band, with the entry
+ *      being a list of supported rates as defined by IEEE 802.11 7.3.2.2 but
+ *      without the length restriction (at most %NL80211_MAX_SUPP_RATES).
+ *
  * @NL80211_ATTR_MAX: highest attribute number currently defined
  * @__NL80211_ATTR_AFTER_LAST: internal use
  */
@@ -1194,6 +1217,13 @@ enum nl80211_attrs {
         NL80211_ATTR_INTERFACE_COMBINATIONS,
         NL80211_ATTR_SOFTWARE_IFTYPES,
 
+        NL80211_ATTR_REKEY_DATA,
+
+        NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS,
+        NL80211_ATTR_MAX_SCHED_SCAN_IE_LEN,
+
+        NL80211_ATTR_SCAN_SUPP_RATES,
+
         /* add attributes here, update the policy in nl80211.c */
 
         __NL80211_ATTR_AFTER_LAST,
@@ -2239,6 +2269,16 @@ struct nl80211_wowlan_pattern_support {
  *
  *      In %NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED, it is a binary attribute
  *      carrying a &struct nl80211_wowlan_pattern_support.
+ * @NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED: Not a real trigger, and cannot be
+ *      used when setting, used only to indicate that GTK rekeying is supported
+ *      by the device (flag)
+ * @NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE: wake up on GTK rekey failure (if
+ *      done by the device) (flag)
+ * @NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST: wake up on EAP Identity Request
+ *      packet (flag)
+ * @NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE: wake up on 4-way handshake (flag)
+ * @NL80211_WOWLAN_TRIG_RFKILL_RELEASE: wake up when rfkill is released
+ *      (on devices that have rfkill in the device) (flag)
  * @NUM_NL80211_WOWLAN_TRIG: number of wake on wireless triggers
  * @MAX_NL80211_WOWLAN_TRIG: highest wowlan trigger attribute number
  */
@@ -2248,6 +2288,11 @@ enum nl80211_wowlan_triggers {
         NL80211_WOWLAN_TRIG_DISCONNECT,
         NL80211_WOWLAN_TRIG_MAGIC_PKT,
         NL80211_WOWLAN_TRIG_PKT_PATTERN,
+        NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED,
+        NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE,
+        NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST,
+        NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE,
+        NL80211_WOWLAN_TRIG_RFKILL_RELEASE,
 
         /* keep last */
         NUM_NL80211_WOWLAN_TRIG,
@@ -2361,4 +2406,28 @@ enum nl80211_plink_state {
         MAX_NL80211_PLINK_STATES = NUM_NL80211_PLINK_STATES - 1
 };
 
+#define NL80211_KCK_LEN                 16
+#define NL80211_KEK_LEN                 16
+#define NL80211_REPLAY_CTR_LEN          8
+
+/**
+ * enum nl80211_rekey_data - attributes for GTK rekey offload
+ * @__NL80211_REKEY_DATA_INVALID: invalid number for nested attributes
+ * @NL80211_REKEY_DATA_KEK: key encryption key (binary)
+ * @NL80211_REKEY_DATA_KCK: key confirmation key (binary)
+ * @NL80211_REKEY_DATA_REPLAY_CTR: replay counter (binary)
+ * @NUM_NL80211_REKEY_DATA: number of rekey attributes (internal)
+ * @MAX_NL80211_REKEY_DATA: highest rekey attribute (internal)
+ */
+enum nl80211_rekey_data {
+        __NL80211_REKEY_DATA_INVALID,
+        NL80211_REKEY_DATA_KEK,
+        NL80211_REKEY_DATA_KCK,
+        NL80211_REKEY_DATA_REPLAY_CTR,
+
+        /* keep last */
+        NUM_NL80211_REKEY_DATA,
+        MAX_NL80211_REKEY_DATA = NUM_NL80211_REKEY_DATA - 1
+};
+
 #endif /* __LINUX_NL80211_H */
diff --git a/include/linux/nodemask.h b/include/linux/nodemask.h
index dba35e413371..7afc36334d52 100644
--- a/include/linux/nodemask.h
+++ b/include/linux/nodemask.h
@@ -66,6 +66,8 @@
  * int num_online_nodes()               Number of online Nodes
  * int num_possible_nodes()             Number of all possible Nodes
  *
+ * int node_random(mask)                Random node with set bit in mask
+ *
  * int node_online(node)                Is some node online?
  * int node_possible(node)              Is some node possible?
  *
@@ -430,6 +432,7 @@ static inline void node_set_offline(int nid)
         node_clear_state(nid, N_ONLINE);
         nr_online_nodes = num_node_state(N_ONLINE);
 }
+
 #else
 
 static inline int node_state(int node, enum node_states state)
@@ -460,6 +463,16 @@ static inline int num_node_state(enum node_states state)
 
 #define node_set_online(node)      node_set_state((node), N_ONLINE)
 #define node_set_offline(node)     node_clear_state((node), N_ONLINE)
+
+#endif
+
+#if defined(CONFIG_NUMA) && (MAX_NUMNODES > 1)
+extern int node_random(const nodemask_t *maskp);
+#else
+static inline int node_random(const nodemask_t *mask)
+{
+        return 0;
+}
 #endif
 
 #define node_online_map         node_states[N_ONLINE]
diff --git a/include/linux/notifier.h b/include/linux/notifier.h
index c0688b0168b3..d65746efc954 100644
--- a/include/linux/notifier.h
+++ b/include/linux/notifier.h
@@ -185,80 +185,17 @@ static inline int notifier_to_errno(int ret)
  *      VC switch chains (for loadable kernel svgalib VC switch helpers) etc...
  */
  
-/* netdevice notifier chain. Please remember to update the rtnetlink
- * notification exclusion list in rtnetlink_event() when adding new
- * types.
- */
-#define NETDEV_UP       0x0001  /* For now you can't veto a device up/down */
-#define NETDEV_DOWN     0x0002
-#define NETDEV_REBOOT   0x0003  /* Tell a protocol stack a network interface
-                                   detected a hardware crash and restarted
-                                   - we can use this eg to kick tcp sessions
-                                   once done */
-#define NETDEV_CHANGE   0x0004  /* Notify device state change */
-#define NETDEV_REGISTER 0x0005
-#define NETDEV_UNREGISTER       0x0006
-#define NETDEV_CHANGEMTU        0x0007
-#define NETDEV_CHANGEADDR       0x0008
-#define NETDEV_GOING_DOWN       0x0009
-#define NETDEV_CHANGENAME       0x000A
-#define NETDEV_FEAT_CHANGE      0x000B
-#define NETDEV_BONDING_FAILOVER 0x000C
-#define NETDEV_PRE_UP           0x000D
-#define NETDEV_PRE_TYPE_CHANGE  0x000E
-#define NETDEV_POST_TYPE_CHANGE 0x000F
-#define NETDEV_POST_INIT        0x0010
-#define NETDEV_UNREGISTER_BATCH 0x0011
-#define NETDEV_RELEASE          0x0012
-#define NETDEV_NOTIFY_PEERS     0x0013
-#define NETDEV_JOIN             0x0014
-
-#define SYS_DOWN        0x0001  /* Notify of system down */
-#define SYS_RESTART     SYS_DOWN
-#define SYS_HALT        0x0002  /* Notify of system halt */
-#define SYS_POWER_OFF   0x0003  /* Notify of system power off */
+/* CPU notfiers are defined in include/linux/cpu.h. */
 
-#define NETLINK_URELEASE        0x0001  /* Unicast netlink socket released */
+/* netdevice notifiers are defined in include/linux/netdevice.h */
 
-#define CPU_ONLINE              0x0002 /* CPU (unsigned)v is up */
-#define CPU_UP_PREPARE          0x0003 /* CPU (unsigned)v coming up */
-#define CPU_UP_CANCELED         0x0004 /* CPU (unsigned)v NOT coming up */
-#define CPU_DOWN_PREPARE        0x0005 /* CPU (unsigned)v going down */
-#define CPU_DOWN_FAILED         0x0006 /* CPU (unsigned)v NOT going down */
-#define CPU_DEAD                0x0007 /* CPU (unsigned)v dead */
-#define CPU_DYING               0x0008 /* CPU (unsigned)v not running any task,
-                                        * not handling interrupts, soon dead.
-                                        * Called on the dying cpu, interrupts
-                                        * are already disabled. Must not
-                                        * sleep, must not fail */
-#define CPU_POST_DEAD           0x0009 /* CPU (unsigned)v dead, cpu_hotplug
-                                        * lock is dropped */
-#define CPU_STARTING            0x000A /* CPU (unsigned)v soon running.
-                                        * Called on the new cpu, just before
-                                        * enabling interrupts. Must not sleep,
-                                        * must not fail */
+/* reboot notifiers are defined in include/linux/reboot.h. */
 
-/* Used for CPU hotplug events occurring while tasks are frozen due to a suspend
- * operation in progress
- */
-#define CPU_TASKS_FROZEN        0x0010
+/* Hibernation and suspend events are defined in include/linux/suspend.h. */
 
-#define CPU_ONLINE_FROZEN       (CPU_ONLINE | CPU_TASKS_FROZEN)
-#define CPU_UP_PREPARE_FROZEN   (CPU_UP_PREPARE | CPU_TASKS_FROZEN)
-#define CPU_UP_CANCELED_FROZEN  (CPU_UP_CANCELED | CPU_TASKS_FROZEN)
-#define CPU_DOWN_PREPARE_FROZEN (CPU_DOWN_PREPARE | CPU_TASKS_FROZEN)
-#define CPU_DOWN_FAILED_FROZEN  (CPU_DOWN_FAILED | CPU_TASKS_FROZEN)
-#define CPU_DEAD_FROZEN         (CPU_DEAD | CPU_TASKS_FROZEN)
-#define CPU_DYING_FROZEN        (CPU_DYING | CPU_TASKS_FROZEN)
-#define CPU_STARTING_FROZEN     (CPU_STARTING | CPU_TASKS_FROZEN)
+/* Virtual Terminal events are defined in include/linux/vt.h. */
 
-/* Hibernation and suspend events */
-#define PM_HIBERNATION_PREPARE  0x0001 /* Going to hibernate */
-#define PM_POST_HIBERNATION     0x0002 /* Hibernation finished */
-#define PM_SUSPEND_PREPARE      0x0003 /* Going to suspend the system */
-#define PM_POST_SUSPEND         0x0004 /* Suspend finished */
-#define PM_RESTORE_PREPARE      0x0005 /* Going to restore a saved image */
-#define PM_POST_RESTORE         0x0006 /* Restore failed */
+#define NETLINK_URELEASE        0x0001  /* Unicast netlink socket released */
 
 /* Console keyboard events.
  * Note: KBD_KEYCODE is always sent before KBD_UNBOUND_KEYCODE, KBD_UNICODE and
@@ -271,12 +208,5 @@ static inline int notifier_to_errno(int ret)
 
 extern struct blocking_notifier_head reboot_notifier_list;
 
-/* Virtual Terminal events. */
-#define VT_ALLOCATE             0x0001 /* Console got allocated */
-#define VT_DEALLOCATE           0x0002 /* Console will be deallocated */
-#define VT_WRITE                0x0003 /* A char got output */
-#define VT_UPDATE               0x0004 /* A bigger update occurred */
-#define VT_PREWRITE             0x0005 /* A char is about to be written to the console */
-
 #endif /* __KERNEL__ */
 #endif /* _LINUX_NOTIFIER_H */
diff --git a/include/linux/nsproxy.h b/include/linux/nsproxy.h
index 50d20aba57d3..cc37a55ad004 100644
--- a/include/linux/nsproxy.h
+++ b/include/linux/nsproxy.h
@@ -68,6 +68,7 @@ void switch_task_namespaces(struct task_struct *tsk, struct nsproxy *new);
 void free_nsproxy(struct nsproxy *ns);
 int unshare_nsproxy_namespaces(unsigned long, struct nsproxy **,
         struct fs_struct *);
+int __init nsproxy_cache_init(void);
 
 static inline void put_nsproxy(struct nsproxy *ns)
 {
diff --git a/include/linux/of.h b/include/linux/of.h
index bfc0ed1b0ced..0085bb01c041 100644
--- a/include/linux/of.h
+++ b/include/linux/of.h
@@ -195,6 +195,14 @@ extern struct device_node *of_find_node_with_property(
 extern struct property *of_find_property(const struct device_node *np,
                                          const char *name,
                                          int *lenp);
+extern int of_property_read_u32_array(const struct device_node *np,
+                                      const char *propname,
+                                      u32 *out_values,
+                                      size_t sz);
+
+extern int of_property_read_string(struct device_node *np,
+                                   const char *propname,
+                                   const char **out_string);
 extern int of_device_is_compatible(const struct device_node *device,
                                    const char *);
 extern int of_device_is_available(const struct device_node *device);
@@ -227,12 +235,34 @@ extern void of_attach_node(struct device_node *);
 extern void of_detach_node(struct device_node *);
 #endif
 
-#else
+#else /* CONFIG_OF */
 
 static inline bool of_have_populated_dt(void)
 {
         return false;
 }
 
+static inline int of_property_read_u32_array(const struct device_node *np,
+                                             const char *propname,
+                                             u32 *out_values, size_t sz)
+{
+        return -ENOSYS;
+}
+
+static inline int of_property_read_string(struct device_node *np,
+                                          const char *propname,
+                                          const char **out_string)
+{
+        return -ENOSYS;
+}
+
 #endif /* CONFIG_OF */
+
+static inline int of_property_read_u32(const struct device_node *np,
+                                       const char *propname,
+                                       u32 *out_value)
+{
+        return of_property_read_u32_array(np, propname, out_value, 1);
+}
+
 #endif /* _LINUX_OF_H */
diff --git a/include/linux/of_address.h b/include/linux/of_address.h
index 2feda6ee6140..3118623c2c1f 100644
--- a/include/linux/of_address.h
+++ b/include/linux/of_address.h
@@ -1,11 +1,16 @@
 #ifndef __OF_ADDRESS_H
 #define __OF_ADDRESS_H
 #include <linux/ioport.h>
+#include <linux/errno.h>
 #include <linux/of.h>
 
 extern u64 of_translate_address(struct device_node *np, const __be32 *addr);
 extern int of_address_to_resource(struct device_node *dev, int index,
                                   struct resource *r);
+extern struct device_node *of_find_matching_node_by_address(
+                                        struct device_node *from,
+                                        const struct of_device_id *matches,
+                                        u64 base_address);
 extern void __iomem *of_iomap(struct device_node *device, int index);
 
 /* Extract an address from a device, returns the region size and
diff --git a/include/linux/of_gpio.h b/include/linux/of_gpio.h
index 6598c04dab01..52280a2b5e63 100644
--- a/include/linux/of_gpio.h
+++ b/include/linux/of_gpio.h
@@ -46,8 +46,9 @@ static inline struct of_mm_gpio_chip *to_of_mm_gpio_chip(struct gpio_chip *gc)
         return container_of(gc, struct of_mm_gpio_chip, gc);
 }
 
-extern int of_get_gpio_flags(struct device_node *np, int index,
-                             enum of_gpio_flags *flags);
+extern int of_get_named_gpio_flags(struct device_node *np,
+                const char *list_name, int index, enum of_gpio_flags *flags);
+
 extern unsigned int of_gpio_count(struct device_node *np);
 
 extern int of_mm_gpiochip_add(struct device_node *np,
@@ -56,12 +57,14 @@ extern int of_mm_gpiochip_add(struct device_node *np,
 extern void of_gpiochip_add(struct gpio_chip *gc);
 extern void of_gpiochip_remove(struct gpio_chip *gc);
 extern struct gpio_chip *of_node_to_gpiochip(struct device_node *np);
+extern int of_gpio_simple_xlate(struct gpio_chip *gc, struct device_node *np,
+                                const void *gpio_spec, u32 *flags);
 
 #else /* CONFIG_OF_GPIO */
 
 /* Drivers may not strictly depend on the GPIO support, so let them link. */
-static inline int of_get_gpio_flags(struct device_node *np, int index,
-                                    enum of_gpio_flags *flags)
+static inline int of_get_named_gpio_flags(struct device_node *np,
+                const char *list_name, int index, enum of_gpio_flags *flags)
 {
         return -ENOSYS;
 }
@@ -71,13 +74,51 @@ static inline unsigned int of_gpio_count(struct device_node *np)
         return 0;
 }
 
+static inline int of_gpio_simple_xlate(struct gpio_chip *gc,
+                                       struct device_node *np,
+                                       const void *gpio_spec, u32 *flags)
+{
+        return -ENOSYS;
+}
+
 static inline void of_gpiochip_add(struct gpio_chip *gc) { }
 static inline void of_gpiochip_remove(struct gpio_chip *gc) { }
 
 #endif /* CONFIG_OF_GPIO */
 
 /**
- * of_get_gpio - Get a GPIO number to use with GPIO API
+ * of_get_gpio_flags() - Get a GPIO number and flags to use with GPIO API
+ * @np:         device node to get GPIO from
+ * @index:      index of the GPIO
+ * @flags:      a flags pointer to fill in
+ *
+ * Returns GPIO number to use with Linux generic GPIO API, or one of the errno
+ * value on the error condition. If @flags is not NULL the function also fills
+ * in flags for the GPIO.
+ */
+static inline int of_get_gpio_flags(struct device_node *np, int index,
+                      enum of_gpio_flags *flags)
+{
+        return of_get_named_gpio_flags(np, "gpios", index, flags);
+}
+
+/**
+ * of_get_named_gpio() - Get a GPIO number to use with GPIO API
+ * @np:         device node to get GPIO from
+ * @propname:   Name of property containing gpio specifier(s)
+ * @index:      index of the GPIO
+ *
+ * Returns GPIO number to use with Linux generic GPIO API, or one of the errno
+ * value on the error condition.
+ */
+static inline int of_get_named_gpio(struct device_node *np,
+                                   const char *propname, int index)
+{
+        return of_get_named_gpio_flags(np, propname, index, NULL);
+}
+
+/**
+ * of_get_gpio() - Get a GPIO number to use with GPIO API
  * @np:         device node to get GPIO from
  * @index:      index of the GPIO
  *
diff --git a/include/linux/of_irq.h b/include/linux/of_irq.h
index e6955f5d1f08..cd2e61ce4e83 100644
--- a/include/linux/of_irq.h
+++ b/include/linux/of_irq.h
@@ -63,6 +63,9 @@ extern int of_irq_map_one(struct device_node *device, int index,
 extern unsigned int irq_create_of_mapping(struct device_node *controller,
                                           const u32 *intspec,
                                           unsigned int intsize);
+#ifdef CONFIG_IRQ_DOMAIN
+extern void irq_dispose_mapping(unsigned int irq);
+#endif
 extern int of_irq_to_resource(struct device_node *dev, int index,
                               struct resource *r);
 extern int of_irq_count(struct device_node *dev);
@@ -70,6 +73,7 @@ extern int of_irq_to_resource_table(struct device_node *dev,
                 struct resource *res, int nr_irqs);
 extern struct device_node *of_irq_find_parent(struct device_node *child);
 
+
 #endif /* CONFIG_OF_IRQ */
 #endif /* CONFIG_OF */
 #endif /* __OF_IRQ_H */
diff --git a/include/linux/of_net.h b/include/linux/of_net.h
index e913081fb52a..f47464188710 100644
--- a/include/linux/of_net.h
+++ b/include/linux/of_net.h
@@ -9,6 +9,7 @@
 
 #ifdef CONFIG_OF_NET
 #include <linux/of.h>
+extern const int of_get_phy_mode(struct device_node *np);
 extern const void *of_get_mac_address(struct device_node *np);
 #endif
 
diff --git a/include/linux/of_pci.h b/include/linux/of_pci.h
index 85a27b650d76..f93e21700d3e 100644
--- a/include/linux/of_pci.h
+++ b/include/linux/of_pci.h
@@ -6,4 +6,9 @@
 struct pci_dev;
 struct of_irq;
 int of_irq_map_pci(struct pci_dev *pdev, struct of_irq *out_irq);
+
+struct device_node;
+struct device_node *of_pci_find_child_device(struct device_node *parent,
+                                             unsigned int devfn);
+
 #endif
diff --git a/include/linux/of_platform.h b/include/linux/of_platform.h
index fb51ae38cea7..5a6f458a4bb7 100644
--- a/include/linux/of_platform.h
+++ b/include/linux/of_platform.h
@@ -20,6 +20,40 @@
 #include <linux/platform_device.h>
 
 /**
+ * struct of_dev_auxdata - lookup table entry for device names & platform_data
+ * @compatible: compatible value of node to match against node
+ * @phys_addr: Start address of registers to match against node
+ * @name: Name to assign for matching nodes
+ * @platform_data: platform_data to assign for matching nodes
+ *
+ * This lookup table allows the caller of of_platform_populate() to override
+ * the names of devices when creating devices from the device tree.  The table
+ * should be terminated with an empty entry.  It also allows the platform_data
+ * pointer to be set.
+ *
+ * The reason for this functionality is that some Linux infrastructure uses
+ * the device name to look up a specific device, but the Linux-specific names
+ * are not encoded into the device tree, so the kernel needs to provide specific
+ * values.
+ *
+ * Note: Using an auxdata lookup table should be considered a last resort when
+ * converting a platform to use the DT.  Normally the automatically generated
+ * device name will not matter, and drivers should obtain data from the device
+ * node instead of from an anonymouns platform_data pointer.
+ */
+struct of_dev_auxdata {
+        char *compatible;
+        resource_size_t phys_addr;
+        char *name;
+        void *platform_data;
+};
+
+/* Macro to simplify populating a lookup table */
+#define OF_DEV_AUXDATA(_compat,_phys,_name,_pdata) \
+        { .compatible = _compat, .phys_addr = _phys, .name = _name, \
+          .platform_data = _pdata }
+
+/**
  * of_platform_driver - Legacy of-aware driver for platform devices.
  *
  * An of_platform_driver driver is attached to a basic platform_device on
@@ -40,6 +74,8 @@ struct of_platform_driver
 #define to_of_platform_driver(drv) \
         container_of(drv,struct of_platform_driver, driver)
 
+extern const struct of_device_id of_default_bus_match_table[];
+
 /* Platform drivers register/unregister */
 extern struct platform_device *of_device_alloc(struct device_node *np,
                                          const char *bus_id,
@@ -55,6 +91,10 @@ extern struct platform_device *of_platform_device_create(struct device_node *np,
 extern int of_platform_bus_probe(struct device_node *root,
                                  const struct of_device_id *matches,
                                  struct device *parent);
+extern int of_platform_populate(struct device_node *root,
+                                const struct of_device_id *matches,
+                                const struct of_dev_auxdata *lookup,
+                                struct device *parent);
 #endif /* !CONFIG_SPARC */
 
 #endif /* CONFIG_OF_DEVICE */
diff --git a/include/linux/oom.h b/include/linux/oom.h
index 4952fb874ad3..13b7b02e599a 100644
--- a/include/linux/oom.h
+++ b/include/linux/oom.h
@@ -64,10 +64,6 @@ static inline void oom_killer_enable(void)
         oom_killer_disabled = false;
 }
 
-/* The badness from the OOM killer */
-extern unsigned long badness(struct task_struct *p, struct mem_cgroup *mem,
-                      const nodemask_t *nodemask, unsigned long uptime);
-
 extern struct task_struct *find_lock_task_mm(struct task_struct *p);
 
 /* sysctls */
diff --git a/include/linux/opp.h b/include/linux/opp.h
index 5449945d589f..7020e9736fc5 100644
--- a/include/linux/opp.h
+++ b/include/linux/opp.h
@@ -94,12 +94,20 @@ static inline int opp_disable(struct device *dev, unsigned long freq)
 #if defined(CONFIG_CPU_FREQ) && defined(CONFIG_PM_OPP)
 int opp_init_cpufreq_table(struct device *dev,
                             struct cpufreq_frequency_table **table);
+void opp_free_cpufreq_table(struct device *dev,
+                                struct cpufreq_frequency_table **table);
 #else
 static inline int opp_init_cpufreq_table(struct device *dev,
                             struct cpufreq_frequency_table **table)
 {
         return -EINVAL;
 }
+
+static inline
+void opp_free_cpufreq_table(struct device *dev,
+                                struct cpufreq_frequency_table **table)
+{
+}
 #endif          /* CONFIG_CPU_FREQ */
 
 #endif          /* __LINUX_OPP_H__ */
diff --git a/include/linux/oprofile.h b/include/linux/oprofile.h
index 7f5cfd3b37dd..49c8727eeb57 100644
--- a/include/linux/oprofile.h
+++ b/include/linux/oprofile.h
@@ -18,7 +18,7 @@
 #include <linux/init.h>
 #include <linux/errno.h>
 #include <linux/printk.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
  
 /* Each escaped entry is prefixed by ESCAPE_CODE
  * then one of the following codes, then the
diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h
index 6081493db68f..e90a673be67e 100644
--- a/include/linux/page-flags.h
+++ b/include/linux/page-flags.h
@@ -124,9 +124,6 @@ enum pageflags {
 
         /* SLOB */
         PG_slob_free = PG_private,
-
-        /* SLUB */
-        PG_slub_frozen = PG_active,
 };
 
 #ifndef __GENERATING_BOUNDS_H
@@ -135,7 +132,7 @@ enum pageflags {
  * Macros to create function definitions for page flags
  */
 #define TESTPAGEFLAG(uname, lname)                                      \
-static inline int Page##uname(struct page *page)                        \
+static inline int Page##uname(const struct page *page)                  \
                         { return test_bit(PG_##lname, &page->flags); }
 
 #define SETPAGEFLAG(uname, lname)                                       \
@@ -173,7 +170,7 @@ static inline int __TestClearPage##uname(struct page *page)		\
         __SETPAGEFLAG(uname, lname)  __CLEARPAGEFLAG(uname, lname)
 
 #define PAGEFLAG_FALSE(uname)                                           \
-static inline int Page##uname(struct page *page)                        \
+static inline int Page##uname(const struct page *page)                  \
                         { return 0; }
 
 #define TESTSCFLAG(uname, lname)                                        \
@@ -212,8 +209,6 @@ PAGEFLAG(SwapBacked, swapbacked) __CLEARPAGEFLAG(SwapBacked, swapbacked)
 
 __PAGEFLAG(SlobFree, slob_free)
 
-__PAGEFLAG(SlubFrozen, slub_frozen)
-
 /*
  * Private page markings that may be used by the filesystem that owns the page
  * for its own purposes.
diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
index 716875e53520..cfaaa6949b8b 100644
--- a/include/linux/pagemap.h
+++ b/include/linux/pagemap.h
@@ -134,7 +134,7 @@ static inline int page_cache_get_speculative(struct page *page)
         VM_BUG_ON(in_interrupt());
 
 #if !defined(CONFIG_SMP) && defined(CONFIG_TREE_RCU)
-# ifdef CONFIG_PREEMPT
+# ifdef CONFIG_PREEMPT_COUNT
         VM_BUG_ON(!in_atomic());
 # endif
         /*
@@ -172,7 +172,7 @@ static inline int page_cache_add_speculative(struct page *page, int count)
         VM_BUG_ON(in_interrupt());
 
 #if !defined(CONFIG_SMP) && defined(CONFIG_TREE_RCU)
-# ifdef CONFIG_PREEMPT
+# ifdef CONFIG_PREEMPT_COUNT
         VM_BUG_ON(!in_atomic());
 # endif
         VM_BUG_ON(page_count(page) == 0);
@@ -255,26 +255,24 @@ static inline struct page *grab_cache_page(struct address_space *mapping,
 extern struct page * grab_cache_page_nowait(struct address_space *mapping,
                                 pgoff_t index);
 extern struct page * read_cache_page_async(struct address_space *mapping,
-                                pgoff_t index, filler_t *filler,
-                                void *data);
+                                pgoff_t index, filler_t *filler, void *data);
 extern struct page * read_cache_page(struct address_space *mapping,
-                                pgoff_t index, filler_t *filler,
-                                void *data);
+                                pgoff_t index, filler_t *filler, void *data);
 extern struct page * read_cache_page_gfp(struct address_space *mapping,
                                 pgoff_t index, gfp_t gfp_mask);
 extern int read_cache_pages(struct address_space *mapping,
                 struct list_head *pages, filler_t *filler, void *data);
 
 static inline struct page *read_mapping_page_async(
-                                                struct address_space *mapping,
-                                                     pgoff_t index, void *data)
+                                struct address_space *mapping,
+                                pgoff_t index, void *data)
 {
         filler_t *filler = (filler_t *)mapping->a_ops->readpage;
         return read_cache_page_async(mapping, index, filler, data);
 }
 
 static inline struct page *read_mapping_page(struct address_space *mapping,
-                                             pgoff_t index, void *data)
+                                pgoff_t index, void *data)
 {
         filler_t *filler = (filler_t *)mapping->a_ops->readpage;
         return read_cache_page(mapping, index, filler, data);
diff --git a/include/linux/pci.h b/include/linux/pci.h
index c446b5ca2d38..f27893b3b724 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -49,7 +49,7 @@
 #include <linux/compiler.h>
 #include <linux/errno.h>
 #include <linux/kobject.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <linux/device.h>
 #include <linux/io.h>
 #include <linux/irqreturn.h>
@@ -843,8 +843,8 @@ void pci_enable_ido(struct pci_dev *dev, unsigned long type);
 void pci_disable_ido(struct pci_dev *dev, unsigned long type);
 
 enum pci_obff_signal_type {
-        PCI_EXP_OBFF_SIGNAL_L0,
-        PCI_EXP_OBFF_SIGNAL_ALWAYS,
+        PCI_EXP_OBFF_SIGNAL_L0 = 0,
+        PCI_EXP_OBFF_SIGNAL_ALWAYS = 1,
 };
 int pci_enable_obff(struct pci_dev *dev, enum pci_obff_signal_type);
 void pci_disable_obff(struct pci_dev *dev);
@@ -879,7 +879,7 @@ void pdev_enable_device(struct pci_dev *);
 void pdev_sort_resources(struct pci_dev *, struct resource_list *);
 int pci_enable_resources(struct pci_dev *, int mask);
 void pci_fixup_irqs(u8 (*)(struct pci_dev *, u8 *),
-                    int (*)(struct pci_dev *, u8, u8));
+                    int (*)(const struct pci_dev *, u8, u8));
 #define HAVE_PCI_REQ_REGIONS    2
 int __must_check pci_request_regions(struct pci_dev *, const char *);
 int __must_check pci_request_regions_exclusive(struct pci_dev *, const char *);
@@ -1589,5 +1589,44 @@ int pci_vpd_find_tag(const u8 *buf, unsigned int off, unsigned int len, u8 rdt);
 int pci_vpd_find_info_keyword(const u8 *buf, unsigned int off,
                               unsigned int len, const char *kw);
 
+/* PCI <-> OF binding helpers */
+#ifdef CONFIG_OF
+struct device_node;
+extern void pci_set_of_node(struct pci_dev *dev);
+extern void pci_release_of_node(struct pci_dev *dev);
+extern void pci_set_bus_of_node(struct pci_bus *bus);
+extern void pci_release_bus_of_node(struct pci_bus *bus);
+
+/* Arch may override this (weak) */
+extern struct device_node * __weak pcibios_get_phb_of_node(struct pci_bus *bus);
+
+static inline struct device_node *pci_device_to_OF_node(struct pci_dev *pdev)
+{
+        return pdev ? pdev->dev.of_node : NULL;
+}
+
+static inline struct device_node *pci_bus_to_OF_node(struct pci_bus *bus)
+{
+        return bus ? bus->dev.of_node : NULL;
+}
+
+#else /* CONFIG_OF */
+static inline void pci_set_of_node(struct pci_dev *dev) { }
+static inline void pci_release_of_node(struct pci_dev *dev) { }
+static inline void pci_set_bus_of_node(struct pci_bus *bus) { }
+static inline void pci_release_bus_of_node(struct pci_bus *bus) { }
+#endif  /* CONFIG_OF */
+
+/**
+ * pci_find_upstream_pcie_bridge - find upstream PCIe-to-PCI bridge of a device
+ * @pdev: the PCI device
+ *
+ * if the device is PCIE, return NULL
+ * if the device isn't connected to a PCIe bridge (that is its parent is a
+ * legacy PCI bridge and the bridge is directly connected to bus 0), return its
+ * parent
+ */
+struct pci_dev *pci_find_upstream_pcie_bridge(struct pci_dev *pdev);
+
 #endif /* __KERNEL__ */
 #endif /* LINUX_PCI_H */
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index a311008af5e1..ae96bbe54518 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -1308,6 +1308,7 @@
 #define PCI_SUBDEVICE_ID_CREATIVE_SB08801       0x0041
 #define PCI_SUBDEVICE_ID_CREATIVE_SB08802       0x0042
 #define PCI_SUBDEVICE_ID_CREATIVE_SB08803       0x0043
+#define PCI_SUBDEVICE_ID_CREATIVE_SB1270        0x0062
 #define PCI_SUBDEVICE_ID_CREATIVE_HENDRIX       0x6000
 
 #define PCI_VENDOR_ID_ECTIVA            0x1102 /* duplicate: CREATIVE */
@@ -1537,6 +1538,7 @@
 #define PCI_DEVICE_ID_RICOH_RL5C476     0x0476
 #define PCI_DEVICE_ID_RICOH_RL5C478     0x0478
 #define PCI_DEVICE_ID_RICOH_R5C822      0x0822
+#define PCI_DEVICE_ID_RICOH_R5CE823     0xe823
 #define PCI_DEVICE_ID_RICOH_R5C832      0x0832
 #define PCI_DEVICE_ID_RICOH_R5C843      0x0843
 
@@ -2102,6 +2104,9 @@
 #define PCI_DEVICE_ID_TIGON3_5761E      0x1680
 #define PCI_DEVICE_ID_TIGON3_5761       0x1681
 #define PCI_DEVICE_ID_TIGON3_5764       0x1684
+#define PCI_DEVICE_ID_NX2_57800         0x168a
+#define PCI_DEVICE_ID_NX2_57840         0x168d
+#define PCI_DEVICE_ID_NX2_57810         0x168e
 #define PCI_DEVICE_ID_TIGON3_5787M      0x1693
 #define PCI_DEVICE_ID_TIGON3_5782       0x1696
 #define PCI_DEVICE_ID_TIGON3_5784       0x1698
@@ -2109,11 +2114,17 @@
 #define PCI_DEVICE_ID_TIGON3_5787       0x169b
 #define PCI_DEVICE_ID_TIGON3_5788       0x169c
 #define PCI_DEVICE_ID_TIGON3_5789       0x169d
+#define PCI_DEVICE_ID_NX2_57800_MF      0x16a5
 #define PCI_DEVICE_ID_TIGON3_5702X      0x16a6
 #define PCI_DEVICE_ID_TIGON3_5703X      0x16a7
 #define PCI_DEVICE_ID_TIGON3_5704S      0x16a8
+#define PCI_DEVICE_ID_NX2_57800_VF      0x16a9
 #define PCI_DEVICE_ID_NX2_5706S         0x16aa
+#define PCI_DEVICE_ID_NX2_57840_MF      0x16ab
 #define PCI_DEVICE_ID_NX2_5708S         0x16ac
+#define PCI_DEVICE_ID_NX2_57840_VF      0x16ad
+#define PCI_DEVICE_ID_NX2_57810_MF      0x16ae
+#define PCI_DEVICE_ID_NX2_57810_VF      0x16af
 #define PCI_DEVICE_ID_TIGON3_5702A3     0x16c6
 #define PCI_DEVICE_ID_TIGON3_5703A3     0x16c7
 #define PCI_DEVICE_ID_TIGON3_5781       0x16dd
@@ -2698,6 +2709,16 @@
 #define PCI_DEVICE_ID_INTEL_ICH10_5     0x3a60
 #define PCI_DEVICE_ID_INTEL_5_3400_SERIES_LPC_MIN       0x3b00
 #define PCI_DEVICE_ID_INTEL_5_3400_SERIES_LPC_MAX       0x3b1f
+#define PCI_DEVICE_ID_INTEL_IOAT_SNB0   0x3c20
+#define PCI_DEVICE_ID_INTEL_IOAT_SNB1   0x3c21
+#define PCI_DEVICE_ID_INTEL_IOAT_SNB2   0x3c22
+#define PCI_DEVICE_ID_INTEL_IOAT_SNB3   0x3c23
+#define PCI_DEVICE_ID_INTEL_IOAT_SNB4   0x3c24
+#define PCI_DEVICE_ID_INTEL_IOAT_SNB5   0x3c25
+#define PCI_DEVICE_ID_INTEL_IOAT_SNB6   0x3c26
+#define PCI_DEVICE_ID_INTEL_IOAT_SNB7   0x3c27
+#define PCI_DEVICE_ID_INTEL_IOAT_SNB8   0x3c2e
+#define PCI_DEVICE_ID_INTEL_IOAT_SNB9   0x3c2f
 #define PCI_DEVICE_ID_INTEL_IOAT_SNB    0x402f
 #define PCI_DEVICE_ID_INTEL_5100_16     0x65f0
 #define PCI_DEVICE_ID_INTEL_5100_21     0x65f5
@@ -2821,7 +2842,11 @@
 #define PCI_DEVICE_ID_NETMOS_9845       0x9845
 #define PCI_DEVICE_ID_NETMOS_9855       0x9855
 #define PCI_DEVICE_ID_NETMOS_9865       0x9865
+#define PCI_DEVICE_ID_NETMOS_9900       0x9900
 #define PCI_DEVICE_ID_NETMOS_9901       0x9901
+#define PCI_DEVICE_ID_NETMOS_9904       0x9904
+#define PCI_DEVICE_ID_NETMOS_9912       0x9912
+#define PCI_DEVICE_ID_NETMOS_9922       0x9922
 
 #define PCI_VENDOR_ID_3COM_2            0xa727
 
diff --git a/include/linux/percpu.h b/include/linux/percpu.h
index 8b97308e65df..9ca008f0c542 100644
--- a/include/linux/percpu.h
+++ b/include/linux/percpu.h
@@ -259,6 +259,9 @@ extern void __bad_size_call_parameter(void);
  * Special handling for cmpxchg_double.  cmpxchg_double is passed two
  * percpu variables.  The first has to be aligned to a double word
  * boundary and the second has to follow directly thereafter.
+ * We enforce this on all architectures even if they don't support
+ * a double cmpxchg instruction, since it's a cheap requirement, and it
+ * avoids breaking the requirement for architectures with the instruction.
  */
 #define __pcpu_double_call_return_bool(stem, pcp1, pcp2, ...)           \
 ({                                                                      \
diff --git a/include/linux/perf_event.h b/include/linux/perf_event.h
index 3412684ce5d5..245bafdafd5e 100644
--- a/include/linux/perf_event.h
+++ b/include/linux/perf_event.h
@@ -61,7 +61,7 @@ enum perf_hw_id {
 /*
  * Generalized hardware cache events:
  *
- *       { L1-D, L1-I, LLC, ITLB, DTLB, BPU } x
+ *       { L1-D, L1-I, LLC, ITLB, DTLB, BPU, NODE } x
  *       { read, write, prefetch } x
  *       { accesses, misses }
  */
@@ -72,6 +72,7 @@ enum perf_hw_cache_id {
         PERF_COUNT_HW_CACHE_DTLB                = 3,
         PERF_COUNT_HW_CACHE_ITLB                = 4,
         PERF_COUNT_HW_CACHE_BPU                 = 5,
+        PERF_COUNT_HW_CACHE_NODE                = 6,
 
         PERF_COUNT_HW_CACHE_MAX,                /* non-ABI */
 };
@@ -137,14 +138,14 @@ enum perf_event_sample_format {
  *
  * struct read_format {
  *      { u64           value;
- *        { u64         time_enabled; } && PERF_FORMAT_ENABLED
- *        { u64         time_running; } && PERF_FORMAT_RUNNING
+ *        { u64         time_enabled; } && PERF_FORMAT_TOTAL_TIME_ENABLED
+ *        { u64         time_running; } && PERF_FORMAT_TOTAL_TIME_RUNNING
  *        { u64         id;           } && PERF_FORMAT_ID
  *      } && !PERF_FORMAT_GROUP
  *
  *      { u64           nr;
- *        { u64         time_enabled; } && PERF_FORMAT_ENABLED
- *        { u64         time_running; } && PERF_FORMAT_RUNNING
+ *        { u64         time_enabled; } && PERF_FORMAT_TOTAL_TIME_ENABLED
+ *        { u64         time_running; } && PERF_FORMAT_TOTAL_TIME_RUNNING
  *        { u64         value;
  *          { u64       id;           } && PERF_FORMAT_ID
  *        }             cntr[nr];
@@ -508,7 +509,7 @@ struct perf_guest_info_callbacks {
 #include <linux/cpu.h>
 #include <linux/irq_work.h>
 #include <linux/jump_label.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <asm/local.h>
 
 #define PERF_MAX_STACK_DEPTH            255
@@ -536,6 +537,16 @@ struct perf_branch_stack {
 
 struct task_struct;
 
+/*
+ * extra PMU register associated with an event
+ */
+struct hw_perf_event_extra {
+        u64             config; /* register value */
+        unsigned int    reg;    /* register address or index */
+        int             alloc;  /* extra register already allocated */
+        int             idx;    /* index in shared_regs->regs[] */
+};
+
 /**
  * struct hw_perf_event - performance event hardware details:
  */
@@ -549,9 +560,7 @@ struct hw_perf_event {
                         unsigned long   event_base;
                         int             idx;
                         int             last_cpu;
-                        unsigned int    extra_reg;
-                        u64             extra_config;
-                        int             extra_alloc;
+                        struct hw_perf_event_extra extra_reg;
                 };
                 struct { /* software */
                         struct hrtimer  hrtimer;
@@ -680,36 +689,9 @@ enum perf_event_active_state {
 };
 
 struct file;
-
-#define PERF_BUFFER_WRITABLE            0x01
-
-struct perf_buffer {
-        atomic_t                        refcount;
-        struct rcu_head                 rcu_head;
-#ifdef CONFIG_PERF_USE_VMALLOC
-        struct work_struct              work;
-        int                             page_order;     /* allocation order  */
-#endif
-        int                             nr_pages;       /* nr of data pages  */
-        int                             writable;       /* are we writable   */
-
-        atomic_t                        poll;           /* POLL_ for wakeups */
-
-        local_t                         head;           /* write position    */
-        local_t                         nest;           /* nested writers    */
-        local_t                         events;         /* event limit       */
-        local_t                         wakeup;         /* wakeup stamp      */
-        local_t                         lost;           /* nr records lost   */
-
-        long                            watermark;      /* wakeup watermark  */
-
-        struct perf_event_mmap_page     *user_page;
-        void                            *data_pages[0];
-};
-
 struct perf_sample_data;
 
-typedef void (*perf_overflow_handler_t)(struct perf_event *, int,
+typedef void (*perf_overflow_handler_t)(struct perf_event *,
                                         struct perf_sample_data *,
                                         struct pt_regs *regs);
 
@@ -745,6 +727,8 @@ struct perf_cgroup {
 };
 #endif
 
+struct ring_buffer;
+
 /**
  * struct perf_event - performance event kernel representation:
  */
@@ -834,7 +818,7 @@ struct perf_event {
         atomic_t                        mmap_count;
         int                             mmap_locked;
         struct user_struct              *mmap_user;
-        struct perf_buffer              *buffer;
+        struct ring_buffer              *rb;
 
         /* poll related */
         wait_queue_head_t               waitq;
@@ -855,6 +839,7 @@ struct perf_event {
         u64                             id;
 
         perf_overflow_handler_t         overflow_handler;
+        void                            *overflow_handler_context;
 
 #ifdef CONFIG_EVENT_TRACING
         struct ftrace_event_call        *tp_event;
@@ -919,8 +904,8 @@ struct perf_event_context {
         u64                             parent_gen;
         u64                             generation;
         int                             pin_count;
-        struct rcu_head                 rcu_head;
         int                             nr_cgroups; /* cgroup events present */
+        struct rcu_head                 rcu_head;
 };
 
 /*
@@ -945,13 +930,11 @@ struct perf_cpu_context {
 
 struct perf_output_handle {
         struct perf_event               *event;
-        struct perf_buffer              *buffer;
+        struct ring_buffer              *rb;
         unsigned long                   wakeup;
         unsigned long                   size;
         void                            *addr;
         int                             page;
-        int                             nmi;
-        int                             sample;
 };
 
 #ifdef CONFIG_PERF_EVENTS
@@ -972,13 +955,15 @@ extern void perf_pmu_disable(struct pmu *pmu);
 extern void perf_pmu_enable(struct pmu *pmu);
 extern int perf_event_task_disable(void);
 extern int perf_event_task_enable(void);
+extern int perf_event_refresh(struct perf_event *event, int refresh);
 extern void perf_event_update_userpage(struct perf_event *event);
 extern int perf_event_release_kernel(struct perf_event *event);
 extern struct perf_event *
 perf_event_create_kernel_counter(struct perf_event_attr *attr,
                                 int cpu,
                                 struct task_struct *task,
-                                perf_overflow_handler_t callback);
+                                perf_overflow_handler_t callback,
+                                void *context);
 extern u64 perf_event_read_value(struct perf_event *event,
                                  u64 *enabled, u64 *running);
 
@@ -1018,7 +1003,7 @@ extern void perf_prepare_sample(struct perf_event_header *header,
                                 struct perf_event *event,
                                 struct pt_regs *regs);
 
-extern int perf_event_overflow(struct perf_event *event, int nmi,
+extern int perf_event_overflow(struct perf_event *event,
                                  struct perf_sample_data *data,
                                  struct pt_regs *regs);
 
@@ -1037,7 +1022,7 @@ static inline int is_software_event(struct perf_event *event)
 
 extern struct jump_label_key perf_swevent_enabled[PERF_COUNT_SW_MAX];
 
-extern void __perf_sw_event(u32, u64, int, struct pt_regs *, u64);
+extern void __perf_sw_event(u32, u64, struct pt_regs *, u64);
 
 #ifndef perf_arch_fetch_caller_regs
 static inline void perf_arch_fetch_caller_regs(struct pt_regs *regs, unsigned long ip) { }
@@ -1059,7 +1044,7 @@ static inline void perf_fetch_caller_regs(struct pt_regs *regs)
 }
 
 static __always_inline void
-perf_sw_event(u32 event_id, u64 nr, int nmi, struct pt_regs *regs, u64 addr)
+perf_sw_event(u32 event_id, u64 nr, struct pt_regs *regs, u64 addr)
 {
         struct pt_regs hot_regs;
 
@@ -1068,7 +1053,7 @@ perf_sw_event(u32 event_id, u64 nr, int nmi, struct pt_regs *regs, u64 addr)
                         perf_fetch_caller_regs(&hot_regs);
                         regs = &hot_regs;
                 }
-                __perf_sw_event(event_id, nr, nmi, regs, addr);
+                __perf_sw_event(event_id, nr, regs, addr);
         }
 }
 
@@ -1082,7 +1067,7 @@ static inline void perf_event_task_sched_in(struct task_struct *task)
 
 static inline void perf_event_task_sched_out(struct task_struct *task, struct task_struct *next)
 {
-        perf_sw_event(PERF_COUNT_SW_CONTEXT_SWITCHES, 1, 1, NULL, 0);
+        perf_sw_event(PERF_COUNT_SW_CONTEXT_SWITCHES, 1, NULL, 0);
 
         __perf_event_task_sched_out(task, next);
 }
@@ -1143,8 +1128,7 @@ extern void perf_bp_event(struct perf_event *event, void *data);
 #endif
 
 extern int perf_output_begin(struct perf_output_handle *handle,
-                             struct perf_event *event, unsigned int size,
-                             int nmi, int sample);
+                             struct perf_event *event, unsigned int size);
 extern void perf_output_end(struct perf_output_handle *handle);
 extern void perf_output_copy(struct perf_output_handle *handle,
                              const void *buf, unsigned int len);
@@ -1166,10 +1150,13 @@ static inline void perf_event_delayed_put(struct task_struct *task)	{ }
 static inline void perf_event_print_debug(void)                         { }
 static inline int perf_event_task_disable(void)                         { return -EINVAL; }
 static inline int perf_event_task_enable(void)                          { return -EINVAL; }
+static inline int perf_event_refresh(struct perf_event *event, int refresh)
+{
+        return -EINVAL;
+}
 
 static inline void
-perf_sw_event(u32 event_id, u64 nr, int nmi,
-                     struct pt_regs *regs, u64 addr)                    { }
+perf_sw_event(u32 event_id, u64 nr, struct pt_regs *regs, u64 addr)     { }
 static inline void
 perf_bp_event(struct perf_event *event, void *data)                     { }
 
diff --git a/include/linux/phy.h b/include/linux/phy.h
index 7da5fa845959..54fc4138955f 100644
--- a/include/linux/phy.h
+++ b/include/linux/phy.h
@@ -26,7 +26,7 @@
 #include <linux/workqueue.h>
 #include <linux/mod_devicetable.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 #define PHY_BASIC_FEATURES      (SUPPORTED_10baseT_Half | \
                                  SUPPORTED_10baseT_Full | \
@@ -53,6 +53,7 @@
 
 /* Interface Mode definitions */
 typedef enum {
+        PHY_INTERFACE_MODE_NA,
         PHY_INTERFACE_MODE_MII,
         PHY_INTERFACE_MODE_GMII,
         PHY_INTERFACE_MODE_SGMII,
@@ -62,7 +63,8 @@ typedef enum {
         PHY_INTERFACE_MODE_RGMII_ID,
         PHY_INTERFACE_MODE_RGMII_RXID,
         PHY_INTERFACE_MODE_RGMII_TXID,
-        PHY_INTERFACE_MODE_RTBI
+        PHY_INTERFACE_MODE_RTBI,
+        PHY_INTERFACE_MODE_SMII,
 } phy_interface_t;
 
 
diff --git a/include/linux/platform_data/fsa9480.h b/include/linux/platform_data/fsa9480.h
new file mode 100644
index 000000000000..72dddcb4bed1
--- /dev/null
+++ b/include/linux/platform_data/fsa9480.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2010 Samsung Electronics
+ * Minkyu Kang <mk7.kang@samsung.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 _FSA9480_H_
+#define _FSA9480_H_
+
+#define FSA9480_ATTACHED        1
+#define FSA9480_DETACHED        0
+
+struct fsa9480_platform_data {
+        void (*cfg_gpio) (void);
+        void (*usb_cb) (u8 attached);
+        void (*uart_cb) (u8 attached);
+        void (*charger_cb) (u8 attached);
+        void (*jig_cb) (u8 attached);
+        void (*reset_cb) (void);
+        void (*usb_power) (u8 on);
+        int wakeup;
+};
+
+#endif /* _FSA9480_H_ */
diff --git a/include/linux/platform_data/ntc_thermistor.h b/include/linux/platform_data/ntc_thermistor.h
new file mode 100644
index 000000000000..abd286215279
--- /dev/null
+++ b/include/linux/platform_data/ntc_thermistor.h
@@ -0,0 +1,53 @@
+/*
+ * ntc_thermistor.h - NTC Thermistors
+ *
+ *  Copyright (C) 2010 Samsung Electronics
+ *  MyungJoo Ham <myungjoo.ham@samsung.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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#ifndef _LINUX_NTC_H
+#define _LINUX_NTC_H
+
+enum ntc_thermistor_type {
+        TYPE_NCPXXWB473,
+        TYPE_NCPXXWL333,
+};
+
+struct ntc_thermistor_platform_data {
+        /*
+         * One (not both) of read_uV and read_ohm should be provided and only
+         * one of the two should be provided.
+         * Both functions should return negative value for an error case.
+         *
+         * pullup_uV, pullup_ohm, pulldown_ohm, and connect are required to use
+         * read_uV()
+         *
+         * How to setup pullup_ohm, pulldown_ohm, and connect is
+         * described at Documentation/hwmon/ntc
+         *
+         * pullup/down_ohm: 0 for infinite / not-connected
+         */
+        int (*read_uV)(void);
+        unsigned int pullup_uV;
+
+        unsigned int pullup_ohm;
+        unsigned int pulldown_ohm;
+        enum { NTC_CONNECTED_POSITIVE, NTC_CONNECTED_GROUND } connect;
+
+        int (*read_ohm)(void);
+};
+
+#endif /* _LINUX_NTC_H */
diff --git a/include/linux/platform_data/pxa_sdhci.h b/include/linux/platform_data/pxa_sdhci.h
new file mode 100644
index 000000000000..51ad0995abac
--- /dev/null
+++ b/include/linux/platform_data/pxa_sdhci.h
@@ -0,0 +1,60 @@
+/*
+ * include/linux/platform_data/pxa_sdhci.h
+ *
+ * Copyright 2010 Marvell
+ *      Zhangfei Gao <zhangfei.gao@marvell.com>
+ *
+ * PXA Platform - SDHCI platform data definitions
+ *
+ * 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 _PXA_SDHCI_H_
+#define _PXA_SDHCI_H_
+
+/* pxa specific flag */
+/* Require clock free running */
+#define PXA_FLAG_ENABLE_CLOCK_GATING (1<<0)
+/* card always wired to host, like on-chip emmc */
+#define PXA_FLAG_CARD_PERMANENT (1<<1)
+/* Board design supports 8-bit data on SD/SDIO BUS */
+#define PXA_FLAG_SD_8_BIT_CAPABLE_SLOT (1<<2)
+
+/*
+ * struct pxa_sdhci_platdata() - Platform device data for PXA SDHCI
+ * @flags: flags for platform requirement
+ * @clk_delay_cycles:
+ *      mmp2: each step is roughly 100ps, 5bits width
+ *      pxa910: each step is 1ns, 4bits width
+ * @clk_delay_sel: select clk_delay, used on pxa910
+ *      0: choose feedback clk
+ *      1: choose feedback clk + delay value
+ *      2: choose internal clk
+ * @clk_delay_enable: enable clk_delay or not, used on pxa910
+ * @ext_cd_gpio: gpio pin used for external CD line
+ * @ext_cd_gpio_invert: invert values for external CD gpio line
+ * @max_speed: the maximum speed supported
+ * @host_caps: Standard MMC host capabilities bit field.
+ * @quirks: quirks of platfrom
+ * @pm_caps: pm_caps of platfrom
+ */
+struct sdhci_pxa_platdata {
+        unsigned int    flags;
+        unsigned int    clk_delay_cycles;
+        unsigned int    clk_delay_sel;
+        bool            clk_delay_enable;
+        unsigned int    ext_cd_gpio;
+        bool            ext_cd_gpio_invert;
+        unsigned int    max_speed;
+        unsigned int    host_caps;
+        unsigned int    quirks;
+        unsigned int    pm_caps;
+};
+
+struct sdhci_pxa {
+        u8      clk_enable;
+        u8      power_mode;
+};
+#endif /* _PXA_SDHCI_H_ */
diff --git a/include/linux/platform_device.h b/include/linux/platform_device.h
index ede1a80e3358..27bb05aae70d 100644
--- a/include/linux/platform_device.h
+++ b/include/linux/platform_device.h
@@ -42,6 +42,7 @@ extern void platform_device_unregister(struct platform_device *);
 extern struct bus_type platform_bus_type;
 extern struct device platform_bus;
 
+extern void arch_setup_pdev_archdata(struct platform_device *);
 extern struct resource *platform_get_resource(struct platform_device *, unsigned int, unsigned int);
 extern int platform_get_irq(struct platform_device *, unsigned int);
 extern struct resource *platform_get_resource_byname(struct platform_device *, unsigned int, const char *);
diff --git a/include/linux/plist.h b/include/linux/plist.h
index c9b9f322c8d8..aa0fb390bd29 100644
--- a/include/linux/plist.h
+++ b/include/linux/plist.h
@@ -77,14 +77,9 @@
 
 #include <linux/kernel.h>
 #include <linux/list.h>
-#include <linux/spinlock_types.h>
 
 struct plist_head {
         struct list_head node_list;
-#ifdef CONFIG_DEBUG_PI_LIST
-        raw_spinlock_t *rawlock;
-        spinlock_t *spinlock;
-#endif
 };
 
 struct plist_node {
@@ -93,37 +88,13 @@ struct plist_node {
         struct list_head        node_list;
 };
 
-#ifdef CONFIG_DEBUG_PI_LIST
-# define PLIST_HEAD_LOCK_INIT(_lock)            .spinlock = _lock
-# define PLIST_HEAD_LOCK_INIT_RAW(_lock)        .rawlock = _lock
-#else
-# define PLIST_HEAD_LOCK_INIT(_lock)
-# define PLIST_HEAD_LOCK_INIT_RAW(_lock)
-#endif
-
-#define _PLIST_HEAD_INIT(head)                          \
-        .node_list = LIST_HEAD_INIT((head).node_list)
-
 /**
  * PLIST_HEAD_INIT - static struct plist_head initializer
  * @head:       struct plist_head variable name
- * @_lock:      lock to initialize for this list
- */
-#define PLIST_HEAD_INIT(head, _lock)                    \
-{                                                       \
-        _PLIST_HEAD_INIT(head),                         \
-        PLIST_HEAD_LOCK_INIT(&(_lock))                  \
-}
-
-/**
- * PLIST_HEAD_INIT_RAW - static struct plist_head initializer
- * @head:       struct plist_head variable name
- * @_lock:      lock to initialize for this list
  */
-#define PLIST_HEAD_INIT_RAW(head, _lock)                \
+#define PLIST_HEAD_INIT(head)                           \
 {                                                       \
-        _PLIST_HEAD_INIT(head),                         \
-        PLIST_HEAD_LOCK_INIT_RAW(&(_lock))              \
+        .node_list = LIST_HEAD_INIT((head).node_list)   \
 }
 
 /**
@@ -141,31 +112,11 @@ struct plist_node {
 /**
  * plist_head_init - dynamic struct plist_head initializer
  * @head:       &struct plist_head pointer
- * @lock:       spinlock protecting the list (debugging)
  */
 static inline void
-plist_head_init(struct plist_head *head, spinlock_t *lock)
+plist_head_init(struct plist_head *head)
 {
         INIT_LIST_HEAD(&head->node_list);
-#ifdef CONFIG_DEBUG_PI_LIST
-        head->spinlock = lock;
-        head->rawlock = NULL;
-#endif
-}
-
-/**
- * plist_head_init_raw - dynamic struct plist_head initializer
- * @head:       &struct plist_head pointer
- * @lock:       raw_spinlock protecting the list (debugging)
- */
-static inline void
-plist_head_init_raw(struct plist_head *head, raw_spinlock_t *lock)
-{
-        INIT_LIST_HEAD(&head->node_list);
-#ifdef CONFIG_DEBUG_PI_LIST
-        head->rawlock = lock;
-        head->spinlock = NULL;
-#endif
 }
 
 /**
diff --git a/include/linux/pm.h b/include/linux/pm.h
index 3160648ccdda..f7c84c9abd30 100644
--- a/include/linux/pm.h
+++ b/include/linux/pm.h
@@ -425,7 +425,8 @@ struct dev_pm_info {
         pm_message_t            power_state;
         unsigned int            can_wakeup:1;
         unsigned int            async_suspend:1;
-        unsigned int            in_suspend:1;   /* Owned by the PM core */
+        bool                    is_prepared:1;  /* Owned by the PM core */
+        bool                    is_suspended:1; /* Ditto */
         spinlock_t              lock;
 #ifdef CONFIG_PM_SLEEP
         struct list_head        entry;
@@ -460,8 +461,8 @@ struct dev_pm_info {
         unsigned long           active_jiffies;
         unsigned long           suspended_jiffies;
         unsigned long           accounting_timestamp;
-        void                    *subsys_data;  /* Owned by the subsystem. */
 #endif
+        void                    *subsys_data;  /* Owned by the subsystem. */
 };
 
 extern void update_pm_runtime_accounting(struct device *dev);
@@ -471,7 +472,7 @@ extern void update_pm_runtime_accounting(struct device *dev);
  * hibernation, system resume and during runtime PM transitions along with
  * subsystem-level and driver-level callbacks.
  */
-struct dev_power_domain {
+struct dev_pm_domain {
         struct dev_pm_ops       ops;
 };
 
@@ -552,11 +553,17 @@ extern void __suspend_report_result(const char *function, void *fn, int ret);
 extern int device_pm_wait_for_dev(struct device *sub, struct device *dev);
 
 extern int pm_generic_prepare(struct device *dev);
+extern int pm_generic_suspend_noirq(struct device *dev);
 extern int pm_generic_suspend(struct device *dev);
+extern int pm_generic_resume_noirq(struct device *dev);
 extern int pm_generic_resume(struct device *dev);
+extern int pm_generic_freeze_noirq(struct device *dev);
 extern int pm_generic_freeze(struct device *dev);
+extern int pm_generic_thaw_noirq(struct device *dev);
 extern int pm_generic_thaw(struct device *dev);
+extern int pm_generic_restore_noirq(struct device *dev);
 extern int pm_generic_restore(struct device *dev);
+extern int pm_generic_poweroff_noirq(struct device *dev);
 extern int pm_generic_poweroff(struct device *dev);
 extern void pm_generic_complete(struct device *dev);
 
diff --git a/include/linux/pm_domain.h b/include/linux/pm_domain.h
new file mode 100644
index 000000000000..21097cb086fe
--- /dev/null
+++ b/include/linux/pm_domain.h
@@ -0,0 +1,108 @@
+/*
+ * pm_domain.h - Definitions and headers related to device power domains.
+ *
+ * Copyright (C) 2011 Rafael J. Wysocki <rjw@sisk.pl>, Renesas Electronics Corp.
+ *
+ * This file is released under the GPLv2.
+ */
+
+#ifndef _LINUX_PM_DOMAIN_H
+#define _LINUX_PM_DOMAIN_H
+
+#include <linux/device.h>
+
+enum gpd_status {
+        GPD_STATE_ACTIVE = 0,   /* PM domain is active */
+        GPD_STATE_BUSY,         /* Something is happening to the PM domain */
+        GPD_STATE_REPEAT,       /* Power off in progress, to be repeated */
+        GPD_STATE_POWER_OFF,    /* PM domain is off */
+};
+
+struct dev_power_governor {
+        bool (*power_down_ok)(struct dev_pm_domain *domain);
+};
+
+struct generic_pm_domain {
+        struct dev_pm_domain domain;    /* PM domain operations */
+        struct list_head gpd_list_node; /* Node in the global PM domains list */
+        struct list_head sd_node;       /* Node in the parent's subdomain list */
+        struct generic_pm_domain *parent;       /* Parent PM domain */
+        struct list_head sd_list;       /* List of dubdomains */
+        struct list_head dev_list;      /* List of devices */
+        struct mutex lock;
+        struct dev_power_governor *gov;
+        struct work_struct power_off_work;
+        unsigned int in_progress;       /* Number of devices being suspended now */
+        unsigned int sd_count;  /* Number of subdomains with power "on" */
+        enum gpd_status status; /* Current state of the domain */
+        wait_queue_head_t status_wait_queue;
+        struct task_struct *poweroff_task;      /* Powering off task */
+        unsigned int resume_count;      /* Number of devices being resumed */
+        unsigned int device_count;      /* Number of devices */
+        unsigned int suspended_count;   /* System suspend device counter */
+        unsigned int prepared_count;    /* Suspend counter of prepared devices */
+        bool suspend_power_off; /* Power status before system suspend */
+        int (*power_off)(struct generic_pm_domain *domain);
+        int (*power_on)(struct generic_pm_domain *domain);
+        int (*start_device)(struct device *dev);
+        int (*stop_device)(struct device *dev);
+        bool (*active_wakeup)(struct device *dev);
+};
+
+static inline struct generic_pm_domain *pd_to_genpd(struct dev_pm_domain *pd)
+{
+        return container_of(pd, struct generic_pm_domain, domain);
+}
+
+struct dev_list_entry {
+        struct list_head node;
+        struct device *dev;
+        bool need_restore;
+};
+
+#ifdef CONFIG_PM_GENERIC_DOMAINS
+extern int pm_genpd_add_device(struct generic_pm_domain *genpd,
+                               struct device *dev);
+extern int pm_genpd_remove_device(struct generic_pm_domain *genpd,
+                                  struct device *dev);
+extern int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
+                                  struct generic_pm_domain *new_subdomain);
+extern int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
+                                     struct generic_pm_domain *target);
+extern void pm_genpd_init(struct generic_pm_domain *genpd,
+                          struct dev_power_governor *gov, bool is_off);
+extern int pm_genpd_poweron(struct generic_pm_domain *genpd);
+extern void pm_genpd_poweroff_unused(void);
+extern void genpd_queue_power_off_work(struct generic_pm_domain *genpd);
+#else
+static inline int pm_genpd_add_device(struct generic_pm_domain *genpd,
+                                      struct device *dev)
+{
+        return -ENOSYS;
+}
+static inline int pm_genpd_remove_device(struct generic_pm_domain *genpd,
+                                         struct device *dev)
+{
+        return -ENOSYS;
+}
+static inline int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
+                                         struct generic_pm_domain *new_sd)
+{
+        return -ENOSYS;
+}
+static inline int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
+                                            struct generic_pm_domain *target)
+{
+        return -ENOSYS;
+}
+static inline void pm_genpd_init(struct generic_pm_domain *genpd,
+                                 struct dev_power_governor *gov, bool is_off) {}
+static inline int pm_genpd_poweron(struct generic_pm_domain *genpd)
+{
+        return -ENOSYS;
+}
+static inline void pm_genpd_poweroff_unused(void) {}
+static inline void genpd_queue_power_off_work(struct generic_pm_domain *gpd) {}
+#endif
+
+#endif /* _LINUX_PM_DOMAIN_H */
diff --git a/include/linux/pm_runtime.h b/include/linux/pm_runtime.h
index 878cf84baeb1..daac05d751b2 100644
--- a/include/linux/pm_runtime.h
+++ b/include/linux/pm_runtime.h
@@ -82,6 +82,11 @@ static inline bool pm_runtime_suspended(struct device *dev)
                 && !dev->power.disable_depth;
 }
 
+static inline bool pm_runtime_status_suspended(struct device *dev)
+{
+        return dev->power.runtime_status == RPM_SUSPENDED;
+}
+
 static inline bool pm_runtime_enabled(struct device *dev)
 {
         return !dev->power.disable_depth;
@@ -130,6 +135,7 @@ static inline void pm_runtime_put_noidle(struct device *dev) {}
 static inline bool device_run_wake(struct device *dev) { return false; }
 static inline void device_set_run_wake(struct device *dev, bool enable) {}
 static inline bool pm_runtime_suspended(struct device *dev) { return false; }
+static inline bool pm_runtime_status_suspended(struct device *dev) { return false; }
 static inline bool pm_runtime_enabled(struct device *dev) { return false; }
 
 static inline int pm_generic_runtime_idle(struct device *dev) { return 0; }
@@ -247,41 +253,41 @@ static inline void pm_runtime_dont_use_autosuspend(struct device *dev)
 
 struct pm_clk_notifier_block {
         struct notifier_block nb;
-        struct dev_power_domain *pwr_domain;
+        struct dev_pm_domain *pm_domain;
         char *con_ids[];
 };
 
-#ifdef CONFIG_PM_RUNTIME_CLK
-extern int pm_runtime_clk_init(struct device *dev);
-extern void pm_runtime_clk_destroy(struct device *dev);
-extern int pm_runtime_clk_add(struct device *dev, const char *con_id);
-extern void pm_runtime_clk_remove(struct device *dev, const char *con_id);
-extern int pm_runtime_clk_suspend(struct device *dev);
-extern int pm_runtime_clk_resume(struct device *dev);
+#ifdef CONFIG_PM_CLK
+extern int pm_clk_init(struct device *dev);
+extern void pm_clk_destroy(struct device *dev);
+extern int pm_clk_add(struct device *dev, const char *con_id);
+extern void pm_clk_remove(struct device *dev, const char *con_id);
+extern int pm_clk_suspend(struct device *dev);
+extern int pm_clk_resume(struct device *dev);
 #else
-static inline int pm_runtime_clk_init(struct device *dev)
+static inline int pm_clk_init(struct device *dev)
 {
         return -EINVAL;
 }
-static inline void pm_runtime_clk_destroy(struct device *dev)
+static inline void pm_clk_destroy(struct device *dev)
 {
 }
-static inline int pm_runtime_clk_add(struct device *dev, const char *con_id)
+static inline int pm_clk_add(struct device *dev, const char *con_id)
 {
         return -EINVAL;
 }
-static inline void pm_runtime_clk_remove(struct device *dev, const char *con_id)
+static inline void pm_clk_remove(struct device *dev, const char *con_id)
 {
 }
-#define pm_runtime_clock_suspend        NULL
-#define pm_runtime_clock_resume         NULL
+#define pm_clk_suspend  NULL
+#define pm_clk_resume   NULL
 #endif
 
 #ifdef CONFIG_HAVE_CLK
-extern void pm_runtime_clk_add_notifier(struct bus_type *bus,
+extern void pm_clk_add_notifier(struct bus_type *bus,
                                         struct pm_clk_notifier_block *clknb);
 #else
-static inline void pm_runtime_clk_add_notifier(struct bus_type *bus,
+static inline void pm_clk_add_notifier(struct bus_type *bus,
                                         struct pm_clk_notifier_block *clknb)
 {
 }
diff --git a/include/linux/pnfs_osd_xdr.h b/include/linux/pnfs_osd_xdr.h
index 76efbdd01622..435dd5fa7453 100644
--- a/include/linux/pnfs_osd_xdr.h
+++ b/include/linux/pnfs_osd_xdr.h
@@ -41,9 +41,6 @@
 
 #include <linux/nfs_fs.h>
 #include <linux/nfs_page.h>
-#include <scsi/osd_protocol.h>
-
-#define PNFS_OSD_OSDNAME_MAXSIZE 256
 
 /*
  * draft-ietf-nfsv4-minorversion-22
@@ -99,12 +96,6 @@ struct pnfs_osd_objid {
 #define _DEVID_HI(oid_device_id) \
         (unsigned long long)be64_to_cpup(((__be64 *)(oid_device_id)->data) + 1)
 
-static inline int
-pnfs_osd_objid_xdr_sz(void)
-{
-        return (NFS4_DEVICEID4_SIZE / 4) + 2 + 2;
-}
-
 enum pnfs_osd_version {
         PNFS_OSD_MISSING              = 0,
         PNFS_OSD_VERSION_1            = 1,
@@ -189,8 +180,6 @@ struct pnfs_osd_targetid {
         struct nfs4_string              oti_scsi_device_id;
 };
 
-enum { PNFS_OSD_TARGETID_MAX = 1 + PNFS_OSD_OSDNAME_MAXSIZE / 4 };
-
 /*   struct netaddr4 {
  *       // see struct rpcb in RFC1833
  *       string r_netid<>;    // network id
@@ -207,12 +196,6 @@ struct pnfs_osd_targetaddr {
         struct pnfs_osd_net_addr        ota_netaddr;
 };
 
-enum {
-        NETWORK_ID_MAX = 16 / 4,
-        UNIVERSAL_ADDRESS_MAX = 64 / 4,
-        PNFS_OSD_TARGETADDR_MAX = 3 +  NETWORK_ID_MAX + UNIVERSAL_ADDRESS_MAX,
-};
-
 struct pnfs_osd_deviceaddr {
         struct pnfs_osd_targetid        oda_targetid;
         struct pnfs_osd_targetaddr      oda_targetaddr;
@@ -222,15 +205,6 @@ struct pnfs_osd_deviceaddr {
         struct nfs4_string              oda_osdname;
 };
 
-enum {
-        ODA_OSDNAME_MAX = PNFS_OSD_OSDNAME_MAXSIZE / 4,
-        PNFS_OSD_DEVICEADDR_MAX =
-                PNFS_OSD_TARGETID_MAX + PNFS_OSD_TARGETADDR_MAX +
-                2 /*oda_lun*/ +
-                1 + OSD_SYSTEMID_LEN +
-                1 + ODA_OSDNAME_MAX,
-};
-
 /* LAYOUTCOMMIT: layoutupdate */
 
 /*   union pnfs_osd_deltaspaceused4 switch (bool dsu_valid) {
@@ -279,7 +253,7 @@ struct pnfs_osd_ioerr {
         u32                     oer_errno;
 };
 
-/* OSD XDR API */
+/* OSD XDR Client API */
 /* Layout helpers */
 /* Layout decoding is done in two parts:
  * 1. First Call pnfs_osd_xdr_decode_layout_map to read in only the header part
@@ -337,8 +311,7 @@ extern int
 pnfs_osd_xdr_encode_layoutupdate(struct xdr_stream *xdr,
                                  struct pnfs_osd_layoutupdate *lou);
 
-/* osd_ioerror encoding/decoding (layout_return) */
-/* Client */
+/* osd_ioerror encoding (layout_return) */
 extern __be32 *pnfs_osd_xdr_ioerr_reserve_space(struct xdr_stream *xdr);
 extern void pnfs_osd_xdr_encode_ioerr(__be32 *p, struct pnfs_osd_ioerr *ioerr);
 
diff --git a/include/linux/pnp.h b/include/linux/pnp.h
index 1bc1338b817b..195aafc6cd07 100644
--- a/include/linux/pnp.h
+++ b/include/linux/pnp.h
@@ -50,7 +50,7 @@ static inline resource_size_t pnp_resource_len(struct resource *res)
 {
         if (res->start == 0 && res->end == 0)
                 return 0;
-        return res->end - res->start + 1;
+        return resource_size(res);
 }
 
 
diff --git a/include/linux/poison.h b/include/linux/poison.h
index 2110a81c5e2a..79159de0e341 100644
--- a/include/linux/poison.h
+++ b/include/linux/poison.h
@@ -40,6 +40,12 @@
 #define RED_INACTIVE    0x09F911029D74E35BULL   /* when obj is inactive */
 #define RED_ACTIVE      0xD84156C5635688C0ULL   /* when obj is active */
 
+#ifdef CONFIG_PHYS_ADDR_T_64BIT
+#define MEMBLOCK_INACTIVE       0x3a84fb0144c9e71bULL
+#else
+#define MEMBLOCK_INACTIVE       0x44c9e71bUL
+#endif
+
 #define SLUB_RED_INACTIVE       0xbb
 #define SLUB_RED_ACTIVE         0xcc
 
diff --git a/include/linux/posix_acl.h b/include/linux/posix_acl.h
index 54211c1cd926..b7681102a4b9 100644
--- a/include/linux/posix_acl.h
+++ b/include/linux/posix_acl.h
@@ -9,6 +9,7 @@
 #define __LINUX_POSIX_ACL_H
 
 #include <linux/slab.h>
+#include <linux/rcupdate.h>
 
 #define ACL_UNDEFINED_ID        (-1)
 
@@ -38,7 +39,10 @@ struct posix_acl_entry {
 };
 
 struct posix_acl {
-        atomic_t                a_refcount;
+        union {
+                atomic_t                a_refcount;
+                struct rcu_head         a_rcu;
+        };
         unsigned int            a_count;
         struct posix_acl_entry  a_entries[0];
 };
@@ -65,7 +69,7 @@ static inline void
 posix_acl_release(struct posix_acl *acl)
 {
         if (acl && atomic_dec_and_test(&acl->a_refcount))
-                kfree(acl);
+                kfree_rcu(acl, a_rcu);
 }
 
 
@@ -73,32 +77,33 @@ posix_acl_release(struct posix_acl *acl)
 
 extern void posix_acl_init(struct posix_acl *, int);
 extern struct posix_acl *posix_acl_alloc(int, gfp_t);
-extern struct posix_acl *posix_acl_clone(const struct posix_acl *, gfp_t);
 extern int posix_acl_valid(const struct posix_acl *);
 extern int posix_acl_permission(struct inode *, const struct posix_acl *, int);
-extern struct posix_acl *posix_acl_from_mode(mode_t, gfp_t);
-extern int posix_acl_equiv_mode(const struct posix_acl *, mode_t *);
-extern int posix_acl_create_masq(struct posix_acl *, mode_t *);
-extern int posix_acl_chmod_masq(struct posix_acl *, mode_t);
+extern struct posix_acl *posix_acl_from_mode(umode_t, gfp_t);
+extern int posix_acl_equiv_mode(const struct posix_acl *, umode_t *);
+extern int posix_acl_create(struct posix_acl **, gfp_t, umode_t *);
+extern int posix_acl_chmod(struct posix_acl **, gfp_t, umode_t);
 
 extern struct posix_acl *get_posix_acl(struct inode *, int);
 extern int set_posix_acl(struct inode *, int, struct posix_acl *);
 
 #ifdef CONFIG_FS_POSIX_ACL
-static inline struct posix_acl *get_cached_acl(struct inode *inode, int type)
+static inline struct posix_acl **acl_by_type(struct inode *inode, int type)
 {
-        struct posix_acl **p, *acl;
         switch (type) {
         case ACL_TYPE_ACCESS:
-                p = &inode->i_acl;
-                break;
+                return &inode->i_acl;
         case ACL_TYPE_DEFAULT:
-                p = &inode->i_default_acl;
-                break;
+                return &inode->i_default_acl;
         default:
-                return ERR_PTR(-EINVAL);
+                BUG();
         }
-        acl = ACCESS_ONCE(*p);
+}
+
+static inline struct posix_acl *get_cached_acl(struct inode *inode, int type)
+{
+        struct posix_acl **p = acl_by_type(inode, type);
+        struct posix_acl *acl = ACCESS_ONCE(*p);
         if (acl) {
                 spin_lock(&inode->i_lock);
                 acl = *p;
@@ -109,41 +114,20 @@ static inline struct posix_acl *get_cached_acl(struct inode *inode, int type)
         return acl;
 }
 
-static inline int negative_cached_acl(struct inode *inode, int type)
+static inline struct posix_acl *get_cached_acl_rcu(struct inode *inode, int type)
 {
-        struct posix_acl **p, *acl;
-        switch (type) {
-        case ACL_TYPE_ACCESS:
-                p = &inode->i_acl;
-                break;
-        case ACL_TYPE_DEFAULT:
-                p = &inode->i_default_acl;
-                break;
-        default:
-                BUG();
-        }
-        acl = ACCESS_ONCE(*p);
-        if (acl)
-                return 0;
-        return 1;
+        return rcu_dereference(*acl_by_type(inode, type));
 }
 
 static inline void set_cached_acl(struct inode *inode,
                                   int type,
                                   struct posix_acl *acl)
 {
-        struct posix_acl *old = NULL;
+        struct posix_acl **p = acl_by_type(inode, type);
+        struct posix_acl *old;
         spin_lock(&inode->i_lock);
-        switch (type) {
-        case ACL_TYPE_ACCESS:
-                old = inode->i_acl;
-                inode->i_acl = posix_acl_dup(acl);
-                break;
-        case ACL_TYPE_DEFAULT:
-                old = inode->i_default_acl;
-                inode->i_default_acl = posix_acl_dup(acl);
-                break;
-        }
+        old = *p;
+        rcu_assign_pointer(*p, posix_acl_dup(acl));
         spin_unlock(&inode->i_lock);
         if (old != ACL_NOT_CACHED)
                 posix_acl_release(old);
@@ -151,18 +135,11 @@ static inline void set_cached_acl(struct inode *inode,
 
 static inline void forget_cached_acl(struct inode *inode, int type)
 {
-        struct posix_acl *old = NULL;
+        struct posix_acl **p = acl_by_type(inode, type);
+        struct posix_acl *old;
         spin_lock(&inode->i_lock);
-        switch (type) {
-        case ACL_TYPE_ACCESS:
-                old = inode->i_acl;
-                inode->i_acl = ACL_NOT_CACHED;
-                break;
-        case ACL_TYPE_DEFAULT:
-                old = inode->i_default_acl;
-                inode->i_default_acl = ACL_NOT_CACHED;
-                break;
-        }
+        old = *p;
+        *p = ACL_NOT_CACHED;
         spin_unlock(&inode->i_lock);
         if (old != ACL_NOT_CACHED)
                 posix_acl_release(old);
diff --git a/include/linux/power/bq20z75.h b/include/linux/power/bq20z75.h
index b0843b68af92..1398eb004e83 100644
--- a/include/linux/power/bq20z75.h
+++ b/include/linux/power/bq20z75.h
@@ -29,11 +29,14 @@
  * @battery_detect:             GPIO which is used to detect battery presence
  * @battery_detect_present:     gpio state when battery is present (0 / 1)
  * @i2c_retry_count:            # of times to retry on i2c IO failure
+ * @poll_retry_count:           # of times to retry looking for new status after
+ *                              external change notification
  */
 struct bq20z75_platform_data {
         int battery_detect;
         int battery_detect_present;
         int i2c_retry_count;
+        int poll_retry_count;
 };
 
 #endif
diff --git a/include/linux/power/max17042_battery.h b/include/linux/power/max17042_battery.h
index 7995deb8bfc1..fe99211fb2b8 100644
--- a/include/linux/power/max17042_battery.h
+++ b/include/linux/power/max17042_battery.h
@@ -23,8 +23,99 @@
 #ifndef __MAX17042_BATTERY_H_
 #define __MAX17042_BATTERY_H_
 
+#define MAX17042_STATUS_BattAbsent      (1 << 3)
+#define MAX17042_BATTERY_FULL   (100)
+#define MAX17042_DEFAULT_SNS_RESISTOR   (10000)
+
+enum max17042_register {
+        MAX17042_STATUS         = 0x00,
+        MAX17042_VALRT_Th       = 0x01,
+        MAX17042_TALRT_Th       = 0x02,
+        MAX17042_SALRT_Th       = 0x03,
+        MAX17042_AtRate         = 0x04,
+        MAX17042_RepCap         = 0x05,
+        MAX17042_RepSOC         = 0x06,
+        MAX17042_Age            = 0x07,
+        MAX17042_TEMP           = 0x08,
+        MAX17042_VCELL          = 0x09,
+        MAX17042_Current        = 0x0A,
+        MAX17042_AvgCurrent     = 0x0B,
+        MAX17042_Qresidual      = 0x0C,
+        MAX17042_SOC            = 0x0D,
+        MAX17042_AvSOC          = 0x0E,
+        MAX17042_RemCap         = 0x0F,
+        MAX17402_FullCAP        = 0x10,
+        MAX17042_TTE            = 0x11,
+        MAX17042_V_empty        = 0x12,
+
+        MAX17042_RSLOW          = 0x14,
+
+        MAX17042_AvgTA          = 0x16,
+        MAX17042_Cycles         = 0x17,
+        MAX17042_DesignCap      = 0x18,
+        MAX17042_AvgVCELL       = 0x19,
+        MAX17042_MinMaxTemp     = 0x1A,
+        MAX17042_MinMaxVolt     = 0x1B,
+        MAX17042_MinMaxCurr     = 0x1C,
+        MAX17042_CONFIG         = 0x1D,
+        MAX17042_ICHGTerm       = 0x1E,
+        MAX17042_AvCap          = 0x1F,
+        MAX17042_ManName        = 0x20,
+        MAX17042_DevName        = 0x21,
+        MAX17042_DevChem        = 0x22,
+
+        MAX17042_TempNom        = 0x24,
+        MAX17042_TempCold       = 0x25,
+        MAX17042_TempHot        = 0x26,
+        MAX17042_AIN            = 0x27,
+        MAX17042_LearnCFG       = 0x28,
+        MAX17042_SHFTCFG        = 0x29,
+        MAX17042_RelaxCFG       = 0x2A,
+        MAX17042_MiscCFG        = 0x2B,
+        MAX17042_TGAIN          = 0x2C,
+        MAx17042_TOFF           = 0x2D,
+        MAX17042_CGAIN          = 0x2E,
+        MAX17042_COFF           = 0x2F,
+
+        MAX17042_Q_empty        = 0x33,
+        MAX17042_T_empty        = 0x34,
+
+        MAX17042_RCOMP0         = 0x38,
+        MAX17042_TempCo         = 0x39,
+        MAX17042_Rx             = 0x3A,
+        MAX17042_T_empty0       = 0x3B,
+        MAX17042_TaskPeriod     = 0x3C,
+        MAX17042_FSTAT          = 0x3D,
+
+        MAX17042_SHDNTIMER      = 0x3F,
+
+        MAX17042_VFRemCap       = 0x4A,
+
+        MAX17042_QH             = 0x4D,
+        MAX17042_QL             = 0x4E,
+};
+
+/*
+ * used for setting a register to a desired value
+ * addr : address for a register
+ * data : setting value for the register
+ */
+struct max17042_reg_data {
+        u8 addr;
+        u16 data;
+};
+
 struct max17042_platform_data {
+        struct max17042_reg_data *init_data;
+        int num_init_data; /* Number of enties in init_data array */
         bool enable_current_sense;
+
+        /*
+         * R_sns in micro-ohms.
+         * default 10000 (if r_sns = 0) as it is the recommended value by
+         * the datasheet although it can be changed by board designers.
+         */
+        unsigned int r_sns;
 };
 
 #endif /* __MAX17042_BATTERY_H_ */
diff --git a/include/linux/preempt.h b/include/linux/preempt.h
index 2e681d9555bd..58969b2a8a82 100644
--- a/include/linux/preempt.h
+++ b/include/linux/preempt.h
@@ -27,6 +27,21 @@
 
 asmlinkage void preempt_schedule(void);
 
+#define preempt_check_resched() \
+do { \
+        if (unlikely(test_thread_flag(TIF_NEED_RESCHED))) \
+                preempt_schedule(); \
+} while (0)
+
+#else /* !CONFIG_PREEMPT */
+
+#define preempt_check_resched()         do { } while (0)
+
+#endif /* CONFIG_PREEMPT */
+
+
+#ifdef CONFIG_PREEMPT_COUNT
+
 #define preempt_disable() \
 do { \
         inc_preempt_count(); \
@@ -39,12 +54,6 @@ do { \
         dec_preempt_count(); \
 } while (0)
 
-#define preempt_check_resched() \
-do { \
-        if (unlikely(test_thread_flag(TIF_NEED_RESCHED))) \
-                preempt_schedule(); \
-} while (0)
-
 #define preempt_enable() \
 do { \
         preempt_enable_no_resched(); \
@@ -80,18 +89,17 @@ do { \
         preempt_check_resched(); \
 } while (0)
 
-#else
+#else /* !CONFIG_PREEMPT_COUNT */
 
 #define preempt_disable()               do { } while (0)
 #define preempt_enable_no_resched()     do { } while (0)
 #define preempt_enable()                do { } while (0)
-#define preempt_check_resched()         do { } while (0)
 
 #define preempt_disable_notrace()               do { } while (0)
 #define preempt_enable_no_resched_notrace()     do { } while (0)
 #define preempt_enable_notrace()                do { } while (0)
 
-#endif
+#endif /* CONFIG_PREEMPT_COUNT */
 
 #ifdef CONFIG_PREEMPT_NOTIFIERS
 
diff --git a/include/linux/proc_fs.h b/include/linux/proc_fs.h
index e7576cf9e32d..643b96c7a94f 100644
--- a/include/linux/proc_fs.h
+++ b/include/linux/proc_fs.h
@@ -5,7 +5,7 @@
 #include <linux/fs.h>
 #include <linux/spinlock.h>
 #include <linux/magic.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 struct net;
 struct completion;
@@ -50,8 +50,6 @@ typedef	int (write_proc_t)(struct file *file, const char __user *buffer,
 
 struct proc_dir_entry {
         unsigned int low_ino;
-        unsigned int namelen;
-        const char *name;
         mode_t mode;
         nlink_t nlink;
         uid_t uid;
@@ -73,9 +71,11 @@ struct proc_dir_entry {
         write_proc_t *write_proc;
         atomic_t count;         /* use count */
         int pde_users;  /* number of callers into module in progress */
-        spinlock_t pde_unload_lock; /* proc_fops checks and pde_users bumps */
         struct completion *pde_unload_completion;
         struct list_head pde_openers;   /* who did ->open, but not ->release */
+        spinlock_t pde_unload_lock; /* proc_fops checks and pde_users bumps */
+        u8 namelen;
+        char name[];
 };
 
 enum kcore_type {
diff --git a/include/linux/pstore.h b/include/linux/pstore.h
index 2455ef2683f0..cc03bbf5c4b8 100644
--- a/include/linux/pstore.h
+++ b/include/linux/pstore.h
@@ -38,9 +38,12 @@ struct pstore_info {
         int             (*open)(struct pstore_info *psi);
         int             (*close)(struct pstore_info *psi);
         ssize_t         (*read)(u64 *id, enum pstore_type_id *type,
-                        struct timespec *time);
-        u64             (*write)(enum pstore_type_id type, size_t size);
-        int             (*erase)(u64 id);
+                        struct timespec *time, struct pstore_info *psi);
+        u64             (*write)(enum pstore_type_id type, unsigned int part,
+                        size_t size, struct pstore_info *psi);
+        int             (*erase)(enum pstore_type_id type, u64 id,
+                        struct pstore_info *psi);
+        void            *data;
 };
 
 #ifdef CONFIG_PSTORE
diff --git a/include/linux/pti.h b/include/linux/pti.h
index 81af667bb2d5..b3ea01a3197e 100644
--- a/include/linux/pti.h
+++ b/include/linux/pti.h
@@ -36,7 +36,8 @@ struct pti_masterchannel {
 
 /* the following functions are defined in misc/pti.c */
 void pti_writedata(struct pti_masterchannel *mc, u8 *buf, int count);
-struct pti_masterchannel *pti_request_masterchannel(u8 type);
+struct pti_masterchannel *pti_request_masterchannel(u8 type,
+                                                    const char *thread_name);
 void pti_release_masterchannel(struct pti_masterchannel *mc);
 
 #endif /*PTI_H_*/
diff --git a/include/linux/ptrace.h b/include/linux/ptrace.h
index 9178d5cc0b01..800f113bea66 100644
--- a/include/linux/ptrace.h
+++ b/include/linux/ptrace.h
@@ -47,6 +47,13 @@
 #define PTRACE_GETREGSET        0x4204
 #define PTRACE_SETREGSET        0x4205
 
+#define PTRACE_SEIZE            0x4206
+#define PTRACE_INTERRUPT        0x4207
+#define PTRACE_LISTEN           0x4208
+
+/* flags in @data for PTRACE_SEIZE */
+#define PTRACE_SEIZE_DEVEL      0x80000000 /* temp flag for development */
+
 /* options set using PTRACE_SETOPTIONS */
 #define PTRACE_O_TRACESYSGOOD   0x00000001
 #define PTRACE_O_TRACEFORK      0x00000002
@@ -65,6 +72,7 @@
 #define PTRACE_EVENT_EXEC       4
 #define PTRACE_EVENT_VFORK_DONE 5
 #define PTRACE_EVENT_EXIT       6
+#define PTRACE_EVENT_STOP       7
 
 #include <asm/ptrace.h>
 
@@ -77,16 +85,22 @@
  * flags.  When the a task is stopped the ptracer owns task->ptrace.
  */
 
+#define PT_SEIZED       0x00010000      /* SEIZE used, enable new behavior */
 #define PT_PTRACED      0x00000001
 #define PT_DTRACE       0x00000002      /* delayed trace (used on m68k, i386) */
 #define PT_TRACESYSGOOD 0x00000004
 #define PT_PTRACE_CAP   0x00000008      /* ptracer can follow suid-exec */
-#define PT_TRACE_FORK   0x00000010
-#define PT_TRACE_VFORK  0x00000020
-#define PT_TRACE_CLONE  0x00000040
-#define PT_TRACE_EXEC   0x00000080
-#define PT_TRACE_VFORK_DONE     0x00000100
-#define PT_TRACE_EXIT   0x00000200
+
+/* PT_TRACE_* event enable flags */
+#define PT_EVENT_FLAG_SHIFT     4
+#define PT_EVENT_FLAG(event)    (1 << (PT_EVENT_FLAG_SHIFT + (event) - 1))
+
+#define PT_TRACE_FORK           PT_EVENT_FLAG(PTRACE_EVENT_FORK)
+#define PT_TRACE_VFORK          PT_EVENT_FLAG(PTRACE_EVENT_VFORK)
+#define PT_TRACE_CLONE          PT_EVENT_FLAG(PTRACE_EVENT_CLONE)
+#define PT_TRACE_EXEC           PT_EVENT_FLAG(PTRACE_EVENT_EXEC)
+#define PT_TRACE_VFORK_DONE     PT_EVENT_FLAG(PTRACE_EVENT_VFORK_DONE)
+#define PT_TRACE_EXIT           PT_EVENT_FLAG(PTRACE_EVENT_EXIT)
 
 #define PT_TRACE_MASK   0x000003f4
 
@@ -105,7 +119,7 @@ extern long arch_ptrace(struct task_struct *child, long request,
 extern int ptrace_readdata(struct task_struct *tsk, unsigned long src, char __user *dst, int len);
 extern int ptrace_writedata(struct task_struct *tsk, char __user *src, unsigned long dst, int len);
 extern void ptrace_disable(struct task_struct *);
-extern int ptrace_check_attach(struct task_struct *task, int kill);
+extern int ptrace_check_attach(struct task_struct *task, bool ignore_state);
 extern int ptrace_request(struct task_struct *child, long request,
                           unsigned long addr, unsigned long data);
 extern void ptrace_notify(int exit_code);
@@ -122,7 +136,7 @@ extern bool ptrace_may_access(struct task_struct *task, unsigned int mode);
 
 static inline int ptrace_reparented(struct task_struct *child)
 {
-        return child->real_parent != child->parent;
+        return !same_thread_group(child->real_parent, child->parent);
 }
 
 static inline void ptrace_unlink(struct task_struct *child)
@@ -137,36 +151,56 @@ int generic_ptrace_pokedata(struct task_struct *tsk, unsigned long addr,
                             unsigned long data);
 
 /**
- * task_ptrace - return %PT_* flags that apply to a task
- * @task:       pointer to &task_struct in question
+ * ptrace_parent - return the task that is tracing the given task
+ * @task: task to consider
  *
- * Returns the %PT_* flags that apply to @task.
+ * Returns %NULL if no one 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 check_unsafe_exec() was called.
  */
-static inline int task_ptrace(struct task_struct *task)
+static inline struct task_struct *ptrace_parent(struct task_struct *task)
 {
-        return task->ptrace;
+        if (unlikely(task->ptrace))
+                return rcu_dereference(task->parent);
+        return NULL;
+}
+
+/**
+ * ptrace_event_enabled - test whether a ptrace event is enabled
+ * @task: ptracee of interest
+ * @event: %PTRACE_EVENT_* to test
+ *
+ * Test whether @event is enabled for ptracee @task.
+ *
+ * Returns %true if @event is enabled, %false otherwise.
+ */
+static inline bool ptrace_event_enabled(struct task_struct *task, int event)
+{
+        return task->ptrace & PT_EVENT_FLAG(event);
 }
 
 /**
  * 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
+ * @event:      %PTRACE_EVENT_* value to report
  * @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.
+ * Check whether @event is enabled and, if so, report @event and @message
+ * to the ptrace parent.
  *
  * Called without locks.
  */
-static inline int ptrace_event(int mask, int event, unsigned long message)
+static inline void ptrace_event(int event, unsigned long message)
 {
-        if (mask && likely(!(current->ptrace & mask)))
-                return 0;
-        current->ptrace_message = message;
-        ptrace_notify((event << 8) | SIGTRAP);
-        return 1;
+        if (unlikely(ptrace_event_enabled(current, event))) {
+                current->ptrace_message = message;
+                ptrace_notify((event << 8) | SIGTRAP);
+        } else if (event == PTRACE_EVENT_EXEC && unlikely(current->ptrace)) {
+                /* legacy EXEC report via SIGTRAP */
+                send_sig(SIGTRAP, current, 0);
+        }
 }
 
 /**
@@ -183,16 +217,24 @@ 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;
+#ifdef CONFIG_HAVE_HW_BREAKPOINT
+        atomic_set(&child->ptrace_bp_refcnt, 1);
+#endif
+        child->jobctl = 0;
         child->ptrace = 0;
-        if (unlikely(ptrace) && (current->ptrace & PT_PTRACED)) {
+        child->parent = child->real_parent;
+
+        if (unlikely(ptrace) && current->ptrace) {
                 child->ptrace = current->ptrace;
                 __ptrace_link(child, current->parent);
-        }
 
-#ifdef CONFIG_HAVE_HW_BREAKPOINT
-        atomic_set(&child->ptrace_bp_refcnt, 1);
-#endif
+                if (child->ptrace & PT_SEIZED)
+                        task_set_jobctl_pending(child, JOBCTL_TRAP_STOP);
+                else
+                        sigaddset(&child->pending.signal, SIGSTOP);
+
+                set_tsk_thread_flag(child, TIF_SIGPENDING);
+        }
 }
 
 /**
diff --git a/include/linux/quota.h b/include/linux/quota.h
index 9a85412e0db6..cb7855699037 100644
--- a/include/linux/quota.h
+++ b/include/linux/quota.h
@@ -180,7 +180,7 @@ enum {
 #include <linux/dqblk_v1.h>
 #include <linux/dqblk_v2.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 typedef __kernel_uid32_t qid_t; /* Type in which we store ids in memory */
 typedef long long qsize_t;      /* Type in which we store sizes */
@@ -415,13 +415,5 @@ struct quota_module_name {
         {QFMT_VFS_V0, "quota_v2"},\
         {0, NULL}}
 
-#else
-
-# /* nodep */ include <sys/cdefs.h>
-
-__BEGIN_DECLS
-long quotactl __P ((unsigned int, const char *, int, caddr_t));
-__END_DECLS
-
 #endif /* __KERNEL__ */
 #endif /* _QUOTA_ */
diff --git a/include/linux/radix-tree.h b/include/linux/radix-tree.h
index 23241c2fecce..9d4539c52e53 100644
--- a/include/linux/radix-tree.h
+++ b/include/linux/radix-tree.h
@@ -39,7 +39,15 @@
  * when it is shrunk, before we rcu free the node. See shrink code for
  * details.
  */
-#define RADIX_TREE_INDIRECT_PTR 1
+#define RADIX_TREE_INDIRECT_PTR         1
+/*
+ * A common use of the radix tree is to store pointers to struct pages;
+ * but shmem/tmpfs needs also to store swap entries in the same tree:
+ * those are marked as exceptional entries to distinguish them.
+ * EXCEPTIONAL_ENTRY tests the bit, EXCEPTIONAL_SHIFT shifts content past it.
+ */
+#define RADIX_TREE_EXCEPTIONAL_ENTRY    2
+#define RADIX_TREE_EXCEPTIONAL_SHIFT    2
 
 #define radix_tree_indirect_to_ptr(ptr) \
         radix_tree_indirect_to_ptr((void __force *)(ptr))
@@ -174,6 +182,28 @@ static inline int radix_tree_deref_retry(void *arg)
 }
 
 /**
+ * radix_tree_exceptional_entry - radix_tree_deref_slot gave exceptional entry?
+ * @arg:        value returned by radix_tree_deref_slot
+ * Returns:     0 if well-aligned pointer, non-0 if exceptional entry.
+ */
+static inline int radix_tree_exceptional_entry(void *arg)
+{
+        /* Not unlikely because radix_tree_exception often tested first */
+        return (unsigned long)arg & RADIX_TREE_EXCEPTIONAL_ENTRY;
+}
+
+/**
+ * radix_tree_exception - radix_tree_deref_slot returned either exception?
+ * @arg:        value returned by radix_tree_deref_slot
+ * Returns:     0 if well-aligned pointer, non-0 if either kind of exception.
+ */
+static inline int radix_tree_exception(void *arg)
+{
+        return unlikely((unsigned long)arg &
+                (RADIX_TREE_INDIRECT_PTR | RADIX_TREE_EXCEPTIONAL_ENTRY));
+}
+
+/**
  * radix_tree_replace_slot      - replace item in a slot
  * @pslot:      pointer to slot, returned by radix_tree_lookup_slot
  * @item:       new item to store in the slot.
@@ -194,8 +224,8 @@ 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 int radix_tree_gang_lookup_slot(struct radix_tree_root *root,
+                        void ***results, unsigned long *indices,
                         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);
@@ -222,6 +252,7 @@ unsigned long radix_tree_range_tag_if_tagged(struct radix_tree_root *root,
                 unsigned long nr_to_tag,
                 unsigned int fromtag, unsigned int totag);
 int radix_tree_tagged(struct radix_tree_root *root, unsigned int tag);
+unsigned long radix_tree_locate_item(struct radix_tree_root *root, void *item);
 
 static inline void radix_tree_preload_end(void)
 {
diff --git a/include/linux/raid/md_p.h b/include/linux/raid/md_p.h
index 75cbf4f62fe8..9e65d9e20662 100644
--- a/include/linux/raid/md_p.h
+++ b/include/linux/raid/md_p.h
@@ -245,10 +245,16 @@ struct mdp_superblock_1 {
         __u8    device_uuid[16]; /* user-space setable, ignored by kernel */
         __u8    devflags;       /* per-device flags.  Only one defined...*/
 #define WriteMostly1    1       /* mask for writemostly flag in above */
-        __u8    pad2[64-57];    /* set to 0 when writing */
+        /* Bad block log.  If there are any bad blocks the feature flag is set.
+         * If offset and size are non-zero, that space is reserved and available
+         */
+        __u8    bblog_shift;    /* shift from sectors to block size */
+        __le16  bblog_size;     /* number of sectors reserved for list */
+        __le32  bblog_offset;   /* sector offset from superblock to bblog,
+                                 * signed - not unsigned */
 
         /* array state information - 64 bytes */
-        __le64  utime;          /* 40 bits second, 24 btes microseconds */
+        __le64  utime;          /* 40 bits second, 24 bits microseconds */
         __le64  events;         /* incremented when superblock updated */
         __le64  resync_offset;  /* data before this offset (from data_offset) known to be in sync */
         __le32  sb_csum;        /* checksum up to devs[max_dev] */
@@ -270,8 +276,8 @@ struct mdp_superblock_1 {
                                            * must be honoured
                                            */
 #define MD_FEATURE_RESHAPE_ACTIVE       4
+#define MD_FEATURE_BAD_BLOCKS           8 /* badblock list is not empty */
 
-#define MD_FEATURE_ALL                  (1|2|4)
+#define MD_FEATURE_ALL                  (1|2|4|8)
 
 #endif 
-
diff --git a/include/linux/ramoops.h b/include/linux/ramoops.h
index 0ae68a2c1212..484fef81cd3a 100644
--- a/include/linux/ramoops.h
+++ b/include/linux/ramoops.h
@@ -10,6 +10,8 @@
 struct ramoops_platform_data {
         unsigned long   mem_size;
         unsigned long   mem_address;
+        unsigned long   record_size;
+        int             dump_oops;
 };
 
 #endif
diff --git a/include/linux/random.h b/include/linux/random.h
index fb7ab9de5f36..d13059f3ea32 100644
--- a/include/linux/random.h
+++ b/include/linux/random.h
@@ -57,17 +57,6 @@ extern void add_interrupt_randomness(int irq);
 extern void get_random_bytes(void *buf, int nbytes);
 void generate_random_uuid(unsigned char uuid_out[16]);
 
-extern __u32 secure_ip_id(__be32 daddr);
-extern u32 secure_ipv4_port_ephemeral(__be32 saddr, __be32 daddr, __be16 dport);
-extern u32 secure_ipv6_port_ephemeral(const __be32 *saddr, const __be32 *daddr,
-                                      __be16 dport);
-extern __u32 secure_tcp_sequence_number(__be32 saddr, __be32 daddr,
-                                        __be16 sport, __be16 dport);
-extern __u32 secure_tcpv6_sequence_number(__be32 *saddr, __be32 *daddr,
-                                          __be16 sport, __be16 dport);
-extern u64 secure_dccp_sequence_number(__be32 saddr, __be32 daddr,
-                                       __be16 sport, __be16 dport);
-
 #ifndef MODULE
 extern const struct file_operations random_fops, urandom_fops;
 #endif
diff --git a/include/linux/rculist.h b/include/linux/rculist.h
index e3beb315517a..d079290843a9 100644
--- a/include/linux/rculist.h
+++ b/include/linux/rculist.h
@@ -183,7 +183,7 @@ static inline void list_splice_init_rcu(struct list_head *list,
         struct list_head *last = list->prev;
         struct list_head *at = head->next;
 
-        if (list_empty(head))
+        if (list_empty(list))
                 return;
 
         /* "first" and "last" tracking list, so initialize it. */
diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
index 99f9aa7c2804..8f4f881a0ad8 100644
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -239,7 +239,7 @@ extern int rcu_read_lock_bh_held(void);
  * Check debug_lockdep_rcu_enabled() to prevent false positives during boot
  * and while lockdep is disabled.
  */
-#ifdef CONFIG_PREEMPT
+#ifdef CONFIG_PREEMPT_COUNT
 static inline int rcu_read_lock_sched_held(void)
 {
         int lockdep_opinion = 0;
@@ -250,12 +250,12 @@ static inline int rcu_read_lock_sched_held(void)
                 lockdep_opinion = lock_is_held(&rcu_sched_lock_map);
         return lockdep_opinion || preempt_count() != 0 || irqs_disabled();
 }
-#else /* #ifdef CONFIG_PREEMPT */
+#else /* #ifdef CONFIG_PREEMPT_COUNT */
 static inline int rcu_read_lock_sched_held(void)
 {
         return 1;
 }
-#endif /* #else #ifdef CONFIG_PREEMPT */
+#endif /* #else #ifdef CONFIG_PREEMPT_COUNT */
 
 #else /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
 
@@ -276,17 +276,17 @@ static inline int rcu_read_lock_bh_held(void)
         return 1;
 }
 
-#ifdef CONFIG_PREEMPT
+#ifdef CONFIG_PREEMPT_COUNT
 static inline int rcu_read_lock_sched_held(void)
 {
         return preempt_count() != 0 || irqs_disabled();
 }
-#else /* #ifdef CONFIG_PREEMPT */
+#else /* #ifdef CONFIG_PREEMPT_COUNT */
 static inline int rcu_read_lock_sched_held(void)
 {
         return 1;
 }
-#endif /* #else #ifdef CONFIG_PREEMPT */
+#endif /* #else #ifdef CONFIG_PREEMPT_COUNT */
 
 #endif /* #else #ifdef CONFIG_DEBUG_LOCK_ALLOC */
 
diff --git a/include/linux/reboot.h b/include/linux/reboot.h
index 3005d5a7fce5..e0879a70e830 100644
--- a/include/linux/reboot.h
+++ b/include/linux/reboot.h
@@ -39,6 +39,11 @@
 
 #include <linux/notifier.h>
 
+#define SYS_DOWN        0x0001  /* Notify of system down */
+#define SYS_RESTART     SYS_DOWN
+#define SYS_HALT        0x0002  /* Notify of system halt */
+#define SYS_POWER_OFF   0x0003  /* Notify of system power off */
+
 extern int register_reboot_notifier(struct notifier_block *);
 extern int unregister_reboot_notifier(struct notifier_block *);
 
diff --git a/include/linux/regmap.h b/include/linux/regmap.h
new file mode 100644
index 000000000000..60a65cd7e1a0
--- /dev/null
+++ b/include/linux/regmap.h
@@ -0,0 +1,82 @@
+#ifndef __LINUX_REGMAP_H
+#define __LINUX_REGMAP_H
+
+/*
+ * Register map access API
+ *
+ * Copyright 2011 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 version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/device.h>
+#include <linux/list.h>
+#include <linux/module.h>
+
+struct i2c_client;
+struct spi_device;
+
+struct regmap_config {
+        int reg_bits;
+        int val_bits;
+};
+
+typedef int (*regmap_hw_write)(struct device *dev, const void *data,
+                               size_t count);
+typedef int (*regmap_hw_gather_write)(struct device *dev,
+                                      const void *reg, size_t reg_len,
+                                      const void *val, size_t val_len);
+typedef int (*regmap_hw_read)(struct device *dev,
+                              const void *reg_buf, size_t reg_size,
+                              void *val_buf, size_t val_size);
+
+/**
+ * Description of a hardware bus for the register map infrastructure.
+ *
+ * @list: Internal use.
+ * @type: Bus type, used to identify bus to be used for a device.
+ * @write: Write operation.
+ * @gather_write: Write operation with split register/value, return -ENOTSUPP
+ *                if not implemented  on a given device.
+ * @read: Read operation.  Data is returned in the buffer used to transmit
+ *         data.
+ * @owner: Module with the bus implementation, used to pin the implementation
+ *         in memory.
+ * @read_flag_mask: Mask to be set in the top byte of the register when doing
+ *                  a read.
+ */
+struct regmap_bus {
+        struct list_head list;
+        struct bus_type *type;
+        regmap_hw_write write;
+        regmap_hw_gather_write gather_write;
+        regmap_hw_read read;
+        struct module *owner;
+        u8 read_flag_mask;
+};
+
+struct regmap *regmap_init(struct device *dev,
+                           const struct regmap_bus *bus,
+                           const struct regmap_config *config);
+struct regmap *regmap_init_i2c(struct i2c_client *i2c,
+                               const struct regmap_config *config);
+struct regmap *regmap_init_spi(struct spi_device *dev,
+                               const struct regmap_config *config);
+
+void regmap_exit(struct regmap *map);
+int regmap_write(struct regmap *map, unsigned int reg, unsigned int val);
+int regmap_raw_write(struct regmap *map, unsigned int reg,
+                     const void *val, size_t val_len);
+int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val);
+int regmap_raw_read(struct regmap *map, unsigned int reg,
+                    void *val, size_t val_len);
+int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
+                     size_t val_count);
+int regmap_update_bits(struct regmap *map, unsigned int reg,
+                       unsigned int mask, unsigned int val);
+
+#endif
diff --git a/include/linux/regulator/consumer.h b/include/linux/regulator/consumer.h
index 9e87c1cb7270..26f6ea4444e3 100644
--- a/include/linux/regulator/consumer.h
+++ b/include/linux/regulator/consumer.h
@@ -122,6 +122,9 @@ struct regulator;
 struct regulator_bulk_data {
         const char *supply;
         struct regulator *consumer;
+
+        /* Internal use */
+        int ret;
 };
 
 #if defined(CONFIG_REGULATOR)
diff --git a/include/linux/regulator/driver.h b/include/linux/regulator/driver.h
index 6c433b89c80d..1a80bc77517d 100644
--- a/include/linux/regulator/driver.h
+++ b/include/linux/regulator/driver.h
@@ -188,18 +188,16 @@ struct regulator_dev {
 
         /* lists we belong to */
         struct list_head list; /* list of all regulators */
-        struct list_head slist; /* list of supplied regulators */
 
         /* lists we own */
         struct list_head consumer_list; /* consumers we supply */
-        struct list_head supply_list; /* regulators we supply */
 
         struct blocking_notifier_head notifier;
         struct mutex mutex; /* consumer lock */
         struct module *owner;
         struct device dev;
         struct regulation_constraints *constraints;
-        struct regulator_dev *supply;   /* for tree */
+        struct regulator *supply;       /* for tree */
 
         void *reg_data;         /* regulator_dev data */
 
diff --git a/include/linux/reiserfs_acl.h b/include/linux/reiserfs_acl.h
index 3fd8c4506bbb..f096b80e73d8 100644
--- a/include/linux/reiserfs_acl.h
+++ b/include/linux/reiserfs_acl.h
@@ -59,11 +59,7 @@ extern const struct xattr_handler reiserfs_posix_acl_access_handler;
 #else
 
 #define reiserfs_cache_default_acl(inode) 0
-
-static inline struct posix_acl *reiserfs_get_acl(struct inode *inode, int type)
-{
-        return NULL;
-}
+#define reiserfs_get_acl NULL
 
 static inline int reiserfs_acl_chmod(struct inode *inode)
 {
diff --git a/include/linux/reiserfs_fs.h b/include/linux/reiserfs_fs.h
index eca75df00fed..96d465f8d3e6 100644
--- a/include/linux/reiserfs_fs.h
+++ b/include/linux/reiserfs_fs.h
@@ -2332,7 +2332,9 @@ __u32 keyed_hash(const signed char *msg, int len);
 __u32 yura_hash(const signed char *msg, int len);
 __u32 r5_hash(const signed char *msg, int len);
 
+#define reiserfs_set_le_bit             __set_bit_le
 #define reiserfs_test_and_set_le_bit    __test_and_set_bit_le
+#define reiserfs_clear_le_bit           __clear_bit_le
 #define reiserfs_test_and_clear_le_bit  __test_and_clear_bit_le
 #define reiserfs_test_le_bit            test_bit_le
 #define reiserfs_find_next_zero_le_bit  find_next_zero_bit_le
diff --git a/include/linux/reiserfs_xattr.h b/include/linux/reiserfs_xattr.h
index 6deef5dc95fb..c2b71473266e 100644
--- a/include/linux/reiserfs_xattr.h
+++ b/include/linux/reiserfs_xattr.h
@@ -41,7 +41,7 @@ int reiserfs_xattr_init(struct super_block *sb, int mount_flags);
 int reiserfs_lookup_privroot(struct super_block *sb);
 int reiserfs_delete_xattrs(struct inode *inode);
 int reiserfs_chown_xattrs(struct inode *inode, struct iattr *attrs);
-int reiserfs_permission(struct inode *inode, int mask, unsigned int flags);
+int reiserfs_permission(struct inode *inode, int mask);
 
 #ifdef CONFIG_REISERFS_FS_XATTR
 #define has_xattr_dir(inode) (REISERFS_I(inode)->i_flags & i_has_xattr_dir)
diff --git a/include/linux/ring_buffer.h b/include/linux/ring_buffer.h
index ab38ac80b0f9..b891de96000f 100644
--- a/include/linux/ring_buffer.h
+++ b/include/linux/ring_buffer.h
@@ -169,7 +169,7 @@ void ring_buffer_set_clock(struct ring_buffer *buffer,
 size_t ring_buffer_page_len(void *page);
 
 
-void *ring_buffer_alloc_read_page(struct ring_buffer *buffer);
+void *ring_buffer_alloc_read_page(struct ring_buffer *buffer, int cpu);
 void ring_buffer_free_read_page(struct ring_buffer *buffer, void *data);
 int ring_buffer_read_page(struct ring_buffer *buffer, void **data_page,
                           size_t len, int cpu, int full);
diff --git a/include/linux/rtmutex.h b/include/linux/rtmutex.h
index 8d522ffeda33..de17134244f3 100644
--- a/include/linux/rtmutex.h
+++ b/include/linux/rtmutex.h
@@ -66,7 +66,7 @@ struct hrtimer_sleeper;
 
 #define __RT_MUTEX_INITIALIZER(mutexname) \
         { .wait_lock = __RAW_SPIN_LOCK_UNLOCKED(mutexname.wait_lock) \
-        , .wait_list = PLIST_HEAD_INIT_RAW(mutexname.wait_list, mutexname.wait_lock) \
+        , .wait_list = PLIST_HEAD_INIT(mutexname.wait_list) \
         , .owner = NULL \
         __DEBUG_RT_MUTEX_INITIALIZER(mutexname)}
 
@@ -100,7 +100,7 @@ extern void rt_mutex_unlock(struct rt_mutex *lock);
 
 #ifdef CONFIG_RT_MUTEXES
 # define INIT_RT_MUTEXES(tsk)                                           \
-        .pi_waiters     = PLIST_HEAD_INIT(tsk.pi_waiters, tsk.pi_lock), \
+        .pi_waiters     = PLIST_HEAD_INIT(tsk.pi_waiters),      \
         INIT_RT_MUTEX_DEBUG(tsk)
 #else
 # define INIT_RT_MUTEXES(tsk)
diff --git a/include/linux/rtnetlink.h b/include/linux/rtnetlink.h
index bbad657a3725..8e872ead88b5 100644
--- a/include/linux/rtnetlink.h
+++ b/include/linux/rtnetlink.h
@@ -585,6 +585,8 @@ enum rtnetlink_groups {
 #define RTNLGRP_PHONET_IFADDR   RTNLGRP_PHONET_IFADDR
         RTNLGRP_PHONET_ROUTE,
 #define RTNLGRP_PHONET_ROUTE    RTNLGRP_PHONET_ROUTE
+        RTNLGRP_DCB,
+#define RTNLGRP_DCB             RTNLGRP_DCB
         __RTNLGRP_MAX
 };
 #define RTNLGRP_MAX     (__RTNLGRP_MAX - 1)
@@ -758,8 +760,7 @@ extern int lockdep_rtnl_is_held(void);
  * or RTNL. Note : Please prefer rtnl_dereference() or rcu_dereference()
  */
 #define rcu_dereference_rtnl(p)                                 \
-        rcu_dereference_check(p, rcu_read_lock_held() ||        \
-                                 lockdep_rtnl_is_held())
+        rcu_dereference_check(p, lockdep_rtnl_is_held())
 
 /**
  * rtnl_dereference - fetch RCU pointer when updates are prevented by RTNL
diff --git a/include/linux/rwsem.h b/include/linux/rwsem.h
index a8afe9cd000c..6a6741440cb7 100644
--- a/include/linux/rwsem.h
+++ b/include/linux/rwsem.h
@@ -15,7 +15,7 @@
 #include <linux/spinlock.h>
 
 #include <asm/system.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 struct rw_semaphore;
 
@@ -124,19 +124,9 @@ extern void downgrade_write(struct rw_semaphore *sem);
  */
 extern void down_read_nested(struct rw_semaphore *sem, int subclass);
 extern void down_write_nested(struct rw_semaphore *sem, int subclass);
-/*
- * Take/release a lock when not the owner will release it.
- *
- * [ This API should be avoided as much as possible - the
- *   proper abstraction for this case is completions. ]
- */
-extern void down_read_non_owner(struct rw_semaphore *sem);
-extern void up_read_non_owner(struct rw_semaphore *sem);
 #else
 # define down_read_nested(sem, subclass)                down_read(sem)
 # define down_write_nested(sem, subclass)       down_write(sem)
-# define down_read_non_owner(sem)               down_read(sem)
-# define up_read_non_owner(sem)                 up_read(sem)
 #endif
 
 #endif /* _LINUX_RWSEM_H */
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 2a8621c4be1e..20b03bf94748 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -808,7 +808,7 @@ enum cpu_idle_type {
  * when BITS_PER_LONG <= 32 are pretty high and the returns do not justify the
  * increased costs.
  */
-#if BITS_PER_LONG > 32
+#if 0 /* BITS_PER_LONG > 32 -- currently broken: it increases power usage under light load  */
 # define SCHED_LOAD_RESOLUTION  10
 # define scale_load(w)          ((w) << SCHED_LOAD_RESOLUTION)
 # define scale_load_down(w)     ((w) >> SCHED_LOAD_RESOLUTION)
@@ -844,6 +844,7 @@ enum cpu_idle_type {
 #define SD_SERIALIZE            0x0400  /* Only a single load balancing instance */
 #define SD_ASYM_PACKING         0x0800  /* Place busy groups earlier in the domain */
 #define SD_PREFER_SIBLING       0x1000  /* Prefer to place tasks in a sibling domain */
+#define SD_OVERLAP              0x2000  /* sched_domains of this level overlap */
 
 enum powersavings_balance_level {
         POWERSAVINGS_BALANCE_NONE = 0,  /* No power saving load balance */
@@ -893,16 +894,21 @@ static inline int sd_power_saving_flags(void)
         return 0;
 }
 
-struct sched_group {
-        struct sched_group *next;       /* Must be a circular list */
+struct sched_group_power {
         atomic_t ref;
-
         /*
          * CPU power of this group, SCHED_LOAD_SCALE being max power for a
          * single CPU.
          */
-        unsigned int cpu_power, cpu_power_orig;
+        unsigned int power, power_orig;
+};
+
+struct sched_group {
+        struct sched_group *next;       /* Must be a circular list */
+        atomic_t ref;
+
         unsigned int group_weight;
+        struct sched_group_power *sgp;
 
         /*
          * The CPUs this group covers.
@@ -1063,6 +1069,7 @@ struct sched_domain;
  */
 #define WF_SYNC         0x01            /* waker goes to sleep after wakup */
 #define WF_FORK         0x02            /* child wakeup after fork */
+#define WF_MIGRATED     0x04            /* internal use, task got migrated */
 
 #define ENQUEUE_WAKEUP          1
 #define ENQUEUE_HEAD            2
@@ -1253,6 +1260,9 @@ struct task_struct {
 #ifdef CONFIG_PREEMPT_RCU
         int rcu_read_lock_nesting;
         char rcu_read_unlock_special;
+#if defined(CONFIG_RCU_BOOST) && defined(CONFIG_TREE_PREEMPT_RCU)
+        int rcu_boosted;
+#endif /* #if defined(CONFIG_RCU_BOOST) && defined(CONFIG_TREE_PREEMPT_RCU) */
         struct list_head rcu_node_entry;
 #endif /* #ifdef CONFIG_PREEMPT_RCU */
 #ifdef CONFIG_TREE_PREEMPT_RCU
@@ -1282,7 +1292,7 @@ struct task_struct {
         int exit_state;
         int exit_code, exit_signal;
         int pdeath_signal;  /*  The signal sent when the parent dies  */
-        unsigned int group_stop;        /* GROUP_STOP_*, siglock protected */
+        unsigned int jobctl;    /* JOBCTL_*, siglock protected */
         /* ??? */
         unsigned int personality;
         unsigned did_exec:1;
@@ -1502,7 +1512,6 @@ struct task_struct {
         short il_next;
         short pref_node_fork;
 #endif
-        atomic_t fs_excl;       /* holding fs exclusive resources */
         struct rcu_head rcu;
 
         /*
@@ -1803,15 +1812,34 @@ extern void thread_group_times(struct task_struct *p, cputime_t *ut, cputime_t *
 #define used_math() tsk_used_math(current)
 
 /*
- * task->group_stop flags
+ * task->jobctl flags
  */
-#define GROUP_STOP_SIGMASK      0xffff    /* signr of the last group stop */
-#define GROUP_STOP_PENDING      (1 << 16) /* task should stop for group stop */
-#define GROUP_STOP_CONSUME      (1 << 17) /* consume group stop count */
-#define GROUP_STOP_TRAPPING     (1 << 18) /* switching from STOPPED to TRACED */
-#define GROUP_STOP_DEQUEUED     (1 << 19) /* stop signal dequeued */
-
-extern void task_clear_group_stop_pending(struct task_struct *task);
+#define JOBCTL_STOP_SIGMASK     0xffff  /* signr of the last group stop */
+
+#define JOBCTL_STOP_DEQUEUED_BIT 16     /* stop signal dequeued */
+#define JOBCTL_STOP_PENDING_BIT 17      /* task should stop for group stop */
+#define JOBCTL_STOP_CONSUME_BIT 18      /* consume group stop count */
+#define JOBCTL_TRAP_STOP_BIT    19      /* trap for STOP */
+#define JOBCTL_TRAP_NOTIFY_BIT  20      /* trap for NOTIFY */
+#define JOBCTL_TRAPPING_BIT     21      /* switching to TRACED */
+#define JOBCTL_LISTENING_BIT    22      /* ptracer is listening for events */
+
+#define JOBCTL_STOP_DEQUEUED    (1 << JOBCTL_STOP_DEQUEUED_BIT)
+#define JOBCTL_STOP_PENDING     (1 << JOBCTL_STOP_PENDING_BIT)
+#define JOBCTL_STOP_CONSUME     (1 << JOBCTL_STOP_CONSUME_BIT)
+#define JOBCTL_TRAP_STOP        (1 << JOBCTL_TRAP_STOP_BIT)
+#define JOBCTL_TRAP_NOTIFY      (1 << JOBCTL_TRAP_NOTIFY_BIT)
+#define JOBCTL_TRAPPING         (1 << JOBCTL_TRAPPING_BIT)
+#define JOBCTL_LISTENING        (1 << JOBCTL_LISTENING_BIT)
+
+#define JOBCTL_TRAP_MASK        (JOBCTL_TRAP_STOP | JOBCTL_TRAP_NOTIFY)
+#define JOBCTL_PENDING_MASK     (JOBCTL_STOP_PENDING | JOBCTL_TRAP_MASK)
+
+extern bool task_set_jobctl_pending(struct task_struct *task,
+                                    unsigned int mask);
+extern void task_clear_jobctl_trapping(struct task_struct *task);
+extern void task_clear_jobctl_pending(struct task_struct *task,
+                                      unsigned int mask);
 
 #ifdef CONFIG_PREEMPT_RCU
 
@@ -2126,7 +2154,7 @@ static inline int dequeue_signal_lock(struct task_struct *tsk, sigset_t *mask, s
         spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
 
         return ret;
-}       
+}
 
 extern void block_all_signals(int (*notifier)(void *priv), void *priv,
                               sigset_t *mask);
@@ -2141,7 +2169,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 int do_notify_parent(struct task_struct *, int);
+extern __must_check bool do_notify_parent(struct task_struct *, int);
 extern void __wake_up_parent(struct task_struct *p, struct task_struct *parent);
 extern void force_sig(int, struct task_struct *);
 extern int send_sig(int, struct task_struct *, int);
@@ -2265,8 +2293,10 @@ static inline int get_nr_threads(struct task_struct *tsk)
         return tsk->signal->nr_threads;
 }
 
-/* de_thread depends on thread_group_leader not being a pid based check */
-#define thread_group_leader(p)  (p == p->group_leader)
+static inline bool thread_group_leader(struct task_struct *p)
+{
+        return p->exit_signal >= 0;
+}
 
 /* Do to the insanities of de_thread it is possible for a process
  * to have the pid of the thread group leader without actually being
@@ -2299,11 +2329,6 @@ static inline int thread_group_empty(struct task_struct *p)
 #define delay_group_leader(p) \
                 (thread_group_leader(p) && !thread_group_empty(p))
 
-static inline int task_detached(struct task_struct *p)
-{
-        return p->exit_signal == -1;
-}
-
 /*
  * Protects ->fs, ->files, ->mm, ->group_info, ->comm, keyring
  * subscriptions and synchronises with wait4().  Also used in procfs.  Also
@@ -2500,7 +2525,7 @@ extern int _cond_resched(void);
 
 extern int __cond_resched_lock(spinlock_t *lock);
 
-#ifdef CONFIG_PREEMPT
+#ifdef CONFIG_PREEMPT_COUNT
 #define PREEMPT_LOCK_OFFSET     PREEMPT_OFFSET
 #else
 #define PREEMPT_LOCK_OFFSET     0
diff --git a/include/linux/sdla.h b/include/linux/sdla.h
index 564acd3a71c1..9995c7fc3f60 100644
--- a/include/linux/sdla.h
+++ b/include/linux/sdla.h
@@ -112,11 +112,7 @@ struct sdla_dlci_conf {
    short Tb_max;
 };
 
-#ifndef __KERNEL__
-
-void sdla(void *cfg_info, char *dev, struct frad_conf *conf, int quiet);
-
-#else
+#ifdef __KERNEL__
 
 /* important Z80 window addresses */
 #define SDLA_CONTROL_WND                0xE000
diff --git a/include/linux/seccomp.h b/include/linux/seccomp.h
index 167c33361d9c..cc7a4e9cc7ad 100644
--- a/include/linux/seccomp.h
+++ b/include/linux/seccomp.h
@@ -19,6 +19,11 @@ static inline void secure_computing(int this_syscall)
 extern long prctl_get_seccomp(void);
 extern long prctl_set_seccomp(unsigned long);
 
+static inline int seccomp_mode(seccomp_t *s)
+{
+        return s->mode;
+}
+
 #else /* CONFIG_SECCOMP */
 
 #include <linux/errno.h>
@@ -37,6 +42,11 @@ static inline long prctl_set_seccomp(unsigned long arg2)
         return -EINVAL;
 }
 
+static inline int seccomp_mode(seccomp_t *s)
+{
+        return 0;
+}
+
 #endif /* CONFIG_SECCOMP */
 
 #endif /* _LINUX_SECCOMP_H */
diff --git a/include/linux/security.h b/include/linux/security.h
index 8ce59ef3e5af..ebd2a53a3d07 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -1456,7 +1456,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, unsigned flags);
+        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);
         int (*inode_setxattr) (struct dentry *dentry, const char *name,
@@ -1720,7 +1720,6 @@ int security_inode_rename(struct inode *old_dir, struct dentry *old_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);
-int security_inode_exec_permission(struct inode *inode, unsigned int flags);
 int security_inode_setattr(struct dentry *dentry, struct iattr *attr);
 int security_inode_getattr(struct vfsmount *mnt, struct dentry *dentry);
 int security_inode_setxattr(struct dentry *dentry, const char *name,
@@ -2113,12 +2112,6 @@ static inline int security_inode_permission(struct inode *inode, int mask)
         return 0;
 }
 
-static inline int security_inode_exec_permission(struct inode *inode,
-                                                  unsigned int flags)
-{
-        return 0;
-}
-
 static inline int security_inode_setattr(struct dentry *dentry,
                                           struct iattr *attr)
 {
diff --git a/include/linux/sem.h b/include/linux/sem.h
index f2961afa2f66..1feb2de2ee57 100644
--- a/include/linux/sem.h
+++ b/include/linux/sem.h
@@ -77,7 +77,7 @@ struct  seminfo {
 #define SEMUSZ  20              /* sizeof struct sem_undo */
 
 #ifdef __KERNEL__
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <linux/rcupdate.h>
 #include <linux/cache.h>
 
diff --git a/include/linux/seq_file.h b/include/linux/seq_file.h
index 03c0232b4169..be720cd2038d 100644
--- a/include/linux/seq_file.h
+++ b/include/linux/seq_file.h
@@ -23,6 +23,7 @@ struct seq_file {
         u64 version;
         struct mutex lock;
         const struct seq_operations *op;
+        int poll_event;
         void *private;
 };
 
diff --git a/include/linux/seqlock.h b/include/linux/seqlock.h
index e9811892844f..c6db9fb33c44 100644
--- a/include/linux/seqlock.h
+++ b/include/linux/seqlock.h
@@ -28,6 +28,7 @@
 
 #include <linux/spinlock.h>
 #include <linux/preempt.h>
+#include <asm/processor.h>
 
 typedef struct {
         unsigned sequence;
diff --git a/include/linux/serial_sci.h b/include/linux/serial_sci.h
index a2afc9fbe186..8bffe9ae2ca0 100644
--- a/include/linux/serial_sci.h
+++ b/include/linux/serial_sci.h
@@ -8,6 +8,8 @@
  * Generic header for SuperH SCI(F) (used by sh/sh64/h8300 and related parts)
  */
 
+#define SCIx_NOT_SUPPORTED      (-1)
+
 enum {
         SCBRR_ALGO_1,           /* ((clk + 16 * bps) / (16 * bps) - 1) */
         SCBRR_ALGO_2,           /* ((clk + 16 * bps) / (32 * bps) - 1) */
@@ -25,6 +27,28 @@ enum {
 #define SCSCR_CKE1      (1 << 1)
 #define SCSCR_CKE0      (1 << 0)
 
+/* SCxSR SCI */
+#define SCI_TDRE  0x80
+#define SCI_RDRF  0x40
+#define SCI_ORER  0x20
+#define SCI_FER   0x10
+#define SCI_PER   0x08
+#define SCI_TEND  0x04
+
+#define SCI_DEFAULT_ERROR_MASK (SCI_PER | SCI_FER)
+
+/* SCxSR SCIF */
+#define SCIF_ER    0x0080
+#define SCIF_TEND  0x0040
+#define SCIF_TDFE  0x0020
+#define SCIF_BRK   0x0010
+#define SCIF_FER   0x0008
+#define SCIF_PER   0x0004
+#define SCIF_RDF   0x0002
+#define SCIF_DR    0x0001
+
+#define SCIF_DEFAULT_ERROR_MASK (SCIF_PER | SCIF_FER | SCIF_ER | SCIF_BRK)
+
 /* Offsets into the sci_port->irqs array */
 enum {
         SCIx_ERI_IRQ,
@@ -32,6 +56,24 @@ enum {
         SCIx_TXI_IRQ,
         SCIx_BRI_IRQ,
         SCIx_NR_IRQS,
+
+        SCIx_MUX_IRQ = SCIx_NR_IRQS,    /* special case */
+};
+
+enum {
+        SCIx_PROBE_REGTYPE,
+
+        SCIx_SCI_REGTYPE,
+        SCIx_IRDA_REGTYPE,
+        SCIx_SCIFA_REGTYPE,
+        SCIx_SCIFB_REGTYPE,
+        SCIx_SH3_SCIF_REGTYPE,
+        SCIx_SH4_SCIF_REGTYPE,
+        SCIx_SH4_SCIF_NO_SCSPTR_REGTYPE,
+        SCIx_SH4_SCIF_FIFODATA_REGTYPE,
+        SCIx_SH7705_SCIF_REGTYPE,
+
+        SCIx_NR_REGTYPES,
 };
 
 #define SCIx_IRQ_MUXED(irq)             \
@@ -42,8 +84,29 @@ enum {
         [SCIx_BRI_IRQ]  = (irq),        \
 }
 
+#define SCIx_IRQ_IS_MUXED(port)                 \
+        ((port)->cfg->irqs[SCIx_ERI_IRQ] ==     \
+         (port)->cfg->irqs[SCIx_RXI_IRQ]) ||    \
+        ((port)->cfg->irqs[SCIx_ERI_IRQ] &&     \
+         !(port)->cfg->irqs[SCIx_RXI_IRQ])
+/*
+ * SCI register subset common for all port types.
+ * Not all registers will exist on all parts.
+ */
+enum {
+        SCSMR, SCBRR, SCSCR, SCxSR,
+        SCFCR, SCFDR, SCxTDR, SCxRDR,
+        SCLSR, SCTFDR, SCRFDR, SCSPTR,
+
+        SCIx_NR_REGS,
+};
+
 struct device;
 
+struct plat_sci_port_ops {
+        void (*init_pins)(struct uart_port *, unsigned int cflag);
+};
+
 /*
  * Platform device specific platform_data struct
  */
@@ -56,6 +119,18 @@ struct plat_sci_port {
         unsigned int    scbrr_algo_id;          /* SCBRR calculation algo */
         unsigned int    scscr;                  /* SCSCR initialization */
 
+        /*
+         * Platform overrides if necessary, defaults otherwise.
+         */
+        int             overrun_bit;
+        unsigned int    error_mask;
+
+        int             port_reg;
+        unsigned char   regshift;
+        unsigned char   regtype;
+
+        struct plat_sci_port_ops        *ops;
+
         struct device   *dma_dev;
 
         unsigned int    dma_slave_tx;
diff --git a/include/linux/sh_clk.h b/include/linux/sh_clk.h
index 9a52f72527dc..3ccf18648d0a 100644
--- a/include/linux/sh_clk.h
+++ b/include/linux/sh_clk.h
@@ -147,4 +147,8 @@ int sh_clk_div4_reparent_register(struct clk *clks, int nr,
 int sh_clk_div6_register(struct clk *clks, int nr);
 int sh_clk_div6_reparent_register(struct clk *clks, int nr);
 
+#define CLKDEV_CON_ID(_id, _clk) { .con_id = _id, .clk = _clk }
+#define CLKDEV_DEV_ID(_id, _clk) { .dev_id = _id, .clk = _clk }
+#define CLKDEV_ICK_ID(_cid, _did, _clk) { .con_id = _cid, .dev_id = _did, .clk = _clk }
+
 #endif /* __SH_CLOCK_H */
diff --git a/include/linux/sh_dma.h b/include/linux/sh_dma.h
index b08cd4efa15c..cb2dd118cc0f 100644
--- a/include/linux/sh_dma.h
+++ b/include/linux/sh_dma.h
@@ -62,6 +62,12 @@ struct sh_dmae_pdata {
         const unsigned int *ts_shift;
         int ts_shift_num;
         u16 dmaor_init;
+        unsigned int chcr_offset;
+        u32 chcr_ie_bit;
+
+        unsigned int dmaor_is_32bit:1;
+        unsigned int needs_tend_set:1;
+        unsigned int no_dmars:1;
 };
 
 /* DMA register */
@@ -71,6 +77,8 @@ struct sh_dmae_pdata {
 #define CHCR    0x0C
 #define DMAOR   0x40
 
+#define TEND    0x18 /* USB-DMAC */
+
 /* DMAOR definitions */
 #define DMAOR_AE        0x00000004
 #define DMAOR_NMIF      0x00000002
diff --git a/include/linux/shm.h b/include/linux/shm.h
index eca6235a46c0..92808b86703b 100644
--- a/include/linux/shm.h
+++ b/include/linux/shm.h
@@ -95,6 +95,9 @@ struct shmid_kernel /* private to the kernel */
         pid_t                   shm_cprid;
         pid_t                   shm_lprid;
         struct user_struct      *mlock_user;
+
+        /* The task created the shm object.  NULL if the task is dead. */
+        struct task_struct      *shm_creator;
 };
 
 /* shm_mode upper byte flags */
@@ -106,6 +109,7 @@ struct shmid_kernel /* private to the kernel */
 #ifdef CONFIG_SYSVIPC
 long do_shmat(int shmid, char __user *shmaddr, int shmflg, unsigned long *addr);
 extern int is_file_shm_hugepages(struct file *file);
+extern void exit_shm(struct task_struct *task);
 #else
 static inline long do_shmat(int shmid, char __user *shmaddr,
                                 int shmflg, unsigned long *addr)
@@ -116,6 +120,9 @@ static inline int is_file_shm_hugepages(struct file *file)
 {
         return 0;
 }
+static inline void exit_shm(struct task_struct *task)
+{
+}
 #endif
 
 #endif /* __KERNEL__ */
diff --git a/include/linux/shmem_fs.h b/include/linux/shmem_fs.h
index 2b7fec840517..9291ac3cc627 100644
--- a/include/linux/shmem_fs.h
+++ b/include/linux/shmem_fs.h
@@ -3,26 +3,20 @@
 
 #include <linux/swap.h>
 #include <linux/mempolicy.h>
+#include <linux/pagemap.h>
 #include <linux/percpu_counter.h>
 
 /* inode in-kernel data */
 
-#define SHMEM_NR_DIRECT 16
-
-#define SHMEM_SYMLINK_INLINE_LEN (SHMEM_NR_DIRECT * sizeof(swp_entry_t))
-
 struct shmem_inode_info {
         spinlock_t              lock;
         unsigned long           flags;
         unsigned long           alloced;        /* data pages alloced to file */
-        unsigned long           swapped;        /* subtotal assigned to swap */
-        unsigned long           next_index;     /* highest alloced index + 1 */
-        struct shared_policy    policy;         /* NUMA memory alloc policy */
-        struct page             *i_indirect;    /* top indirect blocks page */
         union {
-                swp_entry_t     i_direct[SHMEM_NR_DIRECT]; /* first blocks */
-                char            inline_symlink[SHMEM_SYMLINK_INLINE_LEN];
+                unsigned long   swapped;        /* subtotal assigned to swap */
+                char            *symlink;       /* unswappable short symlink */
         };
+        struct shared_policy    policy;         /* NUMA memory alloc policy */
         struct list_head        swaplist;       /* chain of maybes on swap */
         struct list_head        xattr_list;     /* list of shmem_xattr */
         struct inode            vfs_inode;
@@ -45,7 +39,25 @@ static inline struct shmem_inode_info *SHMEM_I(struct inode *inode)
         return container_of(inode, struct shmem_inode_info, vfs_inode);
 }
 
-extern int init_tmpfs(void);
+/*
+ * Functions in mm/shmem.c called directly from elsewhere:
+ */
+extern int shmem_init(void);
 extern int shmem_fill_super(struct super_block *sb, void *data, int silent);
+extern struct file *shmem_file_setup(const char *name,
+                                        loff_t size, unsigned long flags);
+extern int shmem_zero_setup(struct vm_area_struct *);
+extern int shmem_lock(struct file *file, int lock, struct user_struct *user);
+extern struct page *shmem_read_mapping_page_gfp(struct address_space *mapping,
+                                        pgoff_t index, gfp_t gfp_mask);
+extern void shmem_truncate_range(struct inode *inode, loff_t start, loff_t end);
+extern int shmem_unuse(swp_entry_t entry, struct page *page);
+
+static inline struct page *shmem_read_mapping_page(
+                                struct address_space *mapping, pgoff_t index)
+{
+        return shmem_read_mapping_page_gfp(mapping, index,
+                                        mapping_gfp_mask(mapping));
+}
 
 #endif
diff --git a/include/linux/shrinker.h b/include/linux/shrinker.h
new file mode 100644
index 000000000000..790651b4e5ba
--- /dev/null
+++ b/include/linux/shrinker.h
@@ -0,0 +1,42 @@
+#ifndef _LINUX_SHRINKER_H
+#define _LINUX_SHRINKER_H
+
+/*
+ * This struct is used to pass information from page reclaim to the shrinkers.
+ * We consolidate the values for easier extention later.
+ */
+struct shrink_control {
+        gfp_t gfp_mask;
+
+        /* How many slab objects shrinker() should scan and try to reclaim */
+        unsigned long nr_to_scan;
+};
+
+/*
+ * A callback you can register to apply pressure to ageable caches.
+ *
+ * 'sc' is passed shrink_control which includes a count 'nr_to_scan'
+ * and a 'gfpmask'.  It should look through the least-recently-used
+ * 'nr_to_scan' entries and attempt to free them up.  It should return
+ * the number of objects which remain in the cache.  If it returns -1, it means
+ * it cannot do any scanning at this time (eg. there is a risk of deadlock).
+ *
+ * The 'gfpmask' refers to the allocation we are currently trying to
+ * fulfil.
+ *
+ * Note that 'shrink' will be passed nr_to_scan == 0 when the VM is
+ * querying the cache size, so a fastpath for that case is appropriate.
+ */
+struct shrinker {
+        int (*shrink)(struct shrinker *, struct shrink_control *sc);
+        int seeks;      /* seeks to recreate an obj */
+        long batch;     /* reclaim batch size, 0 = default */
+
+        /* These are for internal use */
+        struct list_head list;
+        long nr;        /* objs pending delete */
+};
+#define DEFAULT_SEEKS 2 /* A good number if you don't know better. */
+extern void register_shrinker(struct shrinker *);
+extern void unregister_shrinker(struct shrinker *);
+#endif
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index e8b78ce14474..7b996ed86d5b 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -20,7 +20,7 @@
 #include <linux/time.h>
 #include <linux/cache.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <asm/types.h>
 #include <linux/spinlock.h>
 #include <linux/net.h>
@@ -187,6 +187,20 @@ enum {
 
         /* ensure the originating sk reference is available on driver level */
         SKBTX_DRV_NEEDS_SK_REF = 1 << 3,
+
+        /* device driver supports TX zero-copy buffers */
+        SKBTX_DEV_ZEROCOPY = 1 << 4,
+};
+
+/*
+ * The callback notifies userspace to release buffers when skb DMA is done in
+ * lower device, the skb last reference should be 0 when calling this.
+ * The desc is used to track userspace buffer index.
+ */
+struct ubuf_info {
+        void (*callback)(void *);
+        void *arg;
+        unsigned long desc;
 };
 
 /* This data is invariant across clones and lives at
@@ -211,6 +225,7 @@ struct skb_shared_info {
         /* Intermediate layers must ensure that destructor_arg
          * remains valid until skb destructor */
         void *          destructor_arg;
+
         /* must be last field, see pskb_expand_head() */
         skb_frag_t      frags[MAX_SKB_FRAGS];
 };
@@ -270,15 +285,12 @@ typedef unsigned char *sk_buff_data_t;
  *      struct sk_buff - socket buffer
  *      @next: Next buffer in list
  *      @prev: Previous buffer in list
- *      @sk: Socket we are owned by
  *      @tstamp: Time we arrived
+ *      @sk: Socket we are owned by
  *      @dev: Device we arrived on/are leaving by
- *      @transport_header: Transport layer header
- *      @network_header: Network layer header
- *      @mac_header: Link layer header
+ *      @cb: Control buffer. Free for use by every layer. Put private vars here
  *      @_skb_refdst: destination entry (with norefcount bit)
  *      @sp: the security path, used for xfrm
- *      @cb: Control buffer. Free for use by every layer. Put private vars here
  *      @len: Length of actual data
  *      @data_len: Data length
  *      @mac_len: Length of link layer header
@@ -286,40 +298,45 @@ typedef unsigned char *sk_buff_data_t;
  *      @csum: Checksum (must include start/offset pair)
  *      @csum_start: Offset from skb->head where checksumming should start
  *      @csum_offset: Offset from csum_start where checksum should be stored
+ *      @priority: Packet queueing priority
  *      @local_df: allow local fragmentation
  *      @cloned: Head may be cloned (check refcnt to be sure)
+ *      @ip_summed: Driver fed us an IP checksum
  *      @nohdr: Payload reference only, must not modify header
+ *      @nfctinfo: Relationship of this skb to the connection
  *      @pkt_type: Packet class
  *      @fclone: skbuff clone status
- *      @ip_summed: Driver fed us an IP checksum
- *      @priority: Packet queueing priority
- *      @users: User count - see {datagram,tcp}.c
- *      @protocol: Packet protocol from driver
- *      @truesize: Buffer size 
- *      @head: Head of buffer
- *      @data: Data head pointer
- *      @tail: Tail pointer
- *      @end: End pointer
- *      @destructor: Destruct function
- *      @mark: Generic packet mark
- *      @nfct: Associated connection, if any
  *      @ipvs_property: skbuff is owned by ipvs
  *      @peeked: this packet has been seen already, so stats have been
  *              done for it, don't do them again
  *      @nf_trace: netfilter packet trace flag
- *      @nfctinfo: Relationship of this skb to the connection
+ *      @protocol: Packet protocol from driver
+ *      @destructor: Destruct function
+ *      @nfct: Associated connection, if any
  *      @nfct_reasm: netfilter conntrack re-assembly pointer
  *      @nf_bridge: Saved data about a bridged frame - see br_netfilter.c
  *      @skb_iif: ifindex of device we arrived on
- *      @rxhash: the packet hash computed on receive
- *      @queue_mapping: Queue mapping for multiqueue devices
  *      @tc_index: Traffic control index
  *      @tc_verd: traffic control verdict
+ *      @rxhash: the packet hash computed on receive
+ *      @queue_mapping: Queue mapping for multiqueue devices
  *      @ndisc_nodetype: router type (from link layer)
+ *      @ooo_okay: allow the mapping of a socket to a queue to be changed
  *      @dma_cookie: a cookie to one of several possible DMA operations
  *              done by skb DMA functions
  *      @secmark: security marking
+ *      @mark: Generic packet mark
+ *      @dropcount: total number of sk_receive_queue overflows
  *      @vlan_tci: vlan tag control information
+ *      @transport_header: Transport layer header
+ *      @network_header: Network layer header
+ *      @mac_header: Link layer header
+ *      @tail: Tail pointer
+ *      @end: End pointer
+ *      @head: Head of buffer
+ *      @data: Data head pointer
+ *      @truesize: Buffer size
+ *      @users: User count - see {datagram,tcp}.c
  */
 
 struct sk_buff {
@@ -1256,6 +1273,11 @@ static inline void skb_reserve(struct sk_buff *skb, int len)
         skb->tail += len;
 }
 
+static inline void skb_reset_mac_len(struct sk_buff *skb)
+{
+        skb->mac_len = skb->network_header - skb->mac_header;
+}
+
 #ifdef NET_SKBUFF_DATA_USES_OFFSET
 static inline unsigned char *skb_transport_header(const struct sk_buff *skb)
 {
@@ -1557,16 +1579,22 @@ static inline struct sk_buff *netdev_alloc_skb(struct net_device *dev,
         return __netdev_alloc_skb(dev, length, GFP_ATOMIC);
 }
 
-static inline struct sk_buff *netdev_alloc_skb_ip_align(struct net_device *dev,
-                unsigned int length)
+static inline struct sk_buff *__netdev_alloc_skb_ip_align(struct net_device *dev,
+                unsigned int length, gfp_t gfp)
 {
-        struct sk_buff *skb = netdev_alloc_skb(dev, length + NET_IP_ALIGN);
+        struct sk_buff *skb = __netdev_alloc_skb(dev, length + NET_IP_ALIGN, gfp);
 
         if (NET_IP_ALIGN && skb)
                 skb_reserve(skb, NET_IP_ALIGN);
         return skb;
 }
 
+static inline struct sk_buff *netdev_alloc_skb_ip_align(struct net_device *dev,
+                unsigned int length)
+{
+        return __netdev_alloc_skb_ip_align(dev, length, GFP_ATOMIC);
+}
+
 /**
  *      __netdev_alloc_page - allocate a page for ps-rx on a specific device
  *      @dev: network device to receive on
@@ -2023,8 +2051,7 @@ static inline void sw_tx_timestamp(struct sk_buff *skb)
  * skb_tx_timestamp() - Driver hook for transmit timestamping
  *
  * Ethernet MAC Drivers should call this function in their hard_xmit()
- * function as soon as possible after giving the sk_buff to the MAC
- * hardware, but before freeing the sk_buff.
+ * function immediately before giving the sk_buff to the MAC hardware.
  *
  * @skb: A socket buffer.
  */
@@ -2261,5 +2288,6 @@ static inline void skb_checksum_none_assert(struct sk_buff *skb)
 }
 
 bool skb_partial_csum_set(struct sk_buff *skb, u16 start, u16 off);
+
 #endif  /* __KERNEL__ */
 #endif  /* _LINUX_SKBUFF_H */
diff --git a/include/linux/slab.h b/include/linux/slab.h
index ad4dd1c8d30a..573c809c33d9 100644
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@ -134,6 +134,26 @@ unsigned int kmem_cache_size(struct kmem_cache *);
 #define KMALLOC_MAX_ORDER       (KMALLOC_SHIFT_HIGH - PAGE_SHIFT)
 
 /*
+ * Some archs want to perform DMA into kmalloc caches and need a guaranteed
+ * alignment larger than the alignment of a 64-bit integer.
+ * Setting ARCH_KMALLOC_MINALIGN in arch headers allows that.
+ */
+#ifdef ARCH_DMA_MINALIGN
+#define ARCH_KMALLOC_MINALIGN ARCH_DMA_MINALIGN
+#else
+#define ARCH_KMALLOC_MINALIGN __alignof__(unsigned long long)
+#endif
+
+/*
+ * Setting ARCH_SLAB_MINALIGN in arch headers allows a different alignment.
+ * Intended for arches that get misalignment faults even for 64 bit integer
+ * aligned buffers.
+ */
+#ifndef ARCH_SLAB_MINALIGN
+#define ARCH_SLAB_MINALIGN __alignof__(unsigned long long)
+#endif
+
+/*
  * Common kmalloc functions provided by all allocators
  */
 void * __must_check __krealloc(const void *, size_t, gfp_t);
diff --git a/include/linux/slab_def.h b/include/linux/slab_def.h
index 83203ae9390b..d00e0bacda93 100644
--- a/include/linux/slab_def.h
+++ b/include/linux/slab_def.h
@@ -18,53 +18,25 @@
 #include <trace/events/kmem.h>
 
 /*
- * Enforce a minimum alignment for the kmalloc caches.
- * Usually, the kmalloc caches are cache_line_size() aligned, except when
- * DEBUG and FORCED_DEBUG are enabled, then they are BYTES_PER_WORD aligned.
- * Some archs want to perform DMA into kmalloc caches and need a guaranteed
- * alignment larger than the alignment of a 64-bit integer.
- * ARCH_KMALLOC_MINALIGN allows that.
- * Note that increasing this value may disable some debug features.
- */
-#ifdef ARCH_DMA_MINALIGN
-#define ARCH_KMALLOC_MINALIGN ARCH_DMA_MINALIGN
-#else
-#define ARCH_KMALLOC_MINALIGN __alignof__(unsigned long long)
-#endif
-
-#ifndef ARCH_SLAB_MINALIGN
-/*
- * Enforce a minimum alignment for all caches.
- * Intended for archs that get misalignment faults even for BYTES_PER_WORD
- * aligned buffers. Includes ARCH_KMALLOC_MINALIGN.
- * If possible: Do not enable this flag for CONFIG_DEBUG_SLAB, it disables
- * some debug features.
- */
-#define ARCH_SLAB_MINALIGN 0
-#endif
-
-/*
  * struct kmem_cache
  *
  * manages a cache.
  */
 
 struct kmem_cache {
-/* 1) per-cpu data, touched during every alloc/free */
-        struct array_cache *array[NR_CPUS];
-/* 2) Cache tunables. Protected by cache_chain_mutex */
+/* 1) Cache tunables. Protected by cache_chain_mutex */
         unsigned int batchcount;
         unsigned int limit;
         unsigned int shared;
 
         unsigned int buffer_size;
         u32 reciprocal_buffer_size;
-/* 3) touched by every alloc & free from the backend */
+/* 2) touched by every alloc & free from the backend */
 
         unsigned int flags;             /* constant flags */
         unsigned int num;               /* # of objs per slab */
 
-/* 4) cache_grow/shrink */
+/* 3) cache_grow/shrink */
         /* order of pgs per slab (2^n) */
         unsigned int gfporder;
 
@@ -80,11 +52,11 @@ struct kmem_cache {
         /* constructor func */
         void (*ctor)(void *obj);
 
-/* 5) cache creation/removal */
+/* 4) cache creation/removal */
         const char *name;
         struct list_head next;
 
-/* 6) statistics */
+/* 5) statistics */
 #ifdef CONFIG_DEBUG_SLAB
         unsigned long num_active;
         unsigned long num_allocations;
@@ -111,16 +83,18 @@ struct kmem_cache {
         int obj_size;
 #endif /* CONFIG_DEBUG_SLAB */
 
+/* 6) per-cpu/per-node data, touched during every alloc/free */
         /*
-         * We put nodelists[] at the end of kmem_cache, because we want to size
-         * this array to nr_node_ids slots instead of MAX_NUMNODES
+         * We put array[] at the end of kmem_cache, because we want to size
+         * this array to nr_cpu_ids slots instead of NR_CPUS
          * (see kmem_cache_init())
-         * We still use [MAX_NUMNODES] and not [1] or [0] because cache_cache
-         * is statically defined, so we reserve the max number of nodes.
+         * We still use [NR_CPUS] and not [1] or [0] because cache_cache
+         * is statically defined, so we reserve the max number of cpus.
          */
-        struct kmem_list3 *nodelists[MAX_NUMNODES];
+        struct kmem_list3 **nodelists;
+        struct array_cache *array[NR_CPUS];
         /*
-         * Do not add fields after nodelists[]
+         * Do not add fields after array[]
          */
 };
 
diff --git a/include/linux/slob_def.h b/include/linux/slob_def.h
index 4382db09df4f..0ec00b39d006 100644
--- a/include/linux/slob_def.h
+++ b/include/linux/slob_def.h
@@ -1,16 +1,6 @@
 #ifndef __LINUX_SLOB_DEF_H
 #define __LINUX_SLOB_DEF_H
 
-#ifdef ARCH_DMA_MINALIGN
-#define ARCH_KMALLOC_MINALIGN ARCH_DMA_MINALIGN
-#else
-#define ARCH_KMALLOC_MINALIGN __alignof__(unsigned long)
-#endif
-
-#ifndef ARCH_SLAB_MINALIGN
-#define ARCH_SLAB_MINALIGN __alignof__(unsigned long)
-#endif
-
 void *kmem_cache_alloc_node(struct kmem_cache *, gfp_t flags, int node);
 
 static __always_inline void *kmem_cache_alloc(struct kmem_cache *cachep,
diff --git a/include/linux/slub_def.h b/include/linux/slub_def.h
index c8668d161dd8..f58d6413d230 100644
--- a/include/linux/slub_def.h
+++ b/include/linux/slub_def.h
@@ -24,6 +24,7 @@ enum stat_item {
         ALLOC_FROM_PARTIAL,     /* Cpu slab acquired from partial list */
         ALLOC_SLAB,             /* Cpu slab acquired from page allocator */
         ALLOC_REFILL,           /* Refill cpu slab from slab freelist */
+        ALLOC_NODE_MISMATCH,    /* Switching cpu slab */
         FREE_SLAB,              /* Slab freed to the page allocator */
         CPUSLAB_FLUSH,          /* Abandoning of the cpu slab */
         DEACTIVATE_FULL,        /* Cpu slab was full when deactivated */
@@ -31,8 +32,10 @@ enum stat_item {
         DEACTIVATE_TO_HEAD,     /* Cpu slab was moved to the head of partials */
         DEACTIVATE_TO_TAIL,     /* Cpu slab was moved to the tail of partials */
         DEACTIVATE_REMOTE_FREES,/* Slab contained remotely freed objects */
+        DEACTIVATE_BYPASS,      /* Implicit deactivation */
         ORDER_FALLBACK,         /* Number of times fallback was necessary */
         CMPXCHG_DOUBLE_CPU_FAIL,/* Failure of this_cpu_cmpxchg_double */
+        CMPXCHG_DOUBLE_FAIL,    /* Number of times that cmpxchg double did not match */
         NR_SLUB_STAT_ITEMS };
 
 struct kmem_cache_cpu {
@@ -113,16 +116,6 @@ struct kmem_cache {
 
 #define KMALLOC_SHIFT_LOW ilog2(KMALLOC_MIN_SIZE)
 
-#ifdef ARCH_DMA_MINALIGN
-#define ARCH_KMALLOC_MINALIGN ARCH_DMA_MINALIGN
-#else
-#define ARCH_KMALLOC_MINALIGN __alignof__(unsigned long long)
-#endif
-
-#ifndef ARCH_SLAB_MINALIGN
-#define ARCH_SLAB_MINALIGN __alignof__(unsigned long long)
-#endif
-
 /*
  * Maximum kmalloc object size handled by SLUB. Larger object allocations
  * are passed through to the page allocator. The page allocator "fastpath"
@@ -228,6 +221,19 @@ kmalloc_order(size_t size, gfp_t flags, unsigned int order)
         return ret;
 }
 
+/**
+ * Calling this on allocated memory will check that the memory
+ * is expected to be in use, and print warnings if not.
+ */
+#ifdef CONFIG_SLUB_DEBUG
+extern bool verify_mem_not_deleted(const void *x);
+#else
+static inline bool verify_mem_not_deleted(const void *x)
+{
+        return true;
+}
+#endif
+
 #ifdef CONFIG_TRACING
 extern void *
 kmem_cache_alloc_trace(struct kmem_cache *s, gfp_t gfpflags, size_t size);
diff --git a/include/linux/smp.h b/include/linux/smp.h
index 7ad824d510a2..8cc38d3bab0c 100644
--- a/include/linux/smp.h
+++ b/include/linux/smp.h
@@ -85,12 +85,15 @@ int smp_call_function_any(const struct cpumask *mask,
  * Generic and arch helpers
  */
 #ifdef CONFIG_USE_GENERIC_SMP_HELPERS
+void __init call_function_init(void);
 void generic_smp_call_function_single_interrupt(void);
 void generic_smp_call_function_interrupt(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 call_function_init(void) { }
 #endif
 
 /*
@@ -134,7 +137,7 @@ static inline void smp_send_reschedule(int cpu) { }
 #define smp_prepare_boot_cpu()                  do {} while (0)
 #define smp_call_function_many(mask, func, info, wait) \
                         (up_smp_call_function(func, info))
-static inline void init_call_single_data(void) { }
+static inline void call_function_init(void) { }
 
 static inline int
 smp_call_function_any(const struct cpumask *mask, smp_call_func_t func,
diff --git a/include/linux/socket.h b/include/linux/socket.h
index 4ef98e422fde..e17f82266639 100644
--- a/include/linux/socket.h
+++ b/include/linux/socket.h
@@ -192,7 +192,8 @@ struct ucred {
 #define AF_IEEE802154   36      /* IEEE802154 sockets           */
 #define AF_CAIF         37      /* CAIF sockets                 */
 #define AF_ALG          38      /* Algorithm sockets            */
-#define AF_MAX          39      /* For now.. */
+#define AF_NFC          39      /* NFC sockets                  */
+#define AF_MAX          40      /* For now.. */
 
 /* Protocol families, same as address families. */
 #define PF_UNSPEC       AF_UNSPEC
@@ -234,6 +235,7 @@ struct ucred {
 #define PF_IEEE802154   AF_IEEE802154
 #define PF_CAIF         AF_CAIF
 #define PF_ALG          AF_ALG
+#define PF_NFC          AF_NFC
 #define PF_MAX          AF_MAX
 
 /* Maximum queue length specifiable by listen.  */
diff --git a/include/linux/sonet.h b/include/linux/sonet.h
index 67ad11fcf88b..de8832dd272b 100644
--- a/include/linux/sonet.h
+++ b/include/linux/sonet.h
@@ -58,7 +58,7 @@ struct sonet_stats {
 
 #ifdef __KERNEL__
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 struct k_sonet_stats {
 #define __HANDLE_ITEM(i) atomic_t i
diff --git a/include/linux/spi/74x164.h b/include/linux/spi/74x164.h
index d85c52f294a0..0aa6acc73317 100644
--- a/include/linux/spi/74x164.h
+++ b/include/linux/spi/74x164.h
@@ -1,8 +1,6 @@
 #ifndef LINUX_SPI_74X164_H
 #define LINUX_SPI_74X164_H
 
-#define GEN_74X164_DRIVER_NAME "74x164"
-
 struct gen_74x164_chip_platform_data {
         /* number assigned to the first GPIO */
         unsigned        base;
diff --git a/include/linux/spi/mcp23s08.h b/include/linux/spi/mcp23s08.h
index c42cff8ca191..2d676d5aaa89 100644
--- a/include/linux/spi/mcp23s08.h
+++ b/include/linux/spi/mcp23s08.h
@@ -22,13 +22,4 @@ struct mcp23s08_platform_data {
          * base to base+15 (or base+31 for s17 variant).
          */
         unsigned        base;
-
-        void            *context;       /* param to setup/teardown */
-
-        int             (*setup)(struct spi_device *spi,
-                                        int gpio, unsigned ngpio,
-                                        void *context);
-        int             (*teardown)(struct spi_device *spi,
-                                        int gpio, unsigned ngpio,
-                                        void *context);
 };
diff --git a/include/linux/spinlock.h b/include/linux/spinlock.h
index 0b22d51258e6..7df6c17b0281 100644
--- a/include/linux/spinlock.h
+++ b/include/linux/spinlock.h
@@ -384,7 +384,7 @@ static inline void assert_spin_locked(spinlock_t *lock)
  * Pull the atomic_t declaration:
  * (asm-mips/atomic.h needs above definitions)
  */
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 /**
  * atomic_dec_and_lock - lock on reaching reference count zero
  * @atomic: the atomic counter
diff --git a/include/linux/splice.h b/include/linux/splice.h
index 997c3b4c212b..26e5b613deda 100644
--- a/include/linux/splice.h
+++ b/include/linux/splice.h
@@ -88,5 +88,7 @@ extern ssize_t splice_direct_to_actor(struct file *, struct splice_desc *,
 extern int splice_grow_spd(struct pipe_inode_info *, struct splice_pipe_desc *);
 extern void splice_shrink_spd(struct pipe_inode_info *,
                                 struct splice_pipe_desc *);
+extern void spd_release_page(struct splice_pipe_desc *, unsigned int);
 
+extern const struct pipe_buf_operations page_cache_pipe_buf_ops;
 #endif
diff --git a/include/linux/ssb/ssb.h b/include/linux/ssb/ssb.h
index 252e44821787..8623217f84d0 100644
--- a/include/linux/ssb/ssb.h
+++ b/include/linux/ssb/ssb.h
@@ -27,6 +27,8 @@ struct ssb_sprom {
         u8 et1mdcport;          /* MDIO for enet1 */
         u8 board_rev;           /* Board revision number from SPROM. */
         u8 country_code;        /* Country Code */
+        u16 leddc_on_time;      /* LED Powersave Duty Cycle On Count */
+        u16 leddc_off_time;     /* LED Powersave Duty Cycle Off Count */
         u8 ant_available_a;     /* 2GHz antenna available bits (up to 4) */
         u8 ant_available_bg;    /* 5GHz antenna available bits (up to 4) */
         u16 pa0b0;
@@ -99,7 +101,7 @@ struct ssb_sprom {
 struct ssb_boardinfo {
         u16 vendor;
         u16 type;
-        u16 rev;
+        u8  rev;
 };
 
 
diff --git a/include/linux/ssb/ssb_driver_chipcommon.h b/include/linux/ssb/ssb_driver_chipcommon.h
index a08d693d8324..1a6b0045b06b 100644
--- a/include/linux/ssb/ssb_driver_chipcommon.h
+++ b/include/linux/ssb/ssb_driver_chipcommon.h
@@ -8,7 +8,7 @@
  * gpio interface, extbus, and support for serial and parallel flashes.
  *
  * Copyright 2005, Broadcom Corporation
- * Copyright 2006, Michael Buesch <mb@bu3sch.de>
+ * Copyright 2006, Michael Buesch <m@bues.ch>
  *
  * Licensed under the GPL version 2. See COPYING for details.
  */
diff --git a/include/linux/stacktrace.h b/include/linux/stacktrace.h
index 25310f1d7f37..115b570e3bff 100644
--- a/include/linux/stacktrace.h
+++ b/include/linux/stacktrace.h
@@ -14,8 +14,8 @@ struct stack_trace {
 };
 
 extern void save_stack_trace(struct stack_trace *trace);
-extern void save_stack_trace_regs(struct stack_trace *trace,
-                                  struct pt_regs *regs);
+extern void save_stack_trace_regs(struct pt_regs *regs,
+                                  struct stack_trace *trace);
 extern void save_stack_trace_tsk(struct task_struct *tsk,
                                 struct stack_trace *trace);
 
diff --git a/include/linux/stmmac.h b/include/linux/stmmac.h
index 9529e49b0385..0dddc9e42b6b 100644
--- a/include/linux/stmmac.h
+++ b/include/linux/stmmac.h
@@ -28,11 +28,21 @@
 
 #include <linux/platform_device.h>
 
-/* platform data for platform device structure's platform_data field */
+/* Platfrom data for platform device structure's platform_data field */
+
+struct stmmac_mdio_bus_data {
+        int bus_id;
+        int (*phy_reset)(void *priv);
+        unsigned int phy_mask;
+        int *irqs;
+        int probed_phy_irq;
+};
 
-/* Private data for the STM on-board ethernet driver */
 struct plat_stmmacenet_data {
         int bus_id;
+        int phy_addr;
+        int interface;
+        struct stmmac_mdio_bus_data *mdio_bus_data;
         int pbl;
         int clk_csr;
         int has_gmac;
@@ -40,6 +50,7 @@ struct plat_stmmacenet_data {
         int tx_coe;
         int bugged_jumbo;
         int pmt;
+        int force_sf_dma_mode;
         void (*fix_mac_speed)(void *priv, unsigned int speed);
         void (*bus_setup)(void __iomem *ioaddr);
         int (*init)(struct platform_device *pdev);
@@ -47,14 +58,4 @@ struct plat_stmmacenet_data {
         void *custom_cfg;
         void *bsp_priv;
 };
-
-struct plat_stmmacphy_data {
-        int bus_id;
-        int phy_addr;
-        unsigned int phy_mask;
-        int interface;
-        int (*phy_reset)(void *priv);
-        void *priv;
-};
 #endif
-
diff --git a/include/linux/stop_machine.h b/include/linux/stop_machine.h
index 092dc9b1ce7d..2d04ea916760 100644
--- a/include/linux/stop_machine.h
+++ b/include/linux/stop_machine.h
@@ -94,7 +94,7 @@ static inline int try_stop_cpus(const struct cpumask *cpumask,
  * stop_machine "Bogolock": stop the entire machine, disable
  * interrupts.  This is a very heavy lock, which is equivalent to
  * grabbing every spinlock (and more).  So the "read" side to such a
- * lock is anything which disables preeempt.
+ * lock is anything which disables preemption.
  */
 #if defined(CONFIG_STOP_MACHINE) && defined(CONFIG_SMP)
 
@@ -124,15 +124,19 @@ int stop_machine(int (*fn)(void *), void *data, const struct cpumask *cpus);
  */
 int __stop_machine(int (*fn)(void *), void *data, const struct cpumask *cpus);
 
+int stop_machine_from_inactive_cpu(int (*fn)(void *), void *data,
+                                   const struct cpumask *cpus);
+
 #else    /* CONFIG_STOP_MACHINE && CONFIG_SMP */
 
 static inline int __stop_machine(int (*fn)(void *), void *data,
                                  const struct cpumask *cpus)
 {
+        unsigned long flags;
         int ret;
-        local_irq_disable();
+        local_irq_save(flags);
         ret = fn(data);
-        local_irq_enable();
+        local_irq_restore(flags);
         return ret;
 }
 
@@ -142,5 +146,11 @@ static inline int stop_machine(int (*fn)(void *), void *data,
         return __stop_machine(fn, data, cpus);
 }
 
+static inline int stop_machine_from_inactive_cpu(int (*fn)(void *), void *data,
+                                                 const struct cpumask *cpus)
+{
+        return __stop_machine(fn, data, cpus);
+}
+
 #endif  /* CONFIG_STOP_MACHINE && CONFIG_SMP */
 #endif  /* _LINUX_STOP_MACHINE */
diff --git a/include/linux/sunrpc/auth.h b/include/linux/sunrpc/auth.h
index 8521067ed4f7..febc4dbec2ca 100644
--- a/include/linux/sunrpc/auth.h
+++ b/include/linux/sunrpc/auth.h
@@ -15,7 +15,7 @@
 #include <linux/sunrpc/msg_prot.h>
 #include <linux/sunrpc/xdr.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <linux/rcupdate.h>
 
 /* size of the nodename buffer */
diff --git a/include/linux/sunrpc/bc_xprt.h b/include/linux/sunrpc/bc_xprt.h
index 082884295f80..f7f3ce340c08 100644
--- a/include/linux/sunrpc/bc_xprt.h
+++ b/include/linux/sunrpc/bc_xprt.h
@@ -31,7 +31,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <linux/sunrpc/xprt.h>
 #include <linux/sunrpc/sched.h>
 
-#ifdef CONFIG_NFS_V4_1
+#ifdef CONFIG_SUNRPC_BACKCHANNEL
 struct rpc_rqst *xprt_alloc_bc_request(struct rpc_xprt *xprt);
 void xprt_free_bc_request(struct rpc_rqst *req);
 int xprt_setup_backchannel(struct rpc_xprt *, unsigned int min_reqs);
@@ -47,7 +47,7 @@ static inline int svc_is_backchannel(const struct svc_rqst *rqstp)
                 return 1;
         return 0;
 }
-#else /* CONFIG_NFS_V4_1 */
+#else /* CONFIG_SUNRPC_BACKCHANNEL */
 static inline int xprt_setup_backchannel(struct rpc_xprt *xprt,
                                          unsigned int min_reqs)
 {
@@ -62,6 +62,6 @@ static inline int svc_is_backchannel(const struct svc_rqst *rqstp)
 static inline void xprt_free_bc_request(struct rpc_rqst *req)
 {
 }
-#endif /* CONFIG_NFS_V4_1 */
+#endif /* CONFIG_SUNRPC_BACKCHANNEL */
 #endif /* _LINUX_SUNRPC_BC_XPRT_H */
 
diff --git a/include/linux/sunrpc/cache.h b/include/linux/sunrpc/cache.h
index 8d2eef1a8582..5efd8cef389e 100644
--- a/include/linux/sunrpc/cache.h
+++ b/include/linux/sunrpc/cache.h
@@ -15,7 +15,7 @@
 
 #include <linux/kref.h>
 #include <linux/slab.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <linux/proc_fs.h>
 
 /*
@@ -256,13 +256,4 @@ static inline time_t get_expiry(char **bpp)
         return rv - boot.tv_sec;
 }
 
-#ifdef CONFIG_NFSD_DEPRECATED
-static inline void sunrpc_invalidate(struct cache_head *h,
-                                     struct cache_detail *detail)
-{
-        h->expiry_time = seconds_since_boot() - 1;
-        detail->nextcheck = seconds_since_boot();
-}
-#endif /* CONFIG_NFSD_DEPRECATED */
-
 #endif /*  _LINUX_SUNRPC_CACHE_H_ */
diff --git a/include/linux/sunrpc/gss_krb5_enctypes.h b/include/linux/sunrpc/gss_krb5_enctypes.h
new file mode 100644
index 000000000000..ec6234eee89c
--- /dev/null
+++ b/include/linux/sunrpc/gss_krb5_enctypes.h
@@ -0,0 +1,4 @@
+/*
+ * Dumb way to share this static piece of information with nfsd
+ */
+#define KRB5_SUPPORTED_ENCTYPES "18,17,16,23,3,1,2"
diff --git a/include/linux/sunrpc/sched.h b/include/linux/sunrpc/sched.h
index f73c482ec9c6..e7756896f3ca 100644
--- a/include/linux/sunrpc/sched.h
+++ b/include/linux/sunrpc/sched.h
@@ -84,7 +84,8 @@ struct rpc_task {
 #endif
         unsigned char           tk_priority : 2,/* Task priority */
                                 tk_garb_retry : 2,
-                                tk_cred_retry : 2;
+                                tk_cred_retry : 2,
+                                tk_rebind_retry : 2;
 };
 #define tk_xprt                 tk_client->cl_xprt
 
@@ -226,6 +227,10 @@ void		rpc_init_wait_queue(struct rpc_wait_queue *, const char *);
 void            rpc_destroy_wait_queue(struct rpc_wait_queue *);
 void            rpc_sleep_on(struct rpc_wait_queue *, struct rpc_task *,
                                         rpc_action action);
+void            rpc_sleep_on_priority(struct rpc_wait_queue *,
+                                        struct rpc_task *,
+                                        rpc_action action,
+                                        int priority);
 void            rpc_wake_up_queued_task(struct rpc_wait_queue *,
                                         struct rpc_task *);
 void            rpc_wake_up(struct rpc_wait_queue *);
diff --git a/include/linux/sunrpc/svc.h b/include/linux/sunrpc/svc.h
index ea29330b78bd..223588a976a0 100644
--- a/include/linux/sunrpc/svc.h
+++ b/include/linux/sunrpc/svc.h
@@ -92,7 +92,7 @@ struct svc_serv {
         struct module *         sv_module;      /* optional module to count when
                                                  * adding threads */
         svc_thread_fn           sv_function;    /* main function for threads */
-#if defined(CONFIG_NFS_V4_1)
+#if defined(CONFIG_SUNRPC_BACKCHANNEL)
         struct list_head        sv_cb_list;     /* queue for callback requests
                                                  * that arrive over the same
                                                  * connection */
@@ -100,7 +100,7 @@ struct svc_serv {
         wait_queue_head_t       sv_cb_waitq;    /* sleep here if there are no
                                                  * entries in the svc_cb_list */
         struct svc_xprt         *sv_bc_xprt;    /* callback on fore channel */
-#endif /* CONFIG_NFS_V4_1 */
+#endif /* CONFIG_SUNRPC_BACKCHANNEL */
 };
 
 /*
@@ -273,6 +273,7 @@ struct svc_rqst {
         /* Catering to nfsd */
         struct auth_domain *    rq_client;      /* RPC peer info */
         struct auth_domain *    rq_gssclient;   /* "gss/"-style peer info */
+        int                     rq_cachetype;
         struct svc_cacherep *   rq_cacherep;    /* cache info */
         int                     rq_splice_ok;   /* turned off in gss privacy
                                                  * to prevent encrypting page
diff --git a/include/linux/sunrpc/timer.h b/include/linux/sunrpc/timer.h
index a67fd734c73b..697d6e69d61f 100644
--- a/include/linux/sunrpc/timer.h
+++ b/include/linux/sunrpc/timer.h
@@ -9,7 +9,7 @@
 #ifndef _LINUX_SUNRPC_TIMER_H
 #define _LINUX_SUNRPC_TIMER_H
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 struct rpc_rtt {
         unsigned long timeo;    /* default timeout value */
diff --git a/include/linux/sunrpc/xprt.h b/include/linux/sunrpc/xprt.h
index 81cce3b3ee66..15518a152ac3 100644
--- a/include/linux/sunrpc/xprt.h
+++ b/include/linux/sunrpc/xprt.h
@@ -22,6 +22,7 @@
 #define RPC_MIN_SLOT_TABLE      (2U)
 #define RPC_DEF_SLOT_TABLE      (16U)
 #define RPC_MAX_SLOT_TABLE      (128U)
+#define RPC_MAX_SLOT_TABLE_LIMIT        (65536U)
 
 /*
  * This describes a timeout strategy
@@ -100,18 +101,18 @@ struct rpc_rqst {
         ktime_t                 rq_xtime;       /* transmit time stamp */
         int                     rq_ntrans;
 
-#if defined(CONFIG_NFS_V4_1)
+#if defined(CONFIG_SUNRPC_BACKCHANNEL)
         struct list_head        rq_bc_list;     /* Callback service list */
         unsigned long           rq_bc_pa_state; /* Backchannel prealloc state */
         struct list_head        rq_bc_pa_list;  /* Backchannel prealloc list */
-#endif /* CONFIG_NFS_V4_1 */
+#endif /* CONFIG_SUNRPC_BACKCHANEL */
 };
 #define rq_svec                 rq_snd_buf.head
 #define rq_slen                 rq_snd_buf.len
 
 struct rpc_xprt_ops {
         void            (*set_buffer_size)(struct rpc_xprt *xprt, size_t sndsize, size_t rcvsize);
-        int             (*reserve_xprt)(struct rpc_task *task);
+        int             (*reserve_xprt)(struct rpc_xprt *xprt, struct rpc_task *task);
         void            (*release_xprt)(struct rpc_xprt *xprt, struct rpc_task *task);
         void            (*rpcbind)(struct rpc_task *task);
         void            (*set_port)(struct rpc_xprt *xprt, unsigned short port);
@@ -164,12 +165,12 @@ struct rpc_xprt {
 
         struct rpc_wait_queue   binding;        /* requests waiting on rpcbind */
         struct rpc_wait_queue   sending;        /* requests waiting to send */
-        struct rpc_wait_queue   resend;         /* requests waiting to resend */
         struct rpc_wait_queue   pending;        /* requests in flight */
         struct rpc_wait_queue   backlog;        /* waiting for slot */
         struct list_head        free;           /* free slots */
-        struct rpc_rqst *       slot;           /* slot table storage */
-        unsigned int            max_reqs;       /* total slots */
+        unsigned int            max_reqs;       /* max number of slots */
+        unsigned int            min_reqs;       /* min number of slots */
+        atomic_t                num_reqs;       /* total slots */
         unsigned long           state;          /* transport state */
         unsigned char           shutdown   : 1, /* being shut down */
                                 resvport   : 1; /* use a reserved port */
@@ -200,7 +201,7 @@ struct rpc_xprt {
         u32                     xid;            /* Next XID value to use */
         struct rpc_task *       snd_task;       /* Task blocked in send */
         struct svc_xprt         *bc_xprt;       /* NFSv4.1 backchannel */
-#if defined(CONFIG_NFS_V4_1)
+#if defined(CONFIG_SUNRPC_BACKCHANNEL)
         struct svc_serv         *bc_serv;       /* The RPC service which will */
                                                 /* process the callback */
         unsigned int            bc_alloc_count; /* Total number of preallocs */
@@ -208,7 +209,7 @@ struct rpc_xprt {
                                                  * items */
         struct list_head        bc_pa_list;     /* List of preallocated
                                                  * backchannel rpc_rqst's */
-#endif /* CONFIG_NFS_V4_1 */
+#endif /* CONFIG_SUNRPC_BACKCHANNEL */
         struct list_head        recv;
 
         struct {
@@ -228,15 +229,15 @@ struct rpc_xprt {
         const char              *address_strings[RPC_DISPLAY_MAX];
 };
 
-#if defined(CONFIG_NFS_V4_1)
+#if defined(CONFIG_SUNRPC_BACKCHANNEL)
 /*
  * Backchannel flags
  */
 #define RPC_BC_PA_IN_USE        0x0001          /* Preallocated backchannel */
                                                 /* buffer in use */
-#endif /* CONFIG_NFS_V4_1 */
+#endif /* CONFIG_SUNRPC_BACKCHANNEL */
 
-#if defined(CONFIG_NFS_V4_1)
+#if defined(CONFIG_SUNRPC_BACKCHANNEL)
 static inline int bc_prealloc(struct rpc_rqst *req)
 {
         return test_bit(RPC_BC_PA_IN_USE, &req->rq_bc_pa_state);
@@ -246,7 +247,7 @@ static inline int bc_prealloc(struct rpc_rqst *req)
 {
         return 0;
 }
-#endif /* CONFIG_NFS_V4_1 */
+#endif /* CONFIG_SUNRPC_BACKCHANNEL */
 
 struct xprt_create {
         int                     ident;          /* XPRT_TRANSPORT identifier */
@@ -271,8 +272,8 @@ struct xprt_class {
 struct rpc_xprt         *xprt_create_transport(struct xprt_create *args);
 void                    xprt_connect(struct rpc_task *task);
 void                    xprt_reserve(struct rpc_task *task);
-int                     xprt_reserve_xprt(struct rpc_task *task);
-int                     xprt_reserve_xprt_cong(struct rpc_task *task);
+int                     xprt_reserve_xprt(struct rpc_xprt *xprt, struct rpc_task *task);
+int                     xprt_reserve_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task);
 int                     xprt_prepare_transmit(struct rpc_task *task);
 void                    xprt_transmit(struct rpc_task *task);
 void                    xprt_end_transmit(struct rpc_task *task);
@@ -282,7 +283,9 @@ void			xprt_release_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task);
 void                    xprt_release(struct rpc_task *task);
 struct rpc_xprt *       xprt_get(struct rpc_xprt *xprt);
 void                    xprt_put(struct rpc_xprt *xprt);
-struct rpc_xprt *       xprt_alloc(struct net *net, int size, int max_req);
+struct rpc_xprt *       xprt_alloc(struct net *net, size_t size,
+                                unsigned int num_prealloc,
+                                unsigned int max_req);
 void                    xprt_free(struct rpc_xprt *);
 
 static inline __be32 *xprt_skip_transport_header(struct rpc_xprt *xprt, __be32 *p)
@@ -321,7 +324,6 @@ void			xprt_conditional_disconnect(struct rpc_xprt *xprt, unsigned int cookie);
 #define XPRT_CLOSING            (6)
 #define XPRT_CONNECTION_ABORT   (7)
 #define XPRT_CONNECTION_CLOSE   (8)
-#define XPRT_INITIALIZED        (9)
 
 static inline void xprt_set_connected(struct rpc_xprt *xprt)
 {
diff --git a/include/linux/suspend.h b/include/linux/suspend.h
index 083ffea7ba18..6bbcef22e105 100644
--- a/include/linux/suspend.h
+++ b/include/linux/suspend.h
@@ -92,6 +92,13 @@ typedef int __bitwise suspend_state_t;
  *      @enter() and @wake(), even if any of them fails.  It is executed after
  *      a failing @prepare.
  *
+ * @suspend_again: Returns whether the system should suspend again (true) or
+ *      not (false). If the platform wants to poll sensors or execute some
+ *      code during suspended without invoking userspace and most of devices,
+ *      suspend_again callback is the place assuming that periodic-wakeup or
+ *      alarm-wakeup is already setup. This allows to execute some codes while
+ *      being kept suspended in the view of userland and devices.
+ *
  * @end: Called by the PM core right after resuming devices, to indicate to
  *      the platform that the system has returned to the working state or
  *      the transition to the sleep state has been aborted.
@@ -113,6 +120,7 @@ struct platform_suspend_ops {
         int (*enter)(suspend_state_t state);
         void (*wake)(void);
         void (*finish)(void);
+        bool (*suspend_again)(void);
         void (*end)(void);
         void (*recover)(void);
 };
@@ -260,6 +268,14 @@ static inline int hibernate(void) { return -ENOSYS; }
 static inline bool system_entering_hibernation(void) { return false; }
 #endif /* CONFIG_HIBERNATION */
 
+/* Hibernation and suspend events */
+#define PM_HIBERNATION_PREPARE  0x0001 /* Going to hibernate */
+#define PM_POST_HIBERNATION     0x0002 /* Hibernation finished */
+#define PM_SUSPEND_PREPARE      0x0003 /* Going to suspend the system */
+#define PM_POST_SUSPEND         0x0004 /* Suspend finished */
+#define PM_RESTORE_PREPARE      0x0005 /* Going to restore a saved image */
+#define PM_POST_RESTORE         0x0006 /* Restore failed */
+
 #ifdef CONFIG_PM_SLEEP
 void save_processor_state(void);
 void restore_processor_state(void);
diff --git a/include/linux/swap.h b/include/linux/swap.h
index 384eb5fe530b..14d62490922e 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -9,7 +9,7 @@
 #include <linux/sched.h>
 #include <linux/node.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <asm/page.h>
 
 struct notifier_block;
@@ -251,14 +251,6 @@ static inline void lru_cache_add_file(struct page *page)
 /* linux/mm/vmscan.c */
 extern unsigned long try_to_free_pages(struct zonelist *zonelist, int order,
                                         gfp_t gfp_mask, nodemask_t *mask);
-extern unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *mem,
-                                                  gfp_t gfp_mask, bool noswap,
-                                                  unsigned int swappiness);
-extern unsigned long mem_cgroup_shrink_node_zone(struct mem_cgroup *mem,
-                                                gfp_t gfp_mask, bool noswap,
-                                                unsigned int swappiness,
-                                                struct zone *zone,
-                                                unsigned long *nr_scanned);
 extern int __isolate_lru_page(struct page *page, int mode, int file);
 extern unsigned long shrink_all_memory(unsigned long nr_pages);
 extern int vm_swappiness;
@@ -299,17 +291,14 @@ static inline void scan_unevictable_unregister_node(struct node *node)
 
 extern int kswapd_run(int nid);
 extern void kswapd_stop(int nid);
-
-#ifdef CONFIG_MMU
-/* linux/mm/shmem.c */
-extern int shmem_unuse(swp_entry_t entry, struct page *page);
-#endif /* CONFIG_MMU */
-
 #ifdef CONFIG_CGROUP_MEM_RES_CTLR
-extern void mem_cgroup_get_shmem_target(struct inode *inode, pgoff_t pgoff,
-                                        struct page **pagep, swp_entry_t *ent);
+extern int mem_cgroup_swappiness(struct mem_cgroup *mem);
+#else
+static inline int mem_cgroup_swappiness(struct mem_cgroup *mem)
+{
+        return vm_swappiness;
+}
 #endif
-
 #ifdef CONFIG_SWAP
 /* linux/mm/page_io.c */
 extern int swap_readpage(struct page *);
@@ -358,6 +347,7 @@ struct backing_dev_info;
 extern struct mm_struct *swap_token_mm;
 extern void grab_swap_token(struct mm_struct *);
 extern void __put_swap_token(struct mm_struct *);
+extern void disable_swap_token(struct mem_cgroup *memcg);
 
 static inline int has_swap_token(struct mm_struct *mm)
 {
@@ -370,11 +360,6 @@ static inline void put_swap_token(struct mm_struct *mm)
                 __put_swap_token(mm);
 }
 
-static inline void disable_swap_token(void)
-{
-        put_swap_token(swap_token_mm);
-}
-
 #ifdef CONFIG_CGROUP_MEM_RES_CTLR
 extern void
 mem_cgroup_uncharge_swapcache(struct page *page, swp_entry_t ent, bool swapout);
@@ -500,7 +485,7 @@ static inline int has_swap_token(struct mm_struct *mm)
         return 0;
 }
 
-static inline void disable_swap_token(void)
+static inline void disable_swap_token(struct mem_cgroup *memcg)
 {
 }
 
diff --git a/include/linux/swapops.h b/include/linux/swapops.h
index cd42e30b7c6e..2189d3ffc85d 100644
--- a/include/linux/swapops.h
+++ b/include/linux/swapops.h
@@ -1,3 +1,8 @@
+#ifndef _LINUX_SWAPOPS_H
+#define _LINUX_SWAPOPS_H
+
+#include <linux/radix-tree.h>
+
 /*
  * swapcache pages are stored in the swapper_space radix tree.  We want to
  * get good packing density in that tree, so the index should be dense in
@@ -76,6 +81,22 @@ static inline pte_t swp_entry_to_pte(swp_entry_t entry)
         return __swp_entry_to_pte(arch_entry);
 }
 
+static inline swp_entry_t radix_to_swp_entry(void *arg)
+{
+        swp_entry_t entry;
+
+        entry.val = (unsigned long)arg >> RADIX_TREE_EXCEPTIONAL_SHIFT;
+        return entry;
+}
+
+static inline void *swp_to_radix_entry(swp_entry_t entry)
+{
+        unsigned long value;
+
+        value = entry.val << RADIX_TREE_EXCEPTIONAL_SHIFT;
+        return (void *)(value | RADIX_TREE_EXCEPTIONAL_ENTRY);
+}
+
 #ifdef CONFIG_MIGRATION
 static inline swp_entry_t make_migration_entry(struct page *page, int write)
 {
@@ -169,3 +190,5 @@ static inline int non_swap_entry(swp_entry_t entry)
         return 0;
 }
 #endif
+
+#endif /* _LINUX_SWAPOPS_H */
diff --git a/include/linux/swiotlb.h b/include/linux/swiotlb.h
index 8c0e349f4a6c..445702c60d04 100644
--- a/include/linux/swiotlb.h
+++ b/include/linux/swiotlb.h
@@ -24,6 +24,7 @@ extern int swiotlb_force;
 
 extern void swiotlb_init(int verbose);
 extern void swiotlb_init_with_tbl(char *tlb, unsigned long nslabs, int verbose);
+extern unsigned long swioltb_nr_tbl(void);
 
 /*
  * Enumeration for sync targets
diff --git a/include/linux/sysfs.h b/include/linux/sysfs.h
index c3acda60eee0..d7d2f2158142 100644
--- a/include/linux/sysfs.h
+++ b/include/linux/sysfs.h
@@ -17,7 +17,7 @@
 #include <linux/list.h>
 #include <linux/lockdep.h>
 #include <linux/kobject_ns.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 struct kobject;
 struct module;
@@ -177,9 +177,6 @@ struct sysfs_dirent *sysfs_get_dirent(struct sysfs_dirent *parent_sd,
 struct sysfs_dirent *sysfs_get(struct sysfs_dirent *sd);
 void sysfs_put(struct sysfs_dirent *sd);
 
-/* Called to clear a ns tag when it is no longer valid */
-void sysfs_exit_ns(enum kobj_ns_type type, const void *tag);
-
 int __must_check sysfs_init(void);
 
 #else /* CONFIG_SYSFS */
@@ -338,10 +335,6 @@ static inline void sysfs_put(struct sysfs_dirent *sd)
 {
 }
 
-static inline void sysfs_exit_ns(int type, const void *tag)
-{
-}
-
 static inline int __must_check sysfs_init(void)
 {
         return 0;
diff --git a/include/linux/tc_ematch/tc_em_meta.h b/include/linux/tc_ematch/tc_em_meta.h
index 7138962664f8..b11f8ce2d3c0 100644
--- a/include/linux/tc_ematch/tc_em_meta.h
+++ b/include/linux/tc_ematch/tc_em_meta.h
@@ -67,7 +67,7 @@ enum {
         TCF_META_ID_SK_FORWARD_ALLOCS,
         TCF_META_ID_SK_SNDBUF,
         TCF_META_ID_SK_ALLOCS,
-        TCF_META_ID_SK_ROUTE_CAPS,
+        __TCF_META_ID_SK_ROUTE_CAPS,    /* unimplemented but in ABI already */
         TCF_META_ID_SK_HASH,
         TCF_META_ID_SK_LINGERTIME,
         TCF_META_ID_SK_ACK_BACKLOG,
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index e64f4c67d0ef..531ede8006d9 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -282,6 +282,7 @@ struct tcp_request_sock {
 #endif
         u32                             rcv_isn;
         u32                             snt_isn;
+        u32                             snt_synack; /* synack sent time */
 };
 
 static inline struct tcp_request_sock *tcp_rsk(const struct request_sock *req)
diff --git a/include/linux/thermal.h b/include/linux/thermal.h
index d3ec89fb4122..47b4a27e6e97 100644
--- a/include/linux/thermal.h
+++ b/include/linux/thermal.h
@@ -85,22 +85,6 @@ struct thermal_cooling_device {
                                 ((long)t-2732+5)/10 : ((long)t-2732-5)/10)
 #define CELSIUS_TO_KELVIN(t)    ((t)*10+2732)
 
-#if defined(CONFIG_THERMAL_HWMON)
-/* thermal zone devices with the same type share one hwmon device */
-struct thermal_hwmon_device {
-        char type[THERMAL_NAME_LENGTH];
-        struct device *device;
-        int count;
-        struct list_head tz_list;
-        struct list_head node;
-};
-
-struct thermal_hwmon_attr {
-        struct device_attribute attr;
-        char name[16];
-};
-#endif
-
 struct thermal_zone_device {
         int id;
         char type[THERMAL_NAME_LENGTH];
@@ -120,12 +104,6 @@ struct thermal_zone_device {
         struct mutex lock;      /* protect cooling devices list */
         struct list_head node;
         struct delayed_work poll_queue;
-#if defined(CONFIG_THERMAL_HWMON)
-        struct list_head hwmon_node;
-        struct thermal_hwmon_device *hwmon;
-        struct thermal_hwmon_attr temp_input;   /* hwmon sys attr */
-        struct thermal_hwmon_attr temp_crit;    /* hwmon sys attr */
-#endif
 };
 /* Adding event notification support elements */
 #define THERMAL_GENL_FAMILY_NAME                "thermal_event"
diff --git a/include/linux/topology.h b/include/linux/topology.h
index b91a40e847d2..fc839bfa7935 100644
--- a/include/linux/topology.h
+++ b/include/linux/topology.h
@@ -60,7 +60,7 @@ int arch_update_cpu_topology(void);
  * (in whatever arch specific measurement units returned by node_distance())
  * then switch on zone reclaim on boot.
  */
-#define RECLAIM_DISTANCE 20
+#define RECLAIM_DISTANCE 30
 #endif
 #ifndef PENALTY_FOR_NODE_WITH_CPUS
 #define PENALTY_FOR_NODE_WITH_CPUS      (1)
diff --git a/include/linux/tracehook.h b/include/linux/tracehook.h
index e95f5236611f..a71a2927a6a0 100644
--- a/include/linux/tracehook.h
+++ b/include/linux/tracehook.h
@@ -51,27 +51,12 @@
 #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);
+        int ptrace = current->ptrace;
 
         if (!(ptrace & PT_PTRACED))
                 return;
@@ -145,229 +130,6 @@ static inline void tracehook_report_syscall_exit(struct pt_regs *regs, int step)
 }
 
 /**
- * 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.
- *
- * @task->signal->cred_guard_mutex is held by the caller through the do_execve().
- */
-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 no one 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
- * @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.
- * 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_clone_complete() is called.
- *
- * Called with no locks held, but the child cannot run until this returns.
- */
-static inline void tracehook_report_clone(struct pt_regs *regs,
-                                          unsigned long clone_flags,
-                                          pid_t pid, struct task_struct *child)
-{
-        if (unlikely(task_ptrace(child))) {
-                /*
-                 * It doesn't matter who attached/attaching to this
-                 * task, the pending SIGSTOP is right in any case.
-                 */
-                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
@@ -390,151 +152,6 @@ static inline void tracehook_signal_handler(int sig, siginfo_t *info,
                 ptrace_notify(SIGTRAP);
 }
 
-/**
- * tracehook_consider_ignored_signal - suppress short-circuit of ignored signal
- * @task:               task receiving the signal
- * @sig:                signal number being sent
- *
- * Return zero iff tracing doesn't care to examine this ignored signal,
- * so it can short-circuit normal delivery and never even get queued.
- *
- * Called with @task->sighand->siglock held.
- */
-static inline int tracehook_consider_ignored_signal(struct task_struct *task,
-                                                    int sig)
-{
-        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
- *
- * Return nonzero to prevent special handling of this termination signal.
- * Normally handler for signal 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)
-{
-        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 artificial 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_finish_jctl - report about return from job control stop
- *
- * This is called by do_signal_stop() after wakeup.
- */
-static inline void tracehook_finish_jctl(void)
-{
-}
-
-#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_detached(task))
-                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
diff --git a/include/linux/tty.h b/include/linux/tty.h
index d6f05292e456..44bc0c5617e1 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -5,24 +5,6 @@
  * 'tty.h' defines some structures used by tty_io.c and some defines.
  */
 
-#ifdef __KERNEL__
-#include <linux/fs.h>
-#include <linux/major.h>
-#include <linux/termios.h>
-#include <linux/workqueue.h>
-#include <linux/tty_driver.h>
-#include <linux/tty_ldisc.h>
-#include <linux/mutex.h>
-
-#include <asm/system.h>
-
-
-/*
- * (Note: the *_driver.minor_start values 1, 64, 128, 192 are
- * hardcoded at present.)
- */
-#define NR_UNIX98_PTY_DEFAULT   4096      /* Default maximum for Unix98 ptys */
-#define NR_UNIX98_PTY_MAX       (1 << MINORBITS) /* Absolute limit */
 #define NR_LDISCS               30
 
 /* line disciplines */
@@ -53,6 +35,25 @@
 #define N_TRACESINK     23      /* Trace data routing for MIPI P1149.7 */
 #define N_TRACEROUTER   24      /* Trace data routing for MIPI P1149.7 */
 
+#ifdef __KERNEL__
+#include <linux/fs.h>
+#include <linux/major.h>
+#include <linux/termios.h>
+#include <linux/workqueue.h>
+#include <linux/tty_driver.h>
+#include <linux/tty_ldisc.h>
+#include <linux/mutex.h>
+
+#include <asm/system.h>
+
+
+/*
+ * (Note: the *_driver.minor_start values 1, 64, 128, 192 are
+ * hardcoded at present.)
+ */
+#define NR_UNIX98_PTY_DEFAULT   4096      /* Default maximum for Unix98 ptys */
+#define NR_UNIX98_PTY_MAX       (1 << MINORBITS) /* Absolute limit */
+
 /*
  * This character is the same as _POSIX_VDISABLE: it cannot be used as
  * a c_cc[] character, but indicates that a particular special character
diff --git a/include/linux/tty_ldisc.h b/include/linux/tty_ldisc.h
index 5b07792ccb46..ff7dc08696a8 100644
--- a/include/linux/tty_ldisc.h
+++ b/include/linux/tty_ldisc.h
@@ -76,7 +76,7 @@
  *      tty device.  It is solely the responsibility of the line
  *      discipline to handle poll requests.
  *
- * unsigned int (*receive_buf)(struct tty_struct *, const unsigned char *cp,
+ * void (*receive_buf)(struct tty_struct *, const unsigned char *cp,
  *                     char *fp, int count);
  *
  *      This function is called by the low-level tty driver to send
@@ -84,8 +84,7 @@
  *      processing.  <cp> is a pointer to the buffer of input
  *      character received by the device.  <fp> is a pointer to a
  *      pointer of flag bytes which indicate whether a character was
- *      received with a parity error, etc. Returns the amount of bytes
- *      received.
+ *      received with a parity error, etc.
  * 
  * void (*write_wakeup)(struct tty_struct *);
  *
@@ -141,8 +140,8 @@ struct tty_ldisc_ops {
         /*
          * The following routines are called from below.
          */
-        unsigned int (*receive_buf)(struct tty_struct *,
-                        const unsigned char *cp, char *fp, int count);
+        void    (*receive_buf)(struct tty_struct *, const unsigned char *cp,
+                               char *fp, int count);
         void    (*write_wakeup)(struct tty_struct *);
         void    (*dcd_change)(struct tty_struct *, unsigned int,
                                 struct pps_event_time *);
diff --git a/include/linux/usb/composite.h b/include/linux/usb/composite.h
index b78cba466d3d..a316fba73518 100644
--- a/include/linux/usb/composite.h
+++ b/include/linux/usb/composite.h
@@ -59,6 +59,10 @@ struct usb_configuration;
  * @hs_descriptors: Table of high speed descriptors, using interface and
  *      string identifiers assigned during @bind().  If this pointer is null,
  *      the function will not be available at high speed.
+ * @ss_descriptors: Table of super speed descriptors, using interface and
+ *      string identifiers assigned during @bind(). If this
+ *      pointer is null after initiation, the function will not
+ *      be available at super speed.
  * @config: assigned when @usb_add_function() is called; this is the
  *      configuration with which this function is associated.
  * @bind: Before the gadget can register, all of its functions bind() to the
@@ -77,6 +81,10 @@ struct usb_configuration;
  * @setup: Used for interface-specific control requests.
  * @suspend: Notifies functions when the host stops sending USB traffic.
  * @resume: Notifies functions when the host restarts USB traffic.
+ * @get_status: Returns function status as a reply to
+ *      GetStatus() request when the recepient is Interface.
+ * @func_suspend: callback to be called when
+ *      SetFeature(FUNCTION_SUSPEND) is reseived
  *
  * A single USB function uses one or more interfaces, and should in most
  * cases support operation at both full and high speeds.  Each function is
@@ -106,6 +114,7 @@ struct usb_function {
         struct usb_gadget_strings       **strings;
         struct usb_descriptor_header    **descriptors;
         struct usb_descriptor_header    **hs_descriptors;
+        struct usb_descriptor_header    **ss_descriptors;
 
         struct usb_configuration        *config;
 
@@ -132,6 +141,10 @@ struct usb_function {
         void                    (*suspend)(struct usb_function *);
         void                    (*resume)(struct usb_function *);
 
+        /* USB 3.0 additions */
+        int                     (*get_status)(struct usb_function *);
+        int                     (*func_suspend)(struct usb_function *,
+                                                u8 suspend_opt);
         /* private: */
         /* internals */
         struct list_head                list;
@@ -145,20 +158,8 @@ int usb_function_activate(struct usb_function *);
 
 int usb_interface_id(struct usb_configuration *, struct usb_function *);
 
-/**
- * ep_choose - select descriptor endpoint at current device speed
- * @g: gadget, connected and running at some speed
- * @hs: descriptor to use for high speed operation
- * @fs: descriptor to use for full or low speed operation
- */
-static inline struct usb_endpoint_descriptor *
-ep_choose(struct usb_gadget *g, struct usb_endpoint_descriptor *hs,
-                struct usb_endpoint_descriptor *fs)
-{
-        if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
-                return hs;
-        return fs;
-}
+int config_ep_by_speed(struct usb_gadget *g, struct usb_function *f,
+                        struct usb_ep *_ep);
 
 #define MAX_CONFIG_INTERFACES           16      /* arbitrary; max 255 */
 
@@ -231,6 +232,7 @@ struct usb_configuration {
         struct list_head        list;
         struct list_head        functions;
         u8                      next_interface_id;
+        unsigned                superspeed:1;
         unsigned                highspeed:1;
         unsigned                fullspeed:1;
         struct usb_function     *interface[MAX_CONFIG_INTERFACES];
@@ -252,6 +254,7 @@ int usb_add_config(struct usb_composite_dev *,
  *      identifiers.
  * @strings: tables of strings, keyed by identifiers assigned during bind()
  *      and language IDs provided in control requests
+ * @max_speed: Highest speed the driver supports.
  * @needs_serial: set to 1 if the gadget needs userspace to provide
  *      a serial number.  If one is not provided, warning will be printed.
  * @unbind: Reverses bind; called as a side effect of unregistering
@@ -279,6 +282,7 @@ struct usb_composite_driver {
         const char                              *iManufacturer;
         const struct usb_device_descriptor      *dev;
         struct usb_gadget_strings               **strings;
+        enum usb_device_speed                   max_speed;
         unsigned                needs_serial:1;
 
         int                     (*unbind)(struct usb_composite_dev *);
diff --git a/include/linux/usb/gadget.h b/include/linux/usb/gadget.h
index dd1571db55e7..087f4b931833 100644
--- a/include/linux/usb/gadget.h
+++ b/include/linux/usb/gadget.h
@@ -15,7 +15,13 @@
 #ifndef __LINUX_USB_GADGET_H
 #define __LINUX_USB_GADGET_H
 
+#include <linux/device.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/list.h>
 #include <linux/slab.h>
+#include <linux/types.h>
+#include <linux/usb/ch9.h>
 
 struct usb_ep;
 
@@ -27,6 +33,7 @@ struct usb_ep;
  *      field, and the usb controller needs one, it is responsible
  *      for mapping and unmapping the buffer.
  * @length: Length of that data
+ * @stream_id: The stream id, when USB3.0 bulk streams are being used
  * @no_interrupt: If true, hints that no completion irq is needed.
  *      Helpful sometimes with deep request queues that are handled
  *      directly by DMA controllers.
@@ -81,6 +88,7 @@ struct usb_request {
         unsigned                length;
         dma_addr_t              dma;
 
+        unsigned                stream_id:16;
         unsigned                no_interrupt:1;
         unsigned                zero:1;
         unsigned                short_not_ok:1;
@@ -131,8 +139,17 @@ struct usb_ep_ops {
  * @maxpacket:The maximum packet size used on this endpoint.  The initial
  *      value can sometimes be reduced (hardware allowing), according to
  *      the endpoint descriptor used to configure the endpoint.
- * @driver_data:for use by the gadget driver.  all other fields are
- *      read-only to gadget drivers.
+ * @max_streams: The maximum number of streams supported
+ *      by this EP (0 - 16, actual number is 2^n)
+ * @mult: multiplier, 'mult' value for SS Isoc EPs
+ * @maxburst: the maximum number of bursts supported by this EP (for usb3)
+ * @driver_data:for use by the gadget driver.
+ * @address: used to identify the endpoint when finding descriptor that
+ *      matches connection speed
+ * @desc: endpoint descriptor.  This pointer is set before the endpoint is
+ *      enabled and remains valid until the endpoint is disabled.
+ * @comp_desc: In case of SuperSpeed support, this is the endpoint companion
+ *      descriptor that is used to configure the endpoint
  *
  * the bus controller driver lists all the general purpose endpoints in
  * gadget->ep_list.  the control endpoint (gadget->ep0) is not in that list,
@@ -145,6 +162,12 @@ struct usb_ep {
         const struct usb_ep_ops *ops;
         struct list_head        ep_list;
         unsigned                maxpacket:16;
+        unsigned                max_streams:16;
+        unsigned                mult:2;
+        unsigned                maxburst:4;
+        u8                      address;
+        const struct usb_endpoint_descriptor    *desc;
+        const struct usb_ss_ep_comp_descriptor  *comp_desc;
 };
 
 /*-------------------------------------------------------------------------*/
@@ -153,11 +176,8 @@ struct usb_ep {
  * usb_ep_enable - configure endpoint, making it usable
  * @ep:the endpoint being configured.  may not be the endpoint named "ep0".
  *      drivers discover endpoints through the ep_list of a usb_gadget.
- * @desc:descriptor for desired behavior.  caller guarantees this pointer
- *      remains valid until the endpoint is disabled; the data byte order
- *      is little-endian (usb-standard).
  *
- * when configurations are set, or when interface settings change, the driver
+ * When configurations are set, or when interface settings change, the driver
  * will enable or disable the relevant endpoints.  while it is enabled, an
  * endpoint may be used for i/o until the driver receives a disconnect() from
  * the host or until the endpoint is disabled.
@@ -172,10 +192,9 @@ struct usb_ep {
  *
  * returns zero, or a negative error code.
  */
-static inline int usb_ep_enable(struct usb_ep *ep,
-                                const struct usb_endpoint_descriptor *desc)
+static inline int usb_ep_enable(struct usb_ep *ep)
 {
-        return ep->ops->enable(ep, desc);
+        return ep->ops->enable(ep, ep->desc);
 }
 
 /**
@@ -416,7 +435,16 @@ static inline void usb_ep_fifo_flush(struct usb_ep *ep)
 
 /*-------------------------------------------------------------------------*/
 
+struct usb_dcd_config_params {
+        __u8  bU1devExitLat;    /* U1 Device exit Latency */
+#define USB_DEFULT_U1_DEV_EXIT_LAT      0x01    /* Less then 1 microsec */
+        __le16 bU2DevExitLat;   /* U2 Device exit Latency */
+#define USB_DEFULT_U2_DEV_EXIT_LAT      0x1F4   /* Less then 500 microsec */
+};
+
+
 struct usb_gadget;
+struct usb_gadget_driver;
 
 /* the rest of the api to the controller hardware: device operations,
  * which don't involve endpoints (or i/o).
@@ -430,6 +458,16 @@ struct usb_gadget_ops {
         int     (*pullup) (struct usb_gadget *, int is_on);
         int     (*ioctl)(struct usb_gadget *,
                                 unsigned code, unsigned long param);
+        void    (*get_config_params)(struct usb_dcd_config_params *);
+        int     (*udc_start)(struct usb_gadget *,
+                        struct usb_gadget_driver *);
+        int     (*udc_stop)(struct usb_gadget *,
+                        struct usb_gadget_driver *);
+
+        /* Those two are deprecated */
+        int     (*start)(struct usb_gadget_driver *,
+                        int (*bind)(struct usb_gadget *));
+        int     (*stop)(struct usb_gadget_driver *);
 };
 
 /**
@@ -521,6 +559,24 @@ static inline int gadget_is_dualspeed(struct usb_gadget *g)
 }
 
 /**
+ * gadget_is_superspeed() - return true if the hardware handles
+ * supperspeed
+ * @g: controller that might support supper speed
+ */
+static inline int gadget_is_superspeed(struct usb_gadget *g)
+{
+#ifdef CONFIG_USB_GADGET_SUPERSPEED
+        /*
+         * runtime test would check "g->is_superspeed" ... that might be
+         * useful to work around hardware bugs, but is mostly pointless
+         */
+        return 1;
+#else
+        return 0;
+#endif
+}
+
+/**
  * gadget_is_otg - return true iff the hardware is OTG-ready
  * @g: controller that might have a Mini-AB connector
  *
@@ -821,6 +877,9 @@ int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
  */
 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver);
 
+extern int usb_add_gadget_udc(struct device *parent, struct usb_gadget *gadget);
+extern void usb_del_gadget_udc(struct usb_gadget *gadget);
+
 /*-------------------------------------------------------------------------*/
 
 /* utility to simplify dealing with string descriptors */
@@ -870,12 +929,6 @@ int usb_gadget_config_buf(const struct usb_config_descriptor *config,
 struct usb_descriptor_header **usb_copy_descriptors(
                 struct usb_descriptor_header **);
 
-/* return copy of endpoint descriptor given original descriptor set */
-struct usb_endpoint_descriptor *usb_find_endpoint(
-        struct usb_descriptor_header **src,
-        struct usb_descriptor_header **copy,
-        struct usb_endpoint_descriptor *match);
-
 /**
  * usb_free_descriptors - free descriptors returned by usb_copy_descriptors()
  * @v: vector of descriptors
@@ -892,6 +945,11 @@ static inline void usb_free_descriptors(struct usb_descriptor_header **v)
 extern struct usb_ep *usb_ep_autoconfig(struct usb_gadget *,
                         struct usb_endpoint_descriptor *);
 
+
+extern struct usb_ep *usb_ep_autoconfig_ss(struct usb_gadget *,
+                        struct usb_endpoint_descriptor *,
+                        struct usb_ss_ep_comp_descriptor *);
+
 extern void usb_ep_autoconfig_reset(struct usb_gadget *);
 
 #endif /* __LINUX_USB_GADGET_H */
diff --git a/include/linux/usb/m66592.h b/include/linux/usb/m66592.h
index cda9625e7df0..a4ba31ab2fed 100644
--- a/include/linux/usb/m66592.h
+++ b/include/linux/usb/m66592.h
@@ -38,6 +38,8 @@ struct m66592_platdata {
         /* (external controller only) one = 3.3V, zero = 1.5V */
         unsigned        vif:1;
 
+        /* (external controller only) set one = WR0_N shorted to WR1_N */
+        unsigned        wr0_shorted_to_wr1:1;
 };
 
 #endif /* __LINUX_USB_M66592_H */
diff --git a/include/linux/usb/r8a66597.h b/include/linux/usb/r8a66597.h
index 26d216734057..b6b8660d0c68 100644
--- a/include/linux/usb/r8a66597.h
+++ b/include/linux/usb/r8a66597.h
@@ -3,7 +3,7 @@
  *
  * Copyright (C) 2009  Renesas Solutions Corp.
  *
- * Author : Yoshihiro Shimoda <shimoda.yoshihiro@renesas.com>
+ * Author : Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.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
@@ -31,6 +31,9 @@ struct r8a66597_platdata {
         /* This callback can control port power instead of DVSTCTR register. */
         void (*port_power)(int port, int power);
 
+        /* This parameter is for BUSWAIT */
+        u16             buswait;
+
         /* set one = on chip controller, set zero = external controller */
         unsigned        on_chip:1;
 
@@ -42,6 +45,9 @@ struct r8a66597_platdata {
 
         /* set one = big endian, set zero = little endian */
         unsigned        endian:1;
+
+        /* (external controller only) set one = WR0_N shorted to WR1_N */
+        unsigned        wr0_shorted_to_wr1:1;
 };
 
 /* Register definitions */
diff --git a/include/linux/usb/renesas_usbhs.h b/include/linux/usb/renesas_usbhs.h
index 3a7f1d982dd6..8977431259c6 100644
--- a/include/linux/usb/renesas_usbhs.h
+++ b/include/linux/usb/renesas_usbhs.h
@@ -110,6 +110,23 @@ struct renesas_usbhs_driver_param {
          * delay time from notify_hotplug callback
          */
         int detection_delay;
+
+        /*
+         * option:
+         *
+         * dma id for dmaengine
+         */
+        int d0_tx_id;
+        int d0_rx_id;
+        int d1_tx_id;
+        int d1_rx_id;
+
+        /*
+         * option:
+         *
+         * pio <--> dma border.
+         */
+        int pio_dma_border; /* default is 64byte */
 };
 
 /*
diff --git a/include/linux/usb_usual.h b/include/linux/usb_usual.h
index 71693d4a4fe1..17df3600bcef 100644
--- a/include/linux/usb_usual.h
+++ b/include/linux/usb_usual.h
@@ -62,7 +62,9 @@
         US_FLAG(NO_READ_DISC_INFO,      0x00040000)             \
                 /* cannot handle READ_DISC_INFO */              \
         US_FLAG(NO_READ_CAPACITY_16,    0x00080000)             \
-                /* cannot handle READ_CAPACITY_16 */
+                /* cannot handle READ_CAPACITY_16 */            \
+        US_FLAG(INITIAL_READ10, 0x00100000)                     \
+                /* Initial READ(10) (and others) must be retried */
 
 #define US_FLAG(name, value)    US_FL_##name = value ,
 enum { US_DO_ALL_FLAGS };
diff --git a/include/linux/uts.h b/include/linux/uts.h
index 73eb1ed36ec4..6ddbd86377de 100644
--- a/include/linux/uts.h
+++ b/include/linux/uts.h
@@ -9,7 +9,7 @@
 #endif
 
 #ifndef UTS_NODENAME
-#define UTS_NODENAME "(none)"   /* set by sethostname() */
+#define UTS_NODENAME CONFIG_DEFAULT_HOSTNAME /* set by sethostname() */
 #endif
 
 #ifndef UTS_DOMAINNAME
diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
index 8a4c309d2344..fca24cc50436 100644
--- a/include/linux/videodev2.h
+++ b/include/linux/videodev2.h
@@ -376,7 +376,16 @@ struct v4l2_pix_format {
 #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_MPEG     v4l2_fourcc('M', 'P', 'E', 'G') /* MPEG-1/2/4 Multiplexed */
+#define V4L2_PIX_FMT_H264     v4l2_fourcc('H', '2', '6', '4') /* H264 with start codes */
+#define V4L2_PIX_FMT_H264_NO_SC v4l2_fourcc('A', 'V', 'C', '1') /* H264 without start codes */
+#define V4L2_PIX_FMT_H263     v4l2_fourcc('H', '2', '6', '3') /* H263          */
+#define V4L2_PIX_FMT_MPEG1    v4l2_fourcc('M', 'P', 'G', '1') /* MPEG-1 ES     */
+#define V4L2_PIX_FMT_MPEG2    v4l2_fourcc('M', 'P', 'G', '2') /* MPEG-2 ES     */
+#define V4L2_PIX_FMT_MPEG4    v4l2_fourcc('M', 'P', 'G', '4') /* MPEG-4 ES     */
+#define V4L2_PIX_FMT_XVID     v4l2_fourcc('X', 'V', 'I', 'D') /* Xvid           */
+#define V4L2_PIX_FMT_VC1_ANNEX_G v4l2_fourcc('V', 'C', '1', 'G') /* SMPTE 421M Annex G compliant stream */
+#define V4L2_PIX_FMT_VC1_ANNEX_L v4l2_fourcc('V', 'C', '1', 'L') /* SMPTE 421M Annex L compliant stream */
 
 /*  Vendor-specific formats   */
 #define V4L2_PIX_FMT_CPIA1    v4l2_fourcc('C', 'P', 'I', 'A') /* cpia1 YUV */
@@ -402,6 +411,7 @@ struct v4l2_pix_format {
 #define V4L2_PIX_FMT_CIT_YYVYUY v4l2_fourcc('C', 'I', 'T', 'V') /* one line of Y then 1 line of VYUY */
 #define V4L2_PIX_FMT_KONICA420  v4l2_fourcc('K', 'O', 'N', 'I') /* YUV420 planar in blocks of 256 pixels */
 #define V4L2_PIX_FMT_JPGL       v4l2_fourcc('J', 'P', 'G', 'L') /* JPEG-Lite */
+#define V4L2_PIX_FMT_SE401      v4l2_fourcc('S', '4', '0', '1') /* se401 janggu compressed rgb */
 
 /*
  *      F O R M A T   E N U M E R A T I O N
@@ -1026,6 +1036,7 @@ struct v4l2_ext_controls {
 #define V4L2_CTRL_CLASS_MPEG 0x00990000 /* MPEG-compression controls */
 #define V4L2_CTRL_CLASS_CAMERA 0x009a0000       /* Camera class controls */
 #define V4L2_CTRL_CLASS_FM_TX 0x009b0000        /* FM Modulator control class */
+#define V4L2_CTRL_CLASS_FLASH 0x009c0000        /* Camera flash controls */
 
 #define V4L2_CTRL_ID_MASK         (0x0fffffff)
 #define V4L2_CTRL_ID2CLASS(id)    ((id) & 0x0fff0000UL)
@@ -1039,6 +1050,7 @@ enum v4l2_ctrl_type {
         V4L2_CTRL_TYPE_INTEGER64     = 5,
         V4L2_CTRL_TYPE_CTRL_CLASS    = 6,
         V4L2_CTRL_TYPE_STRING        = 7,
+        V4L2_CTRL_TYPE_BITMASK       = 8,
 };
 
 /*  Used in the VIDIOC_QUERYCTRL ioctl for querying controls */
@@ -1144,14 +1156,19 @@ enum v4l2_colorfx {
 #define V4L2_CID_ILLUMINATORS_1                 (V4L2_CID_BASE+37)
 #define V4L2_CID_ILLUMINATORS_2                 (V4L2_CID_BASE+38)
 
+#define V4L2_CID_MIN_BUFFERS_FOR_CAPTURE        (V4L2_CID_BASE+39)
+#define V4L2_CID_MIN_BUFFERS_FOR_OUTPUT         (V4L2_CID_BASE+40)
+
 /* last CID + 1 */
-#define V4L2_CID_LASTP1                         (V4L2_CID_BASE+39)
+#define V4L2_CID_LASTP1                         (V4L2_CID_BASE+41)
+
+/* Minimum number of buffer neede by the device */
 
 /*  MPEG-class control IDs defined by V4L2 */
 #define V4L2_CID_MPEG_BASE                      (V4L2_CTRL_CLASS_MPEG | 0x900)
 #define V4L2_CID_MPEG_CLASS                     (V4L2_CTRL_CLASS_MPEG | 1)
 
-/*  MPEG streams */
+/*  MPEG streams, specific to multiplexed streams */
 #define V4L2_CID_MPEG_STREAM_TYPE               (V4L2_CID_MPEG_BASE+0)
 enum v4l2_mpeg_stream_type {
         V4L2_MPEG_STREAM_TYPE_MPEG2_PS   = 0, /* MPEG-2 program stream */
@@ -1173,7 +1190,7 @@ enum v4l2_mpeg_stream_vbi_fmt {
         V4L2_MPEG_STREAM_VBI_FMT_IVTV = 1,  /* VBI in private packets, IVTV format */
 };
 
-/*  MPEG audio */
+/*  MPEG audio controls specific to multiplexed streams  */
 #define V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ       (V4L2_CID_MPEG_BASE+100)
 enum v4l2_mpeg_audio_sampling_freq {
         V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100 = 0,
@@ -1289,7 +1306,7 @@ enum v4l2_mpeg_audio_ac3_bitrate {
         V4L2_MPEG_AUDIO_AC3_BITRATE_640K = 18,
 };
 
-/*  MPEG video */
+/*  MPEG video controls specific to multiplexed streams */
 #define V4L2_CID_MPEG_VIDEO_ENCODING            (V4L2_CID_MPEG_BASE+200)
 enum v4l2_mpeg_video_encoding {
         V4L2_MPEG_VIDEO_ENCODING_MPEG_1     = 0,
@@ -1317,6 +1334,141 @@ enum v4l2_mpeg_video_bitrate_mode {
 #define V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION (V4L2_CID_MPEG_BASE+209)
 #define V4L2_CID_MPEG_VIDEO_MUTE                (V4L2_CID_MPEG_BASE+210)
 #define V4L2_CID_MPEG_VIDEO_MUTE_YUV            (V4L2_CID_MPEG_BASE+211)
+#define V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE             (V4L2_CID_MPEG_BASE+212)
+#define V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER        (V4L2_CID_MPEG_BASE+213)
+#define V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB             (V4L2_CID_MPEG_BASE+214)
+#define V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE                     (V4L2_CID_MPEG_BASE+215)
+#define V4L2_CID_MPEG_VIDEO_HEADER_MODE                         (V4L2_CID_MPEG_BASE+216)
+enum v4l2_mpeg_video_header_mode {
+        V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE                    = 0,
+        V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME       = 1,
+
+};
+#define V4L2_CID_MPEG_VIDEO_MAX_REF_PIC                 (V4L2_CID_MPEG_BASE+217)
+#define V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE                (V4L2_CID_MPEG_BASE+218)
+#define V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES       (V4L2_CID_MPEG_BASE+219)
+#define V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB          (V4L2_CID_MPEG_BASE+220)
+#define V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE            (V4L2_CID_MPEG_BASE+221)
+enum v4l2_mpeg_video_multi_slice_mode {
+        V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE         = 0,
+        V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_MB          = 1,
+        V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_BYTES       = 2,
+};
+#define V4L2_CID_MPEG_VIDEO_VBV_SIZE                    (V4L2_CID_MPEG_BASE+222)
+#define V4L2_CID_MPEG_VIDEO_H263_I_FRAME_QP             (V4L2_CID_MPEG_BASE+300)
+#define V4L2_CID_MPEG_VIDEO_H263_P_FRAME_QP             (V4L2_CID_MPEG_BASE+301)
+#define V4L2_CID_MPEG_VIDEO_H263_B_FRAME_QP             (V4L2_CID_MPEG_BASE+302)
+#define V4L2_CID_MPEG_VIDEO_H263_MIN_QP                 (V4L2_CID_MPEG_BASE+303)
+#define V4L2_CID_MPEG_VIDEO_H263_MAX_QP                 (V4L2_CID_MPEG_BASE+304)
+#define V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP             (V4L2_CID_MPEG_BASE+350)
+#define V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP             (V4L2_CID_MPEG_BASE+351)
+#define V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP             (V4L2_CID_MPEG_BASE+352)
+#define V4L2_CID_MPEG_VIDEO_H264_MIN_QP                 (V4L2_CID_MPEG_BASE+353)
+#define V4L2_CID_MPEG_VIDEO_H264_MAX_QP                 (V4L2_CID_MPEG_BASE+354)
+#define V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM          (V4L2_CID_MPEG_BASE+355)
+#define V4L2_CID_MPEG_VIDEO_H264_CPB_SIZE               (V4L2_CID_MPEG_BASE+356)
+#define V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE           (V4L2_CID_MPEG_BASE+357)
+enum v4l2_mpeg_video_h264_entropy_mode {
+        V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CAVLC = 0,
+        V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CABAC = 1,
+};
+#define V4L2_CID_MPEG_VIDEO_H264_I_PERIOD               (V4L2_CID_MPEG_BASE+358)
+#define V4L2_CID_MPEG_VIDEO_H264_LEVEL                  (V4L2_CID_MPEG_BASE+359)
+enum v4l2_mpeg_video_h264_level {
+        V4L2_MPEG_VIDEO_H264_LEVEL_1_0  = 0,
+        V4L2_MPEG_VIDEO_H264_LEVEL_1B   = 1,
+        V4L2_MPEG_VIDEO_H264_LEVEL_1_1  = 2,
+        V4L2_MPEG_VIDEO_H264_LEVEL_1_2  = 3,
+        V4L2_MPEG_VIDEO_H264_LEVEL_1_3  = 4,
+        V4L2_MPEG_VIDEO_H264_LEVEL_2_0  = 5,
+        V4L2_MPEG_VIDEO_H264_LEVEL_2_1  = 6,
+        V4L2_MPEG_VIDEO_H264_LEVEL_2_2  = 7,
+        V4L2_MPEG_VIDEO_H264_LEVEL_3_0  = 8,
+        V4L2_MPEG_VIDEO_H264_LEVEL_3_1  = 9,
+        V4L2_MPEG_VIDEO_H264_LEVEL_3_2  = 10,
+        V4L2_MPEG_VIDEO_H264_LEVEL_4_0  = 11,
+        V4L2_MPEG_VIDEO_H264_LEVEL_4_1  = 12,
+        V4L2_MPEG_VIDEO_H264_LEVEL_4_2  = 13,
+        V4L2_MPEG_VIDEO_H264_LEVEL_5_0  = 14,
+        V4L2_MPEG_VIDEO_H264_LEVEL_5_1  = 15,
+};
+#define V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA      (V4L2_CID_MPEG_BASE+360)
+#define V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA       (V4L2_CID_MPEG_BASE+361)
+#define V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE       (V4L2_CID_MPEG_BASE+362)
+enum v4l2_mpeg_video_h264_loop_filter_mode {
+        V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLED                           = 0,
+        V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED                          = 1,
+        V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED_AT_SLICE_BOUNDARY        = 2,
+};
+#define V4L2_CID_MPEG_VIDEO_H264_PROFILE                (V4L2_CID_MPEG_BASE+363)
+enum v4l2_mpeg_video_h264_profile {
+        V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE                   = 0,
+        V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE       = 1,
+        V4L2_MPEG_VIDEO_H264_PROFILE_MAIN                       = 2,
+        V4L2_MPEG_VIDEO_H264_PROFILE_EXTENDED                   = 3,
+        V4L2_MPEG_VIDEO_H264_PROFILE_HIGH                       = 4,
+        V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_10                    = 5,
+        V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_422                   = 6,
+        V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_444_PREDICTIVE        = 7,
+        V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_10_INTRA              = 8,
+        V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_422_INTRA             = 9,
+        V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_444_INTRA             = 10,
+        V4L2_MPEG_VIDEO_H264_PROFILE_CAVLC_444_INTRA            = 11,
+        V4L2_MPEG_VIDEO_H264_PROFILE_SCALABLE_BASELINE          = 12,
+        V4L2_MPEG_VIDEO_H264_PROFILE_SCALABLE_HIGH              = 13,
+        V4L2_MPEG_VIDEO_H264_PROFILE_SCALABLE_HIGH_INTRA        = 14,
+        V4L2_MPEG_VIDEO_H264_PROFILE_STEREO_HIGH                = 15,
+        V4L2_MPEG_VIDEO_H264_PROFILE_MULTIVIEW_HIGH             = 16,
+};
+#define V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_HEIGHT     (V4L2_CID_MPEG_BASE+364)
+#define V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_WIDTH      (V4L2_CID_MPEG_BASE+365)
+#define V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE         (V4L2_CID_MPEG_BASE+366)
+#define V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC            (V4L2_CID_MPEG_BASE+367)
+enum v4l2_mpeg_video_h264_vui_sar_idc {
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_UNSPECIFIED    = 0,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_1x1            = 1,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_12x11          = 2,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_10x11          = 3,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_16x11          = 4,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_40x33          = 5,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_24x11          = 6,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_20x11          = 7,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_32x11          = 8,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_80x33          = 9,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_18x11          = 10,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_15x11          = 11,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_64x33          = 12,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_160x99         = 13,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_4x3            = 14,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_3x2            = 15,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_2x1            = 16,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_EXTENDED       = 17,
+};
+#define V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP    (V4L2_CID_MPEG_BASE+400)
+#define V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP    (V4L2_CID_MPEG_BASE+401)
+#define V4L2_CID_MPEG_VIDEO_MPEG4_B_FRAME_QP    (V4L2_CID_MPEG_BASE+402)
+#define V4L2_CID_MPEG_VIDEO_MPEG4_MIN_QP        (V4L2_CID_MPEG_BASE+403)
+#define V4L2_CID_MPEG_VIDEO_MPEG4_MAX_QP        (V4L2_CID_MPEG_BASE+404)
+#define V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL         (V4L2_CID_MPEG_BASE+405)
+enum v4l2_mpeg_video_mpeg4_level {
+        V4L2_MPEG_VIDEO_MPEG4_LEVEL_0   = 0,
+        V4L2_MPEG_VIDEO_MPEG4_LEVEL_0B  = 1,
+        V4L2_MPEG_VIDEO_MPEG4_LEVEL_1   = 2,
+        V4L2_MPEG_VIDEO_MPEG4_LEVEL_2   = 3,
+        V4L2_MPEG_VIDEO_MPEG4_LEVEL_3   = 4,
+        V4L2_MPEG_VIDEO_MPEG4_LEVEL_3B  = 5,
+        V4L2_MPEG_VIDEO_MPEG4_LEVEL_4   = 6,
+        V4L2_MPEG_VIDEO_MPEG4_LEVEL_5   = 7,
+};
+#define V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE       (V4L2_CID_MPEG_BASE+406)
+enum v4l2_mpeg_video_mpeg4_profile {
+        V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE                            = 0,
+        V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_SIMPLE                   = 1,
+        V4L2_MPEG_VIDEO_MPEG4_PROFILE_CORE                              = 2,
+        V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE_SCALABLE                   = 3,
+        V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_CODING_EFFICIENCY        = 4,
+};
+#define V4L2_CID_MPEG_VIDEO_MPEG4_QPEL          (V4L2_CID_MPEG_BASE+407)
 
 /*  MPEG-class control IDs specific to the CX2341x driver as defined by V4L2 */
 #define V4L2_CID_MPEG_CX2341X_BASE                              (V4L2_CTRL_CLASS_MPEG | 0x1000)
@@ -1359,6 +1511,33 @@ enum v4l2_mpeg_cx2341x_video_median_filter_type {
 #define V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP    (V4L2_CID_MPEG_CX2341X_BASE+10)
 #define V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS         (V4L2_CID_MPEG_CX2341X_BASE+11)
 
+/*  MPEG-class control IDs specific to the Samsung MFC 5.1 driver as defined by V4L2 */
+#define V4L2_CID_MPEG_MFC51_BASE                                (V4L2_CTRL_CLASS_MPEG | 0x1100)
+
+#define V4L2_CID_MPEG_MFC51_VIDEO_DECODER_H264_DISPLAY_DELAY            (V4L2_CID_MPEG_MFC51_BASE+0)
+#define V4L2_CID_MPEG_MFC51_VIDEO_DECODER_H264_DISPLAY_DELAY_ENABLE     (V4L2_CID_MPEG_MFC51_BASE+1)
+#define V4L2_CID_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE                       (V4L2_CID_MPEG_MFC51_BASE+2)
+enum v4l2_mpeg_mfc51_video_frame_skip_mode {
+        V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_DISABLED          = 0,
+        V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_LEVEL_LIMIT       = 1,
+        V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_BUF_LIMIT         = 2,
+};
+#define V4L2_CID_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE                      (V4L2_CID_MPEG_MFC51_BASE+3)
+enum v4l2_mpeg_mfc51_video_force_frame_type {
+        V4L2_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE_DISABLED         = 0,
+        V4L2_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE_I_FRAME          = 1,
+        V4L2_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE_NOT_CODED        = 2,
+};
+#define V4L2_CID_MPEG_MFC51_VIDEO_PADDING                               (V4L2_CID_MPEG_MFC51_BASE+4)
+#define V4L2_CID_MPEG_MFC51_VIDEO_PADDING_YUV                           (V4L2_CID_MPEG_MFC51_BASE+5)
+#define V4L2_CID_MPEG_MFC51_VIDEO_RC_FIXED_TARGET_BIT                   (V4L2_CID_MPEG_MFC51_BASE+6)
+#define V4L2_CID_MPEG_MFC51_VIDEO_RC_REACTION_COEFF                     (V4L2_CID_MPEG_MFC51_BASE+7)
+#define V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_ACTIVITY             (V4L2_CID_MPEG_MFC51_BASE+50)
+#define V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_DARK                 (V4L2_CID_MPEG_MFC51_BASE+51)
+#define V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_SMOOTH               (V4L2_CID_MPEG_MFC51_BASE+52)
+#define V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_STATIC               (V4L2_CID_MPEG_MFC51_BASE+53)
+#define V4L2_CID_MPEG_MFC51_VIDEO_H264_NUM_REF_PIC_FOR_P                (V4L2_CID_MPEG_MFC51_BASE+54)
+
 /*  Camera class control IDs */
 #define V4L2_CID_CAMERA_CLASS_BASE      (V4L2_CTRL_CLASS_CAMERA | 0x900)
 #define V4L2_CID_CAMERA_CLASS           (V4L2_CTRL_CLASS_CAMERA | 1)
@@ -1427,6 +1606,41 @@ enum v4l2_preemphasis {
 #define V4L2_CID_TUNE_POWER_LEVEL               (V4L2_CID_FM_TX_CLASS_BASE + 113)
 #define V4L2_CID_TUNE_ANTENNA_CAPACITOR         (V4L2_CID_FM_TX_CLASS_BASE + 114)
 
+/* Flash and privacy (indicator) light controls */
+#define V4L2_CID_FLASH_CLASS_BASE               (V4L2_CTRL_CLASS_FLASH | 0x900)
+#define V4L2_CID_FLASH_CLASS                    (V4L2_CTRL_CLASS_FLASH | 1)
+
+#define V4L2_CID_FLASH_LED_MODE                 (V4L2_CID_FLASH_CLASS_BASE + 1)
+enum v4l2_flash_led_mode {
+        V4L2_FLASH_LED_MODE_NONE,
+        V4L2_FLASH_LED_MODE_FLASH,
+        V4L2_FLASH_LED_MODE_TORCH,
+};
+
+#define V4L2_CID_FLASH_STROBE_SOURCE            (V4L2_CID_FLASH_CLASS_BASE + 2)
+enum v4l2_flash_strobe_source {
+        V4L2_FLASH_STROBE_SOURCE_SOFTWARE,
+        V4L2_FLASH_STROBE_SOURCE_EXTERNAL,
+};
+
+#define V4L2_CID_FLASH_STROBE                   (V4L2_CID_FLASH_CLASS_BASE + 3)
+#define V4L2_CID_FLASH_STROBE_STOP              (V4L2_CID_FLASH_CLASS_BASE + 4)
+#define V4L2_CID_FLASH_STROBE_STATUS            (V4L2_CID_FLASH_CLASS_BASE + 5)
+
+#define V4L2_CID_FLASH_TIMEOUT                  (V4L2_CID_FLASH_CLASS_BASE + 6)
+#define V4L2_CID_FLASH_INTENSITY                (V4L2_CID_FLASH_CLASS_BASE + 7)
+#define V4L2_CID_FLASH_TORCH_INTENSITY          (V4L2_CID_FLASH_CLASS_BASE + 8)
+#define V4L2_CID_FLASH_INDICATOR_INTENSITY      (V4L2_CID_FLASH_CLASS_BASE + 9)
+
+#define V4L2_CID_FLASH_FAULT                    (V4L2_CID_FLASH_CLASS_BASE + 10)
+#define V4L2_FLASH_FAULT_OVER_VOLTAGE           (1 << 0)
+#define V4L2_FLASH_FAULT_TIMEOUT                (1 << 1)
+#define V4L2_FLASH_FAULT_OVER_TEMPERATURE       (1 << 2)
+#define V4L2_FLASH_FAULT_SHORT_CIRCUIT          (1 << 3)
+
+#define V4L2_CID_FLASH_CHARGE                   (V4L2_CID_FLASH_CLASS_BASE + 11)
+#define V4L2_CID_FLASH_READY                    (V4L2_CID_FLASH_CLASS_BASE + 12)
+
 /*
  *      T U N I N G
  */
@@ -1791,6 +2005,7 @@ struct v4l2_streamparm {
 #define V4L2_EVENT_ALL                          0
 #define V4L2_EVENT_VSYNC                        1
 #define V4L2_EVENT_EOS                          2
+#define V4L2_EVENT_CTRL                         3
 #define V4L2_EVENT_PRIVATE_START                0x08000000
 
 /* Payload for V4L2_EVENT_VSYNC */
@@ -1799,21 +2014,46 @@ struct v4l2_event_vsync {
         __u8 field;
 } __attribute__ ((packed));
 
+/* Payload for V4L2_EVENT_CTRL */
+#define V4L2_EVENT_CTRL_CH_VALUE                (1 << 0)
+#define V4L2_EVENT_CTRL_CH_FLAGS                (1 << 1)
+
+struct v4l2_event_ctrl {
+        __u32 changes;
+        __u32 type;
+        union {
+                __s32 value;
+                __s64 value64;
+        };
+        __u32 flags;
+        __s32 minimum;
+        __s32 maximum;
+        __s32 step;
+        __s32 default_value;
+};
+
 struct v4l2_event {
         __u32                           type;
         union {
                 struct v4l2_event_vsync vsync;
+                struct v4l2_event_ctrl  ctrl;
                 __u8                    data[64];
         } u;
         __u32                           pending;
         __u32                           sequence;
         struct timespec                 timestamp;
-        __u32                           reserved[9];
+        __u32                           id;
+        __u32                           reserved[8];
 };
 
+#define V4L2_EVENT_SUB_FL_SEND_INITIAL          (1 << 0)
+#define V4L2_EVENT_SUB_FL_ALLOW_FEEDBACK        (1 << 1)
+
 struct v4l2_event_subscription {
         __u32                           type;
-        __u32                           reserved[7];
+        __u32                           id;
+        __u32                           flags;
+        __u32                           reserved[5];
 };
 
 /*
diff --git a/include/linux/virtio.h b/include/linux/virtio.h
index aff5b4f74041..710885749605 100644
--- a/include/linux/virtio.h
+++ b/include/linux/virtio.h
@@ -51,6 +51,13 @@ struct virtqueue {
  *      This re-enables callbacks; it returns "false" if there are pending
  *      buffers in the queue, to detect a possible race between the driver
  *      checking for more work, and enabling callbacks.
+ * virtqueue_enable_cb_delayed: restart callbacks after disable_cb.
+ *      vq: the struct virtqueue we're talking about.
+ *      This re-enables callbacks but hints to the other side to delay
+ *      interrupts until most of the available buffers have been processed;
+ *      it returns "false" if there are many pending buffers in the queue,
+ *      to detect a possible race between the driver checking for more work,
+ *      and enabling callbacks.
  * virtqueue_detach_unused_buf: detach first unused buffer
  *      vq: the struct virtqueue we're talking about.
  *      Returns NULL or the "data" token handed to add_buf
@@ -86,6 +93,8 @@ void virtqueue_disable_cb(struct virtqueue *vq);
 
 bool virtqueue_enable_cb(struct virtqueue *vq);
 
+bool virtqueue_enable_cb_delayed(struct virtqueue *vq);
+
 void *virtqueue_detach_unused_buf(struct virtqueue *vq);
 
 /**
diff --git a/include/linux/virtio_9p.h b/include/linux/virtio_9p.h
index e68b439b2860..277c4ad44e84 100644
--- a/include/linux/virtio_9p.h
+++ b/include/linux/virtio_9p.h
@@ -1,7 +1,30 @@
 #ifndef _LINUX_VIRTIO_9P_H
 #define _LINUX_VIRTIO_9P_H
 /* This header is BSD licensed so anyone can use the definitions to implement
- * compatible drivers/servers. */
+ * compatible drivers/servers.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of IBM nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE. */
 #include <linux/types.h>
 #include <linux/virtio_ids.h>
 #include <linux/virtio_config.h>
diff --git a/include/linux/virtio_balloon.h b/include/linux/virtio_balloon.h
index a50ecd1b81a2..652dc8bea921 100644
--- a/include/linux/virtio_balloon.h
+++ b/include/linux/virtio_balloon.h
@@ -1,7 +1,30 @@
 #ifndef _LINUX_VIRTIO_BALLOON_H
 #define _LINUX_VIRTIO_BALLOON_H
 /* This header is BSD licensed so anyone can use the definitions to implement
- * compatible drivers/servers. */
+ * compatible drivers/servers.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of IBM nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE. */
 #include <linux/virtio_ids.h>
 #include <linux/virtio_config.h>
 
diff --git a/include/linux/virtio_blk.h b/include/linux/virtio_blk.h
index 167720d695ed..e0edb40ca7aa 100644
--- a/include/linux/virtio_blk.h
+++ b/include/linux/virtio_blk.h
@@ -1,7 +1,30 @@
 #ifndef _LINUX_VIRTIO_BLK_H
 #define _LINUX_VIRTIO_BLK_H
 /* This header is BSD licensed so anyone can use the definitions to implement
- * compatible drivers/servers. */
+ * compatible drivers/servers.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of IBM nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE. */
 #include <linux/types.h>
 #include <linux/virtio_ids.h>
 #include <linux/virtio_config.h>
diff --git a/include/linux/virtio_config.h b/include/linux/virtio_config.h
index 800617b4ddd5..39c88c5ad19d 100644
--- a/include/linux/virtio_config.h
+++ b/include/linux/virtio_config.h
@@ -1,7 +1,30 @@
 #ifndef _LINUX_VIRTIO_CONFIG_H
 #define _LINUX_VIRTIO_CONFIG_H
 /* This header, excluding the #ifdef __KERNEL__ part, is BSD licensed so
- * anyone can use the definitions to implement compatible drivers/servers. */
+ * anyone can use the definitions to implement compatible drivers/servers.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of IBM nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE. */
 
 /* Virtio devices use a standardized configuration space to define their
  * features and pass configuration information, but each implementation can
diff --git a/include/linux/virtio_console.h b/include/linux/virtio_console.h
index e4d333543a33..bdf4b0034739 100644
--- a/include/linux/virtio_console.h
+++ b/include/linux/virtio_console.h
@@ -5,7 +5,31 @@
 #include <linux/virtio_config.h>
 /*
  * This header, excluding the #ifdef __KERNEL__ part, is BSD licensed so
- * anyone can use the definitions to implement compatible drivers/servers.
+ * anyone can use the definitions to implement compatible drivers/servers:
+ *
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of IBM nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
  *
  * Copyright (C) Red Hat, Inc., 2009, 2010, 2011
  * Copyright (C) Amit Shah <amit.shah@redhat.com>, 2009, 2010, 2011
diff --git a/include/linux/virtio_ids.h b/include/linux/virtio_ids.h
index 06660c0a78d7..85bb0bb66ffc 100644
--- a/include/linux/virtio_ids.h
+++ b/include/linux/virtio_ids.h
@@ -5,7 +5,29 @@
  *
  * This header is BSD licensed so anyone can use the definitions to implement
  * compatible drivers/servers.
- */
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of IBM nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE. */
 
 #define VIRTIO_ID_NET           1 /* virtio net */
 #define VIRTIO_ID_BLOCK         2 /* virtio block */
diff --git a/include/linux/virtio_net.h b/include/linux/virtio_net.h
index 085e42298ce5..970d5a2a9047 100644
--- a/include/linux/virtio_net.h
+++ b/include/linux/virtio_net.h
@@ -1,7 +1,30 @@
 #ifndef _LINUX_VIRTIO_NET_H
 #define _LINUX_VIRTIO_NET_H
 /* This header is BSD licensed so anyone can use the definitions to implement
- * compatible drivers/servers. */
+ * compatible drivers/servers.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of IBM nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE. */
 #include <linux/types.h>
 #include <linux/virtio_ids.h>
 #include <linux/virtio_config.h>
@@ -40,6 +63,7 @@ struct virtio_net_config {
  * specify GSO or CSUM features, you can simply ignore the header. */
 struct virtio_net_hdr {
 #define VIRTIO_NET_HDR_F_NEEDS_CSUM     1       // Use csum_start, csum_offset
+#define VIRTIO_NET_HDR_F_DATA_VALID     2       // Csum is valid
         __u8 flags;
 #define VIRTIO_NET_HDR_GSO_NONE         0       // Not a GSO frame
 #define VIRTIO_NET_HDR_GSO_TCPV4        1       // GSO frame, IPv4 TCP (TSO)
diff --git a/include/linux/virtio_pci.h b/include/linux/virtio_pci.h
index 9a3d7c48c622..ea66f3f60d63 100644
--- a/include/linux/virtio_pci.h
+++ b/include/linux/virtio_pci.h
@@ -11,6 +11,29 @@
  *
  * This header is BSD licensed so anyone can use the definitions to implement
  * compatible drivers/servers.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of IBM nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
  */
 
 #ifndef _LINUX_VIRTIO_PCI_H
diff --git a/include/linux/virtio_ring.h b/include/linux/virtio_ring.h
index e4d144b132b5..4a32cb6da425 100644
--- a/include/linux/virtio_ring.h
+++ b/include/linux/virtio_ring.h
@@ -7,6 +7,29 @@
  * This header is BSD licensed so anyone can use the definitions to implement
  * compatible drivers/servers.
  *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of IBM nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
  * Copyright Rusty Russell IBM Corporation 2007. */
 #include <linux/types.h>
 
@@ -29,6 +52,12 @@
 /* We support indirect buffer descriptors */
 #define VIRTIO_RING_F_INDIRECT_DESC     28
 
+/* The Guest publishes the used index for which it expects an interrupt
+ * at the end of the avail ring. Host should ignore the avail->flags field. */
+/* The Host publishes the avail index for which it expects a kick
+ * at the end of the used ring. Guest should ignore the used->flags field. */
+#define VIRTIO_RING_F_EVENT_IDX         29
+
 /* Virtio ring descriptors: 16 bytes.  These can chain together via "next". */
 struct vring_desc {
         /* Address (guest-physical). */
@@ -83,6 +112,7 @@ struct vring {
  *      __u16 avail_flags;
  *      __u16 avail_idx;
  *      __u16 available[num];
+ *      __u16 used_event_idx;
  *
  *      // Padding to the next align boundary.
  *      char pad[];
@@ -91,8 +121,14 @@ struct vring {
  *      __u16 used_flags;
  *      __u16 used_idx;
  *      struct vring_used_elem used[num];
+ *      __u16 avail_event_idx;
  * };
  */
+/* We publish the used event index at the end of the available ring, and vice
+ * versa. They are at the end for backwards compatibility. */
+#define vring_used_event(vr) ((vr)->avail->ring[(vr)->num])
+#define vring_avail_event(vr) (*(__u16 *)&(vr)->used->ring[(vr)->num])
+
 static inline void vring_init(struct vring *vr, unsigned int num, void *p,
                               unsigned long align)
 {
@@ -107,7 +143,21 @@ static inline unsigned vring_size(unsigned int num, unsigned long align)
 {
         return ((sizeof(struct vring_desc) * num + sizeof(__u16) * (2 + num)
                  + align - 1) & ~(align - 1))
-                + sizeof(__u16) * 2 + sizeof(struct vring_used_elem) * num;
+                + sizeof(__u16) * 3 + sizeof(struct vring_used_elem) * num;
+}
+
+/* The following is used with USED_EVENT_IDX and AVAIL_EVENT_IDX */
+/* Assuming a given event_idx value from the other size, if
+ * we have just incremented index from old to new_idx,
+ * should we trigger an event? */
+static inline int vring_need_event(__u16 event_idx, __u16 new_idx, __u16 old)
+{
+        /* Note: Xen has similar logic for notification hold-off
+         * in include/xen/interface/io/ring.h with req_event and req_prod
+         * corresponding to event_idx + 1 and new_idx respectively.
+         * Note also that req_event and req_prod in Xen start at 1,
+         * event indexes in virtio start at 0. */
+        return (__u16)(new_idx - event_idx - 1) < (__u16)(new_idx - old);
 }
 
 #ifdef __KERNEL__
diff --git a/include/linux/vmstat.h b/include/linux/vmstat.h
index bcd942fa611c..65efb92da996 100644
--- a/include/linux/vmstat.h
+++ b/include/linux/vmstat.h
@@ -6,7 +6,7 @@
 #include <linux/mm.h>
 #include <linux/mmzone.h>
 #include <linux/vm_event_item.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 extern int sysctl_stat_interval;
 
diff --git a/include/linux/vt.h b/include/linux/vt.h
index d5dd0bc408fd..30a8dd9c83ff 100644
--- a/include/linux/vt.h
+++ b/include/linux/vt.h
@@ -86,6 +86,13 @@ struct vt_setactivate {
 
 #ifdef __KERNEL__
 
+/* Virtual Terminal events. */
+#define VT_ALLOCATE             0x0001 /* Console got allocated */
+#define VT_DEALLOCATE           0x0002 /* Console will be deallocated */
+#define VT_WRITE                0x0003 /* A char got output */
+#define VT_UPDATE               0x0004 /* A bigger update occurred */
+#define VT_PREWRITE             0x0005 /* A char is about to be written to the console */
+
 #ifdef CONFIG_VT_CONSOLE
 
 extern int vt_kmsg_redirect(int new);
diff --git a/include/linux/vt_kern.h b/include/linux/vt_kern.h
index 4d05e14ea60c..c2164fad0083 100644
--- a/include/linux/vt_kern.h
+++ b/include/linux/vt_kern.h
@@ -137,7 +137,7 @@ int vty_init(const struct file_operations *console_fops);
 
 static inline bool vt_force_oops_output(struct vc_data *vc)
 {
-        if (oops_in_progress && vc->vc_panic_force_write)
+        if (oops_in_progress && vc->vc_panic_force_write  && panic_timeout >= 0)
                 return true;
         return false;
 }
diff --git a/include/linux/watchdog.h b/include/linux/watchdog.h
index 011bcfeb9f09..111843f88b2a 100644
--- a/include/linux/watchdog.h
+++ b/include/linux/watchdog.h
@@ -59,6 +59,84 @@ struct watchdog_info {
 #define WATCHDOG_NOWAYOUT       0
 #endif
 
+struct watchdog_ops;
+struct watchdog_device;
+
+/** struct watchdog_ops - The watchdog-devices operations
+ *
+ * @owner:      The module owner.
+ * @start:      The routine for starting the watchdog device.
+ * @stop:       The routine for stopping the watchdog device.
+ * @ping:       The routine that sends a keepalive ping to the watchdog device.
+ * @status:     The routine that shows the status of the watchdog device.
+ * @set_timeout:The routine for setting the watchdog devices timeout value.
+ * @ioctl:      The routines that handles extra ioctl calls.
+ *
+ * The watchdog_ops structure contains a list of low-level operations
+ * that control a watchdog device. It also contains the module that owns
+ * these operations. The start and stop function are mandatory, all other
+ * functions are optonal.
+ */
+struct watchdog_ops {
+        struct module *owner;
+        /* mandatory operations */
+        int (*start)(struct watchdog_device *);
+        int (*stop)(struct watchdog_device *);
+        /* optional operations */
+        int (*ping)(struct watchdog_device *);
+        unsigned int (*status)(struct watchdog_device *);
+        int (*set_timeout)(struct watchdog_device *, unsigned int);
+        long (*ioctl)(struct watchdog_device *, unsigned int, unsigned long);
+};
+
+/** struct watchdog_device - The structure that defines a watchdog device
+ *
+ * @info:       Pointer to a watchdog_info structure.
+ * @ops:        Pointer to the list of watchdog operations.
+ * @bootstatus: Status of the watchdog device at boot.
+ * @timeout:    The watchdog devices timeout value.
+ * @min_timeout:The watchdog devices minimum timeout value.
+ * @max_timeout:The watchdog devices maximum timeout value.
+ * @driver-data:Pointer to the drivers private data.
+ * @status:     Field that contains the devices internal status bits.
+ *
+ * The watchdog_device structure contains all information about a
+ * watchdog timer device.
+ *
+ * The driver-data field may not be accessed directly. It must be accessed
+ * via the watchdog_set_drvdata and watchdog_get_drvdata helpers.
+ */
+struct watchdog_device {
+        const struct watchdog_info *info;
+        const struct watchdog_ops *ops;
+        unsigned int bootstatus;
+        unsigned int timeout;
+        unsigned int min_timeout;
+        unsigned int max_timeout;
+        void *driver_data;
+        unsigned long status;
+/* Bit numbers for status flags */
+#define WDOG_ACTIVE             0       /* Is the watchdog running/active */
+#define WDOG_DEV_OPEN           1       /* Opened via /dev/watchdog ? */
+#define WDOG_ALLOW_RELEASE      2       /* Did we receive the magic char ? */
+#define WDOG_NO_WAY_OUT         3       /* Is 'nowayout' feature set ? */
+};
+
+/* Use the following functions to manipulate watchdog driver specific data */
+static inline void watchdog_set_drvdata(struct watchdog_device *wdd, void *data)
+{
+        wdd->driver_data = data;
+}
+
+static inline void *watchdog_get_drvdata(struct watchdog_device *wdd)
+{
+        return wdd->driver_data;
+}
+
+/* drivers/watchdog/core/watchdog_core.c */
+extern int watchdog_register_device(struct watchdog_device *);
+extern void watchdog_unregister_device(struct watchdog_device *);
+
 #endif  /* __KERNEL__ */
 
 #endif  /* ifndef _LINUX_WATCHDOG_H */
diff --git a/include/linux/wm97xx.h b/include/linux/wm97xx.h
index 38e8c4d9289e..fd98bb968219 100644
--- a/include/linux/wm97xx.h
+++ b/include/linux/wm97xx.h
@@ -38,7 +38,11 @@
 #define WM97XX_ADCSEL_X         0x1000  /* x coord measurement */
 #define WM97XX_ADCSEL_Y         0x2000  /* y coord measurement */
 #define WM97XX_ADCSEL_PRES      0x3000  /* pressure measurement */
-#define WM97XX_ADCSEL_MASK      0x7000
+#define WM97XX_AUX_ID1          0x4000
+#define WM97XX_AUX_ID2          0x5000
+#define WM97XX_AUX_ID3          0x6000
+#define WM97XX_AUX_ID4          0x7000
+#define WM97XX_ADCSEL_MASK      0x7000  /* ADC selection mask */
 #define WM97XX_COO              0x0800  /* enable coordinate mode */
 #define WM97XX_CTC              0x0400  /* enable continuous mode */
 #define WM97XX_CM_RATE_93       0x0000  /* 93.75Hz continuous rate */
@@ -61,13 +65,6 @@
 #define WM97XX_PRP_DET_DIG      0xc000  /* setect on, digitise on */
 #define WM97XX_RPR              0x2000  /* wake up on pen down */
 #define WM97XX_PEN_DOWN         0x8000  /* pen is down */
-#define WM97XX_ADCSRC_MASK      0x7000  /* ADC source mask */
-
-#define WM97XX_AUX_ID1          0x8001
-#define WM97XX_AUX_ID2          0x8002
-#define WM97XX_AUX_ID3          0x8003
-#define WM97XX_AUX_ID4          0x8004
-
 
 /* WM9712 Bits */
 #define WM9712_45W              0x1000  /* set for 5-wire touchscreen */
diff --git a/include/linux/workqueue.h b/include/linux/workqueue.h
index f584aba78ca9..0d556deb497b 100644
--- a/include/linux/workqueue.h
+++ b/include/linux/workqueue.h
@@ -10,7 +10,7 @@
 #include <linux/bitops.h>
 #include <linux/lockdep.h>
 #include <linux/threads.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 struct workqueue_struct;
 
@@ -255,7 +255,7 @@ enum {
         WQ_HIGHPRI              = 1 << 4, /* high priority */
         WQ_CPU_INTENSIVE        = 1 << 5, /* cpu instensive workqueue */
 
-        WQ_DYING                = 1 << 6, /* internal: workqueue is dying */
+        WQ_DRAINING             = 1 << 6, /* internal: workqueue is draining */
         WQ_RESCUER              = 1 << 7, /* internal: workqueue has rescuer */
 
         WQ_MAX_ACTIVE           = 512,    /* I like 512, better ideas? */
@@ -355,6 +355,7 @@ extern int queue_delayed_work_on(int cpu, struct workqueue_struct *wq,
                         struct delayed_work *work, unsigned long delay);
 
 extern void flush_workqueue(struct workqueue_struct *wq);
+extern void drain_workqueue(struct workqueue_struct *wq);
 extern void flush_scheduled_work(void);
 
 extern int schedule_work(struct work_struct *work);
@@ -412,21 +413,6 @@ static inline bool __cancel_delayed_work(struct delayed_work *work)
         return ret;
 }
 
-/* Obsolete. use cancel_delayed_work_sync() */
-static inline __deprecated
-void cancel_rearming_delayed_workqueue(struct workqueue_struct *wq,
-                                        struct delayed_work *work)
-{
-        cancel_delayed_work_sync(work);
-}
-
-/* Obsolete. use cancel_delayed_work_sync() */
-static inline __deprecated
-void cancel_rearming_delayed_work(struct delayed_work *work)
-{
-        cancel_delayed_work_sync(work);
-}
-
 #ifndef CONFIG_SMP
 static inline long work_on_cpu(unsigned int cpu, long (*fn)(void *), void *arg)
 {
diff --git a/include/linux/writeback.h b/include/linux/writeback.h
index 17e7ccc322a5..f1bfa12ea246 100644
--- a/include/linux/writeback.h
+++ b/include/linux/writeback.h
@@ -7,9 +7,39 @@
 #include <linux/sched.h>
 #include <linux/fs.h>
 
-struct backing_dev_info;
+/*
+ * The 1/4 region under the global dirty thresh is for smooth dirty throttling:
+ *
+ *      (thresh - thresh/DIRTY_FULL_SCOPE, thresh)
+ *
+ * The 1/16 region above the global dirty limit will be put to maximum pauses:
+ *
+ *      (limit, limit + limit/DIRTY_MAXPAUSE_AREA)
+ *
+ * The 1/16 region above the max-pause region, dirty exceeded bdi's will be put
+ * to loops:
+ *
+ *      (limit + limit/DIRTY_MAXPAUSE_AREA, limit + limit/DIRTY_PASSGOOD_AREA)
+ *
+ * Further beyond, all dirtier tasks will enter a loop waiting (possibly long
+ * time) for the dirty pages to drop, unless written enough pages.
+ *
+ * The global dirty threshold is normally equal to the global dirty limit,
+ * except when the system suddenly allocates a lot of anonymous memory and
+ * knocks down the global dirty threshold quickly, in which case the global
+ * dirty limit will follow down slowly to prevent livelocking all dirtier tasks.
+ */
+#define DIRTY_SCOPE             8
+#define DIRTY_FULL_SCOPE        (DIRTY_SCOPE / 2)
+#define DIRTY_MAXPAUSE_AREA             16
+#define DIRTY_PASSGOOD_AREA             8
 
-extern spinlock_t inode_wb_list_lock;
+/*
+ * 4MB minimal write chunk size
+ */
+#define MIN_WRITEBACK_PAGES     (4096UL >> (PAGE_CACHE_SHIFT - 10))
+
+struct backing_dev_info;
 
 /*
  * fs/fs-writeback.c
@@ -26,11 +56,6 @@ enum writeback_sync_modes {
  */
 struct writeback_control {
         enum writeback_sync_modes sync_mode;
-        unsigned long *older_than_this; /* If !NULL, only write back inodes
-                                           older than this */
-        unsigned long wb_start;         /* Time writeback_inodes_wb was
-                                           called. This is needed to avoid
-                                           extra jobs and livelock */
         long nr_to_write;               /* Write this many pages, and decrement
                                            this for each page written */
         long pages_skipped;             /* Pages which were not written */
@@ -43,13 +68,11 @@ struct writeback_control {
         loff_t range_start;
         loff_t range_end;
 
-        unsigned nonblocking:1;         /* Don't get stuck on request queues */
-        unsigned encountered_congestion:1; /* An output: a queue is full */
         unsigned for_kupdate:1;         /* A kupdate writeback */
         unsigned for_background:1;      /* A background writeback */
+        unsigned tagged_writepages:1;   /* tag-and-write to avoid livelock */
         unsigned for_reclaim:1;         /* Invoked from the page allocator */
         unsigned range_cyclic:1;        /* range_start is cyclic */
-        unsigned more_io:1;             /* more io to be dispatched */
 };
 
 /*
@@ -62,8 +85,7 @@ void writeback_inodes_sb_nr(struct super_block *, unsigned long nr);
 int writeback_inodes_sb_if_idle(struct super_block *);
 int writeback_inodes_sb_nr_if_idle(struct super_block *, unsigned long nr);
 void sync_inodes_sb(struct super_block *);
-void writeback_inodes_wb(struct bdi_writeback *wb,
-                struct writeback_control *wbc);
+long writeback_inodes_wb(struct bdi_writeback *wb, long nr_pages);
 long wb_do_writeback(struct bdi_writeback *wb, int force_wait);
 void wakeup_flusher_threads(long nr_pages);
 
@@ -94,6 +116,8 @@ static inline void laptop_sync_completion(void) { }
 #endif
 void throttle_vm_writeout(gfp_t gfp_mask);
 
+extern unsigned long global_dirty_limit;
+
 /* These are exported to sysctl. */
 extern int dirty_background_ratio;
 extern unsigned long dirty_background_bytes;
@@ -128,6 +152,13 @@ void global_dirty_limits(unsigned long *pbackground, unsigned long *pdirty);
 unsigned long bdi_dirty_limit(struct backing_dev_info *bdi,
                                unsigned long dirty);
 
+void __bdi_update_bandwidth(struct backing_dev_info *bdi,
+                            unsigned long thresh,
+                            unsigned long dirty,
+                            unsigned long bdi_thresh,
+                            unsigned long bdi_dirty,
+                            unsigned long start_time);
+
 void page_writeback_init(void);
 void balance_dirty_pages_ratelimited_nr(struct address_space *mapping,
                                         unsigned long nr_pages_dirtied);
diff --git a/include/linux/zorro.h b/include/linux/zorro.h
index 7bf9db525e9e..dff42025649b 100644
--- a/include/linux/zorro.h
+++ b/include/linux/zorro.h
@@ -187,7 +187,7 @@ extern struct zorro_dev *zorro_find_device(zorro_id id,
 
 #define zorro_resource_start(z) ((z)->resource.start)
 #define zorro_resource_end(z)   ((z)->resource.end)
-#define zorro_resource_len(z)   ((z)->resource.end-(z)->resource.start+1)
+#define zorro_resource_len(z)   (resource_size(&(z)->resource))
 #define zorro_resource_flags(z) ((z)->resource.flags)
 
 #define zorro_request_device(z, name) \