Merge branch 'master' into for-linus

Conflicts:
	fs/pipe.c

Signed-off-by: Jens Axboe <jaxboe@fusionio.com>

114 files changed, 2757 insertions, 802 deletions

diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index 3da73f5f0ae9..224a38c960d4 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -248,11 +248,12 @@ int acpi_check_region(resource_size_t start, resource_size_t n,
 int acpi_check_mem_region(resource_size_t start, resource_size_t n,
                       const char *name);
 
+int acpi_resources_are_enforced(void);
+
 #ifdef CONFIG_PM_SLEEP
 void __init acpi_no_s4_hw_signature(void);
 void __init acpi_old_suspend_ordering(void);
 void __init acpi_s4_no_nvs(void);
-void __init acpi_set_sci_en_on_resume(void);
 #endif /* CONFIG_PM_SLEEP */
 
 struct acpi_osc_context {
diff --git a/include/linux/aio.h b/include/linux/aio.h
index 811dbb369379..7a8db4155281 100644
--- a/include/linux/aio.h
+++ b/include/linux/aio.h
@@ -212,6 +212,8 @@ extern void kick_iocb(struct kiocb *iocb);
 extern int aio_complete(struct kiocb *iocb, long res, long res2);
 struct mm_struct;
 extern void exit_aio(struct mm_struct *mm);
+extern long do_io_submit(aio_context_t ctx_id, long nr,
+                         struct iocb __user *__user *iocbpp, bool compat);
 #else
 static inline ssize_t wait_on_sync_kiocb(struct kiocb *iocb) { return 0; }
 static inline int aio_put_req(struct kiocb *iocb) { return 0; }
@@ -219,6 +221,9 @@ static inline void kick_iocb(struct kiocb *iocb) { }
 static inline int aio_complete(struct kiocb *iocb, long res, long res2) { return 0; }
 struct mm_struct;
 static inline void exit_aio(struct mm_struct *mm) { }
+static inline long do_io_submit(aio_context_t ctx_id, long nr,
+                                struct iocb __user * __user *iocbpp,
+                                bool compat) { return 0; }
 #endif /* CONFIG_AIO */
 
 static inline struct kiocb *list_kiocb(struct list_head *h)
diff --git a/include/linux/amba/pl022.h b/include/linux/amba/pl022.h
index e4836c6b3dd7..abf26cc47a2b 100644
--- a/include/linux/amba/pl022.h
+++ b/include/linux/amba/pl022.h
@@ -71,6 +71,7 @@ struct ssp_clock_params {
 
 /**
  * enum ssp_rx_endian - endianess of Rx FIFO Data
+ * this feature is only available in ST versionf of PL022
  */
 enum ssp_rx_endian {
         SSP_RX_MSB,
@@ -181,7 +182,8 @@ enum ssp_microwire_wait_state {
 };
 
 /**
- * enum Microwire - whether Full/Half Duplex
+ * enum ssp_duplex - whether Full/Half Duplex on microwire, only
+ * available in the ST Micro variant.
  * @SSP_MICROWIRE_CHANNEL_FULL_DUPLEX: SSPTXD becomes bi-directional,
  *     SSPRXD not used
  * @SSP_MICROWIRE_CHANNEL_HALF_DUPLEX: SSPTXD is an output, SSPRXD is
@@ -193,6 +195,31 @@ enum ssp_duplex {
 };
 
 /**
+ * enum ssp_clkdelay - an optional clock delay on the feedback clock
+ * only available in the ST Micro PL023 variant.
+ * @SSP_FEEDBACK_CLK_DELAY_NONE: no delay, the data coming in from the
+ * slave is sampled directly
+ * @SSP_FEEDBACK_CLK_DELAY_1T: the incoming slave data is sampled with
+ * a delay of T-dt
+ * @SSP_FEEDBACK_CLK_DELAY_2T: dito with a delay if 2T-dt
+ * @SSP_FEEDBACK_CLK_DELAY_3T: dito with a delay if 3T-dt
+ * @SSP_FEEDBACK_CLK_DELAY_4T: dito with a delay if 4T-dt
+ * @SSP_FEEDBACK_CLK_DELAY_5T: dito with a delay if 5T-dt
+ * @SSP_FEEDBACK_CLK_DELAY_6T: dito with a delay if 6T-dt
+ * @SSP_FEEDBACK_CLK_DELAY_7T: dito with a delay if 7T-dt
+ */
+enum ssp_clkdelay {
+        SSP_FEEDBACK_CLK_DELAY_NONE,
+        SSP_FEEDBACK_CLK_DELAY_1T,
+        SSP_FEEDBACK_CLK_DELAY_2T,
+        SSP_FEEDBACK_CLK_DELAY_3T,
+        SSP_FEEDBACK_CLK_DELAY_4T,
+        SSP_FEEDBACK_CLK_DELAY_5T,
+        SSP_FEEDBACK_CLK_DELAY_6T,
+        SSP_FEEDBACK_CLK_DELAY_7T
+};
+
+/**
  * CHIP select/deselect commands
  */
 enum ssp_chip_select {
@@ -235,6 +262,8 @@ struct pl022_ssp_controller {
  * @ctrl_len: Microwire interface: Control length
  * @wait_state: Microwire interface: Wait state
  * @duplex: Microwire interface: Full/Half duplex
+ * @clkdelay: on the PL023 variant, the delay in feeback clock cycles
+ * before sampling the incoming line
  * @cs_control: function pointer to board-specific function to
  * assert/deassert I/O port to control HW generation of devices chip-select.
  * @dma_xfer_type: Type of DMA xfer (Mem-to-periph or Periph-to-Periph)
@@ -258,6 +287,7 @@ struct pl022_config_chip {
         enum ssp_microwire_ctrl_len ctrl_len;
         enum ssp_microwire_wait_state wait_state;
         enum ssp_duplex duplex;
+        enum ssp_clkdelay clkdelay;
         void (*cs_control) (u32 control);
 };
 
diff --git a/include/linux/amba/pl330.h b/include/linux/amba/pl330.h
new file mode 100644
index 000000000000..cbee7de7dd36
--- /dev/null
+++ b/include/linux/amba/pl330.h
@@ -0,0 +1,45 @@
+/* linux/include/linux/amba/pl330.h
+ *
+ * Copyright (C) 2010 Samsung Electronics Co. Ltd.
+ *      Jaswinder Singh <jassi.brar@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.
+ */
+
+#ifndef __AMBA_PL330_H_
+#define __AMBA_PL330_H_
+
+#include <asm/hardware/pl330.h>
+
+struct dma_pl330_peri {
+        /*
+         * Peri_Req i/f of the DMAC that is
+         * peripheral could be reached from.
+         */
+        u8 peri_id; /* {0, 31} */
+        enum pl330_reqtype rqtype;
+
+        /* For M->D and D->M Channels */
+        int burst_sz; /* in power of 2 */
+        dma_addr_t fifo_addr;
+};
+
+struct dma_pl330_platdata {
+        /*
+         * Number of valid peripherals connected to DMAC.
+         * This may be different from the value read from
+         * CR0, as the PL330 implementation might have 'holes'
+         * in the peri list or the peri could also be reached
+         * from another DMAC which the platform prefers.
+         */
+        u8 nr_valid_peri;
+        /* Array of valid peripherals */
+        struct dma_pl330_peri *peri;
+        /* Bytes to allocate for MC buffer */
+        unsigned mcbuf_sz;
+};
+
+#endif  /* __AMBA_PL330_H_ */
diff --git a/include/linux/buffer_head.h b/include/linux/buffer_head.h
index 16ed0284d780..1b9ba193b789 100644
--- a/include/linux/buffer_head.h
+++ b/include/linux/buffer_head.h
@@ -203,6 +203,9 @@ int block_write_full_page_endio(struct page *page, get_block_t *get_block,
 int block_read_full_page(struct page*, get_block_t*);
 int block_is_partially_uptodate(struct page *page, read_descriptor_t *desc,
                                 unsigned long from);
+int block_write_begin_newtrunc(struct file *, struct address_space *,
+                                loff_t, unsigned, unsigned,
+                                struct page **, void **, get_block_t*);
 int block_write_begin(struct file *, struct address_space *,
                                 loff_t, unsigned, unsigned,
                                 struct page **, void **, get_block_t*);
@@ -214,6 +217,9 @@ int generic_write_end(struct file *, struct address_space *,
                                 struct page *, void *);
 void page_zero_new_buffers(struct page *page, unsigned from, unsigned to);
 int block_prepare_write(struct page*, unsigned, unsigned, get_block_t*);
+int cont_write_begin_newtrunc(struct file *, struct address_space *, loff_t,
+                        unsigned, unsigned, struct page **, void **,
+                        get_block_t *, loff_t *);
 int cont_write_begin(struct file *, struct address_space *, loff_t,
                         unsigned, unsigned, struct page **, void **,
                         get_block_t *, loff_t *);
@@ -224,7 +230,10 @@ int block_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf,
 void block_sync_page(struct page *);
 sector_t generic_block_bmap(struct address_space *, sector_t, get_block_t *);
 int block_truncate_page(struct address_space *, loff_t, get_block_t *);
-int file_fsync(struct file *, struct dentry *, int);
+int file_fsync(struct file *, int);
+int nobh_write_begin_newtrunc(struct file *, struct address_space *,
+                                loff_t, unsigned, unsigned,
+                                struct page **, void **, get_block_t*);
 int nobh_write_begin(struct file *, struct address_space *,
                                 loff_t, unsigned, unsigned,
                                 struct page **, void **, get_block_t*);
diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h
index 8f78073d7caa..0c621604baa1 100644
--- a/include/linux/cgroup.h
+++ b/include/linux/cgroup.h
@@ -397,7 +397,7 @@ struct cftype {
          * This callback must be implemented, if you want provide
          * notification functionality.
          */
-        int (*unregister_event)(struct cgroup *cgrp, struct cftype *cft,
+        void (*unregister_event)(struct cgroup *cgrp, struct cftype *cft,
                         struct eventfd_ctx *eventfd);
 };
 
diff --git a/include/linux/compaction.h b/include/linux/compaction.h
new file mode 100644
index 000000000000..5ac51552d908
--- /dev/null
+++ b/include/linux/compaction.h
@@ -0,0 +1,89 @@
+#ifndef _LINUX_COMPACTION_H
+#define _LINUX_COMPACTION_H
+
+/* Return values for compact_zone() and try_to_compact_pages() */
+/* compaction didn't start as it was not possible or direct reclaim was more suitable */
+#define COMPACT_SKIPPED         0
+/* compaction should continue to another pageblock */
+#define COMPACT_CONTINUE        1
+/* direct compaction partially compacted a zone and there are suitable pages */
+#define COMPACT_PARTIAL         2
+/* The full zone was compacted */
+#define COMPACT_COMPLETE        3
+
+#ifdef CONFIG_COMPACTION
+extern int sysctl_compact_memory;
+extern int sysctl_compaction_handler(struct ctl_table *table, int write,
+                        void __user *buffer, size_t *length, loff_t *ppos);
+extern int sysctl_extfrag_threshold;
+extern int sysctl_extfrag_handler(struct ctl_table *table, int write,
+                        void __user *buffer, size_t *length, loff_t *ppos);
+
+extern int fragmentation_index(struct zone *zone, unsigned int order);
+extern unsigned long try_to_compact_pages(struct zonelist *zonelist,
+                        int order, gfp_t gfp_mask, nodemask_t *mask);
+
+/* Do not skip compaction more than 64 times */
+#define COMPACT_MAX_DEFER_SHIFT 6
+
+/*
+ * Compaction is deferred when compaction fails to result in a page
+ * allocation success. 1 << compact_defer_limit compactions are skipped up
+ * to a limit of 1 << COMPACT_MAX_DEFER_SHIFT
+ */
+static inline void defer_compaction(struct zone *zone)
+{
+        zone->compact_considered = 0;
+        zone->compact_defer_shift++;
+
+        if (zone->compact_defer_shift > COMPACT_MAX_DEFER_SHIFT)
+                zone->compact_defer_shift = COMPACT_MAX_DEFER_SHIFT;
+}
+
+/* Returns true if compaction should be skipped this time */
+static inline bool compaction_deferred(struct zone *zone)
+{
+        unsigned long defer_limit = 1UL << zone->compact_defer_shift;
+
+        /* Avoid possible overflow */
+        if (++zone->compact_considered > defer_limit)
+                zone->compact_considered = defer_limit;
+
+        return zone->compact_considered < (1UL << zone->compact_defer_shift);
+}
+
+#else
+static inline unsigned long try_to_compact_pages(struct zonelist *zonelist,
+                        int order, gfp_t gfp_mask, nodemask_t *nodemask)
+{
+        return COMPACT_CONTINUE;
+}
+
+static inline void defer_compaction(struct zone *zone)
+{
+}
+
+static inline bool compaction_deferred(struct zone *zone)
+{
+        return 1;
+}
+
+#endif /* CONFIG_COMPACTION */
+
+#if defined(CONFIG_COMPACTION) && defined(CONFIG_SYSFS) && defined(CONFIG_NUMA)
+extern int compaction_register_node(struct node *node);
+extern void compaction_unregister_node(struct node *node);
+
+#else
+
+static inline int compaction_register_node(struct node *node)
+{
+        return 0;
+}
+
+static inline void compaction_unregister_node(struct node *node)
+{
+}
+#endif /* CONFIG_COMPACTION && CONFIG_SYSFS && CONFIG_NUMA */
+
+#endif /* _LINUX_COMPACTION_H */
diff --git a/include/linux/compat.h b/include/linux/compat.h
index 717c691ecd8e..168f7daa7bde 100644
--- a/include/linux/compat.h
+++ b/include/linux/compat.h
@@ -356,5 +356,9 @@ asmlinkage long compat_sys_newfstatat(unsigned int dfd, char __user * filename,
 asmlinkage long compat_sys_openat(unsigned int dfd, const char __user *filename,
                                   int flags, int mode);
 
+extern ssize_t compat_rw_copy_check_uvector(int type,
+                const struct compat_iovec __user *uvector, unsigned long nr_segs,
+                unsigned long fast_segs, struct iovec *fast_pointer,
+                struct iovec **ret_pointer);
 #endif /* CONFIG_COMPAT */
 #endif /* _LINUX_COMPAT_H */
diff --git a/include/linux/completion.h b/include/linux/completion.h
index 4a6b604ef7e4..51e3145196f6 100644
--- a/include/linux/completion.h
+++ b/include/linux/completion.h
@@ -83,6 +83,8 @@ extern unsigned long wait_for_completion_timeout(struct completion *x,
                                                    unsigned long timeout);
 extern unsigned long wait_for_completion_interruptible_timeout(
                         struct completion *x, unsigned long timeout);
+extern unsigned long wait_for_completion_killable_timeout(
+                        struct completion *x, unsigned long timeout);
 extern bool try_wait_for_completion(struct completion *x);
 extern bool completion_done(struct completion *x);
 
diff --git a/include/linux/cper.h b/include/linux/cper.h
new file mode 100644
index 000000000000..4b38f905b705
--- /dev/null
+++ b/include/linux/cper.h
@@ -0,0 +1,314 @@
+/*
+ * UEFI Common Platform Error Record
+ *
+ * Copyright (C) 2010, Intel Corp.
+ *      Author: Huang Ying <ying.huang@intel.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 LINUX_CPER_H
+#define LINUX_CPER_H
+
+#include <linux/uuid.h>
+
+/* CPER record signature and the size */
+#define CPER_SIG_RECORD                         "CPER"
+#define CPER_SIG_SIZE                           4
+/* Used in signature_end field in struct cper_record_header */
+#define CPER_SIG_END                            0xffffffff
+
+/*
+ * CPER record header revision, used in revision field in struct
+ * cper_record_header
+ */
+#define CPER_RECORD_REV                         0x0100
+
+/*
+ * Severity difinition for error_severity in struct cper_record_header
+ * and section_severity in struct cper_section_descriptor
+ */
+#define CPER_SER_RECOVERABLE                    0x0
+#define CPER_SER_FATAL                          0x1
+#define CPER_SER_CORRECTED                      0x2
+#define CPER_SER_INFORMATIONAL                  0x3
+
+/*
+ * Validation bits difinition for validation_bits in struct
+ * cper_record_header. If set, corresponding fields in struct
+ * cper_record_header contain valid information.
+ *
+ * corresponds platform_id
+ */
+#define CPER_VALID_PLATFORM_ID                  0x0001
+/* corresponds timestamp */
+#define CPER_VALID_TIMESTAMP                    0x0002
+/* corresponds partition_id */
+#define CPER_VALID_PARTITION_ID                 0x0004
+
+/*
+ * Notification type used to generate error record, used in
+ * notification_type in struct cper_record_header
+ *
+ * Corrected Machine Check
+ */
+#define CPER_NOTIFY_CMC                                                 \
+        UUID_LE(0x2DCE8BB1, 0xBDD7, 0x450e, 0xB9, 0xAD, 0x9C, 0xF4,     \
+                0xEB, 0xD4, 0xF8, 0x90)
+/* Corrected Platform Error */
+#define CPER_NOTIFY_CPE                                                 \
+        UUID_LE(0x4E292F96, 0xD843, 0x4a55, 0xA8, 0xC2, 0xD4, 0x81,     \
+                0xF2, 0x7E, 0xBE, 0xEE)
+/* Machine Check Exception */
+#define CPER_NOTIFY_MCE                                                 \
+        UUID_LE(0xE8F56FFE, 0x919C, 0x4cc5, 0xBA, 0x88, 0x65, 0xAB,     \
+                0xE1, 0x49, 0x13, 0xBB)
+/* PCI Express Error */
+#define CPER_NOTIFY_PCIE                                                \
+        UUID_LE(0xCF93C01F, 0x1A16, 0x4dfc, 0xB8, 0xBC, 0x9C, 0x4D,     \
+                0xAF, 0x67, 0xC1, 0x04)
+/* INIT Record (for IPF) */
+#define CPER_NOTIFY_INIT                                                \
+        UUID_LE(0xCC5263E8, 0x9308, 0x454a, 0x89, 0xD0, 0x34, 0x0B,     \
+                0xD3, 0x9B, 0xC9, 0x8E)
+/* Non-Maskable Interrupt */
+#define CPER_NOTIFY_NMI                                                 \
+        UUID_LE(0x5BAD89FF, 0xB7E6, 0x42c9, 0x81, 0x4A, 0xCF, 0x24,     \
+                0x85, 0xD6, 0xE9, 0x8A)
+/* BOOT Error Record */
+#define CPER_NOTIFY_BOOT                                                \
+        UUID_LE(0x3D61A466, 0xAB40, 0x409a, 0xA6, 0x98, 0xF3, 0x62,     \
+                0xD4, 0x64, 0xB3, 0x8F)
+/* DMA Remapping Error */
+#define CPER_NOTIFY_DMAR                                                \
+        UUID_LE(0x667DD791, 0xC6B3, 0x4c27, 0x8A, 0x6B, 0x0F, 0x8E,     \
+                0x72, 0x2D, 0xEB, 0x41)
+
+/*
+ * Flags bits definitions for flags in struct cper_record_header
+ * If set, the error has been recovered
+ */
+#define CPER_HW_ERROR_FLAGS_RECOVERED           0x1
+/* If set, the error is for previous boot */
+#define CPER_HW_ERROR_FLAGS_PREVERR             0x2
+/* If set, the error is injected for testing */
+#define CPER_HW_ERROR_FLAGS_SIMULATED           0x4
+
+/*
+ * CPER section header revision, used in revision field in struct
+ * cper_section_descriptor
+ */
+#define CPER_SEC_REV                            0x0100
+
+/*
+ * Validation bits difinition for validation_bits in struct
+ * cper_section_descriptor. If set, corresponding fields in struct
+ * cper_section_descriptor contain valid information.
+ *
+ * corresponds fru_id
+ */
+#define CPER_SEC_VALID_FRU_ID                   0x1
+/* corresponds fru_text */
+#define CPER_SEC_VALID_FRU_TEXT                 0x2
+
+/*
+ * Flags bits definitions for flags in struct cper_section_descriptor
+ *
+ * If set, the section is associated with the error condition
+ * directly, and should be focused on
+ */
+#define CPER_SEC_PRIMARY                        0x0001
+/*
+ * If set, the error was not contained within the processor or memory
+ * hierarchy and the error may have propagated to persistent storage
+ * or network
+ */
+#define CPER_SEC_CONTAINMENT_WARNING            0x0002
+/* If set, the component must be re-initialized or re-enabled prior to use */
+#define CPER_SEC_RESET                          0x0004
+/* If set, Linux may choose to discontinue use of the resource */
+#define CPER_SEC_ERROR_THRESHOLD_EXCEEDED       0x0008
+/*
+ * If set, resource could not be queried for error information due to
+ * conflicts with other system software or resources. Some fields of
+ * the section will be invalid
+ */
+#define CPER_SEC_RESOURCE_NOT_ACCESSIBLE        0x0010
+/*
+ * If set, action has been taken to ensure error containment (such as
+ * poisoning data), but the error has not been fully corrected and the
+ * data has not been consumed. Linux may choose to take further
+ * corrective action before the data is consumed
+ */
+#define CPER_SEC_LATENT_ERROR                   0x0020
+
+/*
+ * Section type definitions, used in section_type field in struct
+ * cper_section_descriptor
+ *
+ * Processor Generic
+ */
+#define CPER_SEC_PROC_GENERIC                                           \
+        UUID_LE(0x9876CCAD, 0x47B4, 0x4bdb, 0xB6, 0x5E, 0x16, 0xF1,     \
+                0x93, 0xC4, 0xF3, 0xDB)
+/* Processor Specific: X86/X86_64 */
+#define CPER_SEC_PROC_IA                                                \
+        UUID_LE(0xDC3EA0B0, 0xA144, 0x4797, 0xB9, 0x5B, 0x53, 0xFA,     \
+                0x24, 0x2B, 0x6E, 0x1D)
+/* Processor Specific: IA64 */
+#define CPER_SEC_PROC_IPF                                               \
+        UUID_LE(0xE429FAF1, 0x3CB7, 0x11D4, 0x0B, 0xCA, 0x07, 0x00,     \
+                0x80, 0xC7, 0x3C, 0x88, 0x81)
+/* Platform Memory */
+#define CPER_SEC_PLATFORM_MEM                                           \
+        UUID_LE(0xA5BC1114, 0x6F64, 0x4EDE, 0xB8, 0x63, 0x3E, 0x83,     \
+                0xED, 0x7C, 0x83, 0xB1)
+#define CPER_SEC_PCIE                                                   \
+        UUID_LE(0xD995E954, 0xBBC1, 0x430F, 0xAD, 0x91, 0xB4, 0x4D,     \
+                0xCB, 0x3C, 0x6F, 0x35)
+/* Firmware Error Record Reference */
+#define CPER_SEC_FW_ERR_REC_REF                                         \
+        UUID_LE(0x81212A96, 0x09ED, 0x4996, 0x94, 0x71, 0x8D, 0x72,     \
+                0x9C, 0x8E, 0x69, 0xED)
+/* PCI/PCI-X Bus */
+#define CPER_SEC_PCI_X_BUS                                              \
+        UUID_LE(0xC5753963, 0x3B84, 0x4095, 0xBF, 0x78, 0xED, 0xDA,     \
+                0xD3, 0xF9, 0xC9, 0xDD)
+/* PCI Component/Device */
+#define CPER_SEC_PCI_DEV                                                \
+        UUID_LE(0xEB5E4685, 0xCA66, 0x4769, 0xB6, 0xA2, 0x26, 0x06,     \
+                0x8B, 0x00, 0x13, 0x26)
+#define CPER_SEC_DMAR_GENERIC                                           \
+        UUID_LE(0x5B51FEF7, 0xC79D, 0x4434, 0x8F, 0x1B, 0xAA, 0x62,     \
+                0xDE, 0x3E, 0x2C, 0x64)
+/* Intel VT for Directed I/O specific DMAr */
+#define CPER_SEC_DMAR_VT                                                \
+        UUID_LE(0x71761D37, 0x32B2, 0x45cd, 0xA7, 0xD0, 0xB0, 0xFE,     \
+                0xDD, 0x93, 0xE8, 0xCF)
+/* IOMMU specific DMAr */
+#define CPER_SEC_DMAR_IOMMU                                             \
+        UUID_LE(0x036F84E1, 0x7F37, 0x428c, 0xA7, 0x9E, 0x57, 0x5F,     \
+                0xDF, 0xAA, 0x84, 0xEC)
+
+/*
+ * All tables and structs must be byte-packed to match CPER
+ * specification, since the tables are provided by the system BIOS
+ */
+#pragma pack(1)
+
+struct cper_record_header {
+        char    signature[CPER_SIG_SIZE];       /* must be CPER_SIG_RECORD */
+        __u16   revision;                       /* must be CPER_RECORD_REV */
+        __u32   signature_end;                  /* must be CPER_SIG_END */
+        __u16   section_count;
+        __u32   error_severity;
+        __u32   validation_bits;
+        __u32   record_length;
+        __u64   timestamp;
+        uuid_le platform_id;
+        uuid_le partition_id;
+        uuid_le creator_id;
+        uuid_le notification_type;
+        __u64   record_id;
+        __u32   flags;
+        __u64   persistence_information;
+        __u8    reserved[12];                   /* must be zero */
+};
+
+struct cper_section_descriptor {
+        __u32   section_offset;         /* Offset in bytes of the
+                                         *  section body from the base
+                                         *  of the record header */
+        __u32   section_length;
+        __u16   revision;               /* must be CPER_RECORD_REV */
+        __u8    validation_bits;
+        __u8    reserved;               /* must be zero */
+        __u32   flags;
+        uuid_le section_type;
+        uuid_le fru_id;
+        __u32   section_severity;
+        __u8    fru_text[20];
+};
+
+/* Generic Processor Error Section */
+struct cper_sec_proc_generic {
+        __u64   validation_bits;
+        __u8    proc_type;
+        __u8    proc_isa;
+        __u8    proc_error_type;
+        __u8    operation;
+        __u8    flags;
+        __u8    level;
+        __u16   reserved;
+        __u64   cpu_version;
+        char    cpu_brand[128];
+        __u64   proc_id;
+        __u64   target_addr;
+        __u64   requestor_id;
+        __u64   responder_id;
+        __u64   ip;
+};
+
+/* IA32/X64 Processor Error Section */
+struct cper_sec_proc_ia {
+        __u64   validation_bits;
+        __u8    lapic_id;
+        __u8    cpuid[48];
+};
+
+/* IA32/X64 Processor Error Infomation Structure */
+struct cper_ia_err_info {
+        uuid_le err_type;
+        __u64   validation_bits;
+        __u64   check_info;
+        __u64   target_id;
+        __u64   requestor_id;
+        __u64   responder_id;
+        __u64   ip;
+};
+
+/* IA32/X64 Processor Context Information Structure */
+struct cper_ia_proc_ctx {
+        __u16   reg_ctx_type;
+        __u16   reg_arr_size;
+        __u32   msr_addr;
+        __u64   mm_reg_addr;
+};
+
+/* Memory Error Section */
+struct cper_sec_mem_err {
+        __u64   validation_bits;
+        __u64   error_status;
+        __u64   physical_addr;
+        __u64   physical_addr_mask;
+        __u16   node;
+        __u16   card;
+        __u16   module;
+        __u16   bank;
+        __u16   device;
+        __u16   row;
+        __u16   column;
+        __u16   bit_pos;
+        __u64   requestor_id;
+        __u64   responder_id;
+        __u64   target_id;
+        __u8    error_type;
+};
+
+/* Reset to default packing */
+#pragma pack()
+
+u64 cper_next_record_id(void);
+
+#endif
diff --git a/include/linux/cpuidle.h b/include/linux/cpuidle.h
index dcf77fa826b5..55215cce5005 100644
--- a/include/linux/cpuidle.h
+++ b/include/linux/cpuidle.h
@@ -125,6 +125,7 @@ struct cpuidle_driver {
 #ifdef CONFIG_CPU_IDLE
 
 extern int cpuidle_register_driver(struct cpuidle_driver *drv);
+struct cpuidle_driver *cpuidle_get_driver(void);
 extern void cpuidle_unregister_driver(struct cpuidle_driver *drv);
 extern int cpuidle_register_device(struct cpuidle_device *dev);
 extern void cpuidle_unregister_device(struct cpuidle_device *dev);
@@ -137,16 +138,17 @@ extern void cpuidle_disable_device(struct cpuidle_device *dev);
 #else
 
 static inline int cpuidle_register_driver(struct cpuidle_driver *drv)
-{return 0;}
+{return -ENODEV; }
+static inline struct cpuidle_driver *cpuidle_get_driver(void) {return NULL; }
 static inline void cpuidle_unregister_driver(struct cpuidle_driver *drv) { }
 static inline int cpuidle_register_device(struct cpuidle_device *dev)
-{return 0;}
+{return -ENODEV; }
 static inline void cpuidle_unregister_device(struct cpuidle_device *dev) { }
 
 static inline void cpuidle_pause_and_lock(void) { }
 static inline void cpuidle_resume_and_unlock(void) { }
 static inline int cpuidle_enable_device(struct cpuidle_device *dev)
-{return 0;}
+{return -ENODEV; }
 static inline void cpuidle_disable_device(struct cpuidle_device *dev) { }
 
 #endif
diff --git a/include/linux/cpuset.h b/include/linux/cpuset.h
index a73454aec333..457ed765a116 100644
--- a/include/linux/cpuset.h
+++ b/include/linux/cpuset.h
@@ -69,6 +69,7 @@ extern void cpuset_task_status_allowed(struct seq_file *m,
                                         struct task_struct *task);
 
 extern int cpuset_mem_spread_node(void);
+extern int cpuset_slab_spread_node(void);
 
 static inline int cpuset_do_page_mem_spread(void)
 {
@@ -86,9 +87,44 @@ extern void rebuild_sched_domains(void);
 
 extern void cpuset_print_task_mems_allowed(struct task_struct *p);
 
+/*
+ * reading current mems_allowed and mempolicy in the fastpath must protected
+ * by get_mems_allowed()
+ */
+static inline void get_mems_allowed(void)
+{
+        current->mems_allowed_change_disable++;
+
+        /*
+         * ensure that reading mems_allowed and mempolicy happens after the
+         * update of ->mems_allowed_change_disable.
+         *
+         * the write-side task finds ->mems_allowed_change_disable is not 0,
+         * and knows the read-side task is reading mems_allowed or mempolicy,
+         * so it will clear old bits lazily.
+         */
+        smp_mb();
+}
+
+static inline void put_mems_allowed(void)
+{
+        /*
+         * ensure that reading mems_allowed and mempolicy before reducing
+         * mems_allowed_change_disable.
+         *
+         * the write-side task will know that the read-side task is still
+         * reading mems_allowed or mempolicy, don't clears old bits in the
+         * nodemask.
+         */
+        smp_mb();
+        --ACCESS_ONCE(current->mems_allowed_change_disable);
+}
+
 static inline void set_mems_allowed(nodemask_t nodemask)
 {
+        task_lock(current);
         current->mems_allowed = nodemask;
+        task_unlock(current);
 }
 
 #else /* !CONFIG_CPUSETS */
@@ -159,6 +195,11 @@ static inline int cpuset_mem_spread_node(void)
         return 0;
 }
 
+static inline int cpuset_slab_spread_node(void)
+{
+        return 0;
+}
+
 static inline int cpuset_do_page_mem_spread(void)
 {
         return 0;
@@ -187,6 +228,14 @@ static inline void set_mems_allowed(nodemask_t nodemask)
 {
 }
 
+static inline void get_mems_allowed(void)
+{
+}
+
+static inline void put_mems_allowed(void)
+{
+}
+
 #endif /* !CONFIG_CPUSETS */
 
 #endif /* _LINUX_CPUSET_H */
diff --git a/include/linux/cred.h b/include/linux/cred.h
index 52507c3e1387..75c0fa881308 100644
--- a/include/linux/cred.h
+++ b/include/linux/cred.h
@@ -156,7 +156,6 @@ extern int copy_creds(struct task_struct *, unsigned long);
 extern struct cred *cred_alloc_blank(void);
 extern struct cred *prepare_creds(void);
 extern struct cred *prepare_exec_creds(void);
-extern struct cred *prepare_usermodehelper_creds(void);
 extern int commit_creds(struct cred *);
 extern void abort_creds(struct cred *);
 extern const struct cred *override_creds(const struct cred *);
diff --git a/include/linux/crypto.h b/include/linux/crypto.h
index 24d2e30f1b46..a6a7a1c83f54 100644
--- a/include/linux/crypto.h
+++ b/include/linux/crypto.h
@@ -99,13 +99,7 @@
  * as arm where pointers are 32-bit aligned but there are data types such as
  * u64 which require 64-bit alignment.
  */
-#if defined(ARCH_KMALLOC_MINALIGN)
 #define CRYPTO_MINALIGN ARCH_KMALLOC_MINALIGN
-#elif defined(ARCH_SLAB_MINALIGN)
-#define CRYPTO_MINALIGN ARCH_SLAB_MINALIGN
-#else
-#define CRYPTO_MINALIGN __alignof__(unsigned long long)
-#endif
 
 #define CRYPTO_MINALIGN_ATTR __attribute__ ((__aligned__(CRYPTO_MINALIGN)))
 
diff --git a/include/linux/debugfs.h b/include/linux/debugfs.h
index fc1b930f246c..e7d9b20ddc5b 100644
--- a/include/linux/debugfs.h
+++ b/include/linux/debugfs.h
@@ -63,6 +63,8 @@ struct dentry *debugfs_create_x16(const char *name, mode_t mode,
                                   struct dentry *parent, u16 *value);
 struct dentry *debugfs_create_x32(const char *name, mode_t mode,
                                   struct dentry *parent, u32 *value);
+struct dentry *debugfs_create_x64(const char *name, mode_t mode,
+                                  struct dentry *parent, u64 *value);
 struct dentry *debugfs_create_size_t(const char *name, mode_t mode,
                                      struct dentry *parent, size_t *value);
 struct dentry *debugfs_create_bool(const char *name, mode_t mode,
diff --git a/include/linux/device.h b/include/linux/device.h
index 7bb9f426f3e6..0713e10571dd 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -33,6 +33,7 @@ struct class;
 struct class_private;
 struct bus_type;
 struct bus_type_private;
+struct device_node;
 
 struct bus_attribute {
         struct attribute        attr;
@@ -127,6 +128,10 @@ struct device_driver {
 
         bool suppress_bind_attrs;       /* disables bind/unbind via sysfs */
 
+#if defined(CONFIG_OF)
+        const struct of_device_id       *of_match_table;
+#endif
+
         int (*probe) (struct device *dev);
         int (*remove) (struct device *dev);
         void (*shutdown) (struct device *dev);
@@ -435,6 +440,9 @@ struct device {
                                              override */
         /* arch specific additions */
         struct dev_archdata     archdata;
+#ifdef CONFIG_OF
+        struct device_node      *of_node;
+#endif
 
         dev_t                   devt;   /* dev_t, creates the sysfs "dev" */
 
diff --git a/include/linux/dma-mapping.h b/include/linux/dma-mapping.h
index ca32ed78b057..89b7e1a605b8 100644
--- a/include/linux/dma-mapping.h
+++ b/include/linux/dma-mapping.h
@@ -40,16 +40,6 @@ struct dma_map_ops {
         void (*sync_single_for_device)(struct device *dev,
                                        dma_addr_t dma_handle, size_t size,
                                        enum dma_data_direction dir);
-        void (*sync_single_range_for_cpu)(struct device *dev,
-                                          dma_addr_t dma_handle,
-                                          unsigned long offset,
-                                          size_t size,
-                                          enum dma_data_direction dir);
-        void (*sync_single_range_for_device)(struct device *dev,
-                                             dma_addr_t dma_handle,
-                                             unsigned long offset,
-                                             size_t size,
-                                             enum dma_data_direction dir);
         void (*sync_sg_for_cpu)(struct device *dev,
                                 struct scatterlist *sg, int nents,
                                 enum dma_data_direction dir);
@@ -105,21 +95,6 @@ static inline int is_device_dma_capable(struct device *dev)
 #include <asm-generic/dma-mapping-broken.h>
 #endif
 
-/* for backwards compatibility, removed soon */
-static inline void __deprecated dma_sync_single(struct device *dev,
-                                                dma_addr_t addr, size_t size,
-                                                enum dma_data_direction dir)
-{
-        dma_sync_single_for_cpu(dev, addr, size, dir);
-}
-
-static inline void __deprecated dma_sync_sg(struct device *dev,
-                                            struct scatterlist *sg, int nelems,
-                                            enum dma_data_direction dir)
-{
-        dma_sync_sg_for_cpu(dev, sg, nelems, dir);
-}
-
 static inline u64 dma_get_mask(struct device *dev)
 {
         if (dev && dev->dma_mask && *dev->dma_mask)
diff --git a/include/linux/ds2782_battery.h b/include/linux/ds2782_battery.h
new file mode 100644
index 000000000000..b4e281f65c15
--- /dev/null
+++ b/include/linux/ds2782_battery.h
@@ -0,0 +1,8 @@
+#ifndef __LINUX_DS2782_BATTERY_H
+#define __LINUX_DS2782_BATTERY_H
+
+struct ds278x_platform_data {
+        int rsns;
+};
+
+#endif
diff --git a/include/linux/dynamic_debug.h b/include/linux/dynamic_debug.h
index f8c2e1767500..b3cd4de9432b 100644
--- a/include/linux/dynamic_debug.h
+++ b/include/linux/dynamic_debug.h
@@ -28,7 +28,7 @@ struct _ddebug {
         /*
          * The flags field controls the behaviour at the callsite.
          * The bits here are changed dynamically when the user
-         * writes commands to <debugfs>/dynamic_debug/ddebug
+         * writes commands to <debugfs>/dynamic_debug/control
          */
 #define _DPRINTK_FLAGS_PRINT   (1<<0)  /* printk() a message using the format */
 #define _DPRINTK_FLAGS_DEFAULT 0
diff --git a/include/linux/err.h b/include/linux/err.h
index 1b12642636c7..448afc12c78a 100644
--- a/include/linux/err.h
+++ b/include/linux/err.h
@@ -19,22 +19,22 @@
 
 #define IS_ERR_VALUE(x) unlikely((x) >= (unsigned long)-MAX_ERRNO)
 
-static inline void *ERR_PTR(long error)
+static inline void * __must_check ERR_PTR(long error)
 {
         return (void *) error;
 }
 
-static inline long PTR_ERR(const void *ptr)
+static inline long __must_check PTR_ERR(const void *ptr)
 {
         return (long) ptr;
 }
 
-static inline long IS_ERR(const void *ptr)
+static inline long __must_check IS_ERR(const void *ptr)
 {
         return IS_ERR_VALUE((unsigned long)ptr);
 }
 
-static inline long IS_ERR_OR_NULL(const void *ptr)
+static inline long __must_check IS_ERR_OR_NULL(const void *ptr)
 {
         return !ptr || IS_ERR_VALUE((unsigned long)ptr);
 }
@@ -46,7 +46,7 @@ static inline long IS_ERR_OR_NULL(const void *ptr)
  * Explicitly cast an error-valued pointer to another pointer type in such a
  * way as to make it clear that's what's going on.
  */
-static inline void *ERR_CAST(const void *ptr)
+static inline void * __must_check ERR_CAST(const void *ptr)
 {
         /* cast away the const */
         return (void *) ptr;
diff --git a/include/linux/ext3_fs.h b/include/linux/ext3_fs.h
index 5f494b465097..7fc62d4550b2 100644
--- a/include/linux/ext3_fs.h
+++ b/include/linux/ext3_fs.h
@@ -868,7 +868,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 *, struct dentry *, int);
+extern int ext3_sync_file(struct file *, int);
 
 /* hash.c */
 extern int ext3fs_dirhash(const char *name, int len, struct
diff --git a/include/linux/fb.h b/include/linux/fb.h
index 1296af45169d..907ace3a64c8 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -4,8 +4,6 @@
 #include <linux/types.h>
 #include <linux/i2c.h>
 
-struct dentry;
-
 /* Definitions of frame buffers                                         */
 
 #define FB_MAX                  32      /* sufficient for now */
@@ -37,7 +35,7 @@ struct dentry;
 #define FBIOGET_HWCINFO         0x4616
 #define FBIOPUT_MODEINFO        0x4617
 #define FBIOGET_DISPINFO        0x4618
-
+#define FBIO_WAITFORVSYNC       _IOW('F', 0x20, __u32)
 
 #define FB_TYPE_PACKED_PIXELS           0       /* Packed Pixels        */
 #define FB_TYPE_PLANES                  1       /* Non interleaved planes */
@@ -1017,8 +1015,7 @@ 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, struct dentry *dentry,
-                                int datasync);
+extern int fb_deferred_io_fsync(struct file *file, int datasync);
 
 static inline bool fb_be_math(struct fb_info *info)
 {
diff --git a/include/linux/fec.h b/include/linux/fec.h
new file mode 100644
index 000000000000..5d3523d8dd0c
--- /dev/null
+++ b/include/linux/fec.h
@@ -0,0 +1,21 @@
+/* include/linux/fec.h
+ *
+ * Copyright (c) 2009 Orex Computed Radiography
+ *   Baruch Siach <baruch@tkos.co.il>
+ *
+ * Header file for the FEC platform data
+ *
+ * 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 __LINUX_FEC_H__
+#define __LINUX_FEC_H__
+
+#include <linux/phy.h>
+
+struct fec_platform_data {
+        phy_interface_t phy;
+};
+
+#endif
diff --git a/include/linux/file.h b/include/linux/file.h
index 5555508fd517..b1e12970f617 100644
--- a/include/linux/file.h
+++ b/include/linux/file.h
@@ -11,7 +11,6 @@
 
 struct file;
 
-extern void __fput(struct file *);
 extern void fput(struct file *);
 extern void drop_file_write_access(struct file *file);
 
diff --git a/include/linux/firewire.h b/include/linux/firewire.h
index 4bd94bf5e739..72e2b8ac2a5a 100644
--- a/include/linux/firewire.h
+++ b/include/linux/firewire.h
@@ -55,13 +55,11 @@
 #define CSR_DESCRIPTOR          0x01
 #define CSR_VENDOR              0x03
 #define CSR_HARDWARE_VERSION    0x04
-#define CSR_NODE_CAPABILITIES   0x0c
 #define CSR_UNIT                0x11
 #define CSR_SPECIFIER_ID        0x12
 #define CSR_VERSION             0x13
 #define CSR_DEPENDENT_INFO      0x14
 #define CSR_MODEL               0x17
-#define CSR_INSTANCE            0x18
 #define CSR_DIRECTORY_ID        0x20
 
 struct fw_csr_iterator {
@@ -89,7 +87,6 @@ struct fw_card {
         int current_tlabel;
         u64 tlabel_mask;
         struct list_head transaction_list;
-        struct timer_list flush_timer;
         unsigned long reset_jiffies;
 
         unsigned long long guid;
@@ -290,6 +287,8 @@ struct fw_transaction {
         int tlabel;
         int timestamp;
         struct list_head link;
+        struct fw_card *card;
+        struct timer_list split_timeout_timer;
 
         struct fw_packet packet;
 
diff --git a/include/linux/fs.h b/include/linux/fs.h
index b336cb9ca9a0..3428393942a6 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -954,6 +954,7 @@ extern spinlock_t files_lock;
 #define file_list_unlock() spin_unlock(&files_lock);
 
 #define get_file(x)     atomic_long_inc(&(x)->f_count)
+#define fput_atomic(x)  atomic_long_add_unless(&(x)->f_count, -1, 1)
 #define file_count(x)   atomic_long_read(&(x)->f_count)
 
 #ifdef CONFIG_DEBUG_WRITECOUNT
@@ -1497,7 +1498,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 *, struct dentry *, int datasync);
+        int (*fsync) (struct file *, int datasync);
         int (*aio_fsync) (struct kiocb *, int datasync);
         int (*fasync) (int, struct file *, int);
         int (*lock) (struct file *, int, struct file_lock *);
@@ -2212,7 +2213,7 @@ 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, struct dentry *dentry, int datasync);
+extern int blkdev_fsync(struct file *filp, int datasync);
 
 /* fs/splice.c */
 extern ssize_t generic_file_splice_read(struct file *, loff_t *,
@@ -2228,6 +2229,7 @@ extern long do_splice_direct(struct file *in, loff_t *ppos, struct file *out,
 
 extern void
 file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);
+extern loff_t noop_llseek(struct file *file, loff_t offset, int origin);
 extern loff_t no_llseek(struct file *file, loff_t offset, int origin);
 extern loff_t generic_file_llseek(struct file *file, loff_t offset, int origin);
 extern loff_t generic_file_llseek_unlocked(struct file *file, loff_t offset,
@@ -2250,10 +2252,19 @@ static inline int xip_truncate_page(struct address_space *mapping, loff_t from)
 #endif
 
 #ifdef CONFIG_BLOCK
+struct bio;
+typedef void (dio_submit_t)(int rw, struct bio *bio, struct inode *inode,
+                            loff_t file_offset);
+void dio_end_io(struct bio *bio, int error);
+
+ssize_t __blockdev_direct_IO_newtrunc(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,
+        dio_submit_t submit_io, int lock_type);
 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,
-        int lock_type);
+        dio_submit_t submit_io, int lock_type);
 
 enum {
         /* need locking between buffered and direct access */
@@ -2263,13 +2274,31 @@ enum {
         DIO_SKIP_HOLES  = 0x02,
 };
 
+static inline ssize_t blockdev_direct_IO_newtrunc(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)
+{
+        return __blockdev_direct_IO_newtrunc(rw, iocb, inode, bdev, iov, offset,
+                                    nr_segs, get_block, end_io, NULL,
+                                    DIO_LOCKING | DIO_SKIP_HOLES);
+}
+
+static inline ssize_t blockdev_direct_IO_no_locking_newtrunc(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)
+{
+        return __blockdev_direct_IO_newtrunc(rw, iocb, inode, bdev, iov, offset,
+                                nr_segs, get_block, end_io, NULL, 0);
+}
 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)
 {
         return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
-                                    nr_segs, get_block, end_io,
+                                    nr_segs, get_block, end_io, NULL,
                                     DIO_LOCKING | DIO_SKIP_HOLES);
 }
 
@@ -2279,7 +2308,7 @@ static inline ssize_t blockdev_direct_IO_no_locking(int rw, struct kiocb *iocb,
         dio_iodone_t end_io)
 {
         return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
-                                nr_segs, get_block, end_io, 0);
+                                    nr_segs, get_block, end_io, NULL, 0);
 }
 #endif
 
@@ -2335,13 +2364,15 @@ extern int dcache_dir_open(struct inode *, struct file *);
 extern int dcache_dir_close(struct inode *, struct file *);
 extern loff_t dcache_dir_lseek(struct file *, loff_t, int);
 extern int dcache_readdir(struct file *, void *, filldir_t);
+extern int simple_setattr(struct dentry *, struct iattr *);
 extern int simple_getattr(struct vfsmount *, struct dentry *, struct kstat *);
 extern int simple_statfs(struct dentry *, struct kstatfs *);
 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 simple_sync_file(struct file *, struct dentry *, int);
+extern int simple_setsize(struct inode *, loff_t);
+extern int noop_fsync(struct file *, 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,
@@ -2366,7 +2397,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 simple_fsync(struct file *, struct dentry *, int);
+extern int generic_file_fsync(struct file *, int);
 
 #ifdef CONFIG_MIGRATION
 extern int buffer_migrate_page(struct address_space *,
@@ -2377,7 +2408,8 @@ extern int buffer_migrate_page(struct address_space *,
 
 extern int inode_change_ok(const struct inode *, struct iattr *);
 extern int inode_newsize_ok(const struct inode *, loff_t offset);
-extern int __must_check inode_setattr(struct inode *, struct iattr *);
+extern int __must_check inode_setattr(struct inode *, const struct iattr *);
+extern void generic_setattr(struct inode *inode, const struct iattr *attr);
 
 extern void file_update_time(struct file *file);
 
diff --git a/include/linux/ftrace_event.h b/include/linux/ftrace_event.h
index c082f223e2fe..3167f2df4126 100644
--- a/include/linux/ftrace_event.h
+++ b/include/linux/ftrace_event.h
@@ -73,18 +73,25 @@ struct trace_iterator {
 };
 
 
+struct trace_event;
+
 typedef enum print_line_t (*trace_print_func)(struct trace_iterator *iter,
-                                              int flags);
-struct trace_event {
-        struct hlist_node       node;
-        struct list_head        list;
-        int                     type;
+                                      int flags, struct trace_event *event);
+
+struct trace_event_functions {
         trace_print_func        trace;
         trace_print_func        raw;
         trace_print_func        hex;
         trace_print_func        binary;
 };
 
+struct trace_event {
+        struct hlist_node               node;
+        struct list_head                list;
+        int                             type;
+        struct trace_event_functions    *funcs;
+};
+
 extern int register_ftrace_event(struct trace_event *event);
 extern int unregister_ftrace_event(struct trace_event *event);
 
@@ -116,28 +123,70 @@ void tracing_record_cmdline(struct task_struct *tsk);
 
 struct event_filter;
 
+enum trace_reg {
+        TRACE_REG_REGISTER,
+        TRACE_REG_UNREGISTER,
+        TRACE_REG_PERF_REGISTER,
+        TRACE_REG_PERF_UNREGISTER,
+};
+
+struct ftrace_event_call;
+
+struct ftrace_event_class {
+        char                    *system;
+        void                    *probe;
+#ifdef CONFIG_PERF_EVENTS
+        void                    *perf_probe;
+#endif
+        int                     (*reg)(struct ftrace_event_call *event,
+                                       enum trace_reg type);
+        int                     (*define_fields)(struct ftrace_event_call *);
+        struct list_head        *(*get_fields)(struct ftrace_event_call *);
+        struct list_head        fields;
+        int                     (*raw_init)(struct ftrace_event_call *);
+};
+
+enum {
+        TRACE_EVENT_FL_ENABLED_BIT,
+        TRACE_EVENT_FL_FILTERED_BIT,
+};
+
+enum {
+        TRACE_EVENT_FL_ENABLED  = (1 << TRACE_EVENT_FL_ENABLED_BIT),
+        TRACE_EVENT_FL_FILTERED = (1 << TRACE_EVENT_FL_FILTERED_BIT),
+};
+
 struct ftrace_event_call {
         struct list_head        list;
+        struct ftrace_event_class *class;
         char                    *name;
-        char                    *system;
         struct dentry           *dir;
-        struct trace_event      *event;
-        int                     enabled;
-        int                     (*regfunc)(struct ftrace_event_call *);
-        void                    (*unregfunc)(struct ftrace_event_call *);
-        int                     id;
+        struct trace_event      event;
         const char              *print_fmt;
-        int                     (*raw_init)(struct ftrace_event_call *);
-        int                     (*define_fields)(struct ftrace_event_call *);
-        struct list_head        fields;
-        int                     filter_active;
         struct event_filter     *filter;
         void                    *mod;
         void                    *data;
 
+        /*
+         * 32 bit flags:
+         *   bit 1:             enabled
+         *   bit 2:             filter_active
+         *
+         * Changes to flags must hold the event_mutex.
+         *
+         * Note: Reads of flags do not hold the event_mutex since
+         * they occur in critical sections. But the way flags
+         * is currently used, these changes do no affect the code
+         * except that when a change is made, it may have a slight
+         * delay in propagating the changes to other CPUs due to
+         * caching and such.
+         */
+        unsigned int            flags;
+
+#ifdef CONFIG_PERF_EVENTS
         int                     perf_refcount;
-        int                     (*perf_event_enable)(struct ftrace_event_call *);
-        void                    (*perf_event_disable)(struct ftrace_event_call *);
+        struct hlist_head       *perf_events;
+#endif
 };
 
 #define PERF_MAX_TRACE_SIZE     2048
@@ -194,24 +243,22 @@ struct perf_event;
 
 DECLARE_PER_CPU(struct pt_regs, perf_trace_regs);
 
-extern int perf_trace_enable(int event_id);
-extern void perf_trace_disable(int event_id);
-extern int ftrace_profile_set_filter(struct perf_event *event, int event_id,
+extern int  perf_trace_init(struct perf_event *event);
+extern void perf_trace_destroy(struct perf_event *event);
+extern int  perf_trace_enable(struct perf_event *event);
+extern void perf_trace_disable(struct perf_event *event);
+extern int  ftrace_profile_set_filter(struct perf_event *event, int event_id,
                                      char *filter_str);
 extern void ftrace_profile_free_filter(struct perf_event *event);
-extern void *
-perf_trace_buf_prepare(int size, unsigned short type, int *rctxp,
-                         unsigned long *irq_flags);
+extern void *perf_trace_buf_prepare(int size, unsigned short type,
+                                    struct pt_regs *regs, int *rctxp);
 
 static inline void
 perf_trace_buf_submit(void *raw_data, int size, int rctx, u64 addr,
-                       u64 count, unsigned long irq_flags, struct pt_regs *regs)
+                       u64 count, struct pt_regs *regs, void *head)
 {
-        struct trace_entry *entry = raw_data;
-
-        perf_tp_event(entry->type, addr, count, raw_data, size, regs);
+        perf_tp_event(addr, count, raw_data, size, regs, head);
         perf_swevent_put_recursion_context(rctx);
-        local_irq_restore(irq_flags);
 }
 #endif
 
diff --git a/include/linux/fuse.h b/include/linux/fuse.h
index 3e2925a34bf0..88e0eb596919 100644
--- a/include/linux/fuse.h
+++ b/include/linux/fuse.h
@@ -34,6 +34,9 @@
  * 7.13
  *  - make max number of background requests and congestion threshold
  *    tunables
+ *
+ * 7.14
+ *  - add splice support to fuse device
  */
 
 #ifndef _LINUX_FUSE_H
@@ -65,7 +68,7 @@
 #define FUSE_KERNEL_VERSION 7
 
 /** Minor version number of this interface */
-#define FUSE_KERNEL_MINOR_VERSION 13
+#define FUSE_KERNEL_MINOR_VERSION 14
 
 /** The node ID of the root inode */
 #define FUSE_ROOT_ID 1
diff --git a/include/linux/gfp.h b/include/linux/gfp.h
index 4c6d41333f98..975609cb8548 100644
--- a/include/linux/gfp.h
+++ b/include/linux/gfp.h
@@ -15,7 +15,7 @@ struct vm_area_struct;
  * Zone modifiers (see linux/mmzone.h - low three bits)
  *
  * Do not put any conditional on these. If necessary modify the definitions
- * without the underscores and use the consistently. The definitions here may
+ * without the underscores and use them consistently. The definitions here may
  * be used in bit comparisons.
  */
 #define __GFP_DMA       ((__force gfp_t)0x01u)
@@ -101,7 +101,7 @@ struct vm_area_struct;
                         __GFP_NORETRY|__GFP_NOMEMALLOC)
 
 /* Control slab gfp mask during early boot */
-#define GFP_BOOT_MASK __GFP_BITS_MASK & ~(__GFP_WAIT|__GFP_IO|__GFP_FS)
+#define GFP_BOOT_MASK (__GFP_BITS_MASK & ~(__GFP_WAIT|__GFP_IO|__GFP_FS))
 
 /* Control allocation constraints */
 #define GFP_CONSTRAINT_MASK (__GFP_HARDWALL|__GFP_THISNODE)
@@ -152,12 +152,12 @@ static inline int allocflags_to_migratetype(gfp_t gfp_flags)
  * GFP_ZONE_TABLE is a word size bitstring that is used for looking up the
  * zone to use given the lowest 4 bits of gfp_t. Entries are ZONE_SHIFT long
  * and there are 16 of them to cover all possible combinations of
- * __GFP_DMA, __GFP_DMA32, __GFP_MOVABLE and __GFP_HIGHMEM
+ * __GFP_DMA, __GFP_DMA32, __GFP_MOVABLE and __GFP_HIGHMEM.
  *
  * The zone fallback order is MOVABLE=>HIGHMEM=>NORMAL=>DMA32=>DMA.
  * But GFP_MOVABLE is not only a zone specifier but also an allocation
  * policy. Therefore __GFP_MOVABLE plus another zone selector is valid.
- * Only 1bit of the lowest 3 bit (DMA,DMA32,HIGHMEM) can be set to "1".
+ * Only 1 bit of the lowest 3 bits (DMA,DMA32,HIGHMEM) can be set to "1".
  *
  *       bit       result
  *       =================
@@ -187,7 +187,7 @@ static inline int allocflags_to_migratetype(gfp_t gfp_flags)
 
 #define GFP_ZONE_TABLE ( \
         (ZONE_NORMAL << 0 * ZONES_SHIFT)                                \
-        | (OPT_ZONE_DMA << __GFP_DMA * ZONES_SHIFT)                     \
+        | (OPT_ZONE_DMA << __GFP_DMA * ZONES_SHIFT)                     \
         | (OPT_ZONE_HIGHMEM << __GFP_HIGHMEM * ZONES_SHIFT)             \
         | (OPT_ZONE_DMA32 << __GFP_DMA32 * ZONES_SHIFT)                 \
         | (ZONE_NORMAL << __GFP_MOVABLE * ZONES_SHIFT)                  \
@@ -197,7 +197,7 @@ static inline int allocflags_to_migratetype(gfp_t gfp_flags)
 )
 
 /*
- * GFP_ZONE_BAD is a bitmap for all combination of __GFP_DMA, __GFP_DMA32
+ * GFP_ZONE_BAD is a bitmap for all combinations of __GFP_DMA, __GFP_DMA32
  * __GFP_HIGHMEM and __GFP_MOVABLE that are not permitted. One flag per
  * entry starting with bit 0. Bit is set if the combination is not
  * allowed.
@@ -320,17 +320,17 @@ void *alloc_pages_exact(size_t size, gfp_t gfp_mask);
 void free_pages_exact(void *virt, size_t size);
 
 #define __get_free_page(gfp_mask) \
-                __get_free_pages((gfp_mask),0)
+                __get_free_pages((gfp_mask), 0)
 
 #define __get_dma_pages(gfp_mask, order) \
-                __get_free_pages((gfp_mask) | GFP_DMA,(order))
+                __get_free_pages((gfp_mask) | GFP_DMA, (order))
 
 extern void __free_pages(struct page *page, unsigned int order);
 extern void free_pages(unsigned long addr, unsigned int order);
 extern void free_hot_cold_page(struct page *page, int cold);
 
 #define __free_page(page) __free_pages((page), 0)
-#define free_page(addr) free_pages((addr),0)
+#define free_page(addr) free_pages((addr), 0)
 
 void page_alloc_init(void);
 void drain_zone_pages(struct zone *zone, struct per_cpu_pages *pcp);
diff --git a/include/linux/gpio.h b/include/linux/gpio.h
index 4e949a5b5b85..03f616b78cfa 100644
--- a/include/linux/gpio.h
+++ b/include/linux/gpio.h
@@ -51,6 +51,11 @@ static inline int gpio_direction_output(unsigned gpio, int value)
         return -ENOSYS;
 }
 
+static inline int gpio_set_debounce(unsigned gpio, unsigned debounce)
+{
+        return -ENOSYS;
+}
+
 static inline int gpio_get_value(unsigned gpio)
 {
         /* GPIO can never have been requested or set as {in,out}put */
diff --git a/include/linux/highmem.h b/include/linux/highmem.h
index 74152c08ad07..caafd0561aa1 100644
--- a/include/linux/highmem.h
+++ b/include/linux/highmem.h
@@ -27,7 +27,7 @@ static inline void invalidate_kernel_vmap_range(void *vaddr, int size)
 
 #include <asm/kmap_types.h>
 
-#if defined(CONFIG_DEBUG_HIGHMEM) && defined(CONFIG_TRACE_IRQFLAGS_SUPPORT)
+#ifdef CONFIG_DEBUG_HIGHMEM
 
 void debug_kmap_atomic(enum km_type type);
 
diff --git a/include/linux/i2c.h b/include/linux/i2c.h
index 6ed1d59bfb1e..21067b418536 100644
--- a/include/linux/i2c.h
+++ b/include/linux/i2c.h
@@ -34,6 +34,7 @@
 #include <linux/device.h>       /* for struct device */
 #include <linux/sched.h>        /* for completion */
 #include <linux/mutex.h>
+#include <linux/of.h>           /* for struct device_node */
 
 extern struct bus_type i2c_bus_type;
 
@@ -251,6 +252,9 @@ struct i2c_board_info {
         unsigned short  addr;
         void            *platform_data;
         struct dev_archdata     *archdata;
+#ifdef CONFIG_OF
+        struct device_node *of_node;
+#endif
         int             irq;
 };
 
diff --git a/include/linux/i2c/adp8860.h b/include/linux/i2c/adp8860.h
new file mode 100644
index 000000000000..0b4d39855c91
--- /dev/null
+++ b/include/linux/i2c/adp8860.h
@@ -0,0 +1,154 @@
+/*
+ * Definitions and platform data for Analog Devices
+ * Backlight drivers ADP8860
+ *
+ * Copyright 2009-2010 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2 or later.
+ */
+
+#ifndef __LINUX_I2C_ADP8860_H
+#define __LINUX_I2C_ADP8860_H
+
+#include <linux/leds.h>
+#include <linux/types.h>
+
+#define ID_ADP8860              8860
+
+#define ADP8860_MAX_BRIGHTNESS  0x7F
+#define FLAG_OFFT_SHIFT 8
+
+/*
+ * LEDs subdevice platform data
+ */
+
+#define ADP8860_LED_DIS_BLINK   (0 << FLAG_OFFT_SHIFT)
+#define ADP8860_LED_OFFT_600ms  (1 << FLAG_OFFT_SHIFT)
+#define ADP8860_LED_OFFT_1200ms (2 << FLAG_OFFT_SHIFT)
+#define ADP8860_LED_OFFT_1800ms (3 << FLAG_OFFT_SHIFT)
+
+#define ADP8860_LED_ONT_200ms   0
+#define ADP8860_LED_ONT_600ms   1
+#define ADP8860_LED_ONT_800ms   2
+#define ADP8860_LED_ONT_1200ms  3
+
+#define ADP8860_LED_D7          (7)
+#define ADP8860_LED_D6          (6)
+#define ADP8860_LED_D5          (5)
+#define ADP8860_LED_D4          (4)
+#define ADP8860_LED_D3          (3)
+#define ADP8860_LED_D2          (2)
+#define ADP8860_LED_D1          (1)
+
+/*
+ * Backlight subdevice platform data
+ */
+
+#define ADP8860_BL_D7           (1 << 6)
+#define ADP8860_BL_D6           (1 << 5)
+#define ADP8860_BL_D5           (1 << 4)
+#define ADP8860_BL_D4           (1 << 3)
+#define ADP8860_BL_D3           (1 << 2)
+#define ADP8860_BL_D2           (1 << 1)
+#define ADP8860_BL_D1           (1 << 0)
+
+#define ADP8860_FADE_T_DIS      0       /* Fade Timer Disabled */
+#define ADP8860_FADE_T_300ms    1       /* 0.3 Sec */
+#define ADP8860_FADE_T_600ms    2
+#define ADP8860_FADE_T_900ms    3
+#define ADP8860_FADE_T_1200ms   4
+#define ADP8860_FADE_T_1500ms   5
+#define ADP8860_FADE_T_1800ms   6
+#define ADP8860_FADE_T_2100ms   7
+#define ADP8860_FADE_T_2400ms   8
+#define ADP8860_FADE_T_2700ms   9
+#define ADP8860_FADE_T_3000ms   10
+#define ADP8860_FADE_T_3500ms   11
+#define ADP8860_FADE_T_4000ms   12
+#define ADP8860_FADE_T_4500ms   13
+#define ADP8860_FADE_T_5000ms   14
+#define ADP8860_FADE_T_5500ms   15      /* 5.5 Sec */
+
+#define ADP8860_FADE_LAW_LINEAR 0
+#define ADP8860_FADE_LAW_SQUARE 1
+#define ADP8860_FADE_LAW_CUBIC1 2
+#define ADP8860_FADE_LAW_CUBIC2 3
+
+#define ADP8860_BL_AMBL_FILT_80ms       0       /* Light sensor filter time */
+#define ADP8860_BL_AMBL_FILT_160ms      1
+#define ADP8860_BL_AMBL_FILT_320ms      2
+#define ADP8860_BL_AMBL_FILT_640ms      3
+#define ADP8860_BL_AMBL_FILT_1280ms     4
+#define ADP8860_BL_AMBL_FILT_2560ms     5
+#define ADP8860_BL_AMBL_FILT_5120ms     6
+#define ADP8860_BL_AMBL_FILT_10240ms    7       /* 10.24 sec */
+
+/*
+ * Blacklight current 0..30mA
+ */
+#define ADP8860_BL_CUR_mA(I)            ((I * 127) / 30)
+
+/*
+ * L2 comparator current 0..1106uA
+ */
+#define ADP8860_L2_COMP_CURR_uA(I)      ((I * 255) / 1106)
+
+/*
+ * L3 comparator current 0..138uA
+ */
+#define ADP8860_L3_COMP_CURR_uA(I)      ((I * 255) / 138)
+
+struct adp8860_backlight_platform_data {
+        u8 bl_led_assign;       /* 1 = Backlight 0 = Individual LED */
+
+        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_office_max;       /* use BL_CUR_mA(I) 0 <= I <= 30 mA */
+        u8 l2_office_dim;       /* typ = 0, use BL_CUR_mA(I) 0 <= I <= 30 mA */
+        u8 l3_dark_max;         /* use BL_CUR_mA(I) 0 <= I <= 30 mA */
+        u8 l3_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 */
+
+        /**
+         * 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;
+
+        /**
+         * Gain down disable. Setting this option does not allow the
+         * charge pump to switch to lower gains. NOT AVAILABLE on ADP8860
+         * 1 = the charge pump doesn't switch down in gain until all LEDs are 0.
+         *  The charge pump switches up in gain as needed. This feature is
+         *  useful if the ADP8863 charge pump is used to drive an external load.
+         *  This feature must be used when utilizing small fly capacitors
+         *  (0402 or smaller).
+         * 0 = the charge pump automatically switches up and down in gain.
+         *  This provides optimal efficiency, but is not suitable for driving
+         *  loads that are not connected through the ADP8863 diode drivers.
+         *  Additionally, the charge pump fly capacitors should be low ESR
+         * and sized 0603 or greater.
+         */
+
+        u8 gdwn_dis;
+};
+
+#endif /* __LINUX_I2C_ADP8860_H */
diff --git a/include/linux/i2c/max732x.h b/include/linux/i2c/max732x.h
index e10336631c62..c04bac8bf2fe 100644
--- a/include/linux/i2c/max732x.h
+++ b/include/linux/i2c/max732x.h
@@ -7,6 +7,9 @@ struct max732x_platform_data {
         /* number of the first GPIO */
         unsigned        gpio_base;
 
+        /* interrupt base */
+        int             irq_base;
+
         void            *context;       /* param to setup/teardown */
 
         int             (*setup)(struct i2c_client *client,
diff --git a/include/linux/i2c/pca953x.h b/include/linux/i2c/pca953x.h
index d5c5a60c8a0b..139ba52667c8 100644
--- a/include/linux/i2c/pca953x.h
+++ b/include/linux/i2c/pca953x.h
@@ -24,7 +24,7 @@ struct pca953x_platform_data {
         int             (*teardown)(struct i2c_client *client,
                                 unsigned gpio, unsigned ngpio,
                                 void *context);
-        char            **names;
+        const char      *const *names;
 };
 
 #endif /* _LINUX_PCA953X_H */
diff --git a/include/linux/ide.h b/include/linux/ide.h
index b6d448048ae2..7b02aa5ce9b4 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -516,8 +516,8 @@ struct ide_drive_s {
         u8      current_speed;  /* current transfer rate set */
         u8      desired_speed;  /* desired transfer rate set */
         u8      pio_mode;       /* for ->set_pio_mode _only_ */
-        u8      dma_mode;       /* for ->dma_pio_mode _only_ */
-        u8      dn;             /* now wide spread use */
+        u8      dma_mode;       /* for ->set_dma_mode _only_ */
+        u8      dn;             /* now wide spread use */
         u8      acoustic;       /* acoustic management */
         u8      media;          /* disk, cdrom, tape, floppy, ... */
         u8      ready_stat;     /* min status value for drive ready */
diff --git a/include/linux/init_task.h b/include/linux/init_task.h
index 7996fc2c9ba9..2beaa13492be 100644
--- a/include/linux/init_task.h
+++ b/include/linux/init_task.h
@@ -16,7 +16,7 @@ extern struct files_struct init_files;
 extern struct fs_struct init_fs;
 
 #define INIT_SIGNALS(sig) {                                             \
-        .count          = ATOMIC_INIT(1),                               \
+        .nr_threads     = 1,                                            \
         .wait_chldexit  = __WAIT_QUEUE_HEAD_INITIALIZER(sig.wait_chldexit),\
         .shared_pending = {                                             \
                 .list = LIST_HEAD_INIT(sig.shared_pending.list),        \
@@ -35,7 +35,7 @@ extern struct nsproxy init_nsproxy;
 
 #define INIT_SIGHAND(sighand) {                                         \
         .count          = ATOMIC_INIT(1),                               \
-        .action         = { { { .sa_handler = NULL, } }, },             \
+        .action         = { { { .sa_handler = SIG_DFL, } }, },          \
         .siglock        = __SPIN_LOCK_UNLOCKED(sighand.siglock),        \
         .signalfd_wqh   = __WAIT_QUEUE_HEAD_INITIALIZER(sighand.signalfd_wqh),  \
 }
@@ -45,9 +45,9 @@ extern struct group_info init_groups;
 #define INIT_STRUCT_PID {                                               \
         .count          = ATOMIC_INIT(1),                               \
         .tasks          = {                                             \
-                { .first = &init_task.pids[PIDTYPE_PID].node },         \
-                { .first = &init_task.pids[PIDTYPE_PGID].node },        \
-                { .first = &init_task.pids[PIDTYPE_SID].node },         \
+                { .first = NULL },                                      \
+                { .first = NULL },                                      \
+                { .first = NULL },                                      \
         },                                                              \
         .level          = 0,                                            \
         .numbers        = { {                                           \
@@ -61,7 +61,7 @@ extern struct group_info init_groups;
 {                                                               \
         .node = {                                               \
                 .next = NULL,                                   \
-                .pprev = &init_struct_pid.tasks[type].first,    \
+                .pprev = NULL,                                  \
         },                                                      \
         .pid = &init_struct_pid,                                \
 }
@@ -163,6 +163,7 @@ extern struct cred init_cred;
                 [PIDTYPE_PGID] = INIT_PID_LINK(PIDTYPE_PGID),           \
                 [PIDTYPE_SID]  = INIT_PID_LINK(PIDTYPE_SID),            \
         },                                                              \
+        .thread_group   = LIST_HEAD_INIT(tsk.thread_group),             \
         .dirties = INIT_PROP_LOCAL_SINGLE(dirties),                     \
         INIT_IDS                                                        \
         INIT_PERF_EVENTS(tsk)                                           \
diff --git a/include/linux/input.h b/include/linux/input.h
index 83524e4f3290..6fcc9101beeb 100644
--- a/include/linux/input.h
+++ b/include/linux/input.h
@@ -1155,7 +1155,7 @@ struct input_dev {
 
         int sync;
 
-        int abs[ABS_MAX + 1];
+        int abs[ABS_CNT];
         int rep[REP_MAX + 1];
 
         unsigned long key[BITS_TO_LONGS(KEY_CNT)];
@@ -1163,11 +1163,11 @@ struct input_dev {
         unsigned long snd[BITS_TO_LONGS(SND_CNT)];
         unsigned long sw[BITS_TO_LONGS(SW_CNT)];
 
-        int absmax[ABS_MAX + 1];
-        int absmin[ABS_MAX + 1];
-        int absfuzz[ABS_MAX + 1];
-        int absflat[ABS_MAX + 1];
-        int absres[ABS_MAX + 1];
+        int absmax[ABS_CNT];
+        int absmin[ABS_CNT];
+        int absfuzz[ABS_CNT];
+        int absflat[ABS_CNT];
+        int absres[ABS_CNT];
 
         int (*open)(struct input_dev *dev);
         void (*close)(struct input_dev *dev);
diff --git a/include/linux/input/tps6507x-ts.h b/include/linux/input/tps6507x-ts.h
new file mode 100644
index 000000000000..ab1440313924
--- /dev/null
+++ b/include/linux/input/tps6507x-ts.h
@@ -0,0 +1,24 @@
+/* linux/i2c/tps6507x-ts.h
+ *
+ * Functions to access TPS65070 touch screen chip.
+ *
+ * Copyright (c) 2009 RidgeRun (todd.fischer@ridgerun.com)
+ *
+ *
+ *  For licencing details see kernel-base/COPYING
+ */
+
+#ifndef __LINUX_I2C_TPS6507X_TS_H
+#define __LINUX_I2C_TPS6507X_TS_H
+
+/* Board specific touch screen initial values */
+struct touchscreen_init_data {
+        int     poll_period;    /* ms */
+        int     vref;           /* non-zero to leave vref on */
+        __u16   min_pressure;   /* min reading to be treated as a touch */
+        __u16   vendor;
+        __u16   product;
+        __u16   version;
+};
+
+#endif /*  __LINUX_I2C_TPS6507X_TS_H */
diff --git a/include/linux/ivtvfb.h b/include/linux/ivtvfb.h
index 9d88b29ddf55..e8b92f67f10d 100644
--- a/include/linux/ivtvfb.h
+++ b/include/linux/ivtvfb.h
@@ -33,6 +33,5 @@ struct ivtvfb_dma_frame {
 };
 
 #define IVTVFB_IOC_DMA_FRAME    _IOW('V', BASE_VIDIOC_PRIVATE+0, struct ivtvfb_dma_frame)
-#define FBIO_WAITFORVSYNC       _IOW('F', 0x20, __u32)
 
 #endif
diff --git a/include/linux/joystick.h b/include/linux/joystick.h
index 9e20c29c1e14..47199b13e0eb 100644
--- a/include/linux/joystick.h
+++ b/include/linux/joystick.h
@@ -64,8 +64,8 @@ struct js_event {
 #define JSIOCSCORR              _IOW('j', 0x21, struct js_corr)                 /* set correction values */
 #define JSIOCGCORR              _IOR('j', 0x22, struct js_corr)                 /* get correction values */
 
-#define JSIOCSAXMAP             _IOW('j', 0x31, __u8[ABS_MAX + 1])              /* set axis mapping */
-#define JSIOCGAXMAP             _IOR('j', 0x32, __u8[ABS_MAX + 1])              /* get axis mapping */
+#define JSIOCSAXMAP             _IOW('j', 0x31, __u8[ABS_CNT])                  /* set axis mapping */
+#define JSIOCGAXMAP             _IOR('j', 0x32, __u8[ABS_CNT])                  /* get axis mapping */
 #define JSIOCSBTNMAP            _IOW('j', 0x33, __u16[KEY_MAX - BTN_MISC + 1])  /* set button mapping */
 #define JSIOCGBTNMAP            _IOR('j', 0x34, __u16[KEY_MAX - BTN_MISC + 1])  /* get button mapping */
 
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index cc5e3ffe9fce..8317ec4b9f3b 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -24,9 +24,9 @@
 extern const char linux_banner[];
 extern const char linux_proc_banner[];
 
-#define USHORT_MAX      ((u16)(~0U))
-#define SHORT_MAX       ((s16)(USHORT_MAX>>1))
-#define SHORT_MIN       (-SHORT_MAX - 1)
+#define USHRT_MAX       ((u16)(~0U))
+#define SHRT_MAX        ((s16)(USHRT_MAX>>1))
+#define SHRT_MIN        ((s16)(-SHRT_MAX - 1))
 #define INT_MAX         ((int)(~0U>>1))
 #define INT_MIN         (-INT_MAX - 1)
 #define UINT_MAX        (~0U)
@@ -375,6 +375,8 @@ static inline char *pack_hex_byte(char *buf, u8 byte)
         return buf;
 }
 
+extern int hex_to_bin(char ch);
+
 #ifndef pr_fmt
 #define pr_fmt(fmt) fmt
 #endif
@@ -389,6 +391,7 @@ static inline char *pack_hex_byte(char *buf, u8 byte)
         printk(KERN_ERR pr_fmt(fmt), ##__VA_ARGS__)
 #define pr_warning(fmt, ...) \
         printk(KERN_WARNING pr_fmt(fmt), ##__VA_ARGS__)
+#define pr_warn pr_warning
 #define pr_notice(fmt, ...) \
         printk(KERN_NOTICE pr_fmt(fmt), ##__VA_ARGS__)
 #define pr_info(fmt, ...) \
@@ -423,14 +426,13 @@ static inline char *pack_hex_byte(char *buf, u8 byte)
  * no local ratelimit_state used in the !PRINTK case
  */
 #ifdef CONFIG_PRINTK
-#define printk_ratelimited(fmt, ...)  ({                \
-        static struct ratelimit_state _rs = {           \
-                .interval = DEFAULT_RATELIMIT_INTERVAL, \
-                .burst = DEFAULT_RATELIMIT_BURST,       \
-        };                                              \
-                                                        \
-        if (__ratelimit(&_rs))                          \
-                printk(fmt, ##__VA_ARGS__);             \
+#define printk_ratelimited(fmt, ...)  ({                                \
+        static DEFINE_RATELIMIT_STATE(_rs,                              \
+                                      DEFAULT_RATELIMIT_INTERVAL,       \
+                                      DEFAULT_RATELIMIT_BURST);         \
+                                                                        \
+        if (__ratelimit(&_rs))                                          \
+                printk(fmt, ##__VA_ARGS__);                             \
 })
 #else
 /* No effect, but we still get type checking even in the !PRINTK case: */
@@ -447,6 +449,7 @@ static inline char *pack_hex_byte(char *buf, u8 byte)
         printk_ratelimited(KERN_ERR pr_fmt(fmt), ##__VA_ARGS__)
 #define pr_warning_ratelimited(fmt, ...) \
         printk_ratelimited(KERN_WARNING pr_fmt(fmt), ##__VA_ARGS__)
+#define pr_warn_ratelimited pr_warning_ratelimited
 #define pr_notice_ratelimited(fmt, ...) \
         printk_ratelimited(KERN_NOTICE pr_fmt(fmt), ##__VA_ARGS__)
 #define pr_info_ratelimited(fmt, ...) \
diff --git a/include/linux/kmod.h b/include/linux/kmod.h
index facb27fe7de0..6efd7a78de6a 100644
--- a/include/linux/kmod.h
+++ b/include/linux/kmod.h
@@ -23,6 +23,7 @@
 #include <linux/stddef.h>
 #include <linux/errno.h>
 #include <linux/compiler.h>
+#include <linux/workqueue.h>
 
 #define KMOD_PATH_LEN 256
 
@@ -45,19 +46,6 @@ static inline int request_module_nowait(const char *name, ...) { return -ENOSYS;
 
 struct key;
 struct file;
-struct subprocess_info;
-
-/* Allocate a subprocess_info structure */
-struct subprocess_info *call_usermodehelper_setup(char *path, char **argv,
-                                                  char **envp, gfp_t gfp_mask);
-
-/* Set various pieces of state into the subprocess_info structure */
-void call_usermodehelper_setkeys(struct subprocess_info *info,
-                                 struct key *session_keyring);
-int call_usermodehelper_stdinpipe(struct subprocess_info *sub_info,
-                                  struct file **filp);
-void call_usermodehelper_setcleanup(struct subprocess_info *info,
-                                    void (*cleanup)(char **argv, char **envp));
 
 enum umh_wait {
         UMH_NO_WAIT = -1,       /* don't wait at all */
@@ -65,6 +53,29 @@ enum umh_wait {
         UMH_WAIT_PROC = 1,      /* wait for the process to complete */
 };
 
+struct subprocess_info {
+        struct work_struct work;
+        struct completion *complete;
+        char *path;
+        char **argv;
+        char **envp;
+        enum umh_wait wait;
+        int retval;
+        int (*init)(struct subprocess_info *info);
+        void (*cleanup)(struct subprocess_info *info);
+        void *data;
+};
+
+/* Allocate a subprocess_info structure */
+struct subprocess_info *call_usermodehelper_setup(char *path, char **argv,
+                                                  char **envp, gfp_t gfp_mask);
+
+/* Set various pieces of state into the subprocess_info structure */
+void call_usermodehelper_setfns(struct subprocess_info *info,
+                    int (*init)(struct subprocess_info *info),
+                    void (*cleanup)(struct subprocess_info *info),
+                    void *data);
+
 /* Actually execute the sub-process */
 int call_usermodehelper_exec(struct subprocess_info *info, enum umh_wait wait);
 
@@ -73,38 +84,33 @@ int call_usermodehelper_exec(struct subprocess_info *info, enum umh_wait wait);
 void call_usermodehelper_freeinfo(struct subprocess_info *info);
 
 static inline int
-call_usermodehelper(char *path, char **argv, char **envp, enum umh_wait wait)
+call_usermodehelper_fns(char *path, char **argv, char **envp,
+                        enum umh_wait wait,
+                        int (*init)(struct subprocess_info *info),
+                        void (*cleanup)(struct subprocess_info *), void *data)
 {
         struct subprocess_info *info;
         gfp_t gfp_mask = (wait == UMH_NO_WAIT) ? GFP_ATOMIC : GFP_KERNEL;
 
         info = call_usermodehelper_setup(path, argv, envp, gfp_mask);
+
         if (info == NULL)
                 return -ENOMEM;
+
+        call_usermodehelper_setfns(info, init, cleanup, data);
+
         return call_usermodehelper_exec(info, wait);
 }
 
 static inline int
-call_usermodehelper_keys(char *path, char **argv, char **envp,
-                         struct key *session_keyring, enum umh_wait wait)
+call_usermodehelper(char *path, char **argv, char **envp, enum umh_wait wait)
 {
-        struct subprocess_info *info;
-        gfp_t gfp_mask = (wait == UMH_NO_WAIT) ? GFP_ATOMIC : GFP_KERNEL;
-
-        info = call_usermodehelper_setup(path, argv, envp, gfp_mask);
-        if (info == NULL)
-                return -ENOMEM;
-
-        call_usermodehelper_setkeys(info, session_keyring);
-        return call_usermodehelper_exec(info, wait);
+        return call_usermodehelper_fns(path, argv, envp, wait,
+                                       NULL, NULL, NULL);
 }
 
 extern void usermodehelper_init(void);
 
-struct file;
-extern int call_usermodehelper_pipe(char *path, char *argv[], char *envp[],
-                                    struct file **filp);
-
 extern int usermodehelper_disable(void);
 extern void usermodehelper_enable(void);
 
diff --git a/include/linux/lcd.h b/include/linux/lcd.h
index c67fecafff90..8877123f2d6e 100644
--- a/include/linux/lcd.h
+++ b/include/linux/lcd.h
@@ -69,6 +69,29 @@ struct lcd_device {
         struct device dev;
 };
 
+struct lcd_platform_data {
+        /* reset lcd panel device. */
+        int (*reset)(struct lcd_device *ld);
+        /* on or off to lcd panel. if 'enable' is 0 then
+           lcd power off and 1, lcd power on. */
+        int (*power_on)(struct lcd_device *ld, int enable);
+
+        /* it indicates whether lcd panel was enabled
+           from bootloader or not. */
+        int lcd_enabled;
+        /* it means delay for stable time when it becomes low to high
+           or high to low that is dependent on whether reset gpio is
+           low active or high active. */
+        unsigned int reset_delay;
+        /* stable time needing to become lcd power on. */
+        unsigned int power_on_delay;
+        /* stable time needing to become lcd power off. */
+        unsigned int power_off_delay;
+
+        /* it could be used for any purpose. */
+        void *pdata;
+};
+
 static inline void lcd_set_power(struct lcd_device *ld, int power)
 {
         mutex_lock(&ld->update_lock);
diff --git a/include/linux/leds.h b/include/linux/leds.h
index d8bf9665e70c..ba6986a11663 100644
--- a/include/linux/leds.h
+++ b/include/linux/leds.h
@@ -149,14 +149,18 @@ struct gpio_led {
         unsigned        default_state : 2;
         /* default_state should be one of LEDS_GPIO_DEFSTATE_(ON|OFF|KEEP) */
 };
-#define LEDS_GPIO_DEFSTATE_OFF  0
-#define LEDS_GPIO_DEFSTATE_ON   1
-#define LEDS_GPIO_DEFSTATE_KEEP 2
+#define LEDS_GPIO_DEFSTATE_OFF          0
+#define LEDS_GPIO_DEFSTATE_ON           1
+#define LEDS_GPIO_DEFSTATE_KEEP         2
 
 struct gpio_led_platform_data {
         int             num_leds;
         struct gpio_led *leds;
-        int             (*gpio_blink_set)(unsigned gpio,
+
+#define GPIO_LED_NO_BLINK_LOW   0       /* No blink GPIO state low */
+#define GPIO_LED_NO_BLINK_HIGH  1       /* No blink GPIO state high */
+#define GPIO_LED_BLINK          2       /* Plase, blink */
+        int             (*gpio_blink_set)(unsigned gpio, int state,
                                         unsigned long *delay_on,
                                         unsigned long *delay_off);
 };
diff --git a/include/linux/libata.h b/include/linux/libata.h
index ee84e7e12039..3bad2701bfa6 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -386,6 +386,7 @@ enum {
         ATA_HORKAGE_1_5_GBPS    = (1 << 13),    /* force 1.5 Gbps */
         ATA_HORKAGE_NOSETXFER   = (1 << 14),    /* skip SETXFER, SATA only */
         ATA_HORKAGE_BROKEN_FPDMA_AA     = (1 << 15),    /* skip AA */
+        ATA_HORKAGE_DUMP_ID     = (1 << 16),    /* dump IDENTIFY data */
 
          /* DMA mask for user DMA control: User visible values; DO NOT
             renumber */
@@ -513,7 +514,9 @@ struct ata_ioports {
         void __iomem            *command_addr;
         void __iomem            *altstatus_addr;
         void __iomem            *ctl_addr;
+#ifdef CONFIG_ATA_BMDMA
         void __iomem            *bmdma_addr;
+#endif /* CONFIG_ATA_BMDMA */
         void __iomem            *scr_addr;
 };
 #endif /* CONFIG_ATA_SFF */
@@ -721,8 +724,10 @@ struct ata_port {
         u8                      ctl;    /* cache of ATA control register */
         u8                      last_ctl;       /* Cache last written value */
         struct delayed_work     sff_pio_task;
+#ifdef CONFIG_ATA_BMDMA
         struct ata_bmdma_prd    *bmdma_prd;     /* BMDMA SG list */
         dma_addr_t              bmdma_prd_dma;  /* and its DMA mapping */
+#endif /* CONFIG_ATA_BMDMA */
 #endif /* CONFIG_ATA_SFF */
 
         unsigned int            pio_mask;
@@ -856,10 +861,12 @@ struct ata_port_operations {
         void (*sff_irq_clear)(struct ata_port *);
         void (*sff_drain_fifo)(struct ata_queued_cmd *qc);
 
+#ifdef CONFIG_ATA_BMDMA
         void (*bmdma_setup)(struct ata_queued_cmd *qc);
         void (*bmdma_start)(struct ata_queued_cmd *qc);
         void (*bmdma_stop)(struct ata_queued_cmd *qc);
         u8   (*bmdma_status)(struct ata_port *ap);
+#endif /* CONFIG_ATA_BMDMA */
 #endif /* CONFIG_ATA_SFF */
 
         ssize_t (*em_show)(struct ata_port *ap, char *buf);
@@ -1555,7 +1562,6 @@ extern void sata_pmp_error_handler(struct ata_port *ap);
 #ifdef CONFIG_ATA_SFF
 
 extern const struct ata_port_operations ata_sff_port_ops;
-extern const struct ata_port_operations ata_bmdma_port_ops;
 extern const struct ata_port_operations ata_bmdma32_port_ops;
 
 /* PIO only, sg_tablesize and dma_boundary limits can be removed */
@@ -1564,11 +1570,6 @@ extern const struct ata_port_operations ata_bmdma32_port_ops;
         .sg_tablesize           = LIBATA_MAX_PRD,               \
         .dma_boundary           = ATA_DMA_BOUNDARY
 
-#define ATA_BMDMA_SHT(drv_name)                                 \
-        ATA_BASE_SHT(drv_name),                                 \
-        .sg_tablesize           = LIBATA_MAX_PRD,               \
-        .dma_boundary           = ATA_DMA_BOUNDARY
-
 extern void ata_sff_dev_select(struct ata_port *ap, unsigned int device);
 extern u8 ata_sff_check_status(struct ata_port *ap);
 extern void ata_sff_pause(struct ata_port *ap);
@@ -1593,7 +1594,7 @@ extern int ata_sff_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc,
 extern void ata_sff_queue_pio_task(struct ata_port *ap, unsigned long delay);
 extern unsigned int ata_sff_qc_issue(struct ata_queued_cmd *qc);
 extern bool ata_sff_qc_fill_rtf(struct ata_queued_cmd *qc);
-extern unsigned int ata_sff_host_intr(struct ata_port *ap,
+extern unsigned int ata_sff_port_intr(struct ata_port *ap,
                                       struct ata_queued_cmd *qc);
 extern irqreturn_t ata_sff_interrupt(int irq, void *dev_instance);
 extern void ata_sff_lost_interrupt(struct ata_port *ap);
@@ -1625,11 +1626,24 @@ extern int ata_pci_sff_init_one(struct pci_dev *pdev,
                 struct scsi_host_template *sht, void *host_priv, int hflags);
 #endif /* CONFIG_PCI */
 
+#ifdef CONFIG_ATA_BMDMA
+
+extern const struct ata_port_operations ata_bmdma_port_ops;
+
+#define ATA_BMDMA_SHT(drv_name)                                 \
+        ATA_BASE_SHT(drv_name),                                 \
+        .sg_tablesize           = LIBATA_MAX_PRD,               \
+        .dma_boundary           = ATA_DMA_BOUNDARY
+
 extern void ata_bmdma_qc_prep(struct ata_queued_cmd *qc);
 extern unsigned int ata_bmdma_qc_issue(struct ata_queued_cmd *qc);
 extern void ata_bmdma_dumb_qc_prep(struct ata_queued_cmd *qc);
+extern unsigned int ata_bmdma_port_intr(struct ata_port *ap,
+                                      struct ata_queued_cmd *qc);
+extern irqreturn_t ata_bmdma_interrupt(int irq, void *dev_instance);
 extern void ata_bmdma_error_handler(struct ata_port *ap);
 extern void ata_bmdma_post_internal_cmd(struct ata_queued_cmd *qc);
+extern void ata_bmdma_irq_clear(struct ata_port *ap);
 extern void ata_bmdma_setup(struct ata_queued_cmd *qc);
 extern void ata_bmdma_start(struct ata_queued_cmd *qc);
 extern void ata_bmdma_stop(struct ata_queued_cmd *qc);
@@ -1640,7 +1654,15 @@ extern int ata_bmdma_port_start32(struct ata_port *ap);
 #ifdef CONFIG_PCI
 extern int ata_pci_bmdma_clear_simplex(struct pci_dev *pdev);
 extern void ata_pci_bmdma_init(struct ata_host *host);
+extern int ata_pci_bmdma_prepare_host(struct pci_dev *pdev,
+                                      const struct ata_port_info * const * ppi,
+                                      struct ata_host **r_host);
+extern int ata_pci_bmdma_init_one(struct pci_dev *pdev,
+                                  const struct ata_port_info * const * ppi,
+                                  struct scsi_host_template *sht,
+                                  void *host_priv, int hflags);
 #endif /* CONFIG_PCI */
+#endif /* CONFIG_ATA_BMDMA */
 
 /**
  *      ata_sff_busy_wait - Wait for a port status register
diff --git a/include/linux/lis3lv02d.h b/include/linux/lis3lv02d.h
index f1ca0dcc1628..0e8a346424bb 100644
--- a/include/linux/lis3lv02d.h
+++ b/include/linux/lis3lv02d.h
@@ -25,12 +25,14 @@ struct lis3lv02d_platform_data {
 #define LIS3_IRQ1_FF_WU_12      (3 << 0)
 #define LIS3_IRQ1_DATA_READY    (4 << 0)
 #define LIS3_IRQ1_CLICK         (7 << 0)
+#define LIS3_IRQ1_MASK          (7 << 0)
 #define LIS3_IRQ2_DISABLE       (0 << 3)
 #define LIS3_IRQ2_FF_WU_1       (1 << 3)
 #define LIS3_IRQ2_FF_WU_2       (2 << 3)
 #define LIS3_IRQ2_FF_WU_12      (3 << 3)
 #define LIS3_IRQ2_DATA_READY    (4 << 3)
 #define LIS3_IRQ2_CLICK         (7 << 3)
+#define LIS3_IRQ2_MASK          (7 << 3)
 #define LIS3_IRQ_OPEN_DRAIN     (1 << 6)
 #define LIS3_IRQ_ACTIVE_LOW     (1 << 7)
         unsigned char irq_cfg;
@@ -43,6 +45,15 @@ struct lis3lv02d_platform_data {
 #define LIS3_WAKEUP_Z_HI        (1 << 5)
         unsigned char wakeup_flags;
         unsigned char wakeup_thresh;
+        unsigned char wakeup_flags2;
+        unsigned char wakeup_thresh2;
+#define LIS3_HIPASS_CUTFF_8HZ   0
+#define LIS3_HIPASS_CUTFF_4HZ   1
+#define LIS3_HIPASS_CUTFF_2HZ   2
+#define LIS3_HIPASS_CUTFF_1HZ   3
+#define LIS3_HIPASS1_DISABLE    (1 << 2)
+#define LIS3_HIPASS2_DISABLE    (1 << 3)
+        unsigned char hipass_ctrl;
 #define LIS3_NO_MAP             0
 #define LIS3_DEV_X              1
 #define LIS3_DEV_Y              2
@@ -58,6 +69,7 @@ struct lis3lv02d_platform_data {
         /* Limits for selftest are specified in chip data sheet */
         s16 st_min_limits[3]; /* min pass limit x, y, z */
         s16 st_max_limits[3]; /* max pass limit x, y, z */
+        int irq2;
 };
 
 #endif /* __LIS3LV02D_H_ */
diff --git a/include/linux/matroxfb.h b/include/linux/matroxfb.h
index 2203121a43e9..8c22a8938642 100644
--- a/include/linux/matroxfb.h
+++ b/include/linux/matroxfb.h
@@ -4,6 +4,7 @@
 #include <asm/ioctl.h>
 #include <linux/types.h>
 #include <linux/videodev2.h>
+#include <linux/fb.h>
 
 struct matroxioc_output_mode {
         __u32   output;         /* which output */
@@ -37,7 +38,5 @@ enum matroxfb_ctrl_id {
   MATROXFB_CID_LAST
 };
 
-#define FBIO_WAITFORVSYNC       _IOW('F', 0x20, __u32)
-
 #endif
 
diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h
index 44301c6affa8..9411d32840b0 100644
--- a/include/linux/memcontrol.h
+++ b/include/linux/memcontrol.h
@@ -25,6 +25,13 @@ struct page_cgroup;
 struct page;
 struct mm_struct;
 
+extern unsigned long mem_cgroup_isolate_pages(unsigned long nr_to_scan,
+                                        struct list_head *dst,
+                                        unsigned long *scanned, int order,
+                                        int mode, struct zone *z,
+                                        struct mem_cgroup *mem_cont,
+                                        int active, int file);
+
 #ifdef CONFIG_CGROUP_MEM_RES_CTLR
 /*
  * All "charge" functions with gfp_mask should use GFP_KERNEL or
@@ -64,12 +71,6 @@ 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 unsigned long mem_cgroup_isolate_pages(unsigned long nr_to_scan,
-                                        struct list_head *dst,
-                                        unsigned long *scanned, int order,
-                                        int mode, struct zone *z,
-                                        struct mem_cgroup *mem_cont,
-                                        int active, int file);
 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);
 
@@ -89,7 +90,8 @@ int mm_match_cgroup(const struct mm_struct *mm, const struct mem_cgroup *cgroup)
 extern struct cgroup_subsys_state *mem_cgroup_css(struct mem_cgroup *mem);
 
 extern int
-mem_cgroup_prepare_migration(struct page *page, struct mem_cgroup **ptr);
+mem_cgroup_prepare_migration(struct page *page,
+        struct page *newpage, struct mem_cgroup **ptr);
 extern void mem_cgroup_end_migration(struct mem_cgroup *mem,
         struct page *oldpage, struct page *newpage);
 
@@ -226,7 +228,8 @@ static inline struct cgroup_subsys_state *mem_cgroup_css(struct mem_cgroup *mem)
 }
 
 static inline int
-mem_cgroup_prepare_migration(struct page *page, struct mem_cgroup **ptr)
+mem_cgroup_prepare_migration(struct page *page, struct page *newpage,
+        struct mem_cgroup **ptr)
 {
         return 0;
 }
diff --git a/include/linux/memory_hotplug.h b/include/linux/memory_hotplug.h
index 35b07b773e6c..864035fb8f8a 100644
--- a/include/linux/memory_hotplug.h
+++ b/include/linux/memory_hotplug.h
@@ -202,6 +202,7 @@ static inline int is_mem_section_removable(unsigned long pfn,
 }
 #endif /* CONFIG_MEMORY_HOTREMOVE */
 
+extern int mem_online_node(int nid);
 extern int add_memory(int nid, u64 start, u64 size);
 extern int arch_add_memory(int nid, u64 start, u64 size);
 extern int remove_memory(u64 start, u64 size);
diff --git a/include/linux/mempolicy.h b/include/linux/mempolicy.h
index 1cc966cd3e5f..7b9ef6bf45aa 100644
--- a/include/linux/mempolicy.h
+++ b/include/linux/mempolicy.h
@@ -23,6 +23,13 @@ enum {
         MPOL_MAX,       /* always last member of enum */
 };
 
+enum mpol_rebind_step {
+        MPOL_REBIND_ONCE,       /* do rebind work at once(not by two step) */
+        MPOL_REBIND_STEP1,      /* first step(set all the newly nodes) */
+        MPOL_REBIND_STEP2,      /* second step(clean all the disallowed nodes)*/
+        MPOL_REBIND_NSTEP,
+};
+
 /* Flags for set_mempolicy */
 #define MPOL_F_STATIC_NODES     (1 << 15)
 #define MPOL_F_RELATIVE_NODES   (1 << 14)
@@ -51,6 +58,7 @@ enum {
  */
 #define MPOL_F_SHARED  (1 << 0) /* identify shared policies */
 #define MPOL_F_LOCAL   (1 << 1) /* preferred local allocation */
+#define MPOL_F_REBINDING (1 << 2)       /* identify policies in rebinding */
 
 #ifdef __KERNEL__
 
@@ -193,8 +201,8 @@ struct mempolicy *mpol_shared_policy_lookup(struct shared_policy *sp,
 
 extern void numa_default_policy(void);
 extern void numa_policy_init(void);
-extern void mpol_rebind_task(struct task_struct *tsk,
-                                        const nodemask_t *new);
+extern void mpol_rebind_task(struct task_struct *tsk, const nodemask_t *new,
+                                enum mpol_rebind_step step);
 extern void mpol_rebind_mm(struct mm_struct *mm, nodemask_t *new);
 extern void mpol_fix_fork_child_flag(struct task_struct *p);
 
@@ -308,7 +316,8 @@ static inline void numa_default_policy(void)
 }
 
 static inline void mpol_rebind_task(struct task_struct *tsk,
-                                        const nodemask_t *new)
+                                const nodemask_t *new,
+                                enum mpol_rebind_step step)
 {
 }
 
diff --git a/include/linux/mfd/88pm860x.h b/include/linux/mfd/88pm860x.h
index 73f92c5feea2..bfd23bef7363 100644
--- a/include/linux/mfd/88pm860x.h
+++ b/include/linux/mfd/88pm860x.h
@@ -132,6 +132,7 @@ enum {
         PM8607_ID_LDO9,
         PM8607_ID_LDO10,
         PM8607_ID_LDO12,
+        PM8607_ID_LDO13,
         PM8607_ID_LDO14,
 
         PM8607_ID_RG_MAX,
@@ -309,7 +310,7 @@ struct pm860x_chip {
 
 };
 
-#define PM8607_MAX_REGULATOR    15      /* 3 Bucks, 12 LDOs */
+#define PM8607_MAX_REGULATOR    PM8607_ID_RG_MAX        /* 3 Bucks, 13 LDOs */
 
 enum {
         GI2C_PORT = 0,
@@ -369,7 +370,7 @@ extern int pm860x_set_bits(struct i2c_client *, int, unsigned char,
                            unsigned char);
 
 extern int pm860x_device_init(struct pm860x_chip *chip,
-                              struct pm860x_platform_data *pdata);
-extern void pm860x_device_exit(struct pm860x_chip *chip);
+                              struct pm860x_platform_data *pdata) __devinit ;
+extern void pm860x_device_exit(struct pm860x_chip *chip) __devexit ;
 
 #endif /* __LINUX_MFD_88PM860X_H */
diff --git a/include/linux/mfd/ab4500.h b/include/linux/mfd/ab4500.h
deleted file mode 100644
index a42a7033ae53..000000000000
--- a/include/linux/mfd/ab4500.h
+++ /dev/null
@@ -1,262 +0,0 @@
-/*
- * Copyright (C) 2009 ST-Ericsson
- *
- * Author: Srinidhi KASAGAR <srinidhi.kasagar@stericsson.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.
- *
- * AB4500 device core funtions, for client access
- */
-#ifndef MFD_AB4500_H
-#define MFD_AB4500_H
-
-#include <linux/device.h>
-
-/*
- * AB4500 bank addresses
- */
-#define AB4500_SYS_CTRL1_BLOCK  0x1
-#define AB4500_SYS_CTRL2_BLOCK  0x2
-#define AB4500_REGU_CTRL1       0x3
-#define AB4500_REGU_CTRL2       0x4
-#define AB4500_USB              0x5
-#define AB4500_TVOUT            0x6
-#define AB4500_DBI              0x7
-#define AB4500_ECI_AV_ACC       0x8
-#define AB4500_RESERVED         0x9
-#define AB4500_GPADC            0xA
-#define AB4500_CHARGER          0xB
-#define AB4500_GAS_GAUGE        0xC
-#define AB4500_AUDIO            0xD
-#define AB4500_INTERRUPT        0xE
-#define AB4500_RTC              0xF
-#define AB4500_MISC             0x10
-#define AB4500_DEBUG            0x12
-#define AB4500_PROD_TEST        0x13
-#define AB4500_OTP_EMUL         0x15
-
-/*
- * System control 1 register offsets.
- * Bank = 0x01
- */
-#define AB4500_TURNON_STAT_REG          0x0100
-#define AB4500_RESET_STAT_REG           0x0101
-#define AB4500_PONKEY1_PRESS_STAT_REG   0x0102
-
-#define AB4500_FSM_STAT1_REG            0x0140
-#define AB4500_FSM_STAT2_REG            0x0141
-#define AB4500_SYSCLK_REQ_STAT_REG      0x0142
-#define AB4500_USB_STAT1_REG            0x0143
-#define AB4500_USB_STAT2_REG            0x0144
-#define AB4500_STATUS_SPARE1_REG        0x0145
-#define AB4500_STATUS_SPARE2_REG        0x0146
-
-#define AB4500_CTRL1_REG                0x0180
-#define AB4500_CTRL2_REG                0x0181
-
-/*
- * System control 2 register offsets.
- * bank = 0x02
- */
-#define AB4500_CTRL3_REG                0x0200
-#define AB4500_MAIN_WDOG_CTRL_REG       0x0201
-#define AB4500_MAIN_WDOG_TIMER_REG      0x0202
-#define AB4500_LOW_BAT_REG              0x0203
-#define AB4500_BATT_OK_REG              0x0204
-#define AB4500_SYSCLK_TIMER_REG         0x0205
-#define AB4500_SMPSCLK_CTRL_REG         0x0206
-#define AB4500_SMPSCLK_SEL1_REG         0x0207
-#define AB4500_SMPSCLK_SEL2_REG         0x0208
-#define AB4500_SMPSCLK_SEL3_REG         0x0209
-#define AB4500_SYSULPCLK_CONF_REG       0x020A
-#define AB4500_SYSULPCLK_CTRL1_REG      0x020B
-#define AB4500_SYSCLK_CTRL_REG          0x020C
-#define AB4500_SYSCLK_REQ1_VALID_REG    0x020D
-#define AB4500_SYSCLK_REQ_VALID_REG     0x020E
-#define AB4500_SYSCTRL_SPARE_REG        0x020F
-#define AB4500_PAD_CONF_REG             0x0210
-
-/*
- * Regu control1 register offsets
- * Bank = 0x03
- */
-#define AB4500_REGU_SERIAL_CTRL1_REG    0x0300
-#define AB4500_REGU_SERIAL_CTRL2_REG    0x0301
-#define AB4500_REGU_SERIAL_CTRL3_REG    0x0302
-#define AB4500_REGU_REQ_CTRL1_REG       0x0303
-#define AB4500_REGU_REQ_CTRL2_REG       0x0304
-#define AB4500_REGU_REQ_CTRL3_REG       0x0305
-#define AB4500_REGU_REQ_CTRL4_REG       0x0306
-#define AB4500_REGU_MISC1_REG           0x0380
-#define AB4500_REGU_OTGSUPPLY_CTRL_REG  0x0381
-#define AB4500_REGU_VUSB_CTRL_REG       0x0382
-#define AB4500_REGU_VAUDIO_SUPPLY_REG   0x0383
-#define AB4500_REGU_CTRL1_SPARE_REG     0x0384
-
-/*
- * Regu control2 Vmod register offsets
- */
-#define AB4500_REGU_VMOD_REGU_REG       0x0440
-#define AB4500_REGU_VMOD_SEL1_REG       0x0441
-#define AB4500_REGU_VMOD_SEL2_REG       0x0442
-#define AB4500_REGU_CTRL_DISCH_REG      0x0443
-#define AB4500_REGU_CTRL_DISCH2_REG     0x0444
-
-/*
- * USB/ULPI register offsets
- * Bank : 0x5
- */
-#define AB4500_USB_LINE_STAT_REG        0x0580
-#define AB4500_USB_LINE_CTRL1_REG       0x0581
-#define AB4500_USB_LINE_CTRL2_REG       0x0582
-#define AB4500_USB_LINE_CTRL3_REG       0x0583
-#define AB4500_USB_LINE_CTRL4_REG       0x0584
-#define AB4500_USB_LINE_CTRL5_REG       0x0585
-#define AB4500_USB_OTG_CTRL_REG         0x0587
-#define AB4500_USB_OTG_STAT_REG         0x0588
-#define AB4500_USB_OTG_STAT_REG         0x0588
-#define AB4500_USB_CTRL_SPARE_REG       0x0589
-#define AB4500_USB_PHY_CTRL_REG         0x058A
-
-/*
- * TVOUT / CTRL register offsets
- * Bank : 0x06
- */
-#define AB4500_TVOUT_CTRL_REG           0x0680
-
-/*
- * DBI register offsets
- * Bank : 0x07
- */
-#define AB4500_DBI_REG1_REG             0x0700
-#define AB4500_DBI_REG2_REG             0x0701
-
-/*
- * ECI regsiter offsets
- * Bank : 0x08
- */
-#define AB4500_ECI_CTRL_REG             0x0800
-#define AB4500_ECI_HOOKLEVEL_REG        0x0801
-#define AB4500_ECI_DATAOUT_REG          0x0802
-#define AB4500_ECI_DATAIN_REG           0x0803
-
-/*
- * AV Connector register offsets
- * Bank : 0x08
- */
-#define AB4500_AV_CONN_REG              0x0840
-
-/*
- * Accessory detection register offsets
- * Bank : 0x08
- */
-#define AB4500_ACC_DET_DB1_REG          0x0880
-#define AB4500_ACC_DET_DB2_REG          0x0881
-
-/*
- * GPADC register offsets
- * Bank : 0x0A
- */
-#define AB4500_GPADC_CTRL1_REG          0x0A00
-#define AB4500_GPADC_CTRL2_REG          0x0A01
-#define AB4500_GPADC_CTRL3_REG          0x0A02
-#define AB4500_GPADC_AUTO_TIMER_REG     0x0A03
-#define AB4500_GPADC_STAT_REG           0x0A04
-#define AB4500_GPADC_MANDATAL_REG       0x0A05
-#define AB4500_GPADC_MANDATAH_REG       0x0A06
-#define AB4500_GPADC_AUTODATAL_REG      0x0A07
-#define AB4500_GPADC_AUTODATAH_REG      0x0A08
-#define AB4500_GPADC_MUX_CTRL_REG       0x0A09
-
-/*
- * Charger / status register offfsets
- * Bank : 0x0B
- */
-#define AB4500_CH_STATUS1_REG           0x0B00
-#define AB4500_CH_STATUS2_REG           0x0B01
-#define AB4500_CH_USBCH_STAT1_REG       0x0B02
-#define AB4500_CH_USBCH_STAT2_REG       0x0B03
-#define AB4500_CH_FSM_STAT_REG          0x0B04
-#define AB4500_CH_STAT_REG              0x0B05
-
-/*
- * Charger / control register offfsets
- * Bank : 0x0B
- */
-#define AB4500_CH_VOLT_LVL_REG          0x0B40
-
-/*
- * Charger / main control register offfsets
- * Bank : 0x0B
- */
-#define AB4500_MCH_CTRL1                0x0B80
-#define AB4500_MCH_CTRL2                0x0B81
-#define AB4500_MCH_IPT_CURLVL_REG       0x0B82
-#define AB4500_CH_WD_REG                0x0B83
-
-/*
- * Charger / USB control register offsets
- * Bank : 0x0B
- */
-#define AB4500_USBCH_CTRL1_REG          0x0BC0
-#define AB4500_USBCH_CTRL2_REG          0x0BC1
-#define AB4500_USBCH_IPT_CRNTLVL_REG    0x0BC2
-
-/*
- * RTC bank register offsets
- * Bank : 0xF
- */
-#define AB4500_RTC_SOFF_STAT_REG        0x0F00
-#define AB4500_RTC_CC_CONF_REG          0x0F01
-#define AB4500_RTC_READ_REQ_REG         0x0F02
-#define AB4500_RTC_WATCH_TSECMID_REG    0x0F03
-#define AB4500_RTC_WATCH_TSECHI_REG     0x0F04
-#define AB4500_RTC_WATCH_TMIN_LOW_REG   0x0F05
-#define AB4500_RTC_WATCH_TMIN_MID_REG   0x0F06
-#define AB4500_RTC_WATCH_TMIN_HI_REG    0x0F07
-#define AB4500_RTC_ALRM_MIN_LOW_REG     0x0F08
-#define AB4500_RTC_ALRM_MIN_MID_REG     0x0F09
-#define AB4500_RTC_ALRM_MIN_HI_REG      0x0F0A
-#define AB4500_RTC_STAT_REG             0x0F0B
-#define AB4500_RTC_BKUP_CHG_REG         0x0F0C
-#define AB4500_RTC_FORCE_BKUP_REG       0x0F0D
-#define AB4500_RTC_CALIB_REG            0x0F0E
-#define AB4500_RTC_SWITCH_STAT_REG      0x0F0F
-
-/*
- * PWM Out generators
- * Bank: 0x10
- */
-#define AB4500_PWM_OUT_CTRL1_REG        0x1060
-#define AB4500_PWM_OUT_CTRL2_REG        0x1061
-#define AB4500_PWM_OUT_CTRL3_REG        0x1062
-#define AB4500_PWM_OUT_CTRL4_REG        0x1063
-#define AB4500_PWM_OUT_CTRL5_REG        0x1064
-#define AB4500_PWM_OUT_CTRL6_REG        0x1065
-#define AB4500_PWM_OUT_CTRL7_REG        0x1066
-
-#define AB4500_I2C_PAD_CTRL_REG         0x1067
-#define AB4500_REV_REG                  0x1080
-
-/**
- * struct ab4500
- * @spi: spi device structure
- * @tx_buf: transmit buffer
- * @rx_buf: receive buffer
- * @lock: sync primitive
- */
-struct ab4500 {
-        struct spi_device       *spi;
-        unsigned long           tx_buf[4];
-        unsigned long           rx_buf[4];
-        struct mutex            lock;
-};
-
-int ab4500_write(struct ab4500 *ab4500, unsigned char block,
-                unsigned long addr, unsigned char data);
-int ab4500_read(struct ab4500 *ab4500, unsigned char block,
-                unsigned long addr);
-
-#endif /* MFD_AB4500_H */
diff --git a/include/linux/mfd/ab8500.h b/include/linux/mfd/ab8500.h
new file mode 100644
index 000000000000..b63ff3ba3351
--- /dev/null
+++ b/include/linux/mfd/ab8500.h
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) ST-Ericsson SA 2010
+ *
+ * License Terms: GNU General Public License v2
+ * Author: Srinidhi Kasagar <srinidhi.kasagar@stericsson.com>
+ */
+#ifndef MFD_AB8500_H
+#define MFD_AB8500_H
+
+#include <linux/device.h>
+
+/*
+ * Interrupts
+ */
+
+#define AB8500_INT_MAIN_EXT_CH_NOT_OK   0
+#define AB8500_INT_UN_PLUG_TV_DET       1
+#define AB8500_INT_PLUG_TV_DET          2
+#define AB8500_INT_TEMP_WARM            3
+#define AB8500_INT_PON_KEY2DB_F         4
+#define AB8500_INT_PON_KEY2DB_R         5
+#define AB8500_INT_PON_KEY1DB_F         6
+#define AB8500_INT_PON_KEY1DB_R         7
+#define AB8500_INT_BATT_OVV             8
+#define AB8500_INT_MAIN_CH_UNPLUG_DET   10
+#define AB8500_INT_MAIN_CH_PLUG_DET     11
+#define AB8500_INT_USB_ID_DET_F         12
+#define AB8500_INT_USB_ID_DET_R         13
+#define AB8500_INT_VBUS_DET_F           14
+#define AB8500_INT_VBUS_DET_R           15
+#define AB8500_INT_VBUS_CH_DROP_END     16
+#define AB8500_INT_RTC_60S              17
+#define AB8500_INT_RTC_ALARM            18
+#define AB8500_INT_BAT_CTRL_INDB        20
+#define AB8500_INT_CH_WD_EXP            21
+#define AB8500_INT_VBUS_OVV             22
+#define AB8500_INT_MAIN_CH_DROP_END     23
+#define AB8500_INT_CCN_CONV_ACC         24
+#define AB8500_INT_INT_AUD              25
+#define AB8500_INT_CCEOC                26
+#define AB8500_INT_CC_INT_CALIB         27
+#define AB8500_INT_LOW_BAT_F            28
+#define AB8500_INT_LOW_BAT_R            29
+#define AB8500_INT_BUP_CHG_NOT_OK       30
+#define AB8500_INT_BUP_CHG_OK           31
+#define AB8500_INT_GP_HW_ADC_CONV_END   32
+#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_BTEMP_LOW            72
+#define AB8500_INT_BTEMP_LOW_MEDIUM     73
+#define AB8500_INT_BTEMP_MEDIUM_HIGH    74
+#define AB8500_INT_BTEMP_HIGH           75
+#define AB8500_INT_USB_CHARGER_NOT_OK   81
+#define AB8500_INT_ID_WAKEUP_R          82
+#define AB8500_INT_ID_DET_R1R           84
+#define AB8500_INT_ID_DET_R2R           85
+#define AB8500_INT_ID_DET_R3R           86
+#define AB8500_INT_ID_DET_R4R           87
+#define AB8500_INT_ID_WAKEUP_F          88
+#define AB8500_INT_ID_DET_R1F           90
+#define AB8500_INT_ID_DET_R2F           91
+#define AB8500_INT_ID_DET_R3F           92
+#define AB8500_INT_ID_DET_R4F           93
+#define AB8500_INT_USB_CHG_DET_DONE     94
+#define AB8500_INT_USB_CH_TH_PROT_F     96
+#define AB8500_INT_USB_CH_TH_PROP_R     97
+#define AB8500_INT_MAIN_CH_TH_PROP_F    98
+#define AB8500_INT_MAIN_CH_TH_PROT_R    99
+#define AB8500_INT_USB_CHARGER_NOT_OKF  103
+
+#define AB8500_NR_IRQS                  104
+#define AB8500_NUM_IRQ_REGS             13
+
+/**
+ * struct ab8500 - ab8500 internal structure
+ * @dev: parent device
+ * @lock: read/write operations lock
+ * @irq_lock: genirq bus lock
+ * @revision: chip revision
+ * @irq: irq line
+ * @write: register write
+ * @read: register read
+ * @rx_buf: rx buf for SPI
+ * @tx_buf: tx buf for SPI
+ * @mask: cache of IRQ regs for bus lock
+ * @oldmask: cache of previous IRQ regs for bus lock
+ */
+struct ab8500 {
+        struct device   *dev;
+        struct mutex    lock;
+        struct mutex    irq_lock;
+        int             revision;
+        int             irq_base;
+        int             irq;
+
+        int (*write) (struct ab8500 *a8500, u16 addr, u8 data);
+        int (*read) (struct ab8500 *a8500, u16 addr);
+
+        unsigned long   tx_buf[4];
+        unsigned long   rx_buf[4];
+
+        u8 mask[AB8500_NUM_IRQ_REGS];
+        u8 oldmask[AB8500_NUM_IRQ_REGS];
+};
+
+/**
+ * struct ab8500_platform_data - AB8500 platform data
+ * @irq_base: start of AB8500 IRQs, AB8500_NR_IRQS will be used
+ * @init: board-specific initialization after detection of ab8500
+ */
+struct ab8500_platform_data {
+        int irq_base;
+        void (*init) (struct ab8500 *);
+};
+
+extern int ab8500_write(struct ab8500 *a8500, u16 addr, u8 data);
+extern int ab8500_read(struct ab8500 *a8500, u16 addr);
+extern int ab8500_set_bits(struct ab8500 *a8500, u16 addr, u8 mask, u8 data);
+
+extern int __devinit ab8500_init(struct ab8500 *ab8500);
+extern int __devexit ab8500_exit(struct ab8500 *ab8500);
+
+#endif /* MFD_AB8500_H */
diff --git a/include/linux/mfd/ab3100.h b/include/linux/mfd/abx500.h
index 9a881c305a50..390726fcbcb1 100644
--- a/include/linux/mfd/ab3100.h
+++ b/include/linux/mfd/abx500.h
@@ -3,17 +3,37 @@
  * License terms: GNU General Public License (GPL) version 2
  * AB3100 core access functions
  * Author: Linus Walleij <linus.walleij@stericsson.com>
+ *
+ * ABX500 core access functions.
+ * The abx500 interface is used for the Analog Baseband chip
+ * ab3100, ab3550, ab5500 and possibly comming. It is not used for
+ * ab4500 and ab8500 since they are another family of chip.
+ *
+ * Author: Mattias Wallin <mattias.wallin@stericsson.com>
+ * Author: Mattias Nilsson <mattias.i.nilsson@stericsson.com>
+ * Author: Bengt Jonsson <bengt.g.jonsson@stericsson.com>
+ * Author: Rickard Andersson <rickard.andersson@stericsson.com>
  */
 
 #include <linux/device.h>
 #include <linux/regulator/machine.h>
 
-#ifndef MFD_AB3100_H
-#define MFD_AB3100_H
+#ifndef MFD_ABX500_H
+#define MFD_ABX500_H
 
-#define ABUNKNOWN       0
-#define AB3000          1
-#define AB3100          2
+#define AB3100_P1A      0xc0
+#define AB3100_P1B      0xc1
+#define AB3100_P1C      0xc2
+#define AB3100_P1D      0xc3
+#define AB3100_P1E      0xc4
+#define AB3100_P1F      0xc5
+#define AB3100_P1G      0xc6
+#define AB3100_R2A      0xc7
+#define AB3100_R2B      0xc8
+#define AB3550_P1A      0x10
+#define AB5500_1_0      0x20
+#define AB5500_2_0      0x21
+#define AB5500_2_1      0x22
 
 /*
  * AB3100, EVENTA1, A2 and A3 event register flags
@@ -89,7 +109,7 @@ struct ab3100 {
         char chip_name[32];
         u8 chip_id;
         struct blocking_notifier_head event_subscribers;
-        u32 startup_events;
+        u8 startup_events[3];
         bool startup_events_read;
 };
 
@@ -112,18 +132,102 @@ struct ab3100_platform_data {
         int external_voltage;
 };
 
-int ab3100_set_register_interruptible(struct ab3100 *ab3100, u8 reg, u8 regval);
-int ab3100_get_register_interruptible(struct ab3100 *ab3100, u8 reg, u8 *regval);
-int ab3100_get_register_page_interruptible(struct ab3100 *ab3100,
-                             u8 first_reg, u8 *regvals, u8 numregs);
-int ab3100_mask_and_set_register_interruptible(struct ab3100 *ab3100,
-                                 u8 reg, u8 andmask, u8 ormask);
-u8 ab3100_get_chip_type(struct ab3100 *ab3100);
 int ab3100_event_register(struct ab3100 *ab3100,
                           struct notifier_block *nb);
 int ab3100_event_unregister(struct ab3100 *ab3100,
                             struct notifier_block *nb);
-int ab3100_event_registers_startup_state_get(struct ab3100 *ab3100,
-                                             u32 *fatevent);
 
+/* AB3550, STR register flags */
+#define AB3550_STR_ONSWA                                (0x01)
+#define AB3550_STR_ONSWB                                (0x02)
+#define AB3550_STR_ONSWC                                (0x04)
+#define AB3550_STR_DCIO                                 (0x08)
+#define AB3550_STR_BOOT_MODE                            (0x10)
+#define AB3550_STR_SIM_OFF                              (0x20)
+#define AB3550_STR_BATT_REMOVAL                         (0x40)
+#define AB3550_STR_VBUS                                 (0x80)
+
+/* Interrupt mask registers */
+#define AB3550_IMR1 0x29
+#define AB3550_IMR2 0x2a
+#define AB3550_IMR3 0x2b
+#define AB3550_IMR4 0x2c
+#define AB3550_IMR5 0x2d
+
+enum ab3550_devid {
+        AB3550_DEVID_ADC,
+        AB3550_DEVID_DAC,
+        AB3550_DEVID_LEDS,
+        AB3550_DEVID_POWER,
+        AB3550_DEVID_REGULATORS,
+        AB3550_DEVID_SIM,
+        AB3550_DEVID_UART,
+        AB3550_DEVID_RTC,
+        AB3550_DEVID_CHARGER,
+        AB3550_DEVID_FUELGAUGE,
+        AB3550_DEVID_VIBRATOR,
+        AB3550_DEVID_CODEC,
+        AB3550_NUM_DEVICES,
+};
+
+/**
+ * struct abx500_init_setting
+ * Initial value of the registers for driver to use during setup.
+ */
+struct abx500_init_settings {
+        u8 bank;
+        u8 reg;
+        u8 setting;
+};
+
+/**
+ * struct ab3550_platform_data
+ * Data supplied to initialize board connections to the AB3550
+ */
+struct ab3550_platform_data {
+        struct {unsigned int base; unsigned int count; } irq;
+        void *dev_data[AB3550_NUM_DEVICES];
+        size_t dev_data_sz[AB3550_NUM_DEVICES];
+        struct abx500_init_settings *init_settings;
+        unsigned int init_settings_sz;
+};
+
+int abx500_set_register_interruptible(struct device *dev, u8 bank, u8 reg,
+        u8 value);
+int abx500_get_register_interruptible(struct device *dev, u8 bank, u8 reg,
+        u8 *value);
+int abx500_get_register_page_interruptible(struct device *dev, u8 bank,
+        u8 first_reg, u8 *regvals, u8 numregs);
+int abx500_set_register_page_interruptible(struct device *dev, u8 bank,
+        u8 first_reg, u8 *regvals, u8 numregs);
+/**
+ * abx500_mask_and_set_register_inerruptible() - Modifies selected bits of a
+ *      target register
+ *
+ * @dev: The AB sub device.
+ * @bank: The i2c bank number.
+ * @bitmask: The bit mask to use.
+ * @bitvalues: The new bit values.
+ *
+ * Updates the value of an AB register:
+ * value -> ((value & ~bitmask) | (bitvalues & bitmask))
+ */
+int abx500_mask_and_set_register_interruptible(struct device *dev, u8 bank,
+        u8 reg, u8 bitmask, u8 bitvalues);
+int abx500_get_chip_id(struct device *dev);
+int abx500_event_registers_startup_state_get(struct device *dev, u8 *event);
+int abx500_startup_irq_enabled(struct device *dev, unsigned int irq);
+
+struct abx500_ops {
+        int (*get_chip_id) (struct device *);
+        int (*get_register) (struct device *, u8, u8, u8 *);
+        int (*set_register) (struct device *, u8, u8, u8);
+        int (*get_register_page) (struct device *, u8, u8, u8 *, u8);
+        int (*set_register_page) (struct device *, u8, u8, u8 *, u8);
+        int (*mask_and_set_register) (struct device *, u8, u8, u8, u8);
+        int (*event_registers_startup_state_get) (struct device *, u8 *);
+        int (*startup_irq_enabled) (struct device *, unsigned int);
+};
+
+int abx500_register_ops(struct device *core_dev, struct abx500_ops *ops);
 #endif
diff --git a/include/linux/mfd/janz.h b/include/linux/mfd/janz.h
new file mode 100644
index 000000000000..e9994c469803
--- /dev/null
+++ b/include/linux/mfd/janz.h
@@ -0,0 +1,54 @@
+/*
+ * Common Definitions for Janz MODULbus devices
+ *
+ * Copyright (c) 2010 Ira W. Snyder <iws@ovro.caltech.edu>
+ *
+ * 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 JANZ_H
+#define JANZ_H
+
+struct janz_platform_data {
+        /* MODULbus Module Number */
+        unsigned int modno;
+};
+
+/* PLX bridge chip onboard registers */
+struct janz_cmodio_onboard_regs {
+        u8 unused1;
+
+        /*
+         * Read access: interrupt status
+         * Write access: interrupt disable
+         */
+        u8 int_disable;
+        u8 unused2;
+
+        /*
+         * Read access: MODULbus number (hex switch)
+         * Write access: interrupt enable
+         */
+        u8 int_enable;
+        u8 unused3;
+
+        /* write-only */
+        u8 reset_assert;
+        u8 unused4;
+
+        /* write-only */
+        u8 reset_deassert;
+        u8 unused5;
+
+        /* read-write access to serial EEPROM */
+        u8 eep;
+        u8 unused6;
+
+        /* write-only access to EEPROM chip select */
+        u8 enid;
+};
+
+#endif /* JANZ_H */
diff --git a/include/linux/mfd/mc13783.h b/include/linux/mfd/mc13783.h
index 8895d9d8879c..4a894f688549 100644
--- a/include/linux/mfd/mc13783.h
+++ b/include/linux/mfd/mc13783.h
@@ -64,6 +64,70 @@ static inline int mc13783_ackirq(struct mc13783 *mc13783, int irq)
                                         MC13783_ADC0_TSMOD1 | \
                                         MC13783_ADC0_TSMOD2)
 
+struct mc13783_led_platform_data {
+#define MC13783_LED_MD          0
+#define MC13783_LED_AD          1
+#define MC13783_LED_KP          2
+#define MC13783_LED_R1          3
+#define MC13783_LED_G1          4
+#define MC13783_LED_B1          5
+#define MC13783_LED_R2          6
+#define MC13783_LED_G2          7
+#define MC13783_LED_B2          8
+#define MC13783_LED_R3          9
+#define MC13783_LED_G3          10
+#define MC13783_LED_B3          11
+#define MC13783_LED_MAX MC13783_LED_B3
+        int id;
+        const char *name;
+        const char *default_trigger;
+
+/* Three or two bits current selection depending on the led */
+        char max_current;
+};
+
+struct mc13783_leds_platform_data {
+        int num_leds;
+        struct mc13783_led_platform_data *led;
+
+#define MC13783_LED_TRIODE_MD   (1 << 0)
+#define MC13783_LED_TRIODE_AD   (1 << 1)
+#define MC13783_LED_TRIODE_KP   (1 << 2)
+#define MC13783_LED_BOOST_EN    (1 << 3)
+#define MC13783_LED_TC1HALF     (1 << 4)
+#define MC13783_LED_SLEWLIMTC   (1 << 5)
+#define MC13783_LED_SLEWLIMBL   (1 << 6)
+#define MC13783_LED_TRIODE_TC1  (1 << 7)
+#define MC13783_LED_TRIODE_TC2  (1 << 8)
+#define MC13783_LED_TRIODE_TC3  (1 << 9)
+        int flags;
+
+#define MC13783_LED_AB_DISABLED         0
+#define MC13783_LED_AB_MD1              1
+#define MC13783_LED_AB_MD12             2
+#define MC13783_LED_AB_MD123            3
+#define MC13783_LED_AB_MD1234           4
+#define MC13783_LED_AB_MD1234_AD1       5
+#define MC13783_LED_AB_MD1234_AD12      6
+#define MC13783_LED_AB_MD1_AD           7
+        char abmode;
+
+#define MC13783_LED_ABREF_200MV 0
+#define MC13783_LED_ABREF_400MV 1
+#define MC13783_LED_ABREF_600MV 2
+#define MC13783_LED_ABREF_800MV 3
+        char abref;
+
+#define MC13783_LED_PERIOD_10MS         0
+#define MC13783_LED_PERIOD_100MS        1
+#define MC13783_LED_PERIOD_500MS        2
+#define MC13783_LED_PERIOD_2S           3
+        char bl_period;
+        char tc1_period;
+        char tc2_period;
+        char tc3_period;
+};
+
 /* to be cleaned up */
 struct regulator_init_data;
 
@@ -80,12 +144,14 @@ struct mc13783_regulator_platform_data {
 struct mc13783_platform_data {
         int num_regulators;
         struct mc13783_regulator_init_data *regulators;
+        struct mc13783_leds_platform_data *leds;
 
 #define MC13783_USE_TOUCHSCREEN (1 << 0)
 #define MC13783_USE_CODEC       (1 << 1)
 #define MC13783_USE_ADC         (1 << 2)
 #define MC13783_USE_RTC         (1 << 3)
 #define MC13783_USE_REGULATOR   (1 << 4)
+#define MC13783_USE_LED         (1 << 5)
         unsigned int flags;
 };
 
diff --git a/include/linux/mfd/pcf50633/backlight.h b/include/linux/mfd/pcf50633/backlight.h
new file mode 100644
index 000000000000..83747e217b27
--- /dev/null
+++ b/include/linux/mfd/pcf50633/backlight.h
@@ -0,0 +1,51 @@
+/*
+ *  Copyright (C) 2009-2010, Lars-Peter Clausen <lars@metafoo.de>
+ *      PCF50633 backlight device driver
+ *
+ *  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.
+ *
+ *  You should have received a copy of the  GNU General Public License along
+ *  with this program; if not, write  to the Free Software Foundation, Inc.,
+ *  675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#ifndef __LINUX_MFD_PCF50633_BACKLIGHT
+#define __LINUX_MFD_PCF50633_BACKLIGHT
+
+/*
+* @default_brightness: Backlight brightness is initialized to this value
+*
+* Brightness to be used after the driver has been probed.
+* Valid range 0-63.
+*
+* @default_brightness_limit: The actual brightness is limited by this value
+*
+* Brightness limit to be used after the driver has been probed. This is useful
+* when it is not known how much power is available for the backlight during
+* probe.
+* Valid range 0-63. Can be changed later with pcf50633_bl_set_brightness_limit.
+*
+* @ramp_time: Display ramp time when changing brightness
+*
+* When changing the backlights brightness the change is not instant, instead
+* it fades smooth from one state to another. This value specifies how long
+* the fade should take. The lower the value the higher the fade time.
+* Valid range 0-255
+*/
+struct pcf50633_bl_platform_data {
+        unsigned int    default_brightness;
+        unsigned int    default_brightness_limit;
+        uint8_t         ramp_time;
+};
+
+
+struct pcf50633;
+
+int pcf50633_bl_set_brightness_limit(struct pcf50633 *pcf, unsigned int limit);
+
+#endif
+
diff --git a/include/linux/mfd/pcf50633/core.h b/include/linux/mfd/pcf50633/core.h
index 3398bd9aab11..ad411a78870c 100644
--- a/include/linux/mfd/pcf50633/core.h
+++ b/include/linux/mfd/pcf50633/core.h
@@ -18,6 +18,7 @@
 #include <linux/regulator/driver.h>
 #include <linux/regulator/machine.h>
 #include <linux/power_supply.h>
+#include <linux/mfd/pcf50633/backlight.h>
 
 struct pcf50633;
 
@@ -43,6 +44,8 @@ struct pcf50633_platform_data {
         void (*force_shutdown)(struct pcf50633 *);
 
         u8 resumers[5];
+
+        struct pcf50633_bl_platform_data *backlight_data;
 };
 
 struct pcf50633_irq {
@@ -152,6 +155,7 @@ struct pcf50633 {
         struct platform_device *mbc_pdev;
         struct platform_device *adc_pdev;
         struct platform_device *input_pdev;
+        struct platform_device *bl_pdev;
         struct platform_device *regulator_pdev[PCF50633_NUM_REGULATORS];
 };
 
diff --git a/include/linux/mfd/rdc321x.h b/include/linux/mfd/rdc321x.h
new file mode 100644
index 000000000000..4bdf19c8eedf
--- /dev/null
+++ b/include/linux/mfd/rdc321x.h
@@ -0,0 +1,26 @@
+#ifndef __RDC321X_MFD_H
+#define __RDC321X_MFD_H
+
+#include <linux/types.h>
+#include <linux/pci.h>
+
+/* Offsets to be accessed in the southbridge PCI
+ * device configuration register */
+#define RDC321X_WDT_CTRL        0x44
+#define RDC321X_GPIO_CTRL_REG1  0x48
+#define RDC321X_GPIO_DATA_REG1  0x4c
+#define RDC321X_GPIO_CTRL_REG2  0x84
+#define RDC321X_GPIO_DATA_REG2  0x88
+
+#define RDC321X_MAX_GPIO        58
+
+struct rdc321x_gpio_pdata {
+        struct pci_dev *sb_pdev;
+        unsigned max_gpios;
+};
+
+struct rdc321x_wdt_pdata {
+        struct pci_dev *sb_pdev;
+};
+
+#endif /* __RDC321X_MFD_H */
diff --git a/include/linux/mfd/sh_mobile_sdhi.h b/include/linux/mfd/sh_mobile_sdhi.h
index 3bcd7163485c..49067802a6d7 100644
--- a/include/linux/mfd/sh_mobile_sdhi.h
+++ b/include/linux/mfd/sh_mobile_sdhi.h
@@ -1,7 +1,13 @@
 #ifndef __SH_MOBILE_SDHI_H__
 #define __SH_MOBILE_SDHI_H__
 
+#include <linux/types.h>
+
 struct sh_mobile_sdhi_info {
+        int dma_slave_tx;
+        int dma_slave_rx;
+        unsigned long tmio_flags;
+        u32 tmio_ocr_mask;      /* available MMC voltages */
         void (*set_pwr)(struct platform_device *pdev, int state);
 };
 
diff --git a/include/linux/mfd/tc35892.h b/include/linux/mfd/tc35892.h
new file mode 100644
index 000000000000..e47f770d3068
--- /dev/null
+++ b/include/linux/mfd/tc35892.h
@@ -0,0 +1,132 @@
+/*
+ * Copyright (C) ST-Ericsson SA 2010
+ *
+ * License Terms: GNU General Public License, version 2
+ */
+
+#ifndef __LINUX_MFD_TC35892_H
+#define __LINUX_MFD_TC35892_H
+
+#include <linux/device.h>
+
+#define TC35892_RSTCTRL_IRQRST  (1 << 4)
+#define TC35892_RSTCTRL_TIMRST  (1 << 3)
+#define TC35892_RSTCTRL_ROTRST  (1 << 2)
+#define TC35892_RSTCTRL_KBDRST  (1 << 1)
+#define TC35892_RSTCTRL_GPIRST  (1 << 0)
+
+#define TC35892_IRQST           0x91
+
+#define TC35892_MANFCODE_MAGIC  0x03
+#define TC35892_MANFCODE        0x80
+#define TC35892_VERSION         0x81
+#define TC35892_IOCFG           0xA7
+
+#define TC35892_CLKMODE         0x88
+#define TC35892_CLKCFG          0x89
+#define TC35892_CLKEN           0x8A
+
+#define TC35892_RSTCTRL         0x82
+#define TC35892_EXTRSTN         0x83
+#define TC35892_RSTINTCLR       0x84
+
+#define TC35892_GPIOIS0         0xC9
+#define TC35892_GPIOIS1         0xCA
+#define TC35892_GPIOIS2         0xCB
+#define TC35892_GPIOIBE0        0xCC
+#define TC35892_GPIOIBE1        0xCD
+#define TC35892_GPIOIBE2        0xCE
+#define TC35892_GPIOIEV0        0xCF
+#define TC35892_GPIOIEV1        0xD0
+#define TC35892_GPIOIEV2        0xD1
+#define TC35892_GPIOIE0         0xD2
+#define TC35892_GPIOIE1         0xD3
+#define TC35892_GPIOIE2         0xD4
+#define TC35892_GPIORIS0        0xD6
+#define TC35892_GPIORIS1        0xD7
+#define TC35892_GPIORIS2        0xD8
+#define TC35892_GPIOMIS0        0xD9
+#define TC35892_GPIOMIS1        0xDA
+#define TC35892_GPIOMIS2        0xDB
+#define TC35892_GPIOIC0         0xDC
+#define TC35892_GPIOIC1         0xDD
+#define TC35892_GPIOIC2         0xDE
+
+#define TC35892_GPIODATA0       0xC0
+#define TC35892_GPIOMASK0       0xc1
+#define TC35892_GPIODATA1       0xC2
+#define TC35892_GPIOMASK1       0xc3
+#define TC35892_GPIODATA2       0xC4
+#define TC35892_GPIOMASK2       0xC5
+
+#define TC35892_GPIODIR0        0xC6
+#define TC35892_GPIODIR1        0xC7
+#define TC35892_GPIODIR2        0xC8
+
+#define TC35892_GPIOSYNC0       0xE6
+#define TC35892_GPIOSYNC1       0xE7
+#define TC35892_GPIOSYNC2       0xE8
+
+#define TC35892_GPIOWAKE0       0xE9
+#define TC35892_GPIOWAKE1       0xEA
+#define TC35892_GPIOWAKE2       0xEB
+
+#define TC35892_GPIOODM0        0xE0
+#define TC35892_GPIOODE0        0xE1
+#define TC35892_GPIOODM1        0xE2
+#define TC35892_GPIOODE1        0xE3
+#define TC35892_GPIOODM2        0xE4
+#define TC35892_GPIOODE2        0xE5
+
+#define TC35892_INT_GPIIRQ      0
+#define TC35892_INT_TI0IRQ      1
+#define TC35892_INT_TI1IRQ      2
+#define TC35892_INT_TI2IRQ      3
+#define TC35892_INT_ROTIRQ      5
+#define TC35892_INT_KBDIRQ      6
+#define TC35892_INT_PORIRQ      7
+
+#define TC35892_NR_INTERNAL_IRQS        8
+#define TC35892_INT_GPIO(x)     (TC35892_NR_INTERNAL_IRQS + (x))
+
+struct tc35892 {
+        struct mutex lock;
+        struct device *dev;
+        struct i2c_client *i2c;
+
+        int irq_base;
+        int num_gpio;
+        struct tc35892_platform_data *pdata;
+};
+
+extern int tc35892_reg_write(struct tc35892 *tc35892, u8 reg, u8 data);
+extern int tc35892_reg_read(struct tc35892 *tc35892, u8 reg);
+extern int tc35892_block_read(struct tc35892 *tc35892, u8 reg, u8 length,
+                              u8 *values);
+extern int tc35892_block_write(struct tc35892 *tc35892, u8 reg, u8 length,
+                               const u8 *values);
+extern int tc35892_set_bits(struct tc35892 *tc35892, u8 reg, u8 mask, u8 val);
+
+/**
+ * struct tc35892_gpio_platform_data - TC35892 GPIO platform data
+ * @gpio_base: first gpio number assigned to TC35892.  A maximum of
+ *             %TC35892_NR_GPIOS GPIOs will be allocated.
+ */
+struct tc35892_gpio_platform_data {
+        int gpio_base;
+};
+
+/**
+ * struct tc35892_platform_data - TC35892 platform data
+ * @irq_base: base IRQ number.  %TC35892_NR_IRQS irqs will be used.
+ * @gpio: GPIO-specific platform data
+ */
+struct tc35892_platform_data {
+        int irq_base;
+        struct tc35892_gpio_platform_data *gpio;
+};
+
+#define TC35892_NR_GPIOS        24
+#define TC35892_NR_IRQS         TC35892_INT_GPIO(TC35892_NR_GPIOS)
+
+#endif
diff --git a/include/linux/mfd/tmio.h b/include/linux/mfd/tmio.h
index c3f7dff8effc..f07425bc3dcd 100644
--- a/include/linux/mfd/tmio.h
+++ b/include/linux/mfd/tmio.h
@@ -50,17 +50,28 @@
                 tmio_iowrite16((val) >> 16, (base) + ((reg + 2) << (shift))); \
         } while (0)
 
+/* tmio MMC platform flags */
+#define TMIO_MMC_WRPROTECT_DISABLE      (1 << 0)
+
 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);
 void tmio_core_mmc_pwr(void __iomem *cnf, int shift, int state);
 void tmio_core_mmc_clk_div(void __iomem *cnf, int shift, int state);
 
+struct tmio_mmc_dma {
+        void *chan_priv_tx;
+        void *chan_priv_rx;
+};
+
 /*
  * data for the MMC controller
  */
 struct tmio_mmc_data {
         unsigned int                    hclk;
         unsigned long                   capabilities;
+        unsigned long                   flags;
+        u32                             ocr_mask;       /* available voltages */
+        struct tmio_mmc_dma             *dma;
         void (*set_pwr)(struct platform_device *host, int state);
         void (*set_clk_div)(struct platform_device *host, int state);
 };
diff --git a/include/linux/mfd/tps6507x.h b/include/linux/mfd/tps6507x.h
new file mode 100644
index 000000000000..c923e4864f55
--- /dev/null
+++ b/include/linux/mfd/tps6507x.h
@@ -0,0 +1,169 @@
+/* linux/mfd/tps6507x.h
+ *
+ * Functions to access TPS65070 power management chip.
+ *
+ * Copyright (c) 2009 RidgeRun (todd.fischer@ridgerun.com)
+ *
+ *
+ *  For licencing details see kernel-base/COPYING
+ */
+
+#ifndef __LINUX_MFD_TPS6507X_H
+#define __LINUX_MFD_TPS6507X_H
+
+/*
+ * ----------------------------------------------------------------------------
+ * Registers, all 8 bits
+ * ----------------------------------------------------------------------------
+ */
+
+
+/* Register definitions */
+#define TPS6507X_REG_PPATH1                     0X01
+#define TPS6507X_CHG_USB                        BIT(7)
+#define TPS6507X_CHG_AC                         BIT(6)
+#define TPS6507X_CHG_USB_PW_ENABLE              BIT(5)
+#define TPS6507X_CHG_AC_PW_ENABLE               BIT(4)
+#define TPS6507X_CHG_AC_CURRENT                 BIT(2)
+#define TPS6507X_CHG_USB_CURRENT                BIT(0)
+
+#define TPS6507X_REG_INT                        0X02
+#define TPS6507X_REG_MASK_AC_USB                BIT(7)
+#define TPS6507X_REG_MASK_TSC                   BIT(6)
+#define TPS6507X_REG_MASK_PB_IN                 BIT(5)
+#define TPS6507X_REG_TSC_INT                    BIT(3)
+#define TPS6507X_REG_PB_IN_INT                  BIT(2)
+#define TPS6507X_REG_AC_USB_APPLIED             BIT(1)
+#define TPS6507X_REG_AC_USB_REMOVED             BIT(0)
+
+#define TPS6507X_REG_CHGCONFIG0                 0X03
+
+#define TPS6507X_REG_CHGCONFIG1                 0X04
+#define TPS6507X_CON_CTRL1_DCDC1_ENABLE         BIT(4)
+#define TPS6507X_CON_CTRL1_DCDC2_ENABLE         BIT(3)
+#define TPS6507X_CON_CTRL1_DCDC3_ENABLE         BIT(2)
+#define TPS6507X_CON_CTRL1_LDO1_ENABLE          BIT(1)
+#define TPS6507X_CON_CTRL1_LDO2_ENABLE          BIT(0)
+
+#define TPS6507X_REG_CHGCONFIG2                 0X05
+
+#define TPS6507X_REG_CHGCONFIG3                 0X06
+
+#define TPS6507X_REG_ADCONFIG                   0X07
+#define TPS6507X_ADCONFIG_AD_ENABLE             BIT(7)
+#define TPS6507X_ADCONFIG_START_CONVERSION      BIT(6)
+#define TPS6507X_ADCONFIG_CONVERSION_DONE       BIT(5)
+#define TPS6507X_ADCONFIG_VREF_ENABLE           BIT(4)
+#define TPS6507X_ADCONFIG_INPUT_AD_IN1          0
+#define TPS6507X_ADCONFIG_INPUT_AD_IN2          1
+#define TPS6507X_ADCONFIG_INPUT_AD_IN3          2
+#define TPS6507X_ADCONFIG_INPUT_AD_IN4          3
+#define TPS6507X_ADCONFIG_INPUT_TS_PIN          4
+#define TPS6507X_ADCONFIG_INPUT_BAT_CURRENT     5
+#define TPS6507X_ADCONFIG_INPUT_AC_VOLTAGE      6
+#define TPS6507X_ADCONFIG_INPUT_SYS_VOLTAGE     7
+#define TPS6507X_ADCONFIG_INPUT_CHARGER_VOLTAGE 8
+#define TPS6507X_ADCONFIG_INPUT_BAT_VOLTAGE     9
+#define TPS6507X_ADCONFIG_INPUT_THRESHOLD_VOLTAGE 10
+#define TPS6507X_ADCONFIG_INPUT_ISET1_VOLTAGE   11
+#define TPS6507X_ADCONFIG_INPUT_ISET2_VOLTAGE   12
+#define TPS6507X_ADCONFIG_INPUT_REAL_TSC        14
+#define TPS6507X_ADCONFIG_INPUT_TSC             15
+
+#define TPS6507X_REG_TSCMODE                    0X08
+#define TPS6507X_TSCMODE_X_POSITION             0
+#define TPS6507X_TSCMODE_Y_POSITION             1
+#define TPS6507X_TSCMODE_PRESSURE               2
+#define TPS6507X_TSCMODE_X_PLATE                3
+#define TPS6507X_TSCMODE_Y_PLATE                4
+#define TPS6507X_TSCMODE_STANDBY                5
+#define TPS6507X_TSCMODE_ADC_INPUT              6
+#define TPS6507X_TSCMODE_DISABLE                7
+
+#define TPS6507X_REG_ADRESULT_1                 0X09
+
+#define TPS6507X_REG_ADRESULT_2                 0X0A
+#define TPS6507X_REG_ADRESULT_2_MASK            (BIT(1) | BIT(0))
+
+#define TPS6507X_REG_PGOOD                      0X0B
+
+#define TPS6507X_REG_PGOODMASK                  0X0C
+
+#define TPS6507X_REG_CON_CTRL1                  0X0D
+#define TPS6507X_CON_CTRL1_DCDC1_ENABLE         BIT(4)
+#define TPS6507X_CON_CTRL1_DCDC2_ENABLE         BIT(3)
+#define TPS6507X_CON_CTRL1_DCDC3_ENABLE         BIT(2)
+#define TPS6507X_CON_CTRL1_LDO1_ENABLE          BIT(1)
+#define TPS6507X_CON_CTRL1_LDO2_ENABLE          BIT(0)
+
+#define TPS6507X_REG_CON_CTRL2                  0X0E
+
+#define TPS6507X_REG_CON_CTRL3                  0X0F
+
+#define TPS6507X_REG_DEFDCDC1                   0X10
+#define TPS6507X_DEFDCDC1_DCDC1_EXT_ADJ_EN      BIT(7)
+#define TPS6507X_DEFDCDC1_DCDC1_MASK            0X3F
+
+#define TPS6507X_REG_DEFDCDC2_LOW               0X11
+#define TPS6507X_DEFDCDC2_LOW_DCDC2_MASK        0X3F
+
+#define TPS6507X_REG_DEFDCDC2_HIGH              0X12
+#define TPS6507X_DEFDCDC2_HIGH_DCDC2_MASK       0X3F
+
+#define TPS6507X_REG_DEFDCDC3_LOW               0X13
+#define TPS6507X_DEFDCDC3_LOW_DCDC3_MASK        0X3F
+
+#define TPS6507X_REG_DEFDCDC3_HIGH              0X14
+#define TPS6507X_DEFDCDC3_HIGH_DCDC3_MASK       0X3F
+
+#define TPS6507X_REG_DEFSLEW                    0X15
+
+#define TPS6507X_REG_LDO_CTRL1                  0X16
+#define TPS6507X_REG_LDO_CTRL1_LDO1_MASK        0X0F
+
+#define TPS6507X_REG_DEFLDO2                    0X17
+#define TPS6507X_REG_DEFLDO2_LDO2_MASK          0X3F
+
+#define TPS6507X_REG_WLED_CTRL1                 0X18
+
+#define TPS6507X_REG_WLED_CTRL2                 0X19
+
+/* VDCDC MASK */
+#define TPS6507X_DEFDCDCX_DCDC_MASK             0X3F
+
+#define TPS6507X_MAX_REGISTER                   0X19
+
+/**
+ * struct tps6507x_board - packages regulator and touchscreen init data
+ * @tps6507x_regulator_data: regulator initialization values
+ *
+ * Board data may be used to initialize regulator and touchscreen.
+ */
+
+struct tps6507x_board {
+        struct regulator_init_data *tps6507x_pmic_init_data;
+        struct touchscreen_init_data *tps6507x_ts_init_data;
+};
+
+/**
+ * struct tps6507x_dev - tps6507x sub-driver chip access routines
+ * @read_dev() - I2C register read function
+ * @write_dev() - I2C register write function
+ *
+ * Device data may be used to access the TPS6507x chip
+ */
+
+struct tps6507x_dev {
+        struct device *dev;
+        struct i2c_client *i2c_client;
+        int (*read_dev)(struct tps6507x_dev *tps6507x, char reg, int size,
+                        void *dest);
+        int (*write_dev)(struct tps6507x_dev *tps6507x, char reg, int size,
+                         void *src);
+
+        /* Client devices */
+        struct tps6507x_pmic *pmic;
+        struct tps6507x_ts *ts;
+};
+
+#endif /*  __LINUX_MFD_TPS6507X_H */
diff --git a/include/linux/mfd/wm831x/core.h b/include/linux/mfd/wm831x/core.h
index 5915f6e3d9ab..eb5bd4e0e03c 100644
--- a/include/linux/mfd/wm831x/core.h
+++ b/include/linux/mfd/wm831x/core.h
@@ -256,8 +256,9 @@ struct wm831x {
         int irq_masks_cache[WM831X_NUM_IRQ_REGS]; /* Cached hardware value */
 
         /* Chip revision based flags */
-        unsigned has_gpio_ena:1;  /* Has GPIO enable bit */
-        unsigned has_cs_sts:1;    /* Has current sink status bit */
+        unsigned has_gpio_ena:1;         /* Has GPIO enable bit */
+        unsigned has_cs_sts:1;           /* Has current sink status bit */
+        unsigned charger_irq_wake:1;     /* Are charger IRQs a wake source? */
 
         int num_gpio;
 
diff --git a/include/linux/migrate.h b/include/linux/migrate.h
index 7f085c97c799..7238231b8dd4 100644
--- a/include/linux/migrate.h
+++ b/include/linux/migrate.h
@@ -9,7 +9,7 @@ typedef struct page *new_page_t(struct page *, unsigned long private, int **);
 #ifdef CONFIG_MIGRATION
 #define PAGE_MIGRATION 1
 
-extern int putback_lru_pages(struct list_head *l);
+extern void putback_lru_pages(struct list_head *l);
 extern int migrate_page(struct address_space *,
                         struct page *, struct page *);
 extern int migrate_pages(struct list_head *l, new_page_t x,
@@ -19,17 +19,19 @@ extern int fail_migrate_page(struct address_space *,
                         struct page *, struct page *);
 
 extern int migrate_prep(void);
+extern int migrate_prep_local(void);
 extern int migrate_vmas(struct mm_struct *mm,
                 const nodemask_t *from, const nodemask_t *to,
                 unsigned long flags);
 #else
 #define PAGE_MIGRATION 0
 
-static inline int putback_lru_pages(struct list_head *l) { return 0; }
+static inline void putback_lru_pages(struct list_head *l) {}
 static inline int migrate_pages(struct list_head *l, new_page_t x,
                 unsigned long private, int offlining) { return -ENOSYS; }
 
 static inline int migrate_prep(void) { return -ENOSYS; }
+static inline int migrate_prep_local(void) { return -ENOSYS; }
 
 static inline int migrate_vmas(struct mm_struct *mm,
                 const nodemask_t *from, const nodemask_t *to,
diff --git a/include/linux/miscdevice.h b/include/linux/miscdevice.h
index 8b5f7cc0fba6..b631c46cffd9 100644
--- a/include/linux/miscdevice.h
+++ b/include/linux/miscdevice.h
@@ -31,6 +31,8 @@
 #define FUSE_MINOR              229
 #define KVM_MINOR               232
 #define VHOST_NET_MINOR         233
+#define BTRFS_MINOR             234
+#define AUTOFS_MINOR            235
 #define MISC_DYNAMIC_MINOR      255
 
 struct device;
diff --git a/include/linux/mm.h b/include/linux/mm.h
index fb19bb92b809..b969efb03787 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -13,6 +13,7 @@
 #include <linux/debug_locks.h>
 #include <linux/mm_types.h>
 #include <linux/range.h>
+#include <linux/pfn.h>
 
 struct mempolicy;
 struct anon_vma;
@@ -106,6 +107,9 @@ extern unsigned int kobjsize(const void *objp);
 #define VM_PFN_AT_MMAP  0x40000000      /* PFNMAP vma that is fully mapped at mmap time */
 #define VM_MERGEABLE    0x80000000      /* KSM may merge identical pages */
 
+/* Bits set in the VMA until the stack is in its final location */
+#define VM_STACK_INCOMPLETE_SETUP       (VM_RAND_READ | VM_SEQ_READ)
+
 #ifndef VM_STACK_DEFAULT_FLAGS          /* arch can override this */
 #define VM_STACK_DEFAULT_FLAGS VM_DATA_DEFAULT_FLAGS
 #endif
@@ -334,6 +338,7 @@ void put_page(struct page *page);
 void put_pages_list(struct list_head *pages);
 
 void split_page(struct page *page, unsigned int order);
+int split_free_page(struct page *page);
 
 /*
  * Compound pages have a destructor function.  Provide a
@@ -591,7 +596,7 @@ static inline void set_page_links(struct page *page, enum zone_type zone,
 
 static __always_inline void *lowmem_page_address(struct page *page)
 {
-        return __va(page_to_pfn(page) << PAGE_SHIFT);
+        return __va(PFN_PHYS(page_to_pfn(page)));
 }
 
 #if defined(CONFIG_HIGHMEM) && !defined(WANT_PAGE_VIRTUAL)
diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h
index 43eaf5ca5848..f65913c9f5a4 100644
--- a/include/linux/mmc/host.h
+++ b/include/linux/mmc/host.h
@@ -108,6 +108,9 @@ struct mmc_host_ops {
         int     (*get_cd)(struct mmc_host *host);
 
         void    (*enable_sdio_irq)(struct mmc_host *host, int enable);
+
+        /* optional callback for HC quirks */
+        void    (*init_card)(struct mmc_host *host, struct mmc_card *card);
 };
 
 struct mmc_card;
@@ -227,7 +230,7 @@ static inline void *mmc_priv(struct mmc_host *host)
 #define mmc_classdev(x) (&(x)->class_dev)
 #define mmc_hostname(x) (dev_name(&(x)->class_dev))
 
-extern int mmc_suspend_host(struct mmc_host *, pm_message_t);
+extern int mmc_suspend_host(struct mmc_host *);
 extern int mmc_resume_host(struct mmc_host *);
 
 extern void mmc_power_save_host(struct mmc_host *host);
diff --git a/include/linux/mmc/sdhci-spear.h b/include/linux/mmc/sdhci-spear.h
new file mode 100644
index 000000000000..9188c973f3e1
--- /dev/null
+++ b/include/linux/mmc/sdhci-spear.h
@@ -0,0 +1,42 @@
+/*
+ * include/linux/mmc/sdhci-spear.h
+ *
+ * SDHCI declarations specific to ST SPEAr platform
+ *
+ * Copyright (C) 2010 ST Microelectronics
+ * Viresh Kumar<viresh.kumar@st.com>
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#ifndef MMC_SDHCI_SPEAR_H
+#define MMC_SDHCI_SPEAR_H
+
+#include <linux/platform_device.h>
+/*
+ * struct sdhci_plat_data: spear sdhci platform data structure
+ *
+ * @card_power_gpio: gpio pin for enabling/disabling power to sdhci socket
+ * @power_active_high: if set, enable power to sdhci socket by setting
+ *                      card_power_gpio
+ * @power_always_enb: If set, then enable power on probe, otherwise enable only
+ *                      on card insertion and disable on card removal.
+ * card_int_gpio: gpio pin used for card detection
+ */
+struct sdhci_plat_data {
+        int card_power_gpio;
+        int power_active_high;
+        int power_always_enb;
+        int card_int_gpio;
+};
+
+/* This function is used to set platform_data field of pdev->dev */
+static inline void
+sdhci_set_plat_data(struct platform_device *pdev, struct sdhci_plat_data *data)
+{
+        pdev->dev.platform_data = data;
+}
+
+#endif /* MMC_SDHCI_SPEAR_H */
diff --git a/include/linux/mmc/sdio_func.h b/include/linux/mmc/sdio_func.h
index c6c0cceba5fe..31baaf82f458 100644
--- a/include/linux/mmc/sdio_func.h
+++ b/include/linux/mmc/sdio_func.h
@@ -145,6 +145,9 @@ extern void sdio_writew(struct sdio_func *func, u16 b,
 extern void sdio_writel(struct sdio_func *func, u32 b,
         unsigned int addr, int *err_ret);
 
+extern u8 sdio_writeb_readb(struct sdio_func *func, u8 write_byte,
+        unsigned int addr, int *err_ret);
+
 extern int sdio_memcpy_toio(struct sdio_func *func, unsigned int addr,
         void *src, int count);
 extern int sdio_writesb(struct sdio_func *func, unsigned int addr,
diff --git a/include/linux/mmc/sh_mmcif.h b/include/linux/mmc/sh_mmcif.h
new file mode 100644
index 000000000000..aafe832f18aa
--- /dev/null
+++ b/include/linux/mmc/sh_mmcif.h
@@ -0,0 +1,39 @@
+/*
+ * include/linux/mmc/sh_mmcif.h
+ *
+ * platform data for eMMC driver
+ *
+ * Copyright (C) 2010 Renesas Solutions Corp.
+ *
+ * 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.
+ *
+ */
+
+#ifndef __SH_MMCIF_H__
+#define __SH_MMCIF_H__
+
+/*
+ * MMCIF : CE_CLK_CTRL [19:16]
+ * 1000 : Peripheral clock / 512
+ * 0111 : Peripheral clock / 256
+ * 0110 : Peripheral clock / 128
+ * 0101 : Peripheral clock / 64
+ * 0100 : Peripheral clock / 32
+ * 0011 : Peripheral clock / 16
+ * 0010 : Peripheral clock / 8
+ * 0001 : Peripheral clock / 4
+ * 0000 : Peripheral clock / 2
+ * 1111 : Peripheral clock (sup_pclk set '1')
+ */
+
+struct sh_mmcif_plat_data {
+        void (*set_pwr)(struct platform_device *pdev, int state);
+        void (*down_pwr)(struct platform_device *pdev);
+        u8      sup_pclk;       /* 1 :SH7757, 0: SH7724/SH7372 */
+        unsigned long caps;
+        u32     ocr;
+};
+
+#endif /* __SH_MMCIF_H__ */
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index cf9e458e96b0..b4d109e389b8 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -321,6 +321,15 @@ struct zone {
         unsigned long           *pageblock_flags;
 #endif /* CONFIG_SPARSEMEM */
 
+#ifdef CONFIG_COMPACTION
+        /*
+         * On compaction failure, 1<<compact_defer_shift compactions
+         * are skipped before trying again. The number attempted since
+         * last failure is tracked with compact_considered.
+         */
+        unsigned int            compact_considered;
+        unsigned int            compact_defer_shift;
+#endif
 
         ZONE_PADDING(_pad1_)
 
@@ -641,9 +650,10 @@ typedef struct pglist_data {
 
 #include <linux/memory_hotplug.h>
 
+extern struct mutex zonelists_mutex;
 void get_zone_counts(unsigned long *active, unsigned long *inactive,
                         unsigned long *free);
-void build_all_zonelists(void);
+void build_all_zonelists(void *data);
 void wakeup_kswapd(struct zone *zone, int order);
 int zone_watermark_ok(struct zone *z, int order, unsigned long mark,
                 int classzone_idx, int alloc_flags);
@@ -661,6 +671,12 @@ void memory_present(int nid, unsigned long start, unsigned long end);
 static inline void memory_present(int nid, unsigned long start, unsigned long end) {}
 #endif
 
+#ifdef CONFIG_HAVE_MEMORYLESS_NODES
+int local_memory_node(int node_id);
+#else
+static inline int local_memory_node(int node_id) { return node_id; };
+#endif
+
 #ifdef CONFIG_NEED_NODE_MEMMAP_SIZE
 unsigned long __init node_memmap_size_bytes(int, unsigned long, unsigned long);
 #endif
@@ -972,7 +988,7 @@ struct mem_section {
 #endif
 
 #define SECTION_NR_TO_ROOT(sec) ((sec) / SECTIONS_PER_ROOT)
-#define NR_SECTION_ROOTS        (NR_MEM_SECTIONS / SECTIONS_PER_ROOT)
+#define NR_SECTION_ROOTS        DIV_ROUND_UP(NR_MEM_SECTIONS, SECTIONS_PER_ROOT)
 #define SECTION_ROOT_MASK       (SECTIONS_PER_ROOT - 1)
 
 #ifdef CONFIG_SPARSEMEM_EXTREME
diff --git a/include/linux/ncp_fs.h b/include/linux/ncp_fs.h
index 30b06c893944..4522aed00906 100644
--- a/include/linux/ncp_fs.h
+++ b/include/linux/ncp_fs.h
@@ -210,7 +210,7 @@ int ncp_date_dos2unix(__le16 time, __le16 date);
 void ncp_date_unix2dos(int unix_date, __le16 * time, __le16 * date);
 
 /* linux/fs/ncpfs/ioctl.c */
-int ncp_ioctl(struct inode *, struct file *, unsigned int, unsigned long);
+long ncp_ioctl(struct file *, unsigned int, unsigned long);
 long ncp_compat_ioctl(struct file *, unsigned int, unsigned long);
 
 /* linux/fs/ncpfs/sock.c */
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index a1bff6518166..40291f375024 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -1407,17 +1407,25 @@ struct softnet_data {
         struct softnet_data     *rps_ipi_next;
         unsigned int            cpu;
         unsigned int            input_queue_head;
+        unsigned int            input_queue_tail;
 #endif
         unsigned                dropped;
         struct sk_buff_head     input_pkt_queue;
         struct napi_struct      backlog;
 };
 
-static inline void input_queue_head_add(struct softnet_data *sd,
-                                        unsigned int len)
+static inline void input_queue_head_incr(struct softnet_data *sd)
 {
 #ifdef CONFIG_RPS
-        sd->input_queue_head += len;
+        sd->input_queue_head++;
+#endif
+}
+
+static inline void input_queue_tail_incr_save(struct softnet_data *sd,
+                                              unsigned int *qtail)
+{
+#ifdef CONFIG_RPS
+        *qtail = ++sd->input_queue_tail;
 #endif
 }
 
@@ -2326,7 +2334,7 @@ do {								\
 #define netif_vdbg(priv, type, dev, format, args...)            \
 ({                                                              \
         if (0)                                                  \
-                netif_printk(KERN_DEBUG, dev, format, ##args);  \
+                netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \
         0;                                                      \
 })
 #endif
diff --git a/include/linux/netfilter/x_tables.h b/include/linux/netfilter/x_tables.h
index c2ee5d8550cf..c00cc0c4d0b7 100644
--- a/include/linux/netfilter/x_tables.h
+++ b/include/linux/netfilter/x_tables.h
@@ -333,7 +333,7 @@ struct xt_target {
         /* Called when user tries to insert an entry of this type:
            hook_mask is a bitmask of hooks from which it can be
            called. */
-        /* Should return true or false, or an error code (-Exxxx). */
+        /* Should return 0 on success or an error code otherwise (-Exxxx). */
         int (*checkentry)(const struct xt_tgchk_param *);
 
         /* Called when entry of this type deleted. */
diff --git a/include/linux/notifier.h b/include/linux/notifier.h
index 7c3609622334..540703b555cb 100644
--- a/include/linux/notifier.h
+++ b/include/linux/notifier.h
@@ -164,7 +164,10 @@ extern int __srcu_notifier_call_chain(struct srcu_notifier_head *nh,
 /* Encapsulate (negative) errno value (in particular, NOTIFY_BAD <=> EPERM). */
 static inline int notifier_from_errno(int err)
 {
-        return NOTIFY_STOP_MASK | (NOTIFY_OK - err);
+        if (err)
+                return NOTIFY_STOP_MASK | (NOTIFY_OK - err);
+
+        return NOTIFY_OK;
 }
 
 /* Restore (negative) errno value from notify return value. */
diff --git a/include/linux/of_device.h b/include/linux/of_device.h
index d3a74e00a3e1..11651facc5f1 100644
--- a/include/linux/of_device.h
+++ b/include/linux/of_device.h
@@ -1,6 +1,7 @@
 #ifndef _LINUX_OF_DEVICE_H
 #define _LINUX_OF_DEVICE_H
 
+#ifdef CONFIG_OF_DEVICE
 #include <linux/device.h>
 #include <linux/of.h>
 #include <linux/mod_devicetable.h>
@@ -10,7 +11,7 @@
 #define to_of_device(d) container_of(d, struct of_device, dev)
 
 extern const struct of_device_id *of_match_device(
-        const struct of_device_id *matches, const struct of_device *dev);
+        const struct of_device_id *matches, const struct device *dev);
 
 extern struct of_device *of_dev_get(struct of_device *dev);
 extern void of_dev_put(struct of_device *dev);
@@ -26,5 +27,6 @@ static inline void of_device_free(struct of_device *dev)
 
 extern ssize_t of_device_get_modalias(struct of_device *ofdev,
                                         char *str, ssize_t len);
+#endif /* CONFIG_OF_DEVICE */
 
 #endif /* _LINUX_OF_DEVICE_H */
diff --git a/include/linux/of_fdt.h b/include/linux/of_fdt.h
index a1ca92ccb0ff..71e1a916d3fa 100644
--- a/include/linux/of_fdt.h
+++ b/include/linux/of_fdt.h
@@ -57,6 +57,7 @@ struct boot_param_header {
         __be32  dt_struct_size;         /* size of the DT structure block */
 };
 
+#if defined(CONFIG_OF_FLATTREE)
 /* TBD: Temporary export of fdt globals - remove when code fully merged */
 extern int __initdata dt_root_addr_cells;
 extern int __initdata dt_root_size_cells;
@@ -98,6 +99,9 @@ extern int early_init_dt_scan_root(unsigned long node, const char *uname,
 /* Other Prototypes */
 extern void unflatten_device_tree(void);
 extern void early_init_devtree(void *);
+#else /* CONFIG_OF_FLATTREE */
+static inline void unflatten_device_tree(void) {}
+#endif /* CONFIG_OF_FLATTREE */
 
 #endif /* __ASSEMBLY__ */
 #endif /* _LINUX_OF_FDT_H */
diff --git a/include/linux/of_platform.h b/include/linux/of_platform.h
index 908406651330..1643d3761eb4 100644
--- a/include/linux/of_platform.h
+++ b/include/linux/of_platform.h
@@ -11,6 +11,7 @@
  *
  */
 
+#ifdef CONFIG_OF_DEVICE
 #include <linux/module.h>
 #include <linux/device.h>
 #include <linux/mod_devicetable.h>
@@ -30,10 +31,6 @@ extern struct bus_type of_platform_bus_type;
  */
 struct of_platform_driver
 {
-        const char              *name;
-        const struct of_device_id       *match_table;
-        struct module           *owner;
-
         int     (*probe)(struct of_device* dev,
                          const struct of_device_id *match);
         int     (*remove)(struct of_device* dev);
@@ -66,5 +63,6 @@ static inline void of_unregister_platform_driver(struct of_platform_driver *drv)
 extern struct of_device *of_find_device_by_node(struct device_node *np);
 
 extern int of_bus_type_init(struct bus_type *bus, const char *name);
+#endif /* CONFIG_OF_DEVICE */
 
 #endif  /* _LINUX_OF_PLATFORM_H */
diff --git a/include/linux/page_cgroup.h b/include/linux/page_cgroup.h
index aef22ae2af47..5bb13b3db84d 100644
--- a/include/linux/page_cgroup.h
+++ b/include/linux/page_cgroup.h
@@ -40,6 +40,7 @@ enum {
         PCG_USED, /* this object is in use. */
         PCG_ACCT_LRU, /* page has been accounted for */
         PCG_FILE_MAPPED, /* page is accounted as "mapped" */
+        PCG_MIGRATION, /* under page migration */
 };
 
 #define TESTPCGFLAG(uname, lname)                       \
@@ -79,6 +80,10 @@ SETPCGFLAG(FileMapped, FILE_MAPPED)
 CLEARPCGFLAG(FileMapped, FILE_MAPPED)
 TESTPCGFLAG(FileMapped, FILE_MAPPED)
 
+SETPCGFLAG(Migration, MIGRATION)
+CLEARPCGFLAG(Migration, MIGRATION)
+TESTPCGFLAG(Migration, MIGRATION)
+
 static inline int page_cgroup_nid(struct page_cgroup *pc)
 {
         return page_to_nid(pc->page);
diff --git a/include/linux/pci.h b/include/linux/pci.h
index a327322a33ab..6a471aba3b07 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -311,7 +311,8 @@ struct pci_dev {
         unsigned int    is_virtfn:1;
         unsigned int    reset_fn:1;
         unsigned int    is_hotplug_bridge:1;
-        unsigned int    aer_firmware_first:1;
+        unsigned int    __aer_firmware_first_valid:1;
+        unsigned int    __aer_firmware_first:1;
         pci_dev_flags_t dev_flags;
         atomic_t        enable_cnt;     /* pci_enable_device has been called */
 
diff --git a/include/linux/pda_power.h b/include/linux/pda_power.h
index d4cf7a2ceb3e..c9e4d814ff77 100644
--- a/include/linux/pda_power.h
+++ b/include/linux/pda_power.h
@@ -24,6 +24,8 @@ struct pda_power_pdata {
         int (*is_usb_online)(void);
         void (*set_charge)(int flags);
         void (*exit)(struct device *dev);
+        int (*suspend)(pm_message_t state);
+        int (*resume)(void);
 
         char **supplied_to;
         size_t num_supplicants;
diff --git a/include/linux/perf_event.h b/include/linux/perf_event.h
index 3fd5c82e0e18..fb6c91eac7e3 100644
--- a/include/linux/perf_event.h
+++ b/include/linux/perf_event.h
@@ -485,6 +485,7 @@ struct perf_guest_info_callbacks {
 #include <linux/ftrace.h>
 #include <linux/cpu.h>
 #include <asm/atomic.h>
+#include <asm/local.h>
 
 #define PERF_MAX_STACK_DEPTH            255
 
@@ -587,21 +588,19 @@ struct perf_mmap_data {
         struct rcu_head                 rcu_head;
 #ifdef CONFIG_PERF_USE_VMALLOC
         struct work_struct              work;
+        int                             page_order;     /* allocation order  */
 #endif
-        int                             data_order;
         int                             nr_pages;       /* nr of data pages  */
         int                             writable;       /* are we writable   */
         int                             nr_locked;      /* nr pages mlocked  */
 
         atomic_t                        poll;           /* POLL_ for wakeups */
-        atomic_t                        events;         /* event_id limit       */
 
-        atomic_long_t                   head;           /* write position    */
-        atomic_long_t                   done_head;      /* completed head    */
-
-        atomic_t                        lock;           /* concurrent writes */
-        atomic_t                        wakeup;         /* needs a wakeup    */
-        atomic_t                        lost;           /* nr records lost   */
+        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  */
 
@@ -728,6 +727,7 @@ struct perf_event {
         perf_overflow_handler_t         overflow_handler;
 
 #ifdef CONFIG_EVENT_TRACING
+        struct ftrace_event_call        *tp_event;
         struct event_filter             *filter;
 #endif
 
@@ -803,11 +803,12 @@ struct perf_cpu_context {
 struct perf_output_handle {
         struct perf_event               *event;
         struct perf_mmap_data           *data;
-        unsigned long                   head;
-        unsigned long                   offset;
+        unsigned long                   wakeup;
+        unsigned long                   size;
+        void                            *addr;
+        int                             page;
         int                             nmi;
         int                             sample;
-        int                             locked;
 };
 
 #ifdef CONFIG_PERF_EVENTS
@@ -993,8 +994,9 @@ static inline bool perf_paranoid_kernel(void)
 }
 
 extern void perf_event_init(void);
-extern void perf_tp_event(int event_id, u64 addr, u64 count, void *record,
-                          int entry_size, struct pt_regs *regs);
+extern void perf_tp_event(u64 addr, u64 count, void *record,
+                          int entry_size, struct pt_regs *regs,
+                          struct hlist_head *head);
 extern void perf_bp_event(struct perf_event *event, void *data);
 
 #ifndef perf_misc_flags
diff --git a/include/linux/power_supply.h b/include/linux/power_supply.h
index ebd2b8fb00d0..30083a896f36 100644
--- a/include/linux/power_supply.h
+++ b/include/linux/power_supply.h
@@ -114,6 +114,7 @@ enum power_supply_property {
         POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG,
         POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
         POWER_SUPPLY_PROP_TIME_TO_FULL_AVG,
+        POWER_SUPPLY_PROP_TYPE, /* use power_supply.type instead */
         /* Properties of type `const char *' */
         POWER_SUPPLY_PROP_MODEL_NAME,
         POWER_SUPPLY_PROP_MANUFACTURER,
@@ -144,6 +145,11 @@ struct power_supply {
         int (*get_property)(struct power_supply *psy,
                             enum power_supply_property psp,
                             union power_supply_propval *val);
+        int (*set_property)(struct power_supply *psy,
+                            enum power_supply_property psp,
+                            const union power_supply_propval *val);
+        int (*property_is_writeable)(struct power_supply *psy,
+                                     enum power_supply_property psp);
         void (*external_power_changed)(struct power_supply *psy);
         void (*set_charged)(struct power_supply *psy);
 
diff --git a/include/linux/quota.h b/include/linux/quota.h
index 7126a15467f1..94c1f03b50eb 100644
--- a/include/linux/quota.h
+++ b/include/linux/quota.h
@@ -174,8 +174,7 @@ enum {
 #include <linux/rwsem.h>
 #include <linux/spinlock.h>
 #include <linux/wait.h>
-#include <linux/percpu.h>
-#include <linux/smp.h>
+#include <linux/percpu_counter.h>
 
 #include <linux/dqblk_xfs.h>
 #include <linux/dqblk_v1.h>
@@ -254,6 +253,7 @@ enum {
 
 struct dqstats {
         int stat[_DQST_DQSTAT_LAST];
+        struct percpu_counter counter[_DQST_DQSTAT_LAST];
 };
 
 extern struct dqstats *dqstats_pcpu;
@@ -261,20 +261,12 @@ extern struct dqstats dqstats;
 
 static inline void dqstats_inc(unsigned int type)
 {
-#ifdef CONFIG_SMP
-        per_cpu_ptr(dqstats_pcpu, smp_processor_id())->stat[type]++;
-#else
-        dqstats.stat[type]++;
-#endif
+        percpu_counter_inc(&dqstats.counter[type]);
 }
 
 static inline void dqstats_dec(unsigned int type)
 {
-#ifdef CONFIG_SMP
-        per_cpu_ptr(dqstats_pcpu, smp_processor_id())->stat[type]--;
-#else
-        dqstats.stat[type]--;
-#endif
+        percpu_counter_dec(&dqstats.counter[type]);
 }
 
 #define DQ_MOD_B        0       /* dquot modified since read */
@@ -332,8 +324,8 @@ struct dquot_operations {
 
 /* Operations handling requests from userspace */
 struct quotactl_ops {
-        int (*quota_on)(struct super_block *, int, int, char *, int);
-        int (*quota_off)(struct super_block *, int, int);
+        int (*quota_on)(struct super_block *, int, int, char *);
+        int (*quota_off)(struct super_block *, int);
         int (*quota_sync)(struct super_block *, int, int);
         int (*get_info)(struct super_block *, int, struct if_dqinfo *);
         int (*set_info)(struct super_block *, int, struct if_dqinfo *);
diff --git a/include/linux/quotaops.h b/include/linux/quotaops.h
index 370abb1e99cb..aa36793b48bd 100644
--- a/include/linux/quotaops.h
+++ b/include/linux/quotaops.h
@@ -9,6 +9,10 @@
 
 #include <linux/fs.h>
 
+#define DQUOT_SPACE_WARN        0x1
+#define DQUOT_SPACE_RESERVE     0x2
+#define DQUOT_SPACE_NOFAIL      0x4
+
 static inline struct quota_info *sb_dqopt(struct super_block *sb)
 {
         return &sb->s_dquot;
@@ -41,15 +45,22 @@ int dquot_scan_active(struct super_block *sb,
 struct dquot *dquot_alloc(struct super_block *sb, int type);
 void dquot_destroy(struct dquot *dquot);
 
-int __dquot_alloc_space(struct inode *inode, qsize_t number,
-                int warn, int reserve);
-void __dquot_free_space(struct inode *inode, qsize_t number, int reserve);
+int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags);
+void __dquot_free_space(struct inode *inode, qsize_t number, int flags);
 
 int dquot_alloc_inode(const struct inode *inode);
 
 int dquot_claim_space_nodirty(struct inode *inode, qsize_t number);
 void dquot_free_inode(const struct inode *inode);
 
+int dquot_disable(struct super_block *sb, int type, unsigned int flags);
+/* Suspend quotas on remount RO */
+static inline int dquot_suspend(struct super_block *sb, int type)
+{
+        return dquot_disable(sb, type, DQUOT_SUSPENDED);
+}
+int dquot_resume(struct super_block *sb, int type);
+
 int dquot_commit(struct dquot *dquot);
 int dquot_acquire(struct dquot *dquot);
 int dquot_release(struct dquot *dquot);
@@ -58,27 +69,25 @@ int dquot_mark_dquot_dirty(struct dquot *dquot);
 
 int dquot_file_open(struct inode *inode, struct file *file);
 
-int vfs_quota_on(struct super_block *sb, int type, int format_id,
-        char *path, int remount);
-int vfs_quota_enable(struct inode *inode, int type, int format_id,
+int dquot_quota_on(struct super_block *sb, int type, int format_id,
+        char *path);
+int dquot_enable(struct inode *inode, int type, int format_id,
         unsigned int flags);
-int vfs_quota_on_path(struct super_block *sb, int type, int format_id,
+int dquot_quota_on_path(struct super_block *sb, int type, int format_id,
         struct path *path);
-int vfs_quota_on_mount(struct super_block *sb, char *qf_name,
+int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
         int format_id, int type);
-int vfs_quota_off(struct super_block *sb, int type, int remount);
-int vfs_quota_disable(struct super_block *sb, int type, unsigned int flags);
-int vfs_quota_sync(struct super_block *sb, int type, int wait);
-int vfs_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
-int vfs_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
-int vfs_get_dqblk(struct super_block *sb, int type, qid_t id,
+int dquot_quota_off(struct super_block *sb, int type);
+int dquot_quota_sync(struct super_block *sb, int type, int wait);
+int dquot_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
+int dquot_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
+int dquot_get_dqblk(struct super_block *sb, int type, qid_t id,
                 struct fs_disk_quota *di);
-int vfs_set_dqblk(struct super_block *sb, int type, qid_t id,
+int dquot_set_dqblk(struct super_block *sb, int type, qid_t id,
                 struct fs_disk_quota *di);
 
 int __dquot_transfer(struct inode *inode, struct dquot **transfer_to);
 int dquot_transfer(struct inode *inode, struct iattr *iattr);
-int vfs_dq_quota_on_remount(struct super_block *sb);
 
 static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
 {
@@ -145,20 +154,7 @@ static inline unsigned sb_any_quota_active(struct super_block *sb)
  * Operations supported for diskquotas.
  */
 extern const struct dquot_operations dquot_operations;
-extern const struct quotactl_ops vfs_quotactl_ops;
-
-#define sb_dquot_ops (&dquot_operations)
-#define sb_quotactl_ops (&vfs_quotactl_ops)
-
-/* Cannot be called inside a transaction */
-static inline int vfs_dq_off(struct super_block *sb, int remount)
-{
-        int ret = -ENOSYS;
-
-        if (sb->s_qcop && sb->s_qcop->quota_off)
-                ret = sb->s_qcop->quota_off(sb, -1, remount);
-        return ret;
-}
+extern const struct quotactl_ops dquot_quotactl_ops;
 
 #else
 
@@ -203,12 +199,6 @@ static inline int sb_any_quota_active(struct super_block *sb)
         return 0;
 }
 
-/*
- * NO-OP when quota not configured.
- */
-#define sb_dquot_ops                            (NULL)
-#define sb_quotactl_ops                         (NULL)
-
 static inline void dquot_initialize(struct inode *inode)
 {
 }
@@ -226,39 +216,45 @@ static inline void dquot_free_inode(const struct inode *inode)
 {
 }
 
-static inline int vfs_dq_off(struct super_block *sb, int remount)
+static inline int dquot_transfer(struct inode *inode, struct iattr *iattr)
 {
         return 0;
 }
 
-static inline int vfs_dq_quota_on_remount(struct super_block *sb)
+static inline int __dquot_alloc_space(struct inode *inode, qsize_t number,
+                int flags)
 {
+        if (!(flags & DQUOT_SPACE_RESERVE))
+                inode_add_bytes(inode, number);
         return 0;
 }
 
-static inline int dquot_transfer(struct inode *inode, struct iattr *iattr)
+static inline void __dquot_free_space(struct inode *inode, qsize_t number,
+                int flags)
+{
+        if (!(flags & DQUOT_SPACE_RESERVE))
+                inode_sub_bytes(inode, number);
+}
+
+static inline int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
 {
+        inode_add_bytes(inode, number);
         return 0;
 }
 
-static inline int __dquot_alloc_space(struct inode *inode, qsize_t number,
-                int warn, int reserve)
+static inline int dquot_disable(struct super_block *sb, int type,
+                unsigned int flags)
 {
-        if (!reserve)
-                inode_add_bytes(inode, number);
         return 0;
 }
 
-static inline void __dquot_free_space(struct inode *inode, qsize_t number,
-                int reserve)
+static inline int dquot_suspend(struct super_block *sb, int type)
 {
-        if (!reserve)
-                inode_sub_bytes(inode, number);
+        return 0;
 }
 
-static inline int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
+static inline int dquot_resume(struct super_block *sb, int type)
 {
-        inode_add_bytes(inode, number);
         return 0;
 }
 
@@ -268,7 +264,13 @@ static inline int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
 
 static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr)
 {
-        return __dquot_alloc_space(inode, nr, 1, 0);
+        return __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN);
+}
+
+static inline void dquot_alloc_space_nofail(struct inode *inode, qsize_t nr)
+{
+        __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN|DQUOT_SPACE_NOFAIL);
+        mark_inode_dirty(inode);
 }
 
 static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
@@ -286,6 +288,11 @@ static inline int dquot_alloc_block_nodirty(struct inode *inode, qsize_t nr)
         return dquot_alloc_space_nodirty(inode, nr << inode->i_blkbits);
 }
 
+static inline void dquot_alloc_block_nofail(struct inode *inode, qsize_t nr)
+{
+        dquot_alloc_space_nofail(inode, nr << inode->i_blkbits);
+}
+
 static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
 {
         return dquot_alloc_space(inode, nr << inode->i_blkbits);
@@ -293,7 +300,7 @@ static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
 
 static inline int dquot_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
 {
-        return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0, 0);
+        return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0);
 }
 
 static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr)
@@ -308,7 +315,8 @@ static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr)
 
 static inline int dquot_reserve_block(struct inode *inode, qsize_t nr)
 {
-        return __dquot_alloc_space(inode, nr << inode->i_blkbits, 1, 1);
+        return __dquot_alloc_space(inode, nr << inode->i_blkbits,
+                                DQUOT_SPACE_WARN|DQUOT_SPACE_RESERVE);
 }
 
 static inline int dquot_claim_block(struct inode *inode, qsize_t nr)
@@ -345,7 +353,7 @@ static inline void dquot_free_block(struct inode *inode, qsize_t nr)
 static inline void dquot_release_reservation_block(struct inode *inode,
                 qsize_t nr)
 {
-        __dquot_free_space(inode, nr << inode->i_blkbits, 1);
+        __dquot_free_space(inode, nr << inode->i_blkbits, DQUOT_SPACE_RESERVE);
 }
 
 #endif /* _LINUX_QUOTAOPS_ */
diff --git a/include/linux/random.h b/include/linux/random.h
index 25d02fe5c9b5..fb7ab9de5f36 100644
--- a/include/linux/random.h
+++ b/include/linux/random.h
@@ -40,6 +40,10 @@ struct rand_pool_info {
         __u32   buf[0];
 };
 
+struct rnd_state {
+        __u32 s1, s2, s3;
+};
+
 /* Exported functions */
 
 #ifdef __KERNEL__
@@ -74,6 +78,30 @@ unsigned long randomize_range(unsigned long start, unsigned long end, unsigned l
 u32 random32(void);
 void srandom32(u32 seed);
 
+u32 prandom32(struct rnd_state *);
+
+/*
+ * Handle minimum values for seeds
+ */
+static inline u32 __seed(u32 x, u32 m)
+{
+        return (x < m) ? x + m : x;
+}
+
+/**
+ * prandom32_seed - set seed for prandom32().
+ * @state: pointer to state structure to receive the seed.
+ * @seed: arbitrary 64-bit value to use as a seed.
+ */
+static inline void prandom32_seed(struct rnd_state *state, u64 seed)
+{
+        u32 i = (seed >> 32) ^ (seed << 10) ^ seed;
+
+        state->s1 = __seed(i, 1);
+        state->s2 = __seed(i, 7);
+        state->s3 = __seed(i, 15);
+}
+
 #endif /* __KERNEL___ */
 
 #endif /* _LINUX_RANDOM_H */
diff --git a/include/linux/ratelimit.h b/include/linux/ratelimit.h
index 668cf1bef030..8f69d09a41a5 100644
--- a/include/linux/ratelimit.h
+++ b/include/linux/ratelimit.h
@@ -2,7 +2,7 @@
 #define _LINUX_RATELIMIT_H
 
 #include <linux/param.h>
-#include <linux/spinlock_types.h>
+#include <linux/spinlock.h>
 
 #define DEFAULT_RATELIMIT_INTERVAL      (5 * HZ)
 #define DEFAULT_RATELIMIT_BURST         10
@@ -25,6 +25,17 @@ struct ratelimit_state {
                 .burst          = burst_init,                           \
         }
 
+static inline void ratelimit_state_init(struct ratelimit_state *rs,
+                                        int interval, int burst)
+{
+        spin_lock_init(&rs->lock);
+        rs->interval = interval;
+        rs->burst = burst;
+        rs->printed = 0;
+        rs->missed = 0;
+        rs->begin = 0;
+}
+
 extern int ___ratelimit(struct ratelimit_state *rs, const char *func);
 #define __ratelimit(state) ___ratelimit(state, __func__)
 
diff --git a/include/linux/regulator/machine.h b/include/linux/regulator/machine.h
index 234a8476cba8..e2980287245e 100644
--- a/include/linux/regulator/machine.h
+++ b/include/linux/regulator/machine.h
@@ -157,7 +157,11 @@ struct regulator_consumer_supply {
  *
  * Initialisation constraints, our supply and consumers supplies.
  *
- * @supply_regulator_dev: Parent regulator (if any).
+ * @supply_regulator: Parent regulator.  Specified using the regulator name
+ *                    as it appears in the name field in sysfs, which can
+ *                    be explicitly set using the constraints field 'name'.
+ * @supply_regulator_dev: Parent regulator (if any) - DEPRECATED in favour
+ *                        of supply_regulator.
  *
  * @constraints: Constraints.  These must be specified for the regulator to
  *               be usable.
@@ -168,7 +172,8 @@ struct regulator_consumer_supply {
  * @driver_data: Data passed to regulator_init.
  */
 struct regulator_init_data {
-        struct device *supply_regulator_dev; /* or NULL for LINE */
+        const char *supply_regulator;        /* or NULL for system supply */
+        struct device *supply_regulator_dev; /* or NULL for system supply */
 
         struct regulation_constraints constraints;
 
diff --git a/include/linux/rio.h b/include/linux/rio.h
index dc0c75556c63..bd6eb0ed34a7 100644
--- a/include/linux/rio.h
+++ b/include/linux/rio.h
@@ -64,10 +64,13 @@
 #define RIO_INB_MBOX_RESOURCE   1
 #define RIO_OUTB_MBOX_RESOURCE  2
 
+#define RIO_PW_MSG_SIZE         64
+
 extern struct bus_type rio_bus_type;
 extern struct list_head rio_devices;    /* list of all devices */
 
 struct rio_mport;
+union rio_pw_msg;
 
 /**
  * struct rio_dev - RIO device info
@@ -85,11 +88,15 @@ struct rio_mport;
  * @swpinfo: Switch port info
  * @src_ops: Source operation capabilities
  * @dst_ops: Destination operation capabilities
+ * @comp_tag: RIO component tag
+ * @phys_efptr: RIO device extended features pointer
+ * @em_efptr: RIO Error Management features pointer
  * @dma_mask: Mask of bits of RIO address this device implements
  * @rswitch: Pointer to &struct rio_switch if valid for this device
  * @driver: Driver claiming this device
  * @dev: Device model device
  * @riores: RIO resources this device owns
+ * @pwcback: port-write callback function for this device
  * @destid: Network destination ID
  */
 struct rio_dev {
@@ -107,11 +114,15 @@ struct rio_dev {
         u32 swpinfo;            /* Only used for switches */
         u32 src_ops;
         u32 dst_ops;
+        u32 comp_tag;
+        u32 phys_efptr;
+        u32 em_efptr;
         u64 dma_mask;
         struct rio_switch *rswitch;     /* RIO switch info */
         struct rio_driver *driver;      /* RIO driver claiming this device */
         struct device dev;      /* LDM device structure */
         struct resource riores[RIO_MAX_DEV_RESOURCES];
+        int (*pwcback) (struct rio_dev *rdev, union rio_pw_msg *msg, int step);
         u16 destid;
 };
 
@@ -211,8 +222,14 @@ struct rio_net {
  * @hopcount: Hopcount to this switch
  * @destid: Associated destid in the path
  * @route_table: Copy of switch routing table
+ * @port_ok: Status of each port (one bit per port) - OK=1 or UNINIT=0
  * @add_entry: Callback for switch-specific route add function
  * @get_entry: Callback for switch-specific route get function
+ * @clr_table: Callback for switch-specific clear route table function
+ * @set_domain: Callback for switch-specific domain setting function
+ * @get_domain: Callback for switch-specific domain get function
+ * @em_init: Callback for switch-specific error management initialization function
+ * @em_handle: Callback for switch-specific error management handler function
  */
 struct rio_switch {
         struct list_head node;
@@ -220,10 +237,19 @@ struct rio_switch {
         u16 hopcount;
         u16 destid;
         u8 *route_table;
+        u32 port_ok;
         int (*add_entry) (struct rio_mport * mport, u16 destid, u8 hopcount,
                           u16 table, u16 route_destid, u8 route_port);
         int (*get_entry) (struct rio_mport * mport, u16 destid, u8 hopcount,
                           u16 table, u16 route_destid, u8 * route_port);
+        int (*clr_table) (struct rio_mport *mport, u16 destid, u8 hopcount,
+                          u16 table);
+        int (*set_domain) (struct rio_mport *mport, u16 destid, u8 hopcount,
+                           u8 sw_domain);
+        int (*get_domain) (struct rio_mport *mport, u16 destid, u8 hopcount,
+                           u8 *sw_domain);
+        int (*em_init) (struct rio_dev *dev);
+        int (*em_handle) (struct rio_dev *dev, u8 swport);
 };
 
 /* Low-level architecture-dependent routines */
@@ -235,6 +261,7 @@ struct rio_switch {
  * @cread: Callback to perform network read of config space.
  * @cwrite: Callback to perform network write of config space.
  * @dsend: Callback to send a doorbell message.
+ * @pwenable: Callback to enable/disable port-write message handling.
  */
 struct rio_ops {
         int (*lcread) (struct rio_mport *mport, int index, u32 offset, int len,
@@ -246,6 +273,7 @@ struct rio_ops {
         int (*cwrite) (struct rio_mport *mport, int index, u16 destid,
                         u8 hopcount, u32 offset, int len, u32 data);
         int (*dsend) (struct rio_mport *mport, int index, u16 destid, u16 data);
+        int (*pwenable) (struct rio_mport *mport, int enable);
 };
 
 #define RIO_RESOURCE_MEM        0x00000100
@@ -302,21 +330,28 @@ struct rio_device_id {
 };
 
 /**
- * struct rio_route_ops - Per-switch route operations
+ * struct rio_switch_ops - Per-switch operations
  * @vid: RIO vendor ID
  * @did: RIO device ID
- * @add_hook: Callback that adds a route entry
- * @get_hook: Callback that gets a route entry
+ * @init_hook: Callback that performs switch device initialization
  *
- * Defines the operations that are necessary to manipulate the route
- * tables for a particular RIO switch device.
+ * Defines the operations that are necessary to initialize/control
+ * a particular RIO switch device.
  */
-struct rio_route_ops {
+struct rio_switch_ops {
         u16 vid, did;
-        int (*add_hook) (struct rio_mport * mport, u16 destid, u8 hopcount,
-                         u16 table, u16 route_destid, u8 route_port);
-        int (*get_hook) (struct rio_mport * mport, u16 destid, u8 hopcount,
-                         u16 table, u16 route_destid, u8 * route_port);
+        int (*init_hook) (struct rio_dev *rdev, int do_enum);
+};
+
+union rio_pw_msg {
+        struct {
+                u32 comptag;    /* Component Tag CSR */
+                u32 errdetect;  /* Port N Error Detect CSR */
+                u32 is_port;    /* Implementation specific + PortID */
+                u32 ltlerrdet;  /* LTL Error Detect CSR */
+                u32 padding[12];
+        } em;
+        u32 raw[RIO_PW_MSG_SIZE/sizeof(u32)];
 };
 
 /* Architecture and hardware-specific functions */
diff --git a/include/linux/rio_drv.h b/include/linux/rio_drv.h
index c93a58a40033..edc55da717b3 100644
--- a/include/linux/rio_drv.h
+++ b/include/linux/rio_drv.h
@@ -413,6 +413,12 @@ void rio_release_regions(struct rio_dev *);
 int rio_request_region(struct rio_dev *, int, char *);
 void rio_release_region(struct rio_dev *, int);
 
+/* Port-Write management */
+extern int rio_request_inb_pwrite(struct rio_dev *,
+                        int (*)(struct rio_dev *, union rio_pw_msg*, int));
+extern int rio_release_inb_pwrite(struct rio_dev *);
+extern int rio_inb_pwrite_handler(union rio_pw_msg *pw_msg);
+
 /* LDM support */
 int rio_register_driver(struct rio_driver *);
 void rio_unregister_driver(struct rio_driver *);
diff --git a/include/linux/rio_ids.h b/include/linux/rio_ids.h
index 919d4e07d54e..db50e1c288b7 100644
--- a/include/linux/rio_ids.h
+++ b/include/linux/rio_ids.h
@@ -20,5 +20,19 @@
 
 #define RIO_VID_TUNDRA                  0x000d
 #define RIO_DID_TSI500                  0x0500
+#define RIO_DID_TSI568                  0x0568
+#define RIO_DID_TSI572                  0x0572
+#define RIO_DID_TSI574                  0x0574
+#define RIO_DID_TSI576                  0x0578 /* Same ID as Tsi578 */
+#define RIO_DID_TSI577                  0x0577
+#define RIO_DID_TSI578                  0x0578
+
+#define RIO_VID_IDT                     0x0038
+#define RIO_DID_IDT70K200               0x0310
+#define RIO_DID_IDTCPS8                 0x035c
+#define RIO_DID_IDTCPS12                0x035d
+#define RIO_DID_IDTCPS16                0x035b
+#define RIO_DID_IDTCPS6Q                0x035f
+#define RIO_DID_IDTCPS10Q               0x035e
 
 #endif                          /* LINUX_RIO_IDS_H */
diff --git a/include/linux/rio_regs.h b/include/linux/rio_regs.h
index 326540f9b54e..aedee0489fb4 100644
--- a/include/linux/rio_regs.h
+++ b/include/linux/rio_regs.h
@@ -39,6 +39,8 @@
 #define  RIO_PEF_INB_MBOX2              0x00200000      /* [II] Mailbox 2 */
 #define  RIO_PEF_INB_MBOX3              0x00100000      /* [II] Mailbox 3 */
 #define  RIO_PEF_INB_DOORBELL           0x00080000      /* [II] Doorbells */
+#define  RIO_PEF_EXT_RT                 0x00000200      /* [III, 1.3] Extended route table support */
+#define  RIO_PEF_STD_RT                 0x00000100      /* [III, 1.3] Standard route table support */
 #define  RIO_PEF_CTLS                   0x00000010      /* [III] CTLS */
 #define  RIO_PEF_EXT_FEATURES           0x00000008      /* [I] EFT_PTR valid */
 #define  RIO_PEF_ADDR_66                0x00000004      /* [I] 66 bits */
@@ -91,7 +93,10 @@
 #define  RIO_OPS_ATOMIC_CLR             0x00000010      /* [I] Atomic clr op */
 #define  RIO_OPS_PORT_WRITE             0x00000004      /* [I] Port-write op */
 
-                                        /* 0x20-0x3c *//* Reserved */
+                                        /* 0x20-0x30 *//* Reserved */
+
+#define RIO_SWITCH_RT_LIMIT     0x34    /* [III, 1.3] Switch Route Table Destination ID Limit CAR */
+#define  RIO_RT_MAX_DESTID              0x0000ffff
 
 #define RIO_MBOX_CSR            0x40    /* [II] Mailbox CSR */
 #define  RIO_MBOX0_AVAIL                0x80000000      /* [II] Mbox 0 avail */
@@ -153,7 +158,11 @@
 #define RIO_HOST_DID_LOCK_CSR   0x68    /* [III] Host Base Device ID Lock CSR */
 #define RIO_COMPONENT_TAG_CSR   0x6c    /* [III] Component Tag CSR */
 
-                                        /* 0x70-0xf8 *//* Reserved */
+#define RIO_STD_RTE_CONF_DESTID_SEL_CSR 0x70
+#define RIO_STD_RTE_CONF_PORT_SEL_CSR   0x74
+#define RIO_STD_RTE_DEFAULT_PORT        0x78
+
+                                        /* 0x7c-0xf8 *//* Reserved */
                                         /* 0x100-0xfff8 *//* [I] Extended Features Space */
                                         /* 0x10000-0xfffff8 *//* [I] Implementation-defined Space */
 
@@ -183,9 +192,14 @@
 #define RIO_EFB_PAR_EP_ID       0x0001  /* [IV] LP/LVDS EP Devices */
 #define RIO_EFB_PAR_EP_REC_ID   0x0002  /* [IV] LP/LVDS EP Recovery Devices */
 #define RIO_EFB_PAR_EP_FREE_ID  0x0003  /* [IV] LP/LVDS EP Free Devices */
+#define RIO_EFB_SER_EP_ID_V13P  0x0001  /* [VI] LP/Serial EP Devices, RapidIO Spec ver 1.3 and above */
+#define RIO_EFB_SER_EP_REC_ID_V13P      0x0002  /* [VI] LP/Serial EP Recovery Devices, RapidIO Spec ver 1.3 and above */
+#define RIO_EFB_SER_EP_FREE_ID_V13P     0x0003  /* [VI] LP/Serial EP Free Devices, RapidIO Spec ver 1.3 and above */
 #define RIO_EFB_SER_EP_ID       0x0004  /* [VI] LP/Serial EP Devices */
 #define RIO_EFB_SER_EP_REC_ID   0x0005  /* [VI] LP/Serial EP Recovery Devices */
 #define RIO_EFB_SER_EP_FREE_ID  0x0006  /* [VI] LP/Serial EP Free Devices */
+#define RIO_EFB_SER_EP_FREC_ID  0x0009  /* [VI] LP/Serial EP Free Recovery Devices */
+#define RIO_EFB_ERR_MGMNT       0x0007  /* [VIII] Error Management Extensions */
 
 /*
  * Physical 8/16 LP-LVDS
@@ -201,15 +215,71 @@
 #define RIO_PORT_MNT_HEADER             0x0000
 #define RIO_PORT_REQ_CTL_CSR            0x0020
 #define RIO_PORT_RSP_CTL_CSR            0x0024  /* 0x0001/0x0002 */
+#define RIO_PORT_LINKTO_CTL_CSR         0x0020  /* Serial */
+#define RIO_PORT_RSPTO_CTL_CSR          0x0024  /* Serial */
 #define RIO_PORT_GEN_CTL_CSR            0x003c
 #define  RIO_PORT_GEN_HOST              0x80000000
 #define  RIO_PORT_GEN_MASTER            0x40000000
 #define  RIO_PORT_GEN_DISCOVERED        0x20000000
 #define RIO_PORT_N_MNT_REQ_CSR(x)       (0x0040 + x*0x20)       /* 0x0002 */
 #define RIO_PORT_N_MNT_RSP_CSR(x)       (0x0044 + x*0x20)       /* 0x0002 */
+#define  RIO_PORT_N_MNT_RSP_RVAL        0x80000000 /* Response Valid */
+#define  RIO_PORT_N_MNT_RSP_ASTAT       0x000003e0 /* ackID Status */
+#define  RIO_PORT_N_MNT_RSP_LSTAT       0x0000001f /* Link Status */
 #define RIO_PORT_N_ACK_STS_CSR(x)       (0x0048 + x*0x20)       /* 0x0002 */
-#define RIO_PORT_N_ERR_STS_CSR(x)       (0x58 + x*0x20)
-#define PORT_N_ERR_STS_PORT_OK  0x00000002
-#define RIO_PORT_N_CTL_CSR(x)           (0x5c + x*0x20)
+#define  RIO_PORT_N_ACK_CLEAR           0x80000000
+#define  RIO_PORT_N_ACK_INBOUND         0x1f000000
+#define  RIO_PORT_N_ACK_OUTSTAND        0x00001f00
+#define  RIO_PORT_N_ACK_OUTBOUND        0x0000001f
+#define RIO_PORT_N_ERR_STS_CSR(x)       (0x0058 + x*0x20)
+#define  RIO_PORT_N_ERR_STS_PW_OUT_ES   0x00010000 /* Output Error-stopped */
+#define  RIO_PORT_N_ERR_STS_PW_INP_ES   0x00000100 /* Input Error-stopped */
+#define  RIO_PORT_N_ERR_STS_PW_PEND     0x00000010 /* Port-Write Pending */
+#define  RIO_PORT_N_ERR_STS_PORT_ERR    0x00000004
+#define  RIO_PORT_N_ERR_STS_PORT_OK     0x00000002
+#define  RIO_PORT_N_ERR_STS_PORT_UNINIT 0x00000001
+#define  RIO_PORT_N_ERR_STS_CLR_MASK    0x07120204
+#define RIO_PORT_N_CTL_CSR(x)           (0x005c + x*0x20)
+#define  RIO_PORT_N_CTL_PWIDTH          0xc0000000
+#define  RIO_PORT_N_CTL_PWIDTH_1        0x00000000
+#define  RIO_PORT_N_CTL_PWIDTH_4        0x40000000
+#define  RIO_PORT_N_CTL_P_TYP_SER       0x00000001
+#define  RIO_PORT_N_CTL_LOCKOUT         0x00000002
+#define  RIO_PORT_N_CTL_EN_RX_SER       0x00200000
+#define  RIO_PORT_N_CTL_EN_TX_SER       0x00400000
+#define  RIO_PORT_N_CTL_EN_RX_PAR       0x08000000
+#define  RIO_PORT_N_CTL_EN_TX_PAR       0x40000000
+
+/*
+ * Error Management Extensions (RapidIO 1.3+, Part 8)
+ *
+ * Extended Features Block ID=0x0007
+ */
+
+/* General EM Registers (Common for all Ports) */
+
+#define RIO_EM_EFB_HEADER       0x000   /* Error Management Extensions Block Header */
+#define RIO_EM_LTL_ERR_DETECT   0x008   /* Logical/Transport Layer Error Detect CSR */
+#define RIO_EM_LTL_ERR_EN       0x00c   /* Logical/Transport Layer Error Enable CSR */
+#define RIO_EM_LTL_HIADDR_CAP   0x010   /* Logical/Transport Layer High Address Capture CSR */
+#define RIO_EM_LTL_ADDR_CAP     0x014   /* Logical/Transport Layer Address Capture CSR */
+#define RIO_EM_LTL_DEVID_CAP    0x018   /* Logical/Transport Layer Device ID Capture CSR */
+#define RIO_EM_LTL_CTRL_CAP     0x01c   /* Logical/Transport Layer Control Capture CSR */
+#define RIO_EM_PW_TGT_DEVID     0x028   /* Port-write Target deviceID CSR */
+#define RIO_EM_PKT_TTL          0x02c   /* Packet Time-to-live CSR */
+
+/* Per-Port EM Registers */
+
+#define RIO_EM_PN_ERR_DETECT(x) (0x040 + x*0x40) /* Port N Error Detect CSR */
+#define  REM_PED_IMPL_SPEC              0x80000000
+#define  REM_PED_LINK_TO                0x00000001
+#define RIO_EM_PN_ERRRATE_EN(x) (0x044 + x*0x40) /* Port N Error Rate Enable CSR */
+#define RIO_EM_PN_ATTRIB_CAP(x) (0x048 + x*0x40) /* Port N Attributes Capture CSR */
+#define RIO_EM_PN_PKT_CAP_0(x)  (0x04c + x*0x40) /* Port N Packet/Control Symbol Capture 0 CSR */
+#define RIO_EM_PN_PKT_CAP_1(x)  (0x050 + x*0x40) /* Port N Packet Capture 1 CSR */
+#define RIO_EM_PN_PKT_CAP_2(x)  (0x054 + x*0x40) /* Port N Packet Capture 2 CSR */
+#define RIO_EM_PN_PKT_CAP_3(x)  (0x058 + x*0x40) /* Port N Packet Capture 3 CSR */
+#define RIO_EM_PN_ERRRATE(x)    (0x068 + x*0x40) /* Port N Error Rate CSR */
+#define RIO_EM_PN_ERRRATE_TR(x) (0x06c + x*0x40) /* Port N Error Rate Threshold CSR */
 
 #endif                          /* LINUX_RIO_REGS_H */
diff --git a/include/linux/rmap.h b/include/linux/rmap.h
index d25bd224d370..77216742c178 100644
--- a/include/linux/rmap.h
+++ b/include/linux/rmap.h
@@ -26,8 +26,17 @@
  */
 struct anon_vma {
         spinlock_t lock;        /* Serialize access to vma list */
-#ifdef CONFIG_KSM
-        atomic_t ksm_refcount;
+#if defined(CONFIG_KSM) || defined(CONFIG_MIGRATION)
+
+        /*
+         * The external_refcount is taken by either KSM or page migration
+         * to take a reference to an anon_vma when there is no
+         * guarantee that the vma of page tables will exist for
+         * the duration of the operation. A caller that takes
+         * the reference is responsible for clearing up the
+         * anon_vma if they are the last user on release
+         */
+        atomic_t external_refcount;
 #endif
         /*
          * NOTE: the LSB of the head.next is set by
@@ -61,22 +70,22 @@ struct anon_vma_chain {
 };
 
 #ifdef CONFIG_MMU
-#ifdef CONFIG_KSM
-static inline void ksm_refcount_init(struct anon_vma *anon_vma)
+#if defined(CONFIG_KSM) || defined(CONFIG_MIGRATION)
+static inline void anonvma_external_refcount_init(struct anon_vma *anon_vma)
 {
-        atomic_set(&anon_vma->ksm_refcount, 0);
+        atomic_set(&anon_vma->external_refcount, 0);
 }
 
-static inline int ksm_refcount(struct anon_vma *anon_vma)
+static inline int anonvma_external_refcount(struct anon_vma *anon_vma)
 {
-        return atomic_read(&anon_vma->ksm_refcount);
+        return atomic_read(&anon_vma->external_refcount);
 }
 #else
-static inline void ksm_refcount_init(struct anon_vma *anon_vma)
+static inline void anonvma_external_refcount_init(struct anon_vma *anon_vma)
 {
 }
 
-static inline int ksm_refcount(struct anon_vma *anon_vma)
+static inline int anonvma_external_refcount(struct anon_vma *anon_vma)
 {
         return 0;
 }
diff --git a/include/linux/sched.h b/include/linux/sched.h
index b55e988988b5..f118809c953f 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -268,7 +268,6 @@ extern void init_idle(struct task_struct *idle, int cpu);
 extern void init_idle_bootup_task(struct task_struct *idle);
 
 extern int runqueue_is_locked(int cpu);
-extern void task_rq_unlock_wait(struct task_struct *p);
 
 extern cpumask_var_t nohz_cpu_mask;
 #if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ)
@@ -384,7 +383,7 @@ struct user_namespace;
  * 1-3 now and depends on arch. We use "5" as safe margin, here.
  */
 #define MAPCOUNT_ELF_CORE_MARGIN        (5)
-#define DEFAULT_MAX_MAP_COUNT   (USHORT_MAX - MAPCOUNT_ELF_CORE_MARGIN)
+#define DEFAULT_MAX_MAP_COUNT   (USHRT_MAX - MAPCOUNT_ELF_CORE_MARGIN)
 
 extern int sysctl_max_map_count;
 
@@ -527,8 +526,9 @@ struct thread_group_cputimer {
  * the locking of signal_struct.
  */
 struct signal_struct {
-        atomic_t                count;
+        atomic_t                sigcnt;
         atomic_t                live;
+        int                     nr_threads;
 
         wait_queue_head_t       wait_chldexit;  /* for wait4() */
 
@@ -1421,7 +1421,9 @@ struct task_struct {
 #endif
 #ifdef CONFIG_CPUSETS
         nodemask_t mems_allowed;        /* Protected by alloc_lock */
+        int mems_allowed_change_disable;
         int cpuset_mem_spread_rotor;
+        int cpuset_slab_spread_rotor;
 #endif
 #ifdef CONFIG_CGROUPS
         /* Control Group info protected by css_set_lock */
@@ -2034,7 +2036,7 @@ extern int 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);
-extern void zap_other_threads(struct task_struct *p);
+extern int zap_other_threads(struct task_struct *p);
 extern struct sigqueue *sigqueue_alloc(void);
 extern void sigqueue_free(struct sigqueue *);
 extern int send_sigqueue(struct sigqueue *,  struct task_struct *, int group);
@@ -2099,7 +2101,6 @@ extern void flush_thread(void);
 extern void exit_thread(void);
 
 extern void exit_files(struct task_struct *);
-extern void __cleanup_signal(struct signal_struct *);
 extern void __cleanup_sighand(struct sighand_struct *);
 
 extern void exit_itimers(struct signal_struct *);
@@ -2146,6 +2147,11 @@ extern bool current_is_single_threaded(void);
 #define while_each_thread(g, t) \
         while ((t = next_thread(t)) != g)
 
+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)
 
@@ -2392,10 +2398,6 @@ static inline void thread_group_cputime_init(struct signal_struct *sig)
         spin_lock_init(&sig->cputimer.lock);
 }
 
-static inline void thread_group_cputime_free(struct signal_struct *sig)
-{
-}
-
 /*
  * Reevaluate whether the task has signals pending delivery.
  * Wake the task if so.
diff --git a/include/linux/sdhci-pltfm.h b/include/linux/sdhci-pltfm.h
new file mode 100644
index 000000000000..0239bd70241e
--- /dev/null
+++ b/include/linux/sdhci-pltfm.h
@@ -0,0 +1,35 @@
+/*
+ * 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);
+        void (*exit)(struct sdhci_host *host);
+};
+
+#endif /* _SDHCI_PLTFM_H */
diff --git a/include/linux/sem.h b/include/linux/sem.h
index 8a4adbef8a0f..f2961afa2f66 100644
--- a/include/linux/sem.h
+++ b/include/linux/sem.h
@@ -79,6 +79,7 @@ struct  seminfo {
 #ifdef __KERNEL__
 #include <asm/atomic.h>
 #include <linux/rcupdate.h>
+#include <linux/cache.h>
 
 struct task_struct;
 
@@ -91,7 +92,8 @@ struct sem {
 
 /* One sem_array data structure for each set of semaphores in the system. */
 struct sem_array {
-        struct kern_ipc_perm    sem_perm;       /* permissions .. see ipc.h */
+        struct kern_ipc_perm    ____cacheline_aligned_in_smp
+                                sem_perm;       /* permissions .. see ipc.h */
         time_t                  sem_otime;      /* last semop time */
         time_t                  sem_ctime;      /* last change time */
         struct sem              *sem_base;      /* ptr to first semaphore in array */
diff --git a/include/linux/sfi.h b/include/linux/sfi.h
index 9a6f7607174e..0299b4ce63db 100644
--- a/include/linux/sfi.h
+++ b/include/linux/sfi.h
@@ -73,6 +73,8 @@
 #define SFI_SIG_SPIB            "SPIB"
 #define SFI_SIG_I2CB            "I2CB"
 #define SFI_SIG_GPEM            "GPEM"
+#define SFI_SIG_DEVS            "DEVS"
+#define SFI_SIG_GPIO            "GPIO"
 
 #define SFI_SIGNATURE_SIZE      4
 #define SFI_OEM_ID_SIZE         6
@@ -145,6 +147,27 @@ struct sfi_rtc_table_entry {
         u32     irq;
 } __packed;
 
+struct sfi_device_table_entry {
+        u8      type;           /* bus type, I2C, SPI or ...*/
+#define SFI_DEV_TYPE_SPI        0
+#define SFI_DEV_TYPE_I2C        1
+#define SFI_DEV_TYPE_UART       2
+#define SFI_DEV_TYPE_HSI        3
+#define SFI_DEV_TYPE_IPC        4
+
+        u8      host_num;       /* attached to host 0, 1...*/
+        u16     addr;
+        u8      irq;
+        u32     max_freq;
+        char    name[16];
+} __packed;
+
+struct sfi_gpio_table_entry {
+        char    controller_name[16];
+        u16     pin_no;
+        char    pin_name[16];
+} __packed;
+
 struct sfi_spi_table_entry {
         u16     host_num;       /* attached to host 0, 1...*/
         u16     cs;             /* chip select */
@@ -166,7 +189,6 @@ struct sfi_gpe_table_entry {
         u16     phys_id;        /* physical GPE id */
 } __packed;
 
-
 typedef int (*sfi_table_handler) (struct sfi_table_header *table);
 
 #ifdef CONFIG_SFI
diff --git a/include/linux/slab_def.h b/include/linux/slab_def.h
index ca6b2b317991..1812dac8c496 100644
--- a/include/linux/slab_def.h
+++ b/include/linux/slab_def.h
@@ -16,6 +16,30 @@
 #include <linux/compiler.h>
 #include <linux/kmemtrace.h>
 
+#ifndef ARCH_KMALLOC_MINALIGN
+/*
+ * 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.
+ */
+#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
  *
diff --git a/include/linux/slob_def.h b/include/linux/slob_def.h
index 0ec00b39d006..62667f72c2ef 100644
--- a/include/linux/slob_def.h
+++ b/include/linux/slob_def.h
@@ -1,6 +1,14 @@
 #ifndef __LINUX_SLOB_DEF_H
 #define __LINUX_SLOB_DEF_H
 
+#ifndef ARCH_KMALLOC_MINALIGN
+#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 0249d4175bac..4ba59cfc1f75 100644
--- a/include/linux/slub_def.h
+++ b/include/linux/slub_def.h
@@ -75,12 +75,6 @@ struct kmem_cache {
         int offset;             /* Free pointer offset. */
         struct kmem_cache_order_objects oo;
 
-        /*
-         * Avoid an extra cache line for UP, SMP and for the node local to
-         * struct kmem_cache.
-         */
-        struct kmem_cache_node local_node;
-
         /* Allocation and freeing of slabs */
         struct kmem_cache_order_objects max;
         struct kmem_cache_order_objects min;
@@ -102,6 +96,9 @@ struct kmem_cache {
          */
         int remote_node_defrag_ratio;
         struct kmem_cache_node *node[MAX_NUMNODES];
+#else
+        /* Avoid an extra cache line for UP */
+        struct kmem_cache_node local_node;
 #endif
 };
 
@@ -116,6 +113,14 @@ struct kmem_cache {
 
 #define KMALLOC_SHIFT_LOW ilog2(KMALLOC_MIN_SIZE)
 
+#ifndef ARCH_KMALLOC_MINALIGN
+#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"
@@ -132,7 +137,7 @@ struct kmem_cache {
 #ifdef CONFIG_ZONE_DMA
 #define SLUB_DMA __GFP_DMA
 /* Reserve extra caches for potential DMA use */
-#define KMALLOC_CACHES (2 * SLUB_PAGE_SHIFT - 6)
+#define KMALLOC_CACHES (2 * SLUB_PAGE_SHIFT)
 #else
 /* Disable DMA functionality */
 #define SLUB_DMA (__force gfp_t)0
diff --git a/include/linux/spi/spi_bitbang.h b/include/linux/spi/spi_bitbang.h
index 3274c507b8a9..f987a2bee16a 100644
--- a/include/linux/spi/spi_bitbang.h
+++ b/include/linux/spi/spi_bitbang.h
@@ -1,24 +1,6 @@
 #ifndef __SPI_BITBANG_H
 #define __SPI_BITBANG_H
 
-/*
- * Mix this utility code with some glue code to get one of several types of
- * simple SPI master driver.  Two do polled word-at-a-time I/O:
- *
- *   -  GPIO/parport bitbangers.  Provide chipselect() and txrx_word[](),
- *      expanding the per-word routines from the inline templates below.
- *
- *   -  Drivers for controllers resembling bare shift registers.  Provide
- *      chipselect() and txrx_word[](), with custom setup()/cleanup() methods
- *      that use your controller's clock and chipselect registers.
- *
- * Some hardware works well with requests at spi_transfer scope:
- *
- *   -  Drivers leveraging smarter hardware, with fifos or DMA; or for half
- *      duplex (MicroWire) controllers.  Provide chipselect() and txrx_bufs(),
- *      and custom setup()/cleanup() methods.
- */
-
 #include <linux/workqueue.h>
 
 struct spi_bitbang {
@@ -68,86 +50,3 @@ extern int spi_bitbang_start(struct spi_bitbang *spi);
 extern int spi_bitbang_stop(struct spi_bitbang *spi);
 
 #endif  /* __SPI_BITBANG_H */
-
-/*-------------------------------------------------------------------------*/
-
-#ifdef  EXPAND_BITBANG_TXRX
-
-/*
- * The code that knows what GPIO pins do what should have declared four
- * functions, ideally as inlines, before #defining EXPAND_BITBANG_TXRX
- * and including this header:
- *
- *  void setsck(struct spi_device *, int is_on);
- *  void setmosi(struct spi_device *, int is_on);
- *  int getmiso(struct spi_device *);
- *  void spidelay(unsigned);
- *
- * setsck()'s is_on parameter is a zero/nonzero boolean.
- *
- * setmosi()'s is_on parameter is a zero/nonzero boolean.
- *
- * getmiso() is required to return 0 or 1 only. Any other value is invalid
- * and will result in improper operation.
- *
- * A non-inlined routine would call bitbang_txrx_*() routines.  The
- * main loop could easily compile down to a handful of instructions,
- * especially if the delay is a NOP (to run at peak speed).
- *
- * Since this is software, the timings may not be exactly what your board's
- * chips need ... there may be several reasons you'd need to tweak timings
- * in these routines, not just make to make it faster or slower to match a
- * particular CPU clock rate.
- */
-
-static inline u32
-bitbang_txrx_be_cpha0(struct spi_device *spi,
-                unsigned nsecs, unsigned cpol,
-                u32 word, u8 bits)
-{
-        /* if (cpol == 0) this is SPI_MODE_0; else this is SPI_MODE_2 */
-
-        /* clock starts at inactive polarity */
-        for (word <<= (32 - bits); likely(bits); bits--) {
-
-                /* setup MSB (to slave) on trailing edge */
-                setmosi(spi, word & (1 << 31));
-                spidelay(nsecs);        /* T(setup) */
-
-                setsck(spi, !cpol);
-                spidelay(nsecs);
-
-                /* sample MSB (from slave) on leading edge */
-                word <<= 1;
-                word |= getmiso(spi);
-                setsck(spi, cpol);
-        }
-        return word;
-}
-
-static inline u32
-bitbang_txrx_be_cpha1(struct spi_device *spi,
-                unsigned nsecs, unsigned cpol,
-                u32 word, u8 bits)
-{
-        /* if (cpol == 0) this is SPI_MODE_1; else this is SPI_MODE_3 */
-
-        /* clock starts at inactive polarity */
-        for (word <<= (32 - bits); likely(bits); bits--) {
-
-                /* setup MSB (to slave) on leading edge */
-                setsck(spi, !cpol);
-                setmosi(spi, word & (1 << 31));
-                spidelay(nsecs); /* T(setup) */
-
-                setsck(spi, cpol);
-                spidelay(nsecs);
-
-                /* sample MSB (from slave) on trailing edge */
-                word <<= 1;
-                word |= getmiso(spi);
-        }
-        return word;
-}
-
-#endif  /* EXPAND_BITBANG_TXRX */
diff --git a/include/linux/swap.h b/include/linux/swap.h
index ec2b7a42b45f..ff4acea9bbdb 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -152,6 +152,7 @@ enum {
 };
 
 #define SWAP_CLUSTER_MAX 32
+#define COMPACT_CLUSTER_MAX SWAP_CLUSTER_MAX
 
 #define SWAP_MAP_MAX    0x3e    /* Max duplication count, in first swap_map */
 #define SWAP_MAP_BAD    0x3f    /* Note pageblock is bad, in first swap_map */
@@ -224,20 +225,15 @@ static inline void lru_cache_add_anon(struct page *page)
         __lru_cache_add(page, LRU_INACTIVE_ANON);
 }
 
-static inline void lru_cache_add_active_anon(struct page *page)
-{
-        __lru_cache_add(page, LRU_ACTIVE_ANON);
-}
-
 static inline void lru_cache_add_file(struct page *page)
 {
         __lru_cache_add(page, LRU_INACTIVE_FILE);
 }
 
-static inline void lru_cache_add_active_file(struct page *page)
-{
-        __lru_cache_add(page, LRU_ACTIVE_FILE);
-}
+/* LRU Isolation modes. */
+#define ISOLATE_INACTIVE 0      /* Isolate inactive pages. */
+#define ISOLATE_ACTIVE 1        /* Isolate active pages. */
+#define ISOLATE_BOTH 2          /* Isolate both active and inactive pages. */
 
 /* linux/mm/vmscan.c */
 extern unsigned long try_to_free_pages(struct zonelist *zonelist, int order,
@@ -286,6 +282,11 @@ extern void kswapd_stop(int nid);
 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);
+#endif
+
 extern void swap_unplug_io_fn(struct backing_dev_info *, struct page *);
 
 #ifdef CONFIG_SWAP
diff --git a/include/linux/swiotlb.h b/include/linux/swiotlb.h
index febedcf67c7e..81a4e213c6cf 100644
--- a/include/linux/swiotlb.h
+++ b/include/linux/swiotlb.h
@@ -73,16 +73,6 @@ extern void
 swiotlb_sync_sg_for_device(struct device *hwdev, struct scatterlist *sg,
                            int nelems, enum dma_data_direction dir);
 
-extern void
-swiotlb_sync_single_range_for_cpu(struct device *hwdev, dma_addr_t dev_addr,
-                                  unsigned long offset, size_t size,
-                                  enum dma_data_direction dir);
-
-extern void
-swiotlb_sync_single_range_for_device(struct device *hwdev, dma_addr_t dev_addr,
-                                     unsigned long offset, size_t size,
-                                     enum dma_data_direction dir);
-
 extern int
 swiotlb_dma_mapping_error(struct device *hwdev, dma_addr_t dma_addr);
 
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 057929b0a651..a1a86a53bc73 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -103,22 +103,6 @@ struct perf_event_attr;
 #define __SC_TEST5(t5, a5, ...) __SC_TEST(t5); __SC_TEST4(__VA_ARGS__)
 #define __SC_TEST6(t6, a6, ...) __SC_TEST(t6); __SC_TEST5(__VA_ARGS__)
 
-#ifdef CONFIG_PERF_EVENTS
-
-#define TRACE_SYS_ENTER_PERF_INIT(sname)                                       \
-        .perf_event_enable = perf_sysenter_enable,                             \
-        .perf_event_disable = perf_sysenter_disable,
-
-#define TRACE_SYS_EXIT_PERF_INIT(sname)                                        \
-        .perf_event_enable = perf_sysexit_enable,                              \
-        .perf_event_disable = perf_sysexit_disable,
-#else
-#define TRACE_SYS_ENTER_PERF(sname)
-#define TRACE_SYS_ENTER_PERF_INIT(sname)
-#define TRACE_SYS_EXIT_PERF(sname)
-#define TRACE_SYS_EXIT_PERF_INIT(sname)
-#endif /* CONFIG_PERF_EVENTS */
-
 #ifdef CONFIG_FTRACE_SYSCALLS
 #define __SC_STR_ADECL1(t, a)           #a
 #define __SC_STR_ADECL2(t, a, ...)      #a, __SC_STR_ADECL1(__VA_ARGS__)
@@ -134,54 +118,43 @@ struct perf_event_attr;
 #define __SC_STR_TDECL5(t, a, ...)      #t, __SC_STR_TDECL4(__VA_ARGS__)
 #define __SC_STR_TDECL6(t, a, ...)      #t, __SC_STR_TDECL5(__VA_ARGS__)
 
+extern struct ftrace_event_class event_class_syscall_enter;
+extern struct ftrace_event_class event_class_syscall_exit;
+extern struct trace_event_functions enter_syscall_print_funcs;
+extern struct trace_event_functions exit_syscall_print_funcs;
+
 #define SYSCALL_TRACE_ENTER_EVENT(sname)                                \
-        static const struct syscall_metadata __syscall_meta_##sname;    \
+        static struct syscall_metadata __syscall_meta_##sname;          \
         static struct ftrace_event_call                                 \
         __attribute__((__aligned__(4))) event_enter_##sname;            \
-        static struct trace_event enter_syscall_print_##sname = {       \
-                .trace                  = print_syscall_enter,          \
-        };                                                              \
         static struct ftrace_event_call __used                          \
           __attribute__((__aligned__(4)))                               \
           __attribute__((section("_ftrace_events")))                    \
           event_enter_##sname = {                                       \
                 .name                   = "sys_enter"#sname,            \
-                .system                 = "syscalls",                   \
-                .event                  = &enter_syscall_print_##sname, \
-                .raw_init               = init_syscall_trace,           \
-                .define_fields          = syscall_enter_define_fields,  \
-                .regfunc                = reg_event_syscall_enter,      \
-                .unregfunc              = unreg_event_syscall_enter,    \
+                .class                  = &event_class_syscall_enter,   \
+                .event.funcs            = &enter_syscall_print_funcs,   \
                 .data                   = (void *)&__syscall_meta_##sname,\
-                TRACE_SYS_ENTER_PERF_INIT(sname)                        \
         }
 
 #define SYSCALL_TRACE_EXIT_EVENT(sname)                                 \
-        static const struct syscall_metadata __syscall_meta_##sname;    \
+        static struct syscall_metadata __syscall_meta_##sname;          \
         static struct ftrace_event_call                                 \
         __attribute__((__aligned__(4))) event_exit_##sname;             \
-        static struct trace_event exit_syscall_print_##sname = {        \
-                .trace                  = print_syscall_exit,           \
-        };                                                              \
         static struct ftrace_event_call __used                          \
           __attribute__((__aligned__(4)))                               \
           __attribute__((section("_ftrace_events")))                    \
           event_exit_##sname = {                                        \
                 .name                   = "sys_exit"#sname,             \
-                .system                 = "syscalls",                   \
-                .event                  = &exit_syscall_print_##sname,  \
-                .raw_init               = init_syscall_trace,           \
-                .define_fields          = syscall_exit_define_fields,   \
-                .regfunc                = reg_event_syscall_exit,       \
-                .unregfunc              = unreg_event_syscall_exit,     \
+                .class                  = &event_class_syscall_exit,    \
+                .event.funcs            = &exit_syscall_print_funcs,    \
                 .data                   = (void *)&__syscall_meta_##sname,\
-                TRACE_SYS_EXIT_PERF_INIT(sname)                 \
         }
 
 #define SYSCALL_METADATA(sname, nb)                             \
         SYSCALL_TRACE_ENTER_EVENT(sname);                       \
         SYSCALL_TRACE_EXIT_EVENT(sname);                        \
-        static const struct syscall_metadata __used             \
+        static struct syscall_metadata __used                   \
           __attribute__((__aligned__(4)))                       \
           __attribute__((section("__syscalls_metadata")))       \
           __syscall_meta_##sname = {                            \
@@ -191,12 +164,14 @@ struct perf_event_attr;
                 .args           = args_##sname,                 \
                 .enter_event    = &event_enter_##sname,         \
                 .exit_event     = &event_exit_##sname,          \
+                .enter_fields   = LIST_HEAD_INIT(__syscall_meta_##sname.enter_fields), \
+                .exit_fields    = LIST_HEAD_INIT(__syscall_meta_##sname.exit_fields), \
         };
 
 #define SYSCALL_DEFINE0(sname)                                  \
         SYSCALL_TRACE_ENTER_EVENT(_##sname);                    \
         SYSCALL_TRACE_EXIT_EVENT(_##sname);                     \
-        static const struct syscall_metadata __used             \
+        static struct syscall_metadata __used                   \
           __attribute__((__aligned__(4)))                       \
           __attribute__((section("__syscalls_metadata")))       \
           __syscall_meta__##sname = {                           \
@@ -204,6 +179,8 @@ struct perf_event_attr;
                 .nb_args        = 0,                            \
                 .enter_event    = &event_enter__##sname,        \
                 .exit_event     = &event_exit__##sname,         \
+                .enter_fields   = LIST_HEAD_INIT(__syscall_meta__##sname.enter_fields), \
+                .exit_fields    = LIST_HEAD_INIT(__syscall_meta__##sname.exit_fields), \
         };                                                      \
         asmlinkage long sys_##sname(void)
 #else
diff --git a/include/linux/threads.h b/include/linux/threads.h
index 052b12bec8bd..383ab9592bec 100644
--- a/include/linux/threads.h
+++ b/include/linux/threads.h
@@ -33,4 +33,13 @@
 #define PID_MAX_LIMIT (CONFIG_BASE_SMALL ? PAGE_SIZE * 8 : \
         (sizeof(long) > 4 ? 4 * 1024 * 1024 : PID_MAX_DEFAULT))
 
+/*
+ * Define a minimum number of pids per cpu.  Heuristically based
+ * on original pid max of 32k for 32 cpus.  Also, increase the
+ * minimum settable value for pid_max on the running system based
+ * on similar defaults.  See kernel/pid.c:pidmap_init() for details.
+ */
+#define PIDS_PER_CPU_DEFAULT    1024
+#define PIDS_PER_CPU_MIN        8
+
 #endif
diff --git a/include/linux/topology.h b/include/linux/topology.h
index 5b81156780b1..c44df50a05ab 100644
--- a/include/linux/topology.h
+++ b/include/linux/topology.h
@@ -31,6 +31,7 @@
 #include <linux/bitops.h>
 #include <linux/mmzone.h>
 #include <linux/smp.h>
+#include <linux/percpu.h>
 #include <asm/topology.h>
 
 #ifndef node_has_online_mem
@@ -203,8 +204,114 @@ int arch_update_cpu_topology(void);
 #ifndef SD_NODE_INIT
 #error Please define an appropriate SD_NODE_INIT in include/asm/topology.h!!!
 #endif
+
 #endif /* CONFIG_NUMA */
 
+#ifdef CONFIG_USE_PERCPU_NUMA_NODE_ID
+DECLARE_PER_CPU(int, numa_node);
+
+#ifndef numa_node_id
+/* Returns the number of the current Node. */
+static inline int numa_node_id(void)
+{
+        return __this_cpu_read(numa_node);
+}
+#endif
+
+#ifndef cpu_to_node
+static inline int cpu_to_node(int cpu)
+{
+        return per_cpu(numa_node, cpu);
+}
+#endif
+
+#ifndef set_numa_node
+static inline void set_numa_node(int node)
+{
+        percpu_write(numa_node, node);
+}
+#endif
+
+#ifndef set_cpu_numa_node
+static inline void set_cpu_numa_node(int cpu, int node)
+{
+        per_cpu(numa_node, cpu) = node;
+}
+#endif
+
+#else   /* !CONFIG_USE_PERCPU_NUMA_NODE_ID */
+
+/* Returns the number of the current Node. */
+#ifndef numa_node_id
+static inline int numa_node_id(void)
+{
+        return cpu_to_node(raw_smp_processor_id());
+}
+#endif
+
+#endif  /* [!]CONFIG_USE_PERCPU_NUMA_NODE_ID */
+
+#ifdef CONFIG_HAVE_MEMORYLESS_NODES
+
+/*
+ * N.B., Do NOT reference the '_numa_mem_' per cpu variable directly.
+ * It will not be defined when CONFIG_HAVE_MEMORYLESS_NODES is not defined.
+ * Use the accessor functions set_numa_mem(), numa_mem_id() and cpu_to_mem().
+ */
+DECLARE_PER_CPU(int, _numa_mem_);
+
+#ifndef set_numa_mem
+static inline void set_numa_mem(int node)
+{
+        percpu_write(_numa_mem_, node);
+}
+#endif
+
+#ifndef numa_mem_id
+/* Returns the number of the nearest Node with memory */
+static inline int numa_mem_id(void)
+{
+        return __this_cpu_read(_numa_mem_);
+}
+#endif
+
+#ifndef cpu_to_mem
+static inline int cpu_to_mem(int cpu)
+{
+        return per_cpu(_numa_mem_, cpu);
+}
+#endif
+
+#ifndef set_cpu_numa_mem
+static inline void set_cpu_numa_mem(int cpu, int node)
+{
+        per_cpu(_numa_mem_, cpu) = node;
+}
+#endif
+
+#else   /* !CONFIG_HAVE_MEMORYLESS_NODES */
+
+static inline void set_numa_mem(int node) {}
+
+static inline void set_cpu_numa_mem(int cpu, int node) {}
+
+#ifndef numa_mem_id
+/* Returns the number of the nearest Node with memory */
+static inline int numa_mem_id(void)
+{
+        return numa_node_id();
+}
+#endif
+
+#ifndef cpu_to_mem
+static inline int cpu_to_mem(int cpu)
+{
+        return cpu_to_node(cpu);
+}
+#endif
+
+#endif  /* [!]CONFIG_HAVE_MEMORYLESS_NODES */
+
 #ifndef topology_physical_package_id
 #define topology_physical_package_id(cpu)       ((void)(cpu), -1)
 #endif
@@ -218,9 +325,4 @@ int arch_update_cpu_topology(void);
 #define topology_core_cpumask(cpu)              cpumask_of(cpu)
 #endif
 
-/* Returns the number of the current Node. */
-#ifndef numa_node_id
-#define numa_node_id()          (cpu_to_node(raw_smp_processor_id()))
-#endif
-
 #endif /* _LINUX_TOPOLOGY_H */
diff --git a/include/linux/tracepoint.h b/include/linux/tracepoint.h
index 1d85f9a6a199..9a59d1f98cd4 100644
--- a/include/linux/tracepoint.h
+++ b/include/linux/tracepoint.h
@@ -20,12 +20,17 @@
 struct module;
 struct tracepoint;
 
+struct tracepoint_func {
+        void *func;
+        void *data;
+};
+
 struct tracepoint {
         const char *name;               /* Tracepoint name */
         int state;                      /* State. */
         void (*regfunc)(void);
         void (*unregfunc)(void);
-        void **funcs;
+        struct tracepoint_func *funcs;
 } __attribute__((aligned(32)));         /*
                                          * Aligned on 32 bytes because it is
                                          * globally visible and gcc happily
@@ -37,16 +42,19 @@ struct tracepoint {
  * Connect a probe to a tracepoint.
  * Internal API, should not be used directly.
  */
-extern int tracepoint_probe_register(const char *name, void *probe);
+extern int tracepoint_probe_register(const char *name, void *probe, void *data);
 
 /*
  * Disconnect a probe from a tracepoint.
  * Internal API, should not be used directly.
  */
-extern int tracepoint_probe_unregister(const char *name, void *probe);
+extern int
+tracepoint_probe_unregister(const char *name, void *probe, void *data);
 
-extern int tracepoint_probe_register_noupdate(const char *name, void *probe);
-extern int tracepoint_probe_unregister_noupdate(const char *name, void *probe);
+extern int tracepoint_probe_register_noupdate(const char *name, void *probe,
+                                              void *data);
+extern int tracepoint_probe_unregister_noupdate(const char *name, void *probe,
+                                                void *data);
 extern void tracepoint_probe_update_all(void);
 
 struct tracepoint_iter {
@@ -102,17 +110,27 @@ static inline void tracepoint_update_probe_range(struct tracepoint *begin,
 /*
  * it_func[0] is never NULL because there is at least one element in the array
  * when the array itself is non NULL.
+ *
+ * Note, the proto and args passed in includes "__data" as the first parameter.
+ * The reason for this is to handle the "void" prototype. If a tracepoint
+ * has a "void" prototype, then it is invalid to declare a function
+ * as "(void *, void)". The DECLARE_TRACE_NOARGS() will pass in just
+ * "void *data", where as the DECLARE_TRACE() will pass in "void *data, proto".
  */
 #define __DO_TRACE(tp, proto, args)                                     \
         do {                                                            \
-                void **it_func;                                         \
+                struct tracepoint_func *it_func_ptr;                    \
+                void *it_func;                                          \
+                void *__data;                                           \
                                                                         \
                 rcu_read_lock_sched_notrace();                          \
-                it_func = rcu_dereference_sched((tp)->funcs);           \
-                if (it_func) {                                          \
+                it_func_ptr = rcu_dereference_sched((tp)->funcs);       \
+                if (it_func_ptr) {                                      \
                         do {                                            \
-                                ((void(*)(proto))(*it_func))(args);     \
-                        } while (*(++it_func));                         \
+                                it_func = (it_func_ptr)->func;          \
+                                __data = (it_func_ptr)->data;           \
+                                ((void(*)(proto))(it_func))(args);      \
+                        } while ((++it_func_ptr)->func);                \
                 }                                                       \
                 rcu_read_unlock_sched_notrace();                        \
         } while (0)
@@ -122,24 +140,32 @@ static inline void tracepoint_update_probe_range(struct tracepoint *begin,
  * not add unwanted padding between the beginning of the section and the
  * structure. Force alignment to the same alignment as the section start.
  */
-#define DECLARE_TRACE(name, proto, args)                                \
+#define __DECLARE_TRACE(name, proto, args, data_proto, data_args)       \
         extern struct tracepoint __tracepoint_##name;                   \
         static inline void trace_##name(proto)                          \
         {                                                               \
                 if (unlikely(__tracepoint_##name.state))                \
                         __DO_TRACE(&__tracepoint_##name,                \
-                                TP_PROTO(proto), TP_ARGS(args));        \
+                                TP_PROTO(data_proto),                   \
+                                TP_ARGS(data_args));                    \
+        }                                                               \
+        static inline int                                               \
+        register_trace_##name(void (*probe)(data_proto), void *data)    \
+        {                                                               \
+                return tracepoint_probe_register(#name, (void *)probe,  \
+                                                 data);                 \
         }                                                               \
-        static inline int register_trace_##name(void (*probe)(proto))   \
+        static inline int                                               \
+        unregister_trace_##name(void (*probe)(data_proto), void *data)  \
         {                                                               \
-                return tracepoint_probe_register(#name, (void *)probe); \
+                return tracepoint_probe_unregister(#name, (void *)probe, \
+                                                   data);               \
         }                                                               \
-        static inline int unregister_trace_##name(void (*probe)(proto)) \
+        static inline void                                              \
+        check_trace_callback_type_##name(void (*cb)(data_proto))        \
         {                                                               \
-                return tracepoint_probe_unregister(#name, (void *)probe);\
         }
 
-
 #define DEFINE_TRACE_FN(name, reg, unreg)                               \
         static const char __tpstrtab_##name[]                           \
         __attribute__((section("__tracepoints_strings"))) = #name;      \
@@ -156,18 +182,23 @@ static inline void tracepoint_update_probe_range(struct tracepoint *begin,
         EXPORT_SYMBOL(__tracepoint_##name)
 
 #else /* !CONFIG_TRACEPOINTS */
-#define DECLARE_TRACE(name, proto, args)                                \
-        static inline void _do_trace_##name(struct tracepoint *tp, proto) \
-        { }                                                             \
+#define __DECLARE_TRACE(name, proto, args, data_proto, data_args)       \
         static inline void trace_##name(proto)                          \
         { }                                                             \
-        static inline int register_trace_##name(void (*probe)(proto))   \
+        static inline int                                               \
+        register_trace_##name(void (*probe)(data_proto),                \
+                              void *data)                               \
         {                                                               \
                 return -ENOSYS;                                         \
         }                                                               \
-        static inline int unregister_trace_##name(void (*probe)(proto)) \
+        static inline int                                               \
+        unregister_trace_##name(void (*probe)(data_proto),              \
+                                void *data)                             \
         {                                                               \
                 return -ENOSYS;                                         \
+        }                                                               \
+        static inline void check_trace_callback_type_##name(void (*cb)(data_proto)) \
+        {                                                               \
         }
 
 #define DEFINE_TRACE_FN(name, reg, unreg)
@@ -176,6 +207,29 @@ static inline void tracepoint_update_probe_range(struct tracepoint *begin,
 #define EXPORT_TRACEPOINT_SYMBOL(name)
 
 #endif /* CONFIG_TRACEPOINTS */
+
+/*
+ * The need for the DECLARE_TRACE_NOARGS() is to handle the prototype
+ * (void). "void" is a special value in a function prototype and can
+ * not be combined with other arguments. Since the DECLARE_TRACE()
+ * macro adds a data element at the beginning of the prototype,
+ * we need a way to differentiate "(void *data, proto)" from
+ * "(void *data, void)". The second prototype is invalid.
+ *
+ * DECLARE_TRACE_NOARGS() passes "void" as the tracepoint prototype
+ * and "void *__data" as the callback prototype.
+ *
+ * DECLARE_TRACE() passes "proto" as the tracepoint protoype and
+ * "void *__data, proto" as the callback prototype.
+ */
+#define DECLARE_TRACE_NOARGS(name)                                      \
+                __DECLARE_TRACE(name, void, , void *__data, __data)
+
+#define DECLARE_TRACE(name, proto, args)                                \
+                __DECLARE_TRACE(name, PARAMS(proto), PARAMS(args),      \
+                                PARAMS(void *__data, proto),            \
+                                PARAMS(__data, args))
+
 #endif /* DECLARE_TRACE */
 
 #ifndef TRACE_EVENT
diff --git a/include/linux/uinput.h b/include/linux/uinput.h
index 15ddd4483b09..60c81da77f0f 100644
--- a/include/linux/uinput.h
+++ b/include/linux/uinput.h
@@ -166,11 +166,11 @@ struct uinput_ff_erase {
 struct uinput_user_dev {
         char name[UINPUT_MAX_NAME_SIZE];
         struct input_id id;
-        int ff_effects_max;
-        int absmax[ABS_MAX + 1];
-        int absmin[ABS_MAX + 1];
-        int absfuzz[ABS_MAX + 1];
-        int absflat[ABS_MAX + 1];
+        int ff_effects_max;
+        int absmax[ABS_CNT];
+        int absmin[ABS_CNT];
+        int absfuzz[ABS_CNT];
+        int absflat[ABS_CNT];
 };
 #endif  /* __UINPUT_H_ */
 
diff --git a/include/linux/usb/audio-v2.h b/include/linux/usb/audio-v2.h
index 2389f93a28b5..92f1d99f0f17 100644
--- a/include/linux/usb/audio-v2.h
+++ b/include/linux/usb/audio-v2.h
@@ -105,6 +105,22 @@ struct uac_as_header_descriptor_v2 {
         __u8 iChannelNames;
 } __attribute__((packed));
 
+/* 4.10.1.2 Class-Specific AS Isochronous Audio Data Endpoint Descriptor */
+
+struct uac2_iso_endpoint_descriptor {
+        __u8  bLength;                  /* in bytes: 8 */
+        __u8  bDescriptorType;          /* USB_DT_CS_ENDPOINT */
+        __u8  bDescriptorSubtype;       /* EP_GENERAL */
+        __u8  bmAttributes;
+        __u8  bmControls;
+        __u8  bLockDelayUnits;
+        __le16 wLockDelay;
+} __attribute__((packed));
+
+#define UAC2_CONTROL_PITCH              (3 << 0)
+#define UAC2_CONTROL_DATA_OVERRUN       (3 << 2)
+#define UAC2_CONTROL_DATA_UNDERRUN      (3 << 4)
+
 /* 6.1 Interrupt Data Message */
 
 #define UAC2_INTERRUPT_DATA_MSG_VENDOR  (1 << 0)
diff --git a/include/linux/uuid.h b/include/linux/uuid.h
new file mode 100644
index 000000000000..5b7efbfcee4e
--- /dev/null
+++ b/include/linux/uuid.h
@@ -0,0 +1,70 @@
+/*
+ * UUID/GUID definition
+ *
+ * Copyright (C) 2010, Intel Corp.
+ *      Huang Ying <ying.huang@intel.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 _LINUX_UUID_H_
+#define _LINUX_UUID_H_
+
+#include <linux/types.h>
+#include <linux/string.h>
+
+typedef struct {
+        __u8 b[16];
+} uuid_le;
+
+typedef struct {
+        __u8 b[16];
+} uuid_be;
+
+#define UUID_LE(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7)                \
+((uuid_le)                                                              \
+{{ (a) & 0xff, ((a) >> 8) & 0xff, ((a) >> 16) & 0xff, ((a) >> 24) & 0xff, \
+   (b) & 0xff, ((b) >> 8) & 0xff,                                       \
+   (c) & 0xff, ((c) >> 8) & 0xff,                                       \
+   (d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7) }})
+
+#define UUID_BE(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7)                \
+((uuid_be)                                                              \
+{{ ((a) >> 24) & 0xff, ((a) >> 16) & 0xff, ((a) >> 8) & 0xff, (a) & 0xff, \
+   ((b) >> 8) & 0xff, (b) & 0xff,                                       \
+   ((c) >> 8) & 0xff, (c) & 0xff,                                       \
+   (d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7) }})
+
+#define NULL_UUID_LE                                                    \
+        UUID_LE(0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00,     \
+                0x00, 0x00, 0x00, 0x00)
+
+#define NULL_UUID_BE                                                    \
+        UUID_BE(0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00,     \
+                0x00, 0x00, 0x00, 0x00)
+
+static inline int uuid_le_cmp(const uuid_le u1, const uuid_le u2)
+{
+        return memcmp(&u1, &u2, sizeof(uuid_le));
+}
+
+static inline int uuid_be_cmp(const uuid_be u1, const uuid_be u2)
+{
+        return memcmp(&u1, &u2, sizeof(uuid_be));
+}
+
+extern void uuid_le_gen(uuid_le *u);
+extern void uuid_be_gen(uuid_be *u);
+
+#endif
diff --git a/include/linux/vmstat.h b/include/linux/vmstat.h
index 117f0dd8ad03..7f43ccdc1d38 100644
--- a/include/linux/vmstat.h
+++ b/include/linux/vmstat.h
@@ -43,6 +43,10 @@ enum vm_event_item { PGPGIN, PGPGOUT, PSWPIN, PSWPOUT,
                 KSWAPD_LOW_WMARK_HIT_QUICKLY, KSWAPD_HIGH_WMARK_HIT_QUICKLY,
                 KSWAPD_SKIP_CONGESTION_WAIT,
                 PAGEOUTRUN, ALLOCSTALL, PGROTATED,
+#ifdef CONFIG_COMPACTION
+                COMPACTBLOCKS, COMPACTPAGES, COMPACTPAGEFAILED,
+                COMPACTSTALL, COMPACTFAIL, COMPACTSUCCESS,
+#endif
 #ifdef CONFIG_HUGETLB_PAGE
                 HTLB_BUDDY_PGALLOC, HTLB_BUDDY_PGALLOC_FAIL,
 #endif
diff --git a/include/linux/z2_battery.h b/include/linux/z2_battery.h
new file mode 100644
index 000000000000..7b9750404d22
--- /dev/null
+++ b/include/linux/z2_battery.h
@@ -0,0 +1,17 @@
+#ifndef _LINUX_Z2_BATTERY_H
+#define _LINUX_Z2_BATTERY_H
+
+struct z2_battery_info {
+        int      batt_I2C_bus;
+        int      batt_I2C_addr;
+        int      batt_I2C_reg;
+        int      charge_gpio;
+        int      min_voltage;
+        int      max_voltage;
+        int      batt_div;
+        int      batt_mult;
+        int      batt_tech;
+        char    *batt_name;
+};
+
+#endif