447 files changed, 14952 insertions, 2404 deletions

diff --git a/include/linux/Kbuild b/include/linux/Kbuild
index 01f63627505..619b5657af7 100644
--- a/include/linux/Kbuild
+++ b/include/linux/Kbuild
@@ -135,6 +135,7 @@ header-y += firewire-cdev.h
 header-y += firewire-constants.h
 header-y += flat.h
 header-y += fs.h
+header-y += fsl_hypervisor.h
 header-y += fuse.h
 header-y += futex.h
 header-y += gameport.h
diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index 1deb2a73c2d..6001b4da39d 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -238,7 +238,6 @@ extern int acpi_paddr_to_node(u64 start_addr, u64 size);
 extern int pnpacpi_disabled;
 
 #define PXM_INVAL       (-1)
-#define NID_INVAL       (-1)
 
 int acpi_check_resource_conflict(const struct resource *res);
 
@@ -280,6 +279,8 @@ acpi_status acpi_run_osc(acpi_handle handle, struct acpi_osc_context *context);
 #define OSC_SB_CPUHP_OST_SUPPORT        8
 #define OSC_SB_APEI_SUPPORT             16
 
+extern bool osc_sb_apei_support_acked;
+
 /* PCI defined _OSC bits */
 /* _OSC DW1 Definition (OS Support Fields) */
 #define OSC_EXT_PCI_CONFIG_SUPPORT              1
diff --git a/include/linux/adt7461.h b/include/linux/adt7461.h
new file mode 100644
index 00000000000..36f637ad287
--- /dev/null
+++ b/include/linux/adt7461.h
@@ -0,0 +1,42 @@
+/*
+ * include/linux/adt8461.h
+ *
+ * ADT7461, temperature monitoring device from ON Semiconductors
+ *
+ * Copyright (c) 2011, NVIDIA Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#ifndef _LINUX_ADT7461_H
+#define _LINUX_ADT7461_H
+
+#include <linux/types.h>
+
+struct adt7461_platform_data {
+        bool supported_hwrev;
+        bool ext_range;
+        bool therm2;
+        u8 conv_rate;
+        u8 offset;
+        u8 hysteresis;
+        u8 shutdown_ext_limit;
+        u8 shutdown_local_limit;
+        u8 throttling_ext_limit;
+        void (*alarm_fn)(bool raised);
+        int irq_gpio;
+};
+
+#endif /* _LINUX_ADT7461_H */
diff --git a/include/linux/aer.h b/include/linux/aer.h
index 8414de22a77..544abdb2238 100644
--- a/include/linux/aer.h
+++ b/include/linux/aer.h
@@ -51,5 +51,8 @@ static inline int pci_cleanup_aer_uncorrect_error_status(struct pci_dev *dev)
 
 extern void cper_print_aer(const char *prefix, int cper_severity,
                            struct aer_capability_regs *aer);
+extern int cper_severity_to_aer(int cper_severity);
+extern void aer_recover_queue(int domain, unsigned int bus, unsigned int devfn,
+                              int severity);
 #endif //_AER_H_
 
diff --git a/include/linux/aio.h b/include/linux/aio.h
index 7a8db415528..2dcb72bff4b 100644
--- a/include/linux/aio.h
+++ b/include/linux/aio.h
@@ -7,7 +7,7 @@
 #include <linux/uio.h>
 #include <linux/rcupdate.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 #define AIO_MAXSEGS             4
 #define AIO_KIOGRP_NR_ATOMIC    8
diff --git a/include/linux/akm8975.h b/include/linux/akm8975.h
new file mode 100644
index 00000000000..6a7c4326001
--- /dev/null
+++ b/include/linux/akm8975.h
@@ -0,0 +1,87 @@
+/*
+ * Definitions for akm8975 compass chip.
+ */
+#ifndef AKM8975_H
+#define AKM8975_H
+
+#include <linux/ioctl.h>
+
+/*! \name AK8975 operation mode
+ \anchor AK8975_Mode
+ Defines an operation mode of the AK8975.*/
+/*! @{*/
+#define AK8975_MODE_SNG_MEASURE   0x01
+#define AK8975_MODE_SELF_TEST     0x08
+#define AK8975_MODE_FUSE_ACCESS   0x0F
+#define AK8975_MODE_POWER_DOWN    0x00
+/*! @}*/
+
+#define RBUFF_SIZE              8       /* Rx buffer size */
+
+/*! \name AK8975 register address
+\anchor AK8975_REG
+Defines a register address of the AK8975.*/
+/*! @{*/
+#define AK8975_REG_WIA          0x00
+#define AK8975_REG_INFO         0x01
+#define AK8975_REG_ST1          0x02
+#define AK8975_REG_HXL          0x03
+#define AK8975_REG_HXH          0x04
+#define AK8975_REG_HYL          0x05
+#define AK8975_REG_HYH          0x06
+#define AK8975_REG_HZL          0x07
+#define AK8975_REG_HZH          0x08
+#define AK8975_REG_ST2          0x09
+#define AK8975_REG_CNTL         0x0A
+#define AK8975_REG_RSV          0x0B
+#define AK8975_REG_ASTC         0x0C
+#define AK8975_REG_TS1          0x0D
+#define AK8975_REG_TS2          0x0E
+#define AK8975_REG_I2CDIS       0x0F
+/*! @}*/
+
+/*! \name AK8975 fuse-rom address
+\anchor AK8975_FUSE
+Defines a read-only address of the fuse ROM of the AK8975.*/
+/*! @{*/
+#define AK8975_FUSE_ASAX        0x10
+#define AK8975_FUSE_ASAY        0x11
+#define AK8975_FUSE_ASAZ        0x12
+/*! @}*/
+
+#define AKMIO                   0xA1
+
+/* IOCTLs for AKM library */
+#define ECS_IOCTL_WRITE                 _IOW(AKMIO, 0x02, char[5])
+#define ECS_IOCTL_READ                  _IOWR(AKMIO, 0x03, char[5])
+#define ECS_IOCTL_GETDATA               _IOR(AKMIO, 0x08, char[RBUFF_SIZE])
+#define ECS_IOCTL_SET_YPR               _IOW(AKMIO, 0x0C, short[12])
+#define ECS_IOCTL_GET_OPEN_STATUS       _IOR(AKMIO, 0x0D, int)
+#define ECS_IOCTL_GET_CLOSE_STATUS      _IOR(AKMIO, 0x0E, int)
+#define ECS_IOCTL_GET_DELAY             _IOR(AKMIO, 0x30, short)
+
+/* IOCTLs for APPs */
+#define ECS_IOCTL_APP_SET_MFLAG         _IOW(AKMIO, 0x11, short)
+#define ECS_IOCTL_APP_GET_MFLAG         _IOW(AKMIO, 0x12, short)
+#define ECS_IOCTL_APP_SET_AFLAG         _IOW(AKMIO, 0x13, short)
+#define ECS_IOCTL_APP_GET_AFLAG         _IOR(AKMIO, 0x14, short)
+#define ECS_IOCTL_APP_SET_DELAY         _IOW(AKMIO, 0x18, short)
+#define ECS_IOCTL_APP_GET_DELAY         ECS_IOCTL_GET_DELAY
+/* Set raw magnetic vector flag */
+#define ECS_IOCTL_APP_SET_MVFLAG        _IOW(AKMIO, 0x19, short)
+/* Get raw magnetic vector flag */
+#define ECS_IOCTL_APP_GET_MVFLAG        _IOR(AKMIO, 0x1A, short)
+#define ECS_IOCTL_APP_SET_TFLAG         _IOR(AKMIO, 0x15, short)
+
+
+struct akm8975_platform_data {
+        int intr;
+
+        int (*init)(void);
+        void (*exit)(void);
+        int (*power_on)(void);
+        int (*power_off)(void);
+};
+
+#endif
+
diff --git a/include/linux/amba/mmci.h b/include/linux/amba/mmci.h
index 21114810c7c..60c737f7bda 100644
--- a/include/linux/amba/mmci.h
+++ b/include/linux/amba/mmci.h
@@ -5,6 +5,15 @@
 #define AMBA_MMCI_H
 
 #include <linux/mmc/host.h>
+#include <linux/mmc/card.h>
+#include <linux/mmc/sdio_func.h>
+
+struct embedded_sdio_data {
+        struct sdio_cis cis;
+        struct sdio_cccr cccr;
+        struct sdio_embedded_func *funcs;
+        int num_funcs;
+};
 
 /* Just some dummy forwarding */
 struct dma_chan;
@@ -55,6 +64,9 @@ struct mmci_platform_data {
         bool (*dma_filter)(struct dma_chan *chan, void *filter_param);
         void *dma_rx_param;
         void *dma_tx_param;
+        unsigned int status_irq;
+        struct embedded_sdio_data *embedded_sdio;
+        int (*register_status_notify)(void (*callback)(int card_present, void *dev_id), void *dev_id);
 };
 
 #endif
diff --git a/include/linux/amba/pl08x.h b/include/linux/amba/pl08x.h
index 3111385b8ca..e6e28f37d8e 100644
--- a/include/linux/amba/pl08x.h
+++ b/include/linux/amba/pl08x.h
@@ -172,8 +172,11 @@ struct pl08x_dma_chan {
         int phychan_hold;
         struct tasklet_struct tasklet;
         char *name;
-        struct pl08x_channel_data *cd;
-        dma_addr_t runtime_addr;
+        const struct pl08x_channel_data *cd;
+        dma_addr_t src_addr;
+        dma_addr_t dst_addr;
+        u32 src_cctl;
+        u32 dst_cctl;
         enum dma_data_direction runtime_direction;
         dma_cookie_t lc;
         struct list_head pend_list;
@@ -202,7 +205,7 @@ struct pl08x_dma_chan {
  * @mem_buses: buses which memory can be accessed from: PL08X_AHB1 | PL08X_AHB2
  */
 struct pl08x_platform_data {
-        struct pl08x_channel_data *slave_channels;
+        const struct pl08x_channel_data *slave_channels;
         unsigned int num_slave_channels;
         struct pl08x_channel_data memcpy_channel;
         int (*get_signal)(struct pl08x_dma_chan *);
diff --git a/include/linux/amd-iommu.h b/include/linux/amd-iommu.h
new file mode 100644
index 00000000000..ef00610837d
--- /dev/null
+++ b/include/linux/amd-iommu.h
@@ -0,0 +1,171 @@
+/*
+ * Copyright (C) 2007-2010 Advanced Micro Devices, Inc.
+ * Author: Joerg Roedel <joerg.roedel@amd.com>
+ *         Leo Duran <leo.duran@amd.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+
+#ifndef _ASM_X86_AMD_IOMMU_H
+#define _ASM_X86_AMD_IOMMU_H
+
+#include <linux/types.h>
+
+#ifdef CONFIG_AMD_IOMMU
+
+struct task_struct;
+struct pci_dev;
+
+extern int amd_iommu_detect(void);
+
+
+/**
+ * amd_iommu_enable_device_erratum() - Enable erratum workaround for device
+ *                                     in the IOMMUv2 driver
+ * @pdev: The PCI device the workaround is necessary for
+ * @erratum: The erratum workaround to enable
+ *
+ * The function needs to be called before amd_iommu_init_device().
+ * Possible values for the erratum number are for now:
+ * - AMD_PRI_DEV_ERRATUM_ENABLE_RESET - Reset PRI capability when PRI
+ *                                      is enabled
+ * - AMD_PRI_DEV_ERRATUM_LIMIT_REQ_ONE - Limit number of outstanding PRI
+ *                                       requests to one
+ */
+#define AMD_PRI_DEV_ERRATUM_ENABLE_RESET                0
+#define AMD_PRI_DEV_ERRATUM_LIMIT_REQ_ONE               1
+
+extern void amd_iommu_enable_device_erratum(struct pci_dev *pdev, u32 erratum);
+
+/**
+ * amd_iommu_init_device() - Init device for use with IOMMUv2 driver
+ * @pdev: The PCI device to initialize
+ * @pasids: Number of PASIDs to support for this device
+ *
+ * This function does all setup for the device pdev so that it can be
+ * used with IOMMUv2.
+ * Returns 0 on success or negative value on error.
+ */
+extern int amd_iommu_init_device(struct pci_dev *pdev, int pasids);
+
+/**
+ * amd_iommu_free_device() - Free all IOMMUv2 related device resources
+ *                           and disable IOMMUv2 usage for this device
+ * @pdev: The PCI device to disable IOMMUv2 usage for'
+ */
+extern void amd_iommu_free_device(struct pci_dev *pdev);
+
+/**
+ * amd_iommu_bind_pasid() - Bind a given task to a PASID on a device
+ * @pdev: The PCI device to bind the task to
+ * @pasid: The PASID on the device the task should be bound to
+ * @task: the task to bind
+ *
+ * The function returns 0 on success or a negative value on error.
+ */
+extern int amd_iommu_bind_pasid(struct pci_dev *pdev, int pasid,
+                                struct task_struct *task);
+
+/**
+ * amd_iommu_unbind_pasid() - Unbind a PASID from its task on
+ *                            a device
+ * @pdev: The device of the PASID
+ * @pasid: The PASID to unbind
+ *
+ * When this function returns the device is no longer using the PASID
+ * and the PASID is no longer bound to its task.
+ */
+extern void amd_iommu_unbind_pasid(struct pci_dev *pdev, int pasid);
+
+/**
+ * amd_iommu_set_invalid_ppr_cb() - Register a call-back for failed
+ *                                  PRI requests
+ * @pdev: The PCI device the call-back should be registered for
+ * @cb: The call-back function
+ *
+ * The IOMMUv2 driver invokes this call-back when it is unable to
+ * successfully handle a PRI request. The device driver can then decide
+ * which PRI response the device should see. Possible return values for
+ * the call-back are:
+ *
+ * - AMD_IOMMU_INV_PRI_RSP_SUCCESS - Send SUCCESS back to the device
+ * - AMD_IOMMU_INV_PRI_RSP_INVALID - Send INVALID back to the device
+ * - AMD_IOMMU_INV_PRI_RSP_FAIL    - Send Failure back to the device,
+ *                                   the device is required to disable
+ *                                   PRI when it receives this response
+ *
+ * The function returns 0 on success or negative value on error.
+ */
+#define AMD_IOMMU_INV_PRI_RSP_SUCCESS   0
+#define AMD_IOMMU_INV_PRI_RSP_INVALID   1
+#define AMD_IOMMU_INV_PRI_RSP_FAIL      2
+
+typedef int (*amd_iommu_invalid_ppr_cb)(struct pci_dev *pdev,
+                                        int pasid,
+                                        unsigned long address,
+                                        u16);
+
+extern int amd_iommu_set_invalid_ppr_cb(struct pci_dev *pdev,
+                                        amd_iommu_invalid_ppr_cb cb);
+
+/**
+ * amd_iommu_device_info() - Get information about IOMMUv2 support of a
+ *                           PCI device
+ * @pdev: PCI device to query information from
+ * @info: A pointer to an amd_iommu_device_info structure which will contain
+ *        the information about the PCI device
+ *
+ * Returns 0 on success, negative value on error
+ */
+
+#define AMD_IOMMU_DEVICE_FLAG_ATS_SUP     0x1    /* ATS feature supported */
+#define AMD_IOMMU_DEVICE_FLAG_PRI_SUP     0x2    /* PRI feature supported */
+#define AMD_IOMMU_DEVICE_FLAG_PASID_SUP   0x4    /* PASID context supported */
+#define AMD_IOMMU_DEVICE_FLAG_EXEC_SUP    0x8    /* Device may request execution
+                                                    on memory pages */
+#define AMD_IOMMU_DEVICE_FLAG_PRIV_SUP   0x10    /* Device may request
+                                                    super-user privileges */
+
+struct amd_iommu_device_info {
+        int max_pasids;
+        u32 flags;
+};
+
+extern int amd_iommu_device_info(struct pci_dev *pdev,
+                                 struct amd_iommu_device_info *info);
+
+/**
+ * amd_iommu_set_invalidate_ctx_cb() - Register a call-back for invalidating
+ *                                     a pasid context. This call-back is
+ *                                     invoked when the IOMMUv2 driver needs to
+ *                                     invalidate a PASID context, for example
+ *                                     because the task that is bound to that
+ *                                     context is about to exit.
+ *
+ * @pdev: The PCI device the call-back should be registered for
+ * @cb: The call-back function
+ */
+
+typedef void (*amd_iommu_invalidate_ctx)(struct pci_dev *pdev, int pasid);
+
+extern int amd_iommu_set_invalidate_ctx_cb(struct pci_dev *pdev,
+                                           amd_iommu_invalidate_ctx cb);
+
+#else
+
+static inline int amd_iommu_detect(void) { return -ENODEV; }
+
+#endif
+
+#endif /* _ASM_X86_AMD_IOMMU_H */
diff --git a/include/linux/android_aid.h b/include/linux/android_aid.h
new file mode 100644
index 00000000000..0f904b3ba7f
--- /dev/null
+++ b/include/linux/android_aid.h
@@ -0,0 +1,28 @@
+/* include/linux/android_aid.h
+ *
+ * Copyright (C) 2008 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _LINUX_ANDROID_AID_H
+#define _LINUX_ANDROID_AID_H
+
+/* AIDs that the kernel treats differently */
+#define AID_NET_BT_ADMIN 3001
+#define AID_NET_BT       3002
+#define AID_INET         3003
+#define AID_NET_RAW      3004
+#define AID_NET_ADMIN    3005
+#define AID_NET_BW_STATS 3006  /* read bandwidth statistics */
+#define AID_NET_BW_ACCT  3007  /* change bandwidth statistics accounting */
+
+#endif
diff --git a/include/linux/android_alarm.h b/include/linux/android_alarm.h
new file mode 100644
index 00000000000..f8f14e793db
--- /dev/null
+++ b/include/linux/android_alarm.h
@@ -0,0 +1,106 @@
+/* include/linux/android_alarm.h
+ *
+ * Copyright (C) 2006-2007 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _LINUX_ANDROID_ALARM_H
+#define _LINUX_ANDROID_ALARM_H
+
+#include <linux/ioctl.h>
+#include <linux/time.h>
+
+enum android_alarm_type {
+        /* return code bit numbers or set alarm arg */
+        ANDROID_ALARM_RTC_WAKEUP,
+        ANDROID_ALARM_RTC,
+        ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP,
+        ANDROID_ALARM_ELAPSED_REALTIME,
+        ANDROID_ALARM_SYSTEMTIME,
+
+        ANDROID_ALARM_TYPE_COUNT,
+
+        /* return code bit numbers */
+        /* ANDROID_ALARM_TIME_CHANGE = 16 */
+};
+
+#ifdef __KERNEL__
+
+#include <linux/ktime.h>
+#include <linux/rbtree.h>
+
+/*
+ * The alarm interface is similar to the hrtimer interface but adds support
+ * for wakeup from suspend. It also adds an elapsed realtime clock that can
+ * be used for periodic timers that need to keep runing while the system is
+ * suspended and not be disrupted when the wall time is set.
+ */
+
+/**
+ * struct alarm - the basic alarm structure
+ * @node:       red black tree node for time ordered insertion
+ * @type:       alarm type. rtc/elapsed-realtime/systemtime, wakeup/non-wakeup.
+ * @softexpires: the absolute earliest expiry time of the alarm.
+ * @expires:    the absolute expiry time.
+ * @function:   alarm expiry callback function
+ *
+ * The alarm structure must be initialized by alarm_init()
+ *
+ */
+
+struct alarm {
+        struct rb_node          node;
+        enum android_alarm_type type;
+        ktime_t                 softexpires;
+        ktime_t                 expires;
+        void                    (*function)(struct alarm *);
+};
+
+void alarm_init(struct alarm *alarm,
+        enum android_alarm_type type, void (*function)(struct alarm *));
+void alarm_start_range(struct alarm *alarm, ktime_t start, ktime_t end);
+int alarm_try_to_cancel(struct alarm *alarm);
+int alarm_cancel(struct alarm *alarm);
+ktime_t alarm_get_elapsed_realtime(void);
+
+/* set rtc while preserving elapsed realtime */
+int alarm_set_rtc(const struct timespec ts);
+
+#endif
+
+enum android_alarm_return_flags {
+        ANDROID_ALARM_RTC_WAKEUP_MASK = 1U << ANDROID_ALARM_RTC_WAKEUP,
+        ANDROID_ALARM_RTC_MASK = 1U << ANDROID_ALARM_RTC,
+        ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP_MASK =
+                                1U << ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP,
+        ANDROID_ALARM_ELAPSED_REALTIME_MASK =
+                                1U << ANDROID_ALARM_ELAPSED_REALTIME,
+        ANDROID_ALARM_SYSTEMTIME_MASK = 1U << ANDROID_ALARM_SYSTEMTIME,
+        ANDROID_ALARM_TIME_CHANGE_MASK = 1U << 16
+};
+
+/* Disable alarm */
+#define ANDROID_ALARM_CLEAR(type)           _IO('a', 0 | ((type) << 4))
+
+/* Ack last alarm and wait for next */
+#define ANDROID_ALARM_WAIT                  _IO('a', 1)
+
+#define ALARM_IOW(c, type, size)            _IOW('a', (c) | ((type) << 4), size)
+/* Set alarm */
+#define ANDROID_ALARM_SET(type)             ALARM_IOW(2, type, struct timespec)
+#define ANDROID_ALARM_SET_AND_WAIT(type)    ALARM_IOW(3, type, struct timespec)
+#define ANDROID_ALARM_GET_TIME(type)        ALARM_IOW(4, type, struct timespec)
+#define ANDROID_ALARM_SET_RTC               _IOW('a', 5, struct timespec)
+#define ANDROID_ALARM_BASE_CMD(cmd)         (cmd & ~(_IOC(0, 0, 0xf0, 0)))
+#define ANDROID_ALARM_IOCTL_TO_TYPE(cmd)    (_IOC_NR(cmd) >> 4)
+
+#endif
diff --git a/include/linux/anon_inodes.h b/include/linux/anon_inodes.h
index 69a21e0ebd3..8013a45242f 100644
--- a/include/linux/anon_inodes.h
+++ b/include/linux/anon_inodes.h
@@ -8,6 +8,8 @@
 #ifndef _LINUX_ANON_INODES_H
 #define _LINUX_ANON_INODES_H
 
+struct file_operations;
+
 struct file *anon_inode_getfile(const char *name,
                                 const struct file_operations *fops,
                                 void *priv, int flags);
diff --git a/include/linux/arcdevice.h b/include/linux/arcdevice.h
index 7d650a0e3d8..7216b0daf54 100644
--- a/include/linux/arcdevice.h
+++ b/include/linux/arcdevice.h
@@ -20,6 +20,7 @@
 #include <linux/if_arcnet.h>
 
 #ifdef __KERNEL__
+#include  <linux/irqreturn.h>
 
 #ifndef bool
 #define bool int
diff --git a/include/linux/ashmem.h b/include/linux/ashmem.h
new file mode 100644
index 00000000000..1976b10ef93
--- /dev/null
+++ b/include/linux/ashmem.h
@@ -0,0 +1,48 @@
+/*
+ * include/linux/ashmem.h
+ *
+ * Copyright 2008 Google Inc.
+ * Author: Robert Love
+ *
+ * This file is dual licensed.  It may be redistributed and/or modified
+ * under the terms of the Apache 2.0 License OR version 2 of the GNU
+ * General Public License.
+ */
+
+#ifndef _LINUX_ASHMEM_H
+#define _LINUX_ASHMEM_H
+
+#include <linux/limits.h>
+#include <linux/ioctl.h>
+
+#define ASHMEM_NAME_LEN         256
+
+#define ASHMEM_NAME_DEF         "dev/ashmem"
+
+/* Return values from ASHMEM_PIN: Was the mapping purged while unpinned? */
+#define ASHMEM_NOT_PURGED       0
+#define ASHMEM_WAS_PURGED       1
+
+/* Return values from ASHMEM_GET_PIN_STATUS: Is the mapping pinned? */
+#define ASHMEM_IS_UNPINNED      0
+#define ASHMEM_IS_PINNED        1
+
+struct ashmem_pin {
+        __u32 offset;   /* offset into region, in bytes, page-aligned */
+        __u32 len;      /* length forward from offset, in bytes, page-aligned */
+};
+
+#define __ASHMEMIOC             0x77
+
+#define ASHMEM_SET_NAME         _IOW(__ASHMEMIOC, 1, char[ASHMEM_NAME_LEN])
+#define ASHMEM_GET_NAME         _IOR(__ASHMEMIOC, 2, char[ASHMEM_NAME_LEN])
+#define ASHMEM_SET_SIZE         _IOW(__ASHMEMIOC, 3, size_t)
+#define ASHMEM_GET_SIZE         _IO(__ASHMEMIOC, 4)
+#define ASHMEM_SET_PROT_MASK    _IOW(__ASHMEMIOC, 5, unsigned long)
+#define ASHMEM_GET_PROT_MASK    _IO(__ASHMEMIOC, 6)
+#define ASHMEM_PIN              _IOW(__ASHMEMIOC, 7, struct ashmem_pin)
+#define ASHMEM_UNPIN            _IOW(__ASHMEMIOC, 8, struct ashmem_pin)
+#define ASHMEM_GET_PIN_STATUS   _IO(__ASHMEMIOC, 9)
+#define ASHMEM_PURGE_ALL_CACHES _IO(__ASHMEMIOC, 10)
+
+#endif  /* _LINUX_ASHMEM_H */
diff --git a/include/linux/ath9k_platform.h b/include/linux/ath9k_platform.h
index 60a7c49dcb4..6e3f54f3784 100644
--- a/include/linux/ath9k_platform.h
+++ b/include/linux/ath9k_platform.h
@@ -30,6 +30,8 @@ struct ath9k_platform_data {
         u32 gpio_val;
 
         bool is_clk_25mhz;
+        int (*get_mac_revision)(void);
+        int (*external_reset)(void);
 };
 
 #endif /* _LINUX_ATH9K_PLATFORM_H */
diff --git a/include/linux/atmdev.h b/include/linux/atmdev.h
index 381f4cec826..49a83ca900b 100644
--- a/include/linux/atmdev.h
+++ b/include/linux/atmdev.h
@@ -220,7 +220,7 @@ struct atm_cirange {
 #include <linux/skbuff.h> /* struct sk_buff */
 #include <linux/uio.h>
 #include <net/sock.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 #ifdef CONFIG_PROC_FS
 #include <linux/proc_fs.h>
diff --git a/include/linux/atomic.h b/include/linux/atomic.h
index ee456c79b0e..42b77b5446d 100644
--- a/include/linux/atomic.h
+++ b/include/linux/atomic.h
@@ -1,8 +1,32 @@
+/* Atomic operations usable in machine independent code */
 #ifndef _LINUX_ATOMIC_H
 #define _LINUX_ATOMIC_H
 #include <asm/atomic.h>
 
 /**
+ * atomic_add_unless - add unless the number is already a given value
+ * @v: pointer of type atomic_t
+ * @a: the amount to add to v...
+ * @u: ...unless v is equal to u.
+ *
+ * Atomically adds @a to @v, so long as @v was not already @u.
+ * Returns non-zero if @v was not @u, and zero otherwise.
+ */
+static inline int atomic_add_unless(atomic_t *v, int a, int u)
+{
+        return __atomic_add_unless(v, a, u) != u;
+}
+
+/**
+ * atomic_inc_not_zero - increment unless the number is zero
+ * @v: pointer of type atomic_t
+ *
+ * Atomically increments @v by 1, so long as @v is non-zero.
+ * Returns non-zero if @v was non-zero, and zero otherwise.
+ */
+#define atomic_inc_not_zero(v)          atomic_add_unless((v), 1, 0)
+
+/**
  * atomic_inc_not_zero_hint - increment if not null
  * @v: pointer of type atomic_t
  * @hint: probable value of the atomic before the increment
@@ -34,6 +58,32 @@ static inline int atomic_inc_not_zero_hint(atomic_t *v, int hint)
 }
 #endif
 
+#ifndef atomic_inc_unless_negative
+static inline int atomic_inc_unless_negative(atomic_t *p)
+{
+        int v, v1;
+        for (v = 0; v >= 0; v = v1) {
+                v1 = atomic_cmpxchg(p, v, v + 1);
+                if (likely(v1 == v))
+                        return 1;
+        }
+        return 0;
+}
+#endif
+
+#ifndef atomic_dec_unless_positive
+static inline int atomic_dec_unless_positive(atomic_t *p)
+{
+        int v, v1;
+        for (v = 0; v <= 0; v = v1) {
+                v1 = atomic_cmpxchg(p, v, v - 1);
+                if (likely(v1 == v))
+                        return 1;
+        }
+        return 0;
+}
+#endif
+
 #ifndef CONFIG_ARCH_HAS_ATOMIC_OR
 static inline void atomic_or(int i, atomic_t *v)
 {
@@ -47,4 +97,8 @@ static inline void atomic_or(int i, atomic_t *v)
 }
 #endif /* #ifndef CONFIG_ARCH_HAS_ATOMIC_OR */
 
+#include <asm-generic/atomic-long.h>
+#ifdef CONFIG_GENERIC_ATOMIC64
+#include <asm-generic/atomic64.h>
+#endif
 #endif /* _LINUX_ATOMIC_H */
diff --git a/include/linux/audit.h b/include/linux/audit.h
index 9d339eb2788..0c8006129fb 100644
--- a/include/linux/audit.h
+++ b/include/linux/audit.h
@@ -613,6 +613,12 @@ extern void		    audit_log_d_path(struct audit_buffer *ab,
 extern void                 audit_log_key(struct audit_buffer *ab,
                                           char *key);
 extern void                 audit_log_lost(const char *message);
+#ifdef CONFIG_SECURITY
+extern void                 audit_log_secctx(struct audit_buffer *ab, u32 secid);
+#else
+#define audit_log_secctx(b,s) do { ; } while (0)
+#endif
+
 extern int                  audit_update_lsm_rules(void);
 
                                 /* Private API (for audit.c only) */
@@ -635,6 +641,7 @@ extern int audit_enabled;
 #define audit_log_untrustedstring(a,s) do { ; } while (0)
 #define audit_log_d_path(b, p, d) do { ; } while (0)
 #define audit_log_key(b, k) do { ; } while (0)
+#define audit_log_secctx(b,s) do { ; } while (0)
 #define audit_enabled 0
 #endif
 #endif
diff --git a/include/linux/backing-dev.h b/include/linux/backing-dev.h
index 96f4094b706..3b2f9cb8298 100644
--- a/include/linux/backing-dev.h
+++ b/include/linux/backing-dev.h
@@ -16,7 +16,7 @@
 #include <linux/sched.h>
 #include <linux/timer.h>
 #include <linux/writeback.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 struct page;
 struct device;
@@ -40,6 +40,7 @@ typedef int (congested_fn)(void *, int);
 enum bdi_stat_item {
         BDI_RECLAIMABLE,
         BDI_WRITEBACK,
+        BDI_WRITTEN,
         NR_BDI_STAT_ITEMS
 };
 
@@ -57,6 +58,7 @@ struct bdi_writeback {
         struct list_head b_dirty;       /* dirty inodes */
         struct list_head b_io;          /* parked for writeback */
         struct list_head b_more_io;     /* parked for more writeback */
+        spinlock_t list_lock;           /* protects the b_* lists */
 };
 
 struct backing_dev_info {
@@ -71,6 +73,11 @@ struct backing_dev_info {
 
         struct percpu_counter bdi_stat[NR_BDI_STAT_ITEMS];
 
+        unsigned long bw_time_stamp;    /* last time write bw is updated */
+        unsigned long written_stamp;    /* pages written at bw_time_stamp */
+        unsigned long write_bandwidth;  /* the estimated write bandwidth */
+        unsigned long avg_write_bandwidth; /* further smoothed write bw */
+
         struct prop_local_percpu completions;
         int dirty_exceeded;
 
@@ -106,6 +113,7 @@ int bdi_writeback_thread(void *data);
 int bdi_has_dirty_io(struct backing_dev_info *bdi);
 void bdi_arm_supers_timer(void);
 void bdi_wakeup_thread_delayed(struct backing_dev_info *bdi);
+void bdi_lock_two(struct bdi_writeback *wb1, struct bdi_writeback *wb2);
 
 extern spinlock_t bdi_lock;
 extern struct list_head bdi_list;
diff --git a/include/linux/basic_mmio_gpio.h b/include/linux/basic_mmio_gpio.h
index 98999cf107c..feb91219674 100644
--- a/include/linux/basic_mmio_gpio.h
+++ b/include/linux/basic_mmio_gpio.h
@@ -63,15 +63,10 @@ static inline struct bgpio_chip *to_bgpio_chip(struct gpio_chip *gc)
         return container_of(gc, struct bgpio_chip, gc);
 }
 
-int __devexit bgpio_remove(struct bgpio_chip *bgc);
-int __devinit bgpio_init(struct bgpio_chip *bgc,
-                         struct device *dev,
-                         unsigned long sz,
-                         void __iomem *dat,
-                         void __iomem *set,
-                         void __iomem *clr,
-                         void __iomem *dirout,
-                         void __iomem *dirin,
-                         bool big_endian);
+int bgpio_remove(struct bgpio_chip *bgc);
+int bgpio_init(struct bgpio_chip *bgc, struct device *dev,
+               unsigned long sz, void __iomem *dat, void __iomem *set,
+               void __iomem *clr, void __iomem *dirout, void __iomem *dirin,
+               bool big_endian);
 
 #endif /* __BASIC_MMIO_GPIO_H */
diff --git a/include/linux/bcma/bcma.h b/include/linux/bcma/bcma.h
index 08763e4e848..8c96654bef1 100644
--- a/include/linux/bcma/bcma.h
+++ b/include/linux/bcma/bcma.h
@@ -6,6 +6,7 @@
 
 #include <linux/bcma/bcma_driver_chipcommon.h>
 #include <linux/bcma/bcma_driver_pci.h>
+#include <linux/ssb/ssb.h> /* SPROM sharing */
 
 #include "bcma_regs.h"
 
@@ -24,6 +25,11 @@ struct bcma_chipinfo {
         u8 pkg;
 };
 
+enum bcma_clkmode {
+        BCMA_CLKMODE_FAST,
+        BCMA_CLKMODE_DYNAMIC,
+};
+
 struct bcma_host_ops {
         u8 (*read8)(struct bcma_device *core, u16 offset);
         u16 (*read16)(struct bcma_device *core, u16 offset);
@@ -31,6 +37,12 @@ struct bcma_host_ops {
         void (*write8)(struct bcma_device *core, u16 offset, u8 value);
         void (*write16)(struct bcma_device *core, u16 offset, u16 value);
         void (*write32)(struct bcma_device *core, u16 offset, u32 value);
+#ifdef CONFIG_BCMA_BLOCKIO
+        void (*block_read)(struct bcma_device *core, void *buffer,
+                           size_t count, u16 offset, u8 reg_width);
+        void (*block_write)(struct bcma_device *core, const void *buffer,
+                            size_t count, u16 offset, u8 reg_width);
+#endif
         /* Agent ops */
         u32 (*aread32)(struct bcma_device *core, u16 offset);
         void (*awrite32)(struct bcma_device *core, u16 offset, u32 value);
@@ -117,6 +129,8 @@ struct bcma_device {
         struct bcma_device_id id;
 
         struct device dev;
+        struct device *dma_dev;
+        unsigned int irq;
         bool dev_registered;
 
         u8 core_index;
@@ -179,6 +193,10 @@ struct bcma_bus {
 
         struct bcma_drv_cc drv_cc;
         struct bcma_drv_pci drv_pci;
+
+        /* We decided to share SPROM struct with SSB as long as we do not need
+         * any hacks for BCMA. This simplifies drivers code. */
+        struct ssb_sprom sprom;
 };
 
 extern inline u32 bcma_read8(struct bcma_device *core, u16 offset)
@@ -208,6 +226,18 @@ void bcma_write32(struct bcma_device *core, u16 offset, u32 value)
 {
         core->bus->ops->write32(core, offset, value);
 }
+#ifdef CONFIG_BCMA_BLOCKIO
+extern inline void bcma_block_read(struct bcma_device *core, void *buffer,
+                                   size_t count, u16 offset, u8 reg_width)
+{
+        core->bus->ops->block_read(core, buffer, count, offset, reg_width);
+}
+extern inline void bcma_block_write(struct bcma_device *core, const void *buffer,
+                                    size_t count, u16 offset, u8 reg_width)
+{
+        core->bus->ops->block_write(core, buffer, count, offset, reg_width);
+}
+#endif
 extern inline u32 bcma_aread32(struct bcma_device *core, u16 offset)
 {
         return core->bus->ops->aread32(core, offset);
@@ -218,7 +248,24 @@ void bcma_awrite32(struct bcma_device *core, u16 offset, u32 value)
         core->bus->ops->awrite32(core, offset, value);
 }
 
+#define bcma_mask32(cc, offset, mask) \
+        bcma_write32(cc, offset, bcma_read32(cc, offset) & (mask))
+#define bcma_set32(cc, offset, set) \
+        bcma_write32(cc, offset, bcma_read32(cc, offset) | (set))
+#define bcma_maskset32(cc, offset, mask, set) \
+        bcma_write32(cc, offset, (bcma_read32(cc, offset) & (mask)) | (set))
+
 extern bool bcma_core_is_enabled(struct bcma_device *core);
+extern void bcma_core_disable(struct bcma_device *core, u32 flags);
 extern int bcma_core_enable(struct bcma_device *core, u32 flags);
+extern void bcma_core_set_clockmode(struct bcma_device *core,
+                                    enum bcma_clkmode clkmode);
+extern void bcma_core_pll_ctl(struct bcma_device *core, u32 req, u32 status,
+                              bool on);
+#define BCMA_DMA_TRANSLATION_MASK       0xC0000000
+#define  BCMA_DMA_TRANSLATION_NONE      0x00000000
+#define  BCMA_DMA_TRANSLATION_DMA32_CMT 0x40000000 /* Client Mode Translation for 32-bit DMA */
+#define  BCMA_DMA_TRANSLATION_DMA64_CMT 0x80000000 /* Client Mode Translation for 64-bit DMA */
+extern u32 bcma_core_dma_translation(struct bcma_device *core);
 
 #endif /* LINUX_BCMA_H_ */
diff --git a/include/linux/bcma/bcma_driver_chipcommon.h b/include/linux/bcma/bcma_driver_chipcommon.h
index 083c3b6cd5c..a0f684615ae 100644
--- a/include/linux/bcma/bcma_driver_chipcommon.h
+++ b/include/linux/bcma/bcma_driver_chipcommon.h
@@ -179,15 +179,7 @@
 #define BCMA_CC_PROG_WAITCNT            0x0124
 #define BCMA_CC_FLASH_CFG               0x0128
 #define BCMA_CC_FLASH_WAITCNT           0x012C
-#define BCMA_CC_CLKCTLST                0x01E0 /* Clock control and status (rev >= 20) */
-#define  BCMA_CC_CLKCTLST_FORCEALP      0x00000001 /* Force ALP request */
-#define  BCMA_CC_CLKCTLST_FORCEHT       0x00000002 /* Force HT request */
-#define  BCMA_CC_CLKCTLST_FORCEILP      0x00000004 /* Force ILP request */
-#define  BCMA_CC_CLKCTLST_HAVEALPREQ    0x00000008 /* ALP available request */
-#define  BCMA_CC_CLKCTLST_HAVEHTREQ     0x00000010 /* HT available request */
-#define  BCMA_CC_CLKCTLST_HWCROFF       0x00000020 /* Force HW clock request off */
-#define  BCMA_CC_CLKCTLST_HAVEHT        0x00010000 /* HT available */
-#define  BCMA_CC_CLKCTLST_HAVEALP       0x00020000 /* APL available */
+/* 0x1E0 is defined as shared BCMA_CLKCTLST */
 #define BCMA_CC_HW_WORKAROUND           0x01E4 /* Hardware workaround (rev >= 20) */
 #define BCMA_CC_UART0_DATA              0x0300
 #define BCMA_CC_UART0_IMR               0x0304
@@ -244,6 +236,8 @@
 #define BCMA_CC_REGCTL_DATA             0x065C
 #define BCMA_CC_PLLCTL_ADDR             0x0660
 #define BCMA_CC_PLLCTL_DATA             0x0664
+#define BCMA_CC_SPROM                   0x0800 /* SPROM beginning */
+#define BCMA_CC_SPROM_PCIE6             0x0830 /* SPROM beginning on PCIe rev >= 6 */
 
 /* Data for the PMU, if available.
  * Check availability with ((struct bcma_chipcommon)->capabilities & BCMA_CC_CAP_PMU)
diff --git a/include/linux/bcma/bcma_driver_pci.h b/include/linux/bcma/bcma_driver_pci.h
index b7e191cf00e..3871b668caf 100644
--- a/include/linux/bcma/bcma_driver_pci.h
+++ b/include/linux/bcma/bcma_driver_pci.h
@@ -85,5 +85,7 @@ struct bcma_drv_pci {
 #define pcicore_write32(pc, offset, val)        bcma_write32((pc)->core, offset, val)
 
 extern void bcma_core_pci_init(struct bcma_drv_pci *pc);
+extern int bcma_core_pci_irq_ctl(struct bcma_drv_pci *pc,
+                                 struct bcma_device *core, bool enable);
 
 #endif /* LINUX_BCMA_DRIVER_PCI_H_ */
diff --git a/include/linux/bcma/bcma_regs.h b/include/linux/bcma/bcma_regs.h
index f82d88a960c..9faae2ae02e 100644
--- a/include/linux/bcma/bcma_regs.h
+++ b/include/linux/bcma/bcma_regs.h
@@ -1,13 +1,38 @@
 #ifndef LINUX_BCMA_REGS_H_
 #define LINUX_BCMA_REGS_H_
 
+/* Some single registers are shared between many cores */
+/* BCMA_CLKCTLST: ChipCommon (rev >= 20), PCIe, 80211 */
+#define BCMA_CLKCTLST                   0x01E0 /* Clock control and status */
+#define  BCMA_CLKCTLST_FORCEALP         0x00000001 /* Force ALP request */
+#define  BCMA_CLKCTLST_FORCEHT          0x00000002 /* Force HT request */
+#define  BCMA_CLKCTLST_FORCEILP         0x00000004 /* Force ILP request */
+#define  BCMA_CLKCTLST_HAVEALPREQ       0x00000008 /* ALP available request */
+#define  BCMA_CLKCTLST_HAVEHTREQ        0x00000010 /* HT available request */
+#define  BCMA_CLKCTLST_HWCROFF          0x00000020 /* Force HW clock request off */
+#define  BCMA_CLKCTLST_EXTRESREQ        0x00000700 /* Mask of external resource requests */
+#define  BCMA_CLKCTLST_HAVEALP          0x00010000 /* ALP available */
+#define  BCMA_CLKCTLST_HAVEHT           0x00020000 /* HT available */
+#define  BCMA_CLKCTLST_BP_ON_ALP        0x00040000 /* RO: running on ALP clock */
+#define  BCMA_CLKCTLST_BP_ON_HT         0x00080000 /* RO: running on HT clock */
+#define  BCMA_CLKCTLST_EXTRESST         0x07000000 /* Mask of external resource status */
+/* Is there any BCM4328 on BCMA bus? */
+#define  BCMA_CLKCTLST_4328A0_HAVEHT    0x00010000 /* 4328a0 has reversed bits */
+#define  BCMA_CLKCTLST_4328A0_HAVEALP   0x00020000 /* 4328a0 has reversed bits */
+
 /* Agent registers (common for every core) */
-#define BCMA_IOCTL                      0x0408
+#define BCMA_IOCTL                      0x0408 /* IO control */
 #define  BCMA_IOCTL_CLK                 0x0001
 #define  BCMA_IOCTL_FGC                 0x0002
 #define  BCMA_IOCTL_CORE_BITS           0x3FFC
 #define  BCMA_IOCTL_PME_EN              0x4000
 #define  BCMA_IOCTL_BIST_EN             0x8000
+#define BCMA_IOST                       0x0500 /* IO status */
+#define  BCMA_IOST_CORE_BITS            0x0FFF
+#define  BCMA_IOST_DMA64                0x1000
+#define  BCMA_IOST_GATED_CLK            0x2000
+#define  BCMA_IOST_BIST_ERROR           0x4000
+#define  BCMA_IOST_BIST_DONE            0x8000
 #define BCMA_RESET_CTL                  0x0800
 #define  BCMA_RESET_CTL_RESET           0x0001
 
diff --git a/include/linux/binfmts.h b/include/linux/binfmts.h
index 8845613fd7e..fd88a3945aa 100644
--- a/include/linux/binfmts.h
+++ b/include/linux/binfmts.h
@@ -111,6 +111,7 @@ extern int __must_check remove_arg_zero(struct linux_binprm *);
 extern int search_binary_handler(struct linux_binprm *, struct pt_regs *);
 extern int flush_old_exec(struct linux_binprm * bprm);
 extern void setup_new_exec(struct linux_binprm * bprm);
+extern void would_dump(struct linux_binprm *, struct file *);
 
 extern int suid_dumpable;
 #define SUID_DUMP_DISABLE       0       /* No setuid dumping */
diff --git a/include/linux/bit_spinlock.h b/include/linux/bit_spinlock.h
index b4326bfa684..ac4d9f8b52e 100644
--- a/include/linux/bit_spinlock.h
+++ b/include/linux/bit_spinlock.h
@@ -3,7 +3,7 @@
 
 #include <linux/kernel.h>
 #include <linux/preempt.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 /*
  *  bit-based spin_lock()
@@ -88,7 +88,7 @@ static inline int bit_spin_is_locked(int bitnum, unsigned long *addr)
 {
 #if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
         return test_bit(bitnum, addr);
-#elif defined CONFIG_PREEMPT
+#elif defined CONFIG_PREEMPT_COUNT
         return preempt_count();
 #else
         return 1;
diff --git a/include/linux/bitmap.h b/include/linux/bitmap.h
index dcafe0bf000..7ad634501e4 100644
--- a/include/linux/bitmap.h
+++ b/include/linux/bitmap.h
@@ -144,7 +144,9 @@ extern int bitmap_find_free_region(unsigned long *bitmap, int bits, int order);
 extern void bitmap_release_region(unsigned long *bitmap, int pos, int order);
 extern int bitmap_allocate_region(unsigned long *bitmap, int pos, int order);
 extern void bitmap_copy_le(void *dst, const unsigned long *src, int nbits);
+extern int bitmap_ord_to_pos(const unsigned long *bitmap, int n, int bits);
 
+#define BITMAP_FIRST_WORD_MASK(start) (~0UL << ((start) % BITS_PER_LONG))
 #define BITMAP_LAST_WORD_MASK(nbits)                                    \
 (                                                                       \
         ((nbits) % BITS_PER_LONG) ?                                     \
diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h
index 6395692b2e7..71fc53bb8f1 100644
--- a/include/linux/blk_types.h
+++ b/include/linux/blk_types.h
@@ -124,8 +124,13 @@ enum rq_flag_bits {
 
         __REQ_SYNC,             /* request is sync (sync write or read) */
         __REQ_META,             /* metadata io request */
+        __REQ_PRIO,             /* boost priority in cfq */
         __REQ_DISCARD,          /* request to discard sectors */
+        __REQ_SECURE,           /* secure discard (used with __REQ_DISCARD) */
+
         __REQ_NOIDLE,           /* don't anticipate more IO after this one */
+        __REQ_FUA,              /* forced unit access */
+        __REQ_FLUSH,            /* request for cache flush */
 
         /* bio only flags */
         __REQ_RAHEAD,           /* read ahead, can fail anytime */
@@ -135,7 +140,6 @@ enum rq_flag_bits {
         /* request only flags */
         __REQ_SORTED,           /* elevator knows about this request */
         __REQ_SOFTBARRIER,      /* may not be passed by ioscheduler */
-        __REQ_FUA,              /* forced unit access */
         __REQ_NOMERGE,          /* don't touch this for merging */
         __REQ_STARTED,          /* drive already may have started this one */
         __REQ_DONTPREP,         /* don't call prep for this one */
@@ -146,11 +150,9 @@ enum rq_flag_bits {
         __REQ_PREEMPT,          /* set for "ide_preempt" requests */
         __REQ_ALLOCED,          /* request came from our alloc pool */
         __REQ_COPY_USER,        /* contains copies of user pages */
-        __REQ_FLUSH,            /* request for cache flush */
         __REQ_FLUSH_SEQ,        /* request for flush sequence */
         __REQ_IO_STAT,          /* account I/O stat */
         __REQ_MIXED_MERGE,      /* merge of different types, fail separately */
-        __REQ_SECURE,           /* secure discard (used with __REQ_DISCARD) */
         __REQ_NR_BITS,          /* stops here */
 };
 
@@ -160,14 +162,15 @@ enum rq_flag_bits {
 #define REQ_FAILFAST_DRIVER     (1 << __REQ_FAILFAST_DRIVER)
 #define REQ_SYNC                (1 << __REQ_SYNC)
 #define REQ_META                (1 << __REQ_META)
+#define REQ_PRIO                (1 << __REQ_PRIO)
 #define REQ_DISCARD             (1 << __REQ_DISCARD)
 #define REQ_NOIDLE              (1 << __REQ_NOIDLE)
 
 #define REQ_FAILFAST_MASK \
         (REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER)
 #define REQ_COMMON_MASK \
-        (REQ_WRITE | REQ_FAILFAST_MASK | REQ_SYNC | REQ_META | REQ_DISCARD | \
-         REQ_NOIDLE | REQ_FLUSH | REQ_FUA | REQ_SECURE)
+        (REQ_WRITE | REQ_FAILFAST_MASK | REQ_SYNC | REQ_META | REQ_PRIO | \
+         REQ_DISCARD | REQ_NOIDLE | REQ_FLUSH | REQ_FUA | REQ_SECURE)
 #define REQ_CLONE_MASK          REQ_COMMON_MASK
 
 #define REQ_RAHEAD              (1 << __REQ_RAHEAD)
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 1a23722e887..5e30b45d3d6 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -30,6 +30,7 @@ struct request_pm_state;
 struct blk_trace;
 struct request;
 struct sg_io_hdr;
+struct bsg_job;
 
 #define BLKDEV_MIN_RQ   4
 #define BLKDEV_MAX_RQ   128     /* Default maximum */
@@ -73,7 +74,7 @@ enum rq_cmd_type_bits {
 
 /*
  * try to put the fields that are referenced together in the same cacheline.
- * if you modify this structure, be sure to check block/blk-core.c:rq_init()
+ * if you modify this structure, be sure to check block/blk-core.c:blk_rq_init()
  * as well!
  */
 struct request {
@@ -117,6 +118,7 @@ struct request {
                 struct {
                         unsigned int            seq;
                         struct list_head        list;
+                        rq_end_io_fn            *saved_end_io;
                 } flush;
         };
 
@@ -209,6 +211,7 @@ typedef int (merge_bvec_fn) (struct request_queue *, struct bvec_merge_data *,
 typedef void (softirq_done_fn)(struct request *);
 typedef int (dma_drain_needed_fn)(struct request *);
 typedef int (lld_busy_fn) (struct request_queue *q);
+typedef int (bsg_job_fn) (struct bsg_job *);
 
 enum blk_eh_timer_return {
         BLK_EH_NOT_HANDLED,
@@ -260,8 +263,7 @@ struct queue_limits {
         unsigned char           discard_zeroes_data;
 };
 
-struct request_queue
-{
+struct request_queue {
         /*
          * Together with queue_head for cacheline sharing
          */
@@ -304,14 +306,14 @@ struct request_queue
         void                    *queuedata;
 
         /*
-         * queue needs bounce pages for pages above this limit
+         * various queue flags, see QUEUE_* below
          */
-        gfp_t                   bounce_gfp;
+        unsigned long           queue_flags;
 
         /*
-         * various queue flags, see QUEUE_* below
+         * queue needs bounce pages for pages above this limit
          */
-        unsigned long           queue_flags;
+        gfp_t                   bounce_gfp;
 
         /*
          * protects queue structures from reentrancy. ->__queue_lock should
@@ -334,8 +336,8 @@ struct request_queue
         unsigned int            nr_congestion_off;
         unsigned int            nr_batching;
 
-        void                    *dma_drain_buffer;
         unsigned int            dma_drain_size;
+        void                    *dma_drain_buffer;
         unsigned int            dma_pad_mask;
         unsigned int            dma_alignment;
 
@@ -376,6 +378,8 @@ struct request_queue
         struct mutex            sysfs_lock;
 
 #if defined(CONFIG_BLK_DEV_BSG)
+        bsg_job_fn              *bsg_job_fn;
+        int                     bsg_job_size;
         struct bsg_class_device bsg_dev;
 #endif
 
@@ -393,7 +397,7 @@ struct request_queue
 #define QUEUE_FLAG_ELVSWITCH    6       /* don't use elevator, just do FIFO */
 #define QUEUE_FLAG_BIDI         7       /* queue supports bidi requests */
 #define QUEUE_FLAG_NOMERGES     8       /* disable merge attempts */
-#define QUEUE_FLAG_SAME_COMP    9       /* force complete on same CPU */
+#define QUEUE_FLAG_SAME_COMP    9       /* complete on same CPU-group */
 #define QUEUE_FLAG_FAIL_IO     10       /* fake timeout */
 #define QUEUE_FLAG_STACKABLE   11       /* supports request stacking */
 #define QUEUE_FLAG_NONROT      12       /* non-rotational device (SSD) */
@@ -403,6 +407,7 @@ struct request_queue
 #define QUEUE_FLAG_NOXMERGES   15       /* No extended merges */
 #define QUEUE_FLAG_ADD_RANDOM  16       /* Contributes to random pool */
 #define QUEUE_FLAG_SECDISCARD  17       /* supports SECDISCARD */
+#define QUEUE_FLAG_SAME_FORCE  18       /* force complete on same CPU */
 
 #define QUEUE_FLAG_DEFAULT      ((1 << QUEUE_FLAG_IO_STAT) |            \
                                  (1 << QUEUE_FLAG_STACKABLE)    |       \
@@ -798,9 +803,6 @@ extern void blk_unprep_request(struct request *);
  */
 extern struct request_queue *blk_init_queue_node(request_fn_proc *rfn,
                                         spinlock_t *lock, int node_id);
-extern struct request_queue *blk_init_allocated_queue_node(struct request_queue *,
-                                                           request_fn_proc *,
-                                                           spinlock_t *, int node_id);
 extern struct request_queue *blk_init_queue(request_fn_proc *, spinlock_t *);
 extern struct request_queue *blk_init_allocated_queue(struct request_queue *,
                                                       request_fn_proc *, spinlock_t *);
@@ -857,12 +859,20 @@ struct request_queue *blk_alloc_queue(gfp_t);
 struct request_queue *blk_alloc_queue_node(gfp_t, int);
 extern void blk_put_queue(struct request_queue *);
 
+/*
+ * Note: Code in between changing the blk_plug list/cb_list or element of such
+ * lists is preemptable, but such code can't do sleep (or be very careful),
+ * otherwise data is corrupted. For details, please check schedule() where
+ * blk_schedule_flush_plug() is called.
+ */
 struct blk_plug {
         unsigned long magic;
         struct list_head list;
         struct list_head cb_list;
         unsigned int should_sort;
 };
+#define BLK_MAX_REQUEST_COUNT 16
+
 struct blk_plug_cb {
         struct list_head list;
         void (*callback)(struct blk_plug_cb *);
diff --git a/include/linux/blktrace_api.h b/include/linux/blktrace_api.h
index 8c7c2de7631..8e9e4bc6d73 100644
--- a/include/linux/blktrace_api.h
+++ b/include/linux/blktrace_api.h
@@ -14,7 +14,7 @@
 enum blktrace_cat {
         BLK_TC_READ     = 1 << 0,       /* reads */
         BLK_TC_WRITE    = 1 << 1,       /* writes */
-        BLK_TC_BARRIER  = 1 << 2,       /* barrier */
+        BLK_TC_FLUSH    = 1 << 2,       /* flush */
         BLK_TC_SYNC     = 1 << 3,       /* sync IO */
         BLK_TC_SYNCIO   = BLK_TC_SYNC,
         BLK_TC_QUEUE    = 1 << 4,       /* queueing/merging */
@@ -28,8 +28,9 @@ enum blktrace_cat {
         BLK_TC_META     = 1 << 12,      /* metadata */
         BLK_TC_DISCARD  = 1 << 13,      /* discard requests */
         BLK_TC_DRV_DATA = 1 << 14,      /* binary per-driver data */
+        BLK_TC_FUA      = 1 << 15,      /* fua requests */
 
-        BLK_TC_END      = 1 << 15,      /* only 16-bits, reminder */
+        BLK_TC_END      = 1 << 15,      /* we've run out of bits! */
 };
 
 #define BLK_TC_SHIFT            (16)
diff --git a/include/linux/bq27x00.h b/include/linux/bq27x00.h
new file mode 100644
index 00000000000..b95cd203523
--- /dev/null
+++ b/include/linux/bq27x00.h
@@ -0,0 +1,30 @@
+/*
+ * include/linux/bq27x00.h
+ *
+ * BQ27x00 battery driver
+ *
+ * Copyright (c) 2011, NVIDIA Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#ifndef _LINUX_BQ27x00_H
+#define _LINUX_BQ27x00_H
+
+struct bq27x00_platform_data {
+        int ac_persent_gpio;
+};
+
+#endif /* _LINUX_BQ27x00_H */
diff --git a/include/linux/bsg-lib.h b/include/linux/bsg-lib.h
new file mode 100644
index 00000000000..f55ab8cdc10
--- /dev/null
+++ b/include/linux/bsg-lib.h
@@ -0,0 +1,73 @@
+/*
+ *  BSG helper library
+ *
+ *  Copyright (C) 2008   James Smart, Emulex Corporation
+ *  Copyright (C) 2011   Red Hat, Inc.  All rights reserved.
+ *  Copyright (C) 2011   Mike Christie
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+#ifndef _BLK_BSG_
+#define _BLK_BSG_
+
+#include <linux/blkdev.h>
+
+struct request;
+struct device;
+struct scatterlist;
+struct request_queue;
+
+struct bsg_buffer {
+        unsigned int payload_len;
+        int sg_cnt;
+        struct scatterlist *sg_list;
+};
+
+struct bsg_job {
+        struct device *dev;
+        struct request *req;
+
+        /* Transport/driver specific request/reply structs */
+        void *request;
+        void *reply;
+
+        unsigned int request_len;
+        unsigned int reply_len;
+        /*
+         * On entry : reply_len indicates the buffer size allocated for
+         * the reply.
+         *
+         * Upon completion : the message handler must set reply_len
+         *  to indicates the size of the reply to be returned to the
+         *  caller.
+         */
+
+        /* DMA payloads for the request/response */
+        struct bsg_buffer request_payload;
+        struct bsg_buffer reply_payload;
+
+        void *dd_data;          /* Used for driver-specific storage */
+};
+
+void bsg_job_done(struct bsg_job *job, int result,
+                  unsigned int reply_payload_rcv_len);
+int bsg_setup_queue(struct device *dev, struct request_queue *q, char *name,
+                    bsg_job_fn *job_fn, int dd_job_size);
+void bsg_request_fn(struct request_queue *q);
+void bsg_remove_queue(struct request_queue *q);
+void bsg_goose_queue(struct request_queue *q);
+
+#endif
diff --git a/include/linux/buffer_head.h b/include/linux/buffer_head.h
index 503c8a6b307..458f497738a 100644
--- a/include/linux/buffer_head.h
+++ b/include/linux/buffer_head.h
@@ -12,7 +12,7 @@
 #include <linux/linkage.h>
 #include <linux/pagemap.h>
 #include <linux/wait.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 #ifdef CONFIG_BLOCK
 
diff --git a/include/linux/ceph/libceph.h b/include/linux/ceph/libceph.h
index 6365f041745..563755181c1 100644
--- a/include/linux/ceph/libceph.h
+++ b/include/linux/ceph/libceph.h
@@ -35,7 +35,7 @@
 #define CEPH_OPT_MYIP             (1<<2) /* specified my ip */
 #define CEPH_OPT_NOCRC            (1<<3) /* no data crc on writes */
 
-#define CEPH_OPT_DEFAULT   (0);
+#define CEPH_OPT_DEFAULT   (0)
 
 #define ceph_set_opt(client, opt) \
         (client)->options->flags |= CEPH_OPT_##opt;
diff --git a/include/linux/ceph/messenger.h b/include/linux/ceph/messenger.h
index 31d91a64838..d7adf151d33 100644
--- a/include/linux/ceph/messenger.h
+++ b/include/linux/ceph/messenger.h
@@ -94,6 +94,7 @@ struct ceph_msg {
         bool more_to_follow;
         bool needs_out_seq;
         int front_max;
+        unsigned long ack_stamp;        /* tx: when we were acked */
 
         struct ceph_msgpool *pool;
 };
diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h
index ab4ac0ccb85..cefedc8ced9 100644
--- a/include/linux/cgroup.h
+++ b/include/linux/cgroup.h
@@ -84,12 +84,6 @@ enum {
         CSS_REMOVED, /* This CSS is dead */
 };
 
-/* Caller must verify that the css is not for root cgroup */
-static inline void __css_get(struct cgroup_subsys_state *css, int count)
-{
-        atomic_add(count, &css->refcnt);
-}
-
 /*
  * Call css_get() to hold a reference on the css; it can be used
  * for a reference obtained via:
@@ -97,6 +91,7 @@ static inline void __css_get(struct cgroup_subsys_state *css, int count)
  * - task->cgroups for a locked task
  */
 
+extern void __css_get(struct cgroup_subsys_state *css, int count);
 static inline void css_get(struct cgroup_subsys_state *css)
 {
         /* We don't need to reference count the root state */
@@ -143,10 +138,7 @@ static inline void css_put(struct cgroup_subsys_state *css)
 enum {
         /* Control Group is dead */
         CGRP_REMOVED,
-        /*
-         * Control Group has previously had a child cgroup or a task,
-         * but no longer (only if CGRP_NOTIFY_ON_RELEASE is set)
-         */
+        /* Control Group has ever had a child cgroup or a task */
         CGRP_RELEASABLE,
         /* Control Group requires release notifications to userspace */
         CGRP_NOTIFY_ON_RELEASE,
@@ -287,6 +279,7 @@ struct css_set {
 
         /* For RCU-protected deletion */
         struct rcu_head rcu_head;
+        struct work_struct work;
 };
 
 /*
@@ -466,6 +459,7 @@ struct cgroup_subsys {
                                                   struct cgroup *cgrp);
         int (*pre_destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);
         void (*destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);
+        int (*allow_attach)(struct cgroup *cgrp, struct task_struct *tsk);
         int (*can_attach)(struct cgroup_subsys *ss, struct cgroup *cgrp,
                           struct task_struct *tsk);
         int (*can_attach_task)(struct cgroup *cgrp, struct task_struct *tsk);
@@ -539,7 +533,6 @@ static inline struct cgroup_subsys_state *cgroup_subsys_state(
  */
 #define task_subsys_state_check(task, subsys_id, __c)                   \
         rcu_dereference_check(task->cgroups->subsys[subsys_id],         \
-                              rcu_read_lock_held() ||                   \
                               lockdep_is_held(&task->alloc_lock) ||     \
                               cgroup_lock_is_held() || (__c))
 
diff --git a/include/linux/clocksource.h b/include/linux/clocksource.h
index 18a1baf31f2..c86c940d1de 100644
--- a/include/linux/clocksource.h
+++ b/include/linux/clocksource.h
@@ -22,6 +22,10 @@
 typedef u64 cycle_t;
 struct clocksource;
 
+#ifdef CONFIG_ARCH_CLOCKSOURCE_DATA
+#include <asm/clocksource.h>
+#endif
+
 /**
  * struct cyclecounter - hardware abstraction for a free running counter
  *      Provides completely state-free accessors to the underlying hardware.
@@ -152,8 +156,9 @@ extern u64 timecounter_cyc2time(struct timecounter *tc,
  * @mult:               cycle to nanosecond multiplier
  * @shift:              cycle to nanosecond divisor (power of two)
  * @max_idle_ns:        max idle time permitted by the clocksource (nsecs)
+ * @maxadj              maximum adjustment value to mult (~11%)
  * @flags:              flags describing special properties
- * @vread:              vsyscall based read
+ * @archdata:           arch-specific data
  * @suspend:            suspend function for the clocksource, if necessary
  * @resume:             resume function for the clocksource, if necessary
  */
@@ -168,17 +173,14 @@ struct clocksource {
         u32 mult;
         u32 shift;
         u64 max_idle_ns;
-
-#ifdef CONFIG_IA64
-        void *fsys_mmio;        /* used by fsyscall asm code */
-#define CLKSRC_FSYS_MMIO_SET(mmio, addr)      ((mmio) = (addr))
-#else
-#define CLKSRC_FSYS_MMIO_SET(mmio, addr)      do { } while (0)
+        u32 maxadj;
+#ifdef CONFIG_ARCH_CLOCKSOURCE_DATA
+        struct arch_clocksource_data archdata;
 #endif
+
         const char *name;
         struct list_head list;
         int rating;
-        cycle_t (*vread)(void);
         int (*enable)(struct clocksource *cs);
         void (*disable)(struct clocksource *cs);
         unsigned long flags;
diff --git a/include/linux/cm3217.h b/include/linux/cm3217.h
new file mode 100644
index 00000000000..29c72b58f8e
--- /dev/null
+++ b/include/linux/cm3217.h
@@ -0,0 +1,59 @@
+/* include/linux/cm3217.h
+ *
+ * Copyright (C) 2011 Capella Microsystems Inc.
+ * Author: Frank Hsieh <pengyueh@gmail.com>
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef __LINUX_CM3217_H
+#define __LINUX_CM3217_H
+
+#define CM3217_I2C_NAME                 "cm3217"
+
+#define ALS_W_CMD1_addr                 (0x20 >> 1)
+#define ALS_W_CMD2_addr                 (0x22 >> 1)
+#define ALS_R_MSB_addr                  (0x21 >> 1)
+#define ALS_R_LSB_addr                  (0x23 >> 1)
+
+#define ALS_CALIBRATED                  0x6E93
+
+/* cm3217 */
+
+/* for ALS command 20h */
+#define CM3217_ALS_BIT5_Default_1       (1 << 5)
+#define CM3217_ALS_IT_HALF_T            (0 << 2)
+#define CM3217_ALS_IT_1_T               (1 << 2)
+#define CM3217_ALS_IT_2_T               (2 << 2)
+#define CM3217_ALS_IT_4_T               (4 << 2)
+#define CM3217_ALS_WDM_DEFAULT_1        (1 << 1)
+#define CM3217_ALS_SD                   (1 << 0)
+
+/* for ALS command 22h */
+#define CM3217_ALS_IT_800ms             (0 << 5)
+#define CM3217_ALS_IT_400ms             (1 << 5)
+#define CM3217_ALS_IT_266ms             (2 << 5)
+#define CM3217_ALS_IT_200ms             (3 << 5)
+#define CM3217_ALS_IT_130ms             (4 << 5)
+#define CM3217_ALS_IT_100ms             (5 << 5)
+#define CM3217_ALS_IT_80ms              (6 << 5)
+#define CM3217_ALS_IT_66ms              (7 << 5)
+
+struct cm3217_platform_data {
+        uint16_t levels[10];
+        uint16_t golden_adc;
+        int (*power) (int, uint8_t);    /* power to the chip */
+        uint16_t ALS_slave_address;
+};
+
+#define LS_PWR_ON (1 << 0)
+
+#endif
diff --git a/include/linux/cn_proc.h b/include/linux/cn_proc.h
index 47dac5ea8d3..12c517b51ca 100644
--- a/include/linux/cn_proc.h
+++ b/include/linux/cn_proc.h
@@ -53,6 +53,7 @@ struct proc_event {
                 PROC_EVENT_UID  = 0x00000004,
                 PROC_EVENT_GID  = 0x00000040,
                 PROC_EVENT_SID  = 0x00000080,
+                PROC_EVENT_PTRACE = 0x00000100,
                 /* "next" should be 0x00000400 */
                 /* "last" is the last process event: exit */
                 PROC_EVENT_EXIT = 0x80000000
@@ -95,6 +96,13 @@ struct proc_event {
                         __kernel_pid_t process_tgid;
                 } sid;
 
+                struct ptrace_proc_event {
+                        __kernel_pid_t process_pid;
+                        __kernel_pid_t process_tgid;
+                        __kernel_pid_t tracer_pid;
+                        __kernel_pid_t tracer_tgid;
+                } ptrace;
+
                 struct exit_proc_event {
                         __kernel_pid_t process_pid;
                         __kernel_pid_t process_tgid;
@@ -109,6 +117,7 @@ void proc_fork_connector(struct task_struct *task);
 void proc_exec_connector(struct task_struct *task);
 void proc_id_connector(struct task_struct *task, int which_id);
 void proc_sid_connector(struct task_struct *task);
+void proc_ptrace_connector(struct task_struct *task, int which_id);
 void proc_exit_connector(struct task_struct *task);
 #else
 static inline void proc_fork_connector(struct task_struct *task)
@@ -124,6 +133,10 @@ static inline void proc_id_connector(struct task_struct *task,
 static inline void proc_sid_connector(struct task_struct *task)
 {}
 
+static inline void proc_ptrace_connector(struct task_struct *task,
+                                         int ptrace_id)
+{}
+
 static inline void proc_exit_connector(struct task_struct *task)
 {}
 #endif  /* CONFIG_PROC_EVENTS */
diff --git a/include/linux/compat.h b/include/linux/compat.h
index 846bb179257..c6e7523bf76 100644
--- a/include/linux/compat.h
+++ b/include/linux/compat.h
@@ -438,16 +438,6 @@ asmlinkage long compat_sys_ppoll(struct pollfd __user *ufds,
                                  struct compat_timespec __user *tsp,
                                  const compat_sigset_t __user *sigmask,
                                  compat_size_t sigsetsize);
-#if (defined(CONFIG_NFSD) || defined(CONFIG_NFSD_MODULE)) && \
-        !defined(CONFIG_NFSD_DEPRECATED)
-union compat_nfsctl_res;
-struct compat_nfsctl_arg;
-asmlinkage long compat_sys_nfsservctl(int cmd,
-                                      struct compat_nfsctl_arg __user *arg,
-                                      union compat_nfsctl_res __user *res);
-#else
-asmlinkage long compat_sys_nfsservctl(int cmd, void *notused, void *notused2);
-#endif
 asmlinkage long compat_sys_signalfd4(int ufd,
                                      const compat_sigset_t __user *sigmask,
                                      compat_size_t sigsetsize, int flags);
diff --git a/include/linux/configfs.h b/include/linux/configfs.h
index 645778ad899..3081c58d696 100644
--- a/include/linux/configfs.h
+++ b/include/linux/configfs.h
@@ -42,7 +42,7 @@
 #include <linux/mutex.h>
 #include <linux/err.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 #define CONFIGFS_ITEM_NAME_LEN  20
 
diff --git a/include/linux/connector.h b/include/linux/connector.h
index f696bccd48c..3c9c54fd569 100644
--- a/include/linux/connector.h
+++ b/include/linux/connector.h
@@ -1,7 +1,7 @@
 /*
  *      connector.h
  * 
- * 2004-2005 Copyright (c) Evgeniy Polyakov <johnpol@2ka.mipt.ru>
+ * 2004-2005 Copyright (c) Evgeniy Polyakov <zbr@ioremap.net>
  * All rights reserved.
  * 
  * This program is free software; you can redistribute it and/or modify
@@ -75,7 +75,7 @@ struct cn_msg {
 
 #ifdef __KERNEL__
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 #include <linux/list.h>
 #include <linux/workqueue.h>
diff --git a/include/linux/cordic.h b/include/linux/cordic.h
new file mode 100644
index 00000000000..f932093e20c
--- /dev/null
+++ b/include/linux/cordic.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2011 Broadcom Corporation
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+#ifndef __CORDIC_H_
+#define __CORDIC_H_
+
+#include <linux/types.h>
+
+/**
+ * struct cordic_iq - i/q coordinate.
+ *
+ * @i: real part of coordinate (in phase).
+ * @q: imaginary part of coordinate (quadrature).
+ */
+struct cordic_iq {
+        s32 i;
+        s32 q;
+};
+
+/**
+ * cordic_calc_iq() - calculates the i/q coordinate for given angle.
+ *
+ * @theta: angle in degrees for which i/q coordinate is to be calculated.
+ * @coord: function output parameter holding the i/q coordinate.
+ *
+ * The function calculates the i/q coordinate for a given angle using
+ * cordic algorithm. The coordinate consists of a real (i) and an
+ * imaginary (q) part. The real part is essentially the cosine of the
+ * angle and the imaginary part is the sine of the angle. The returned
+ * values are scaled by 2^16 for precision. The range for theta is
+ * for -180 degrees to +180 degrees. Passed values outside this range are
+ * converted before doing the actual calculation.
+ */
+struct cordic_iq cordic_calc_iq(s32 theta);
+
+#endif /* __CORDIC_H_ */
diff --git a/include/linux/cpu.h b/include/linux/cpu.h
index 5f09323ee88..54d948ec49a 100644
--- a/include/linux/cpu.h
+++ b/include/linux/cpu.h
@@ -70,6 +70,39 @@ enum {
         CPU_PRI_WORKQUEUE       = 5,
 };
 
+#define CPU_ONLINE              0x0002 /* CPU (unsigned)v is up */
+#define CPU_UP_PREPARE          0x0003 /* CPU (unsigned)v coming up */
+#define CPU_UP_CANCELED         0x0004 /* CPU (unsigned)v NOT coming up */
+#define CPU_DOWN_PREPARE        0x0005 /* CPU (unsigned)v going down */
+#define CPU_DOWN_FAILED         0x0006 /* CPU (unsigned)v NOT going down */
+#define CPU_DEAD                0x0007 /* CPU (unsigned)v dead */
+#define CPU_DYING               0x0008 /* CPU (unsigned)v not running any task,
+                                        * not handling interrupts, soon dead.
+                                        * Called on the dying cpu, interrupts
+                                        * are already disabled. Must not
+                                        * sleep, must not fail */
+#define CPU_POST_DEAD           0x0009 /* CPU (unsigned)v dead, cpu_hotplug
+                                        * lock is dropped */
+#define CPU_STARTING            0x000A /* CPU (unsigned)v soon running.
+                                        * Called on the new cpu, just before
+                                        * enabling interrupts. Must not sleep,
+                                        * must not fail */
+
+/* Used for CPU hotplug events occurring while tasks are frozen due to a suspend
+ * operation in progress
+ */
+#define CPU_TASKS_FROZEN        0x0010
+
+#define CPU_ONLINE_FROZEN       (CPU_ONLINE | CPU_TASKS_FROZEN)
+#define CPU_UP_PREPARE_FROZEN   (CPU_UP_PREPARE | CPU_TASKS_FROZEN)
+#define CPU_UP_CANCELED_FROZEN  (CPU_UP_CANCELED | CPU_TASKS_FROZEN)
+#define CPU_DOWN_PREPARE_FROZEN (CPU_DOWN_PREPARE | CPU_TASKS_FROZEN)
+#define CPU_DOWN_FAILED_FROZEN  (CPU_DOWN_FAILED | CPU_TASKS_FROZEN)
+#define CPU_DEAD_FROZEN         (CPU_DEAD | CPU_TASKS_FROZEN)
+#define CPU_DYING_FROZEN        (CPU_DYING | CPU_TASKS_FROZEN)
+#define CPU_STARTING_FROZEN     (CPU_STARTING | CPU_TASKS_FROZEN)
+
+
 #ifdef CONFIG_SMP
 /* Need to know about CPUs going up/down? */
 #if defined(CONFIG_HOTPLUG_CPU) || !defined(MODULE)
@@ -174,4 +207,11 @@ static inline int disable_nonboot_cpus(void) { return 0; }
 static inline void enable_nonboot_cpus(void) {}
 #endif /* !CONFIG_PM_SLEEP_SMP */
 
+#define IDLE_START 1
+#define IDLE_END 2
+
+void idle_notifier_register(struct notifier_block *n);
+void idle_notifier_unregister(struct notifier_block *n);
+void idle_notifier_call_chain(unsigned long val);
+
 #endif /* _LINUX_CPU_H_ */
diff --git a/include/linux/cpuacct.h b/include/linux/cpuacct.h
new file mode 100644
index 00000000000..8f68e733fe1
--- /dev/null
+++ b/include/linux/cpuacct.h
@@ -0,0 +1,43 @@
+/* include/linux/cpuacct.h
+ *
+ * Copyright (C) 2010 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _CPUACCT_H_
+#define _CPUACCT_H_
+
+#include <linux/cgroup.h>
+
+#ifdef CONFIG_CGROUP_CPUACCT
+
+/*
+ * Platform specific CPU frequency hooks for cpuacct. These functions are
+ * called from the scheduler.
+ */
+struct cpuacct_charge_calls {
+        /*
+         * Platforms can take advantage of this data and use
+         * per-cpu allocations if necessary.
+         */
+        void (*init) (void **cpuacct_data);
+        void (*charge) (void *cpuacct_data,  u64 cputime, unsigned int cpu);
+        void (*cpufreq_show) (void *cpuacct_data, struct cgroup_map_cb *cb);
+        /* Returns power consumed in milliWatt seconds */
+        u64 (*power_usage) (void *cpuacct_data);
+};
+
+int cpuacct_charge_register(struct cpuacct_charge_calls *fn);
+
+#endif /* CONFIG_CGROUP_CPUACCT */
+
+#endif // _CPUACCT_H_
diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h
index 11be48e0d16..c6126b9fb7c 100644
--- a/include/linux/cpufreq.h
+++ b/include/linux/cpufreq.h
@@ -324,11 +324,16 @@ static inline unsigned int cpufreq_get(unsigned int cpu)
 /* query the last known CPU freq (in kHz). If zero, cpufreq couldn't detect it */
 #ifdef CONFIG_CPU_FREQ
 unsigned int cpufreq_quick_get(unsigned int cpu);
+unsigned int cpufreq_quick_get_max(unsigned int cpu);
 #else
 static inline unsigned int cpufreq_quick_get(unsigned int cpu)
 {
         return 0;
 }
+static inline unsigned int cpufreq_quick_get_max(unsigned int cpu)
+{
+        return 0;
+}
 #endif
 
 
@@ -358,6 +363,9 @@ extern struct cpufreq_governor cpufreq_gov_ondemand;
 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE)
 extern struct cpufreq_governor cpufreq_gov_conservative;
 #define CPUFREQ_DEFAULT_GOVERNOR        (&cpufreq_gov_conservative)
+#elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_INTERACTIVE)
+extern struct cpufreq_governor cpufreq_gov_interactive;
+#define CPUFREQ_DEFAULT_GOVERNOR        (&cpufreq_gov_interactive)
 #endif
 
 
diff --git a/include/linux/cpuidle.h b/include/linux/cpuidle.h
index 36719ead50e..b51629e15cf 100644
--- a/include/linux/cpuidle.h
+++ b/include/linux/cpuidle.h
@@ -122,6 +122,8 @@ struct cpuidle_driver {
 };
 
 #ifdef CONFIG_CPU_IDLE
+extern void disable_cpuidle(void);
+extern int cpuidle_idle_call(void);
 
 extern int cpuidle_register_driver(struct cpuidle_driver *drv);
 struct cpuidle_driver *cpuidle_get_driver(void);
@@ -135,6 +137,8 @@ extern int cpuidle_enable_device(struct cpuidle_device *dev);
 extern void cpuidle_disable_device(struct cpuidle_device *dev);
 
 #else
+static inline void disable_cpuidle(void) { }
+static inline int cpuidle_idle_call(void) { return -ENODEV; }
 
 static inline int cpuidle_register_driver(struct cpuidle_driver *drv)
 {return -ENODEV; }
diff --git a/include/linux/cpumask.h b/include/linux/cpumask.h
index b24ac56477b..4f7a6323747 100644
--- a/include/linux/cpumask.h
+++ b/include/linux/cpumask.h
@@ -617,6 +617,20 @@ static inline size_t cpumask_size(void)
  *        ... use 'tmpmask' like a normal struct cpumask * ...
  *
  *      free_cpumask_var(tmpmask);
+ *
+ *
+ * However, one notable exception is there. alloc_cpumask_var() allocates
+ * only nr_cpumask_bits bits (in the other hand, real cpumask_t always has
+ * NR_CPUS bits). Therefore you don't have to dereference cpumask_var_t.
+ *
+ *      cpumask_var_t tmpmask;
+ *      if (!alloc_cpumask_var(&tmpmask, GFP_KERNEL))
+ *              return -ENOMEM;
+ *
+ *      var = *tmpmask;
+ *
+ * This code makes NR_CPUS length memcopy and brings to a memory corruption.
+ * cpumask_copy() provide safe copy functionality.
  */
 #ifdef CONFIG_CPUMASK_OFFSTACK
 typedef struct cpumask *cpumask_var_t;
diff --git a/include/linux/crc8.h b/include/linux/crc8.h
new file mode 100644
index 00000000000..13c8dabb044
--- /dev/null
+++ b/include/linux/crc8.h
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2011 Broadcom Corporation
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+#ifndef __CRC8_H_
+#define __CRC8_H_
+
+#include <linux/types.h>
+
+/* see usage of this value in crc8() description */
+#define CRC8_INIT_VALUE         0xFF
+
+/*
+ * Return value of crc8() indicating valid message+crc. This is true
+ * if a CRC is inverted before transmission. The CRC computed over the
+ * whole received bitstream is _table[x], where x is the bit pattern
+ * of the modification (almost always 0xff).
+ */
+#define CRC8_GOOD_VALUE(_table) (_table[0xFF])
+
+/* required table size for crc8 algorithm */
+#define CRC8_TABLE_SIZE                 256
+
+/* helper macro assuring right table size is used */
+#define DECLARE_CRC8_TABLE(_table) \
+        static u8 _table[CRC8_TABLE_SIZE]
+
+/**
+ * crc8_populate_lsb - fill crc table for given polynomial in regular bit order.
+ *
+ * @table:      table to be filled.
+ * @polynomial: polynomial for which table is to be filled.
+ *
+ * This function fills the provided table according the polynomial provided for
+ * regular bit order (lsb first). Polynomials in CRC algorithms are typically
+ * represented as shown below.
+ *
+ *      poly = x^8 + x^7 + x^6 + x^4 + x^2 + 1
+ *
+ * For lsb first direction x^7 maps to the lsb. So the polynomial is as below.
+ *
+ * - lsb first: poly = 10101011(1) = 0xAB
+ */
+void crc8_populate_lsb(u8 table[CRC8_TABLE_SIZE], u8 polynomial);
+
+/**
+ * crc8_populate_msb - fill crc table for given polynomial in reverse bit order.
+ *
+ * @table:      table to be filled.
+ * @polynomial: polynomial for which table is to be filled.
+ *
+ * This function fills the provided table according the polynomial provided for
+ * reverse bit order (msb first). Polynomials in CRC algorithms are typically
+ * represented as shown below.
+ *
+ *      poly = x^8 + x^7 + x^6 + x^4 + x^2 + 1
+ *
+ * For msb first direction x^7 maps to the msb. So the polynomial is as below.
+ *
+ * - msb first: poly = (1)11010101 = 0xD5
+ */
+void crc8_populate_msb(u8 table[CRC8_TABLE_SIZE], u8 polynomial);
+
+/**
+ * crc8() - calculate a crc8 over the given input data.
+ *
+ * @table:      crc table used for calculation.
+ * @pdata:      pointer to data buffer.
+ * @nbytes:     number of bytes in data buffer.
+ * @crc:        previous returned crc8 value.
+ *
+ * The CRC8 is calculated using the polynomial given in crc8_populate_msb()
+ * or crc8_populate_lsb().
+ *
+ * The caller provides the initial value (either %CRC8_INIT_VALUE
+ * or the previous returned value) to allow for processing of
+ * discontiguous blocks of data.  When generating the CRC the
+ * caller is responsible for complementing the final return value
+ * and inserting it into the byte stream.  When validating a byte
+ * stream (including CRC8), a final return value of %CRC8_GOOD_VALUE
+ * indicates the byte stream data can be considered valid.
+ *
+ * Reference:
+ * "A Painless Guide to CRC Error Detection Algorithms", ver 3, Aug 1993
+ * Williams, Ross N., ross<at>ross.net
+ * (see URL http://www.ross.net/crc/download/crc_v3.txt).
+ */
+u8 crc8(const u8 table[CRC8_TABLE_SIZE], u8 *pdata, size_t nbytes, u8 crc);
+
+#endif /* __CRC8_H_ */
diff --git a/include/linux/cred.h b/include/linux/cred.h
index 82607992f30..40308969ed0 100644
--- a/include/linux/cred.h
+++ b/include/linux/cred.h
@@ -16,7 +16,7 @@
 #include <linux/init.h>
 #include <linux/key.h>
 #include <linux/selinux.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 struct user_struct;
 struct cred;
@@ -265,10 +265,11 @@ static inline void put_cred(const struct cred *_cred)
 /**
  * current_cred - Access the current task's subjective credentials
  *
- * Access the subjective credentials of the current task.
+ * Access the subjective credentials of the current task.  RCU-safe,
+ * since nobody else can modify it.
  */
 #define current_cred() \
-        (current->cred)
+        rcu_dereference_protected(current->cred, 1)
 
 /**
  * __task_cred - Access a task's objective credentials
@@ -284,7 +285,6 @@ static inline void put_cred(const struct cred *_cred)
         ({                                                              \
                 const struct task_struct *__t = (task);                 \
                 rcu_dereference_check(__t->real_cred,                   \
-                                      rcu_read_lock_held() ||           \
                                       task_is_dead(__t));               \
         })
 
@@ -307,8 +307,8 @@ static inline void put_cred(const struct cred *_cred)
 #define get_current_user()                              \
 ({                                                      \
         struct user_struct *__u;                        \
-        struct cred *__cred;                            \
-        __cred = (struct cred *) current_cred();        \
+        const struct cred *__cred;                      \
+        __cred = current_cred();                        \
         __u = get_uid(__cred->user);                    \
         __u;                                            \
 })
@@ -322,8 +322,8 @@ static inline void put_cred(const struct cred *_cred)
 #define get_current_groups()                            \
 ({                                                      \
         struct group_info *__groups;                    \
-        struct cred *__cred;                            \
-        __cred = (struct cred *) current_cred();        \
+        const struct cred *__cred;                      \
+        __cred = current_cred();                        \
         __groups = get_group_info(__cred->group_info);  \
         __groups;                                       \
 })
@@ -342,7 +342,7 @@ static inline void put_cred(const struct cred *_cred)
 
 #define current_cred_xxx(xxx)                   \
 ({                                              \
-        current->cred->xxx;                     \
+        current_cred()->xxx;                    \
 })
 
 #define current_uid()           (current_cred_xxx(uid))
diff --git a/include/linux/crypto.h b/include/linux/crypto.h
index a6a7a1c83f5..e5e468e9133 100644
--- a/include/linux/crypto.h
+++ b/include/linux/crypto.h
@@ -17,7 +17,7 @@
 #ifndef _LINUX_CRYPTO_H
 #define _LINUX_CRYPTO_H
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/list.h>
diff --git a/include/linux/cryptohash.h b/include/linux/cryptohash.h
index ec78a4bbe1d..2cd9f1cf9fa 100644
--- a/include/linux/cryptohash.h
+++ b/include/linux/cryptohash.h
@@ -3,11 +3,16 @@
 
 #define SHA_DIGEST_WORDS 5
 #define SHA_MESSAGE_BYTES (512 /*bits*/ / 8)
-#define SHA_WORKSPACE_WORDS 80
+#define SHA_WORKSPACE_WORDS 16
 
 void sha_init(__u32 *buf);
 void sha_transform(__u32 *digest, const char *data, __u32 *W);
 
+#define MD5_DIGEST_WORDS 4
+#define MD5_MESSAGE_BYTES 64
+
+void md5_transform(__u32 *hash, __u32 const *in);
+
 __u32 half_md4_transform(__u32 buf[4], __u32 const in[8]);
 
 #endif
diff --git a/include/linux/cs5535.h b/include/linux/cs5535.h
index 6fe2114f8ad..c077aec3a6f 100644
--- a/include/linux/cs5535.h
+++ b/include/linux/cs5535.h
@@ -11,6 +11,8 @@
 #ifndef _CS5535_H
 #define _CS5535_H
 
+#include <asm/msr.h>
+
 /* MSRs */
 #define MSR_GLIU_P2D_RO0        0x10000029
 
@@ -38,17 +40,75 @@
 #define MSR_MFGPT_NR            0x51400029
 #define MSR_MFGPT_SETUP         0x5140002B
 
+#define MSR_RTC_DOMA_OFFSET     0x51400055
+#define MSR_RTC_MONA_OFFSET     0x51400056
+#define MSR_RTC_CEN_OFFSET      0x51400057
+
 #define MSR_LX_SPARE_MSR        0x80000011      /* DC-specific */
 
 #define MSR_GX_GLD_MSR_CONFIG   0xC0002001
 #define MSR_GX_MSR_PADSEL       0xC0002011
 
+static inline int cs5535_pic_unreqz_select_high(unsigned int group,
+                                                unsigned int irq)
+{
+        uint32_t lo, hi;
+
+        rdmsr(MSR_PIC_ZSEL_HIGH, lo, hi);
+        lo &= ~(0xF << (group * 4));
+        lo |= (irq & 0xF) << (group * 4);
+        wrmsr(MSR_PIC_ZSEL_HIGH, lo, hi);
+        return 0;
+}
+
+/* PIC registers */
+#define CS5536_PIC_INT_SEL1     0x4d0
+#define CS5536_PIC_INT_SEL2     0x4d1
+
 /* resource sizes */
 #define LBAR_GPIO_SIZE          0xFF
 #define LBAR_MFGPT_SIZE         0x40
 #define LBAR_ACPI_SIZE          0x40
 #define LBAR_PMS_SIZE           0x80
 
+/*
+ * PMC registers (PMS block)
+ * It is only safe to access these registers as dword accesses.
+ * See CS5536 Specification Update erratas 17 & 18
+ */
+#define CS5536_PM_SCLK          0x10
+#define CS5536_PM_IN_SLPCTL     0x20
+#define CS5536_PM_WKXD          0x34
+#define CS5536_PM_WKD           0x30
+#define CS5536_PM_SSC           0x54
+
+/*
+ * PM registers (ACPI block)
+ * It is only safe to access these registers as dword accesses.
+ * See CS5536 Specification Update erratas 17 & 18
+ */
+#define CS5536_PM1_STS          0x00
+#define CS5536_PM1_EN           0x02
+#define CS5536_PM1_CNT          0x08
+#define CS5536_PM_GPE0_STS      0x18
+#define CS5536_PM_GPE0_EN       0x1c
+
+/* CS5536_PM1_STS bits */
+#define CS5536_WAK_FLAG         (1 << 15)
+#define CS5536_PWRBTN_FLAG      (1 << 8)
+
+/* CS5536_PM1_EN bits */
+#define CS5536_PM_PWRBTN        (1 << 8)
+#define CS5536_PM_RTC           (1 << 10)
+
+/* CS5536_PM_GPE0_STS bits */
+#define CS5536_GPIOM7_PME_FLAG  (1 << 31)
+#define CS5536_GPIOM6_PME_FLAG  (1 << 30)
+
+/* CS5536_PM_GPE0_EN bits */
+#define CS5536_GPIOM7_PME_EN    (1 << 31)
+#define CS5536_GPIOM6_PME_EN    (1 << 30)
+
 /* VSA2 magic values */
 #define VSA_VRC_INDEX           0xAC1C
 #define VSA_VRC_DATA            0xAC1E
diff --git a/include/linux/ctype.h b/include/linux/ctype.h
index a3d6ee0044f..8acfe312f94 100644
--- a/include/linux/ctype.h
+++ b/include/linux/ctype.h
@@ -52,4 +52,13 @@ static inline unsigned char __toupper(unsigned char c)
 #define tolower(c) __tolower(c)
 #define toupper(c) __toupper(c)
 
+/*
+ * Fast implementation of tolower() for internal usage. Do not use in your
+ * code.
+ */
+static inline char _tolower(const char c)
+{
+        return c | 0x20;
+}
+
 #endif
diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index 19d90a55541..713c7c62443 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -1,7 +1,7 @@
 #ifndef __LINUX_DCACHE_H
 #define __LINUX_DCACHE_H
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <linux/list.h>
 #include <linux/rculist.h>
 #include <linux/rculist_bl.h>
@@ -180,12 +180,12 @@ struct dentry_operations {
  */
 
 /* d_flags entries */
-#define DCACHE_AUTOFS_PENDING 0x0001    /* autofs: "under construction" */
-#define DCACHE_NFSFS_RENAMED  0x0002
-     /* this dentry has been "silly renamed" and has to be deleted on the last
-      * dput() */
+#define DCACHE_OP_HASH          0x0001
+#define DCACHE_OP_COMPARE       0x0002
+#define DCACHE_OP_REVALIDATE    0x0004
+#define DCACHE_OP_DELETE        0x0008
 
-#define DCACHE_DISCONNECTED     0x0004
+#define DCACHE_DISCONNECTED     0x0010
      /* This dentry is possibly not currently connected to the dcache tree, in
       * which case its parent will either be itself, or will have this flag as
       * well.  nfsd will not use a dentry with this bit set, but will first
@@ -196,26 +196,23 @@ struct dentry_operations {
       * dentry into place and return that dentry rather than the passed one,
       * typically using d_splice_alias. */
 
-#define DCACHE_REFERENCED       0x0008  /* Recently used, don't discard. */
-#define DCACHE_RCUACCESS        0x0010  /* Entry has ever been RCU-visible */
-#define DCACHE_INOTIFY_PARENT_WATCHED 0x0020
-     /* Parent inode is watched by inotify */
-
-#define DCACHE_COOKIE           0x0040  /* For use by dcookie subsystem */
-#define DCACHE_FSNOTIFY_PARENT_WATCHED 0x0080
-     /* Parent inode is watched by some fsnotify listener */
+#define DCACHE_REFERENCED       0x0020  /* Recently used, don't discard. */
+#define DCACHE_RCUACCESS        0x0040  /* Entry has ever been RCU-visible */
 
 #define DCACHE_CANT_MOUNT       0x0100
 #define DCACHE_GENOCIDE         0x0200
 
-#define DCACHE_OP_HASH          0x1000
-#define DCACHE_OP_COMPARE       0x2000
-#define DCACHE_OP_REVALIDATE    0x4000
-#define DCACHE_OP_DELETE        0x8000
+#define DCACHE_NFSFS_RENAMED    0x1000
+     /* this dentry has been "silly renamed" and has to be deleted on the last
+      * dput() */
+#define DCACHE_COOKIE           0x2000  /* For use by dcookie subsystem */
+#define DCACHE_FSNOTIFY_PARENT_WATCHED 0x4000
+     /* Parent inode is watched by some fsnotify listener */
 
 #define DCACHE_MOUNTED          0x10000 /* is a mountpoint */
 #define DCACHE_NEED_AUTOMOUNT   0x20000 /* handle automount on this dir */
 #define DCACHE_MANAGE_TRANSIT   0x40000 /* manage transit from this dirent */
+#define DCACHE_NEED_LOOKUP      0x80000 /* dentry requires i_op->lookup */
 #define DCACHE_MANAGED_DENTRY \
         (DCACHE_MOUNTED|DCACHE_NEED_AUTOMOUNT|DCACHE_MANAGE_TRANSIT)
 
@@ -340,7 +337,8 @@ extern int d_validate(struct dentry *, struct dentry *);
  */
 extern char *dynamic_dname(struct dentry *, char *, int, const char *, ...);
 
-extern char *__d_path(const struct path *path, struct path *root, char *, int);
+extern char *__d_path(const struct path *, const struct path *, char *, int);
+extern char *d_absolute_path(const struct path *, char *, int);
 extern char *d_path(const struct path *, char *, int);
 extern char *d_path_with_unreachable(const struct path *, char *, int);
 extern char *dentry_path_raw(struct dentry *, char *, int);
@@ -416,7 +414,12 @@ static inline bool d_mountpoint(struct dentry *dentry)
         return dentry->d_flags & DCACHE_MOUNTED;
 }
 
-extern struct dentry *lookup_create(struct nameidata *nd, int is_dir);
+static inline bool d_need_lookup(struct dentry *dentry)
+{
+        return dentry->d_flags & DCACHE_NEED_LOOKUP;
+}
+
+extern void d_clear_need_lookup(struct dentry *dentry);
 
 extern int sysctl_vfs_cache_pressure;
 
diff --git a/include/linux/dcbnl.h b/include/linux/dcbnl.h
index c52280047e2..65a2562f66b 100644
--- a/include/linux/dcbnl.h
+++ b/include/linux/dcbnl.h
@@ -203,6 +203,7 @@ struct dcbmsg {
  * @DCB_CMD_GFEATCFG: get DCBX features flags
  * @DCB_CMD_SFEATCFG: set DCBX features negotiation flags
  * @DCB_CMD_CEE_GET: get CEE aggregated configuration
+ * @DCB_CMD_IEEE_DEL: delete IEEE 802.1Qaz configuration
  */
 enum dcbnl_commands {
         DCB_CMD_UNDEFINED,
@@ -246,6 +247,7 @@ enum dcbnl_commands {
         DCB_CMD_SFEATCFG,
 
         DCB_CMD_CEE_GET,
+        DCB_CMD_IEEE_DEL,
 
         __DCB_CMD_ENUM_MAX,
         DCB_CMD_MAX = __DCB_CMD_ENUM_MAX - 1,
@@ -331,18 +333,30 @@ enum ieee_attrs_app {
 #define DCB_ATTR_IEEE_APP_MAX (__DCB_ATTR_IEEE_APP_MAX - 1)
 
 /**
- * enum cee_attrs - CEE DCBX get attributes
+ * enum cee_attrs - CEE DCBX get attributes.
  *
  * @DCB_ATTR_CEE_UNSPEC: unspecified
  * @DCB_ATTR_CEE_PEER_PG: peer PG configuration - get only
  * @DCB_ATTR_CEE_PEER_PFC: peer PFC configuration - get only
- * @DCB_ATTR_CEE_PEER_APP: peer APP tlv - get only
+ * @DCB_ATTR_CEE_PEER_APP_TABLE: peer APP tlv - get only
+ * @DCB_ATTR_CEE_TX_PG: TX PG configuration (DCB_CMD_PGTX_GCFG)
+ * @DCB_ATTR_CEE_RX_PG: RX PG configuration (DCB_CMD_PGRX_GCFG)
+ * @DCB_ATTR_CEE_PFC: PFC configuration (DCB_CMD_PFC_GCFG)
+ * @DCB_ATTR_CEE_APP_TABLE: APP configuration (multi DCB_CMD_GAPP)
+ * @DCB_ATTR_CEE_FEAT: DCBX features flags (DCB_CMD_GFEATCFG)
+ *
+ * An aggregated collection of the cee std negotiated parameters.
  */
 enum cee_attrs {
         DCB_ATTR_CEE_UNSPEC,
         DCB_ATTR_CEE_PEER_PG,
         DCB_ATTR_CEE_PEER_PFC,
         DCB_ATTR_CEE_PEER_APP_TABLE,
+        DCB_ATTR_CEE_TX_PG,
+        DCB_ATTR_CEE_RX_PG,
+        DCB_ATTR_CEE_PFC,
+        DCB_ATTR_CEE_APP_TABLE,
+        DCB_ATTR_CEE_FEAT,
         __DCB_ATTR_CEE_MAX
 };
 #define DCB_ATTR_CEE_MAX (__DCB_ATTR_CEE_MAX - 1)
@@ -355,6 +369,13 @@ enum peer_app_attr {
 };
 #define DCB_ATTR_CEE_PEER_APP_MAX (__DCB_ATTR_CEE_PEER_APP_MAX - 1)
 
+enum cee_attrs_app {
+        DCB_ATTR_CEE_APP_UNSPEC,
+        DCB_ATTR_CEE_APP,
+        __DCB_ATTR_CEE_APP_MAX
+};
+#define DCB_ATTR_CEE_APP_MAX (__DCB_ATTR_CEE_APP_MAX - 1)
+
 /**
  * enum dcbnl_pfc_attrs - DCB Priority Flow Control user priority nested attrs
  *
diff --git a/include/linux/dccp.h b/include/linux/dccp.h
index d638e85dc50..710c04302a1 100644
--- a/include/linux/dccp.h
+++ b/include/linux/dccp.h
@@ -236,6 +236,7 @@ enum dccp_packet_dequeueing_policy {
 #ifdef __KERNEL__
 
 #include <linux/in.h>
+#include <linux/interrupt.h>
 #include <linux/ktime.h>
 #include <linux/list.h>
 #include <linux/uio.h>
diff --git a/include/linux/debug_locks.h b/include/linux/debug_locks.h
index 2833452ea01..5033fb88c10 100644
--- a/include/linux/debug_locks.h
+++ b/include/linux/debug_locks.h
@@ -2,7 +2,7 @@
 #define __LINUX_DEBUG_LOCKING_H
 
 #include <linux/kernel.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <asm/system.h>
 
 struct task_struct;
diff --git a/include/linux/device-mapper.h b/include/linux/device-mapper.h
index 4427e045405..99e3e50b5c5 100644
--- a/include/linux/device-mapper.h
+++ b/include/linux/device-mapper.h
@@ -197,6 +197,11 @@ struct dm_target {
          * whether or not its underlying devices have support.
          */
         unsigned discards_supported:1;
+
+        /*
+         * Set if this target does not return zeroes on discarded blocks.
+         */
+        unsigned discard_zeroes_data_unsupported:1;
 };
 
 /* Each target can link one of these into the table */
@@ -208,6 +213,49 @@ struct dm_target_callbacks {
 int dm_register_target(struct target_type *t);
 void dm_unregister_target(struct target_type *t);
 
+/*
+ * Target argument parsing.
+ */
+struct dm_arg_set {
+        unsigned argc;
+        char **argv;
+};
+
+/*
+ * The minimum and maximum value of a numeric argument, together with
+ * the error message to use if the number is found to be outside that range.
+ */
+struct dm_arg {
+        unsigned min;
+        unsigned max;
+        char *error;
+};
+
+/*
+ * Validate the next argument, either returning it as *value or, if invalid,
+ * returning -EINVAL and setting *error.
+ */
+int dm_read_arg(struct dm_arg *arg, struct dm_arg_set *arg_set,
+                unsigned *value, char **error);
+
+/*
+ * Process the next argument as the start of a group containing between
+ * arg->min and arg->max further arguments. Either return the size as
+ * *num_args or, if invalid, return -EINVAL and set *error.
+ */
+int dm_read_arg_group(struct dm_arg *arg, struct dm_arg_set *arg_set,
+                      unsigned *num_args, char **error);
+
+/*
+ * Return the current argument and shift to the next.
+ */
+const char *dm_shift_arg(struct dm_arg_set *as);
+
+/*
+ * Move through num_args arguments.
+ */
+void dm_consume_args(struct dm_arg_set *as, unsigned num_args);
+
 /*-----------------------------------------------------------------
  * Functions for creating and manipulating mapped devices.
  * Drop the reference with dm_put when you finish with the object.
diff --git a/include/linux/device.h b/include/linux/device.h
index e4f62d8896b..e838e143baa 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -22,7 +22,7 @@
 #include <linux/types.h>
 #include <linux/module.h>
 #include <linux/pm.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <asm/device.h>
 
 struct device;
@@ -33,6 +33,7 @@ struct class;
 struct subsys_private;
 struct bus_type;
 struct device_node;
+struct iommu_ops;
 
 struct bus_attribute {
         struct attribute        attr;
@@ -67,6 +68,9 @@ extern void bus_remove_file(struct bus_type *, struct bus_attribute *);
  * @resume:     Called to bring a device on this bus out of sleep mode.
  * @pm:         Power management operations of this bus, callback the specific
  *              device driver's pm-ops.
+ * @iommu_ops   IOMMU specific operations for this bus, used to attach IOMMU
+ *              driver implementations to a bus and allow the driver to do
+ *              bus-specific setup
  * @p:          The private data of the driver core, only the driver core can
  *              touch this.
  *
@@ -96,6 +100,8 @@ struct bus_type {
 
         const struct dev_pm_ops *pm;
 
+        struct iommu_ops *iommu_ops;
+
         struct subsys_private *p;
 };
 
@@ -516,7 +522,7 @@ struct device_dma_parameters {
  *              minimizes board-specific #ifdefs in drivers.
  * @power:      For device power management.
  *              See Documentation/power/devices.txt for details.
- * @pwr_domain: Provide callbacks that are executed during system suspend,
+ * @pm_domain:  Provide callbacks that are executed during system suspend,
  *              hibernation, system resume and during runtime PM transitions
  *              along with subsystem-level and driver-level callbacks.
  * @numa_node:  NUMA node this device is close to.
@@ -567,7 +573,7 @@ struct device {
         void            *platform_data; /* Platform specific data, device
                                            core doesn't touch it */
         struct dev_pm_info      power;
-        struct dev_power_domain *pwr_domain;
+        struct dev_pm_domain    *pm_domain;
 
 #ifdef CONFIG_NUMA
         int             numa_node;      /* NUMA node this device is close to */
diff --git a/include/linux/dio.h b/include/linux/dio.h
index b2dd31ca171..2cc0fd00463 100644
--- a/include/linux/dio.h
+++ b/include/linux/dio.h
@@ -254,7 +254,7 @@ static inline struct dio_driver *dio_dev_driver(const struct dio_dev *d)
 
 #define dio_resource_start(d) ((d)->resource.start)
 #define dio_resource_end(d)   ((d)->resource.end)
-#define dio_resource_len(d)   ((d)->resource.end-(d)->resource.start+1)
+#define dio_resource_len(d)   (resource_size(&(d)->resource))
 #define dio_resource_flags(d) ((d)->resource.flags)
 
 #define dio_request_device(d, name) \
diff --git a/include/linux/dm-ioctl.h b/include/linux/dm-ioctl.h
index 3708455ee6c..0cb8eff76bd 100644
--- a/include/linux/dm-ioctl.h
+++ b/include/linux/dm-ioctl.h
@@ -267,9 +267,9 @@ enum {
 #define DM_DEV_SET_GEOMETRY     _IOWR(DM_IOCTL, DM_DEV_SET_GEOMETRY_CMD, struct dm_ioctl)
 
 #define DM_VERSION_MAJOR        4
-#define DM_VERSION_MINOR        20
+#define DM_VERSION_MINOR        21
 #define DM_VERSION_PATCHLEVEL   0
-#define DM_VERSION_EXTRA        "-ioctl (2011-02-02)"
+#define DM_VERSION_EXTRA        "-ioctl (2011-07-06)"
 
 /* Status bits */
 #define DM_READONLY_FLAG        (1 << 0) /* In/Out */
diff --git a/include/linux/dm-kcopyd.h b/include/linux/dm-kcopyd.h
index 298d587e349..5e54458e920 100644
--- a/include/linux/dm-kcopyd.h
+++ b/include/linux/dm-kcopyd.h
@@ -42,5 +42,20 @@ int dm_kcopyd_copy(struct dm_kcopyd_client *kc, struct dm_io_region *from,
                    unsigned num_dests, struct dm_io_region *dests,
                    unsigned flags, dm_kcopyd_notify_fn fn, void *context);
 
+/*
+ * Prepare a callback and submit it via the kcopyd thread.
+ *
+ * dm_kcopyd_prepare_callback allocates a callback structure and returns it.
+ * It must not be called from interrupt context.
+ * The returned value should be passed into dm_kcopyd_do_callback.
+ *
+ * dm_kcopyd_do_callback submits the callback.
+ * It may be called from interrupt context.
+ * The callback is issued from the kcopyd thread.
+ */
+void *dm_kcopyd_prepare_callback(struct dm_kcopyd_client *kc,
+                                 dm_kcopyd_notify_fn fn, void *context);
+void dm_kcopyd_do_callback(void *job, int read_err, unsigned long write_err);
+
 #endif  /* __KERNEL__ */
 #endif  /* _LINUX_DM_KCOPYD_H */
diff --git a/include/linux/dma-buf.h b/include/linux/dma-buf.h
new file mode 100644
index 00000000000..f8ac076afa5
--- /dev/null
+++ b/include/linux/dma-buf.h
@@ -0,0 +1,176 @@
+/*
+ * Header file for dma buffer sharing framework.
+ *
+ * Copyright(C) 2011 Linaro Limited. All rights reserved.
+ * Author: Sumit Semwal <sumit.semwal@ti.com>
+ *
+ * Many thanks to linaro-mm-sig list, and specially
+ * Arnd Bergmann <arnd@arndb.de>, Rob Clark <rob@ti.com> and
+ * Daniel Vetter <daniel@ffwll.ch> for their support in creation and
+ * refining of this idea.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef __DMA_BUF_H__
+#define __DMA_BUF_H__
+
+#include <linux/file.h>
+#include <linux/err.h>
+#include <linux/device.h>
+#include <linux/scatterlist.h>
+#include <linux/list.h>
+#include <linux/dma-mapping.h>
+
+struct dma_buf;
+struct dma_buf_attachment;
+
+/**
+ * struct dma_buf_ops - operations possible on struct dma_buf
+ * @attach: [optional] allows different devices to 'attach' themselves to the
+ *          given buffer. It might return -EBUSY to signal that backing storage
+ *          is already allocated and incompatible with the requirements
+ *          of requesting device.
+ * @detach: [optional] detach a given device from this buffer.
+ * @map_dma_buf: returns list of scatter pages allocated, increases usecount
+ *               of the buffer. Requires atleast one attach to be called
+ *               before. Returned sg list should already be mapped into
+ *               _device_ address space. This call may sleep. May also return
+ *               -EINTR. Should return -EINVAL if attach hasn't been called yet.
+ * @unmap_dma_buf: decreases usecount of buffer, might deallocate scatter
+ *                 pages.
+ * @release: release this buffer; to be called after the last dma_buf_put.
+ */
+struct dma_buf_ops {
+        int (*attach)(struct dma_buf *, struct device *,
+                        struct dma_buf_attachment *);
+
+        void (*detach)(struct dma_buf *, struct dma_buf_attachment *);
+
+        /* For {map,unmap}_dma_buf below, any specific buffer attributes
+         * required should get added to device_dma_parameters accessible
+         * via dev->dma_params.
+         */
+        struct sg_table * (*map_dma_buf)(struct dma_buf_attachment *,
+                                                enum dma_data_direction);
+        void (*unmap_dma_buf)(struct dma_buf_attachment *,
+                                                struct sg_table *);
+        /* TODO: Add try_map_dma_buf version, to return immed with -EBUSY
+         * if the call would block.
+         */
+
+        /* after final dma_buf_put() */
+        void (*release)(struct dma_buf *);
+
+};
+
+/**
+ * struct dma_buf - shared buffer object
+ * @size: size of the buffer
+ * @file: file pointer used for sharing buffers across, and for refcounting.
+ * @attachments: list of dma_buf_attachment that denotes all devices attached.
+ * @ops: dma_buf_ops associated with this buffer object.
+ * @priv: exporter specific private data for this buffer object.
+ */
+struct dma_buf {
+        size_t size;
+        struct file *file;
+        struct list_head attachments;
+        const struct dma_buf_ops *ops;
+        /* mutex to serialize list manipulation and other ops */
+        struct mutex lock;
+        void *priv;
+};
+
+/**
+ * struct dma_buf_attachment - holds device-buffer attachment data
+ * @dmabuf: buffer for this attachment.
+ * @dev: device attached to the buffer.
+ * @node: list of dma_buf_attachment.
+ * @priv: exporter specific attachment data.
+ *
+ * This structure holds the attachment information between the dma_buf buffer
+ * and its user device(s). The list contains one attachment struct per device
+ * attached to the buffer.
+ */
+struct dma_buf_attachment {
+        struct dma_buf *dmabuf;
+        struct device *dev;
+        struct list_head node;
+        void *priv;
+};
+
+#ifdef CONFIG_DMA_SHARED_BUFFER
+struct dma_buf_attachment *dma_buf_attach(struct dma_buf *dmabuf,
+                                                        struct device *dev);
+void dma_buf_detach(struct dma_buf *dmabuf,
+                                struct dma_buf_attachment *dmabuf_attach);
+struct dma_buf *dma_buf_export(void *priv, struct dma_buf_ops *ops,
+                        size_t size, int flags);
+int dma_buf_fd(struct dma_buf *dmabuf);
+struct dma_buf *dma_buf_get(int fd);
+void dma_buf_put(struct dma_buf *dmabuf);
+
+struct sg_table *dma_buf_map_attachment(struct dma_buf_attachment *,
+                                        enum dma_data_direction);
+void dma_buf_unmap_attachment(struct dma_buf_attachment *, struct sg_table *);
+#else
+
+static inline struct dma_buf_attachment *dma_buf_attach(struct dma_buf *dmabuf,
+                                                        struct device *dev)
+{
+        return ERR_PTR(-ENODEV);
+}
+
+static inline void dma_buf_detach(struct dma_buf *dmabuf,
+                                  struct dma_buf_attachment *dmabuf_attach)
+{
+        return;
+}
+
+static inline struct dma_buf *dma_buf_export(void *priv,
+                                                struct dma_buf_ops *ops,
+                                                size_t size, int flags)
+{
+        return ERR_PTR(-ENODEV);
+}
+
+static inline int dma_buf_fd(struct dma_buf *dmabuf)
+{
+        return -ENODEV;
+}
+
+static inline struct dma_buf *dma_buf_get(int fd)
+{
+        return ERR_PTR(-ENODEV);
+}
+
+static inline void dma_buf_put(struct dma_buf *dmabuf)
+{
+        return;
+}
+
+static inline struct sg_table *dma_buf_map_attachment(
+        struct dma_buf_attachment *attach, enum dma_data_direction write)
+{
+        return ERR_PTR(-ENODEV);
+}
+
+static inline void dma_buf_unmap_attachment(struct dma_buf_attachment *attach,
+                                                struct sg_table *sg)
+{
+        return;
+}
+
+#endif /* CONFIG_DMA_SHARED_BUFFER */
+
+#endif /* __DMA_BUF_H__ */
diff --git a/include/linux/dma-direction.h b/include/linux/dma-direction.h
new file mode 100644
index 00000000000..95b6a82f595
--- /dev/null
+++ b/include/linux/dma-direction.h
@@ -0,0 +1,13 @@
+#ifndef _LINUX_DMA_DIRECTION_H
+#define _LINUX_DMA_DIRECTION_H
+/*
+ * These definitions mirror those in pci.h, so they can be used
+ * interchangeably with their PCI_ counterparts.
+ */
+enum dma_data_direction {
+        DMA_BIDIRECTIONAL = 0,
+        DMA_TO_DEVICE = 1,
+        DMA_FROM_DEVICE = 2,
+        DMA_NONE = 3,
+};
+#endif
diff --git a/include/linux/dma-mapping.h b/include/linux/dma-mapping.h
index ba8319ae5fc..347fdc32177 100644
--- a/include/linux/dma-mapping.h
+++ b/include/linux/dma-mapping.h
@@ -4,17 +4,9 @@
 #include <linux/device.h>
 #include <linux/err.h>
 #include <linux/dma-attrs.h>
+#include <linux/dma-direction.h>
 #include <linux/scatterlist.h>
 
-/* These definitions mirror those in pci.h, so they can be used
- * interchangeably with their PCI_ counterparts */
-enum dma_data_direction {
-        DMA_BIDIRECTIONAL = 0,
-        DMA_TO_DEVICE = 1,
-        DMA_FROM_DEVICE = 2,
-        DMA_NONE = 3,
-};
-
 struct dma_map_ops {
         void* (*alloc_coherent)(struct device *dev, size_t size,
                                 dma_addr_t *dma_handle, gfp_t gfp);
@@ -54,27 +46,6 @@ struct dma_map_ops {
 
 #define DMA_BIT_MASK(n) (((n) == 64) ? ~0ULL : ((1ULL<<(n))-1))
 
-typedef u64 DMA_nnBIT_MASK __deprecated;
-
-/*
- * NOTE: do not use the below macros in new code and do not add new definitions
- * here.
- *
- * Instead, just open-code DMA_BIT_MASK(n) within your driver
- */
-#define DMA_64BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(64)
-#define DMA_48BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(48)
-#define DMA_47BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(47)
-#define DMA_40BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(40)
-#define DMA_39BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(39)
-#define DMA_35BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(35)
-#define DMA_32BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(32)
-#define DMA_31BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(31)
-#define DMA_30BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(30)
-#define DMA_29BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(29)
-#define DMA_28BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(28)
-#define DMA_24BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(24)
-
 #define DMA_MASK_NONE   0x0ULL
 
 static inline int valid_dma_direction(int dma_direction)
diff --git a/include/linux/dma_remapping.h b/include/linux/dma_remapping.h
index bbd8661b347..57c9a8ae4f2 100644
--- a/include/linux/dma_remapping.h
+++ b/include/linux/dma_remapping.h
@@ -25,11 +25,13 @@ struct intel_iommu;
 struct dmar_domain;
 struct root_entry;
 
-extern void free_dmar_iommu(struct intel_iommu *iommu);
 
-#ifdef CONFIG_DMAR
+#ifdef CONFIG_INTEL_IOMMU
+extern void free_dmar_iommu(struct intel_iommu *iommu);
 extern int iommu_calculate_agaw(struct intel_iommu *iommu);
 extern int iommu_calculate_max_sagaw(struct intel_iommu *iommu);
+extern int dmar_disabled;
+extern int intel_iommu_enabled;
 #else
 static inline int iommu_calculate_agaw(struct intel_iommu *iommu)
 {
@@ -39,8 +41,12 @@ static inline int iommu_calculate_max_sagaw(struct intel_iommu *iommu)
 {
         return 0;
 }
+static inline void free_dmar_iommu(struct intel_iommu *iommu)
+{
+}
+#define dmar_disabled   (1)
+#define intel_iommu_enabled (0)
 #endif
 
-extern int dmar_disabled;
 
 #endif
diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h
index eee7addec28..8fbf40e0713 100644
--- a/include/linux/dmaengine.h
+++ b/include/linux/dmaengine.h
@@ -23,7 +23,9 @@
 
 #include <linux/device.h>
 #include <linux/uio.h>
-#include <linux/dma-mapping.h>
+#include <linux/dma-direction.h>
+
+struct scatterlist;
 
 /**
  * typedef dma_cookie_t - an opaque DMA cookie
diff --git a/include/linux/dmar.h b/include/linux/dmar.h
index 7b776d71d36..a8b1a847c10 100644
--- a/include/linux/dmar.h
+++ b/include/linux/dmar.h
@@ -26,8 +26,13 @@
 #include <linux/msi.h>
 #include <linux/irqreturn.h>
 
+/* DMAR Flags */
+#define DMAR_INTR_REMAP         0x1
+#define DMAR_X2APIC_OPT_OUT     0x2
+
 struct intel_iommu;
-#if defined(CONFIG_DMAR) || defined(CONFIG_INTR_REMAP)
+#ifdef CONFIG_DMAR_TABLE
+extern struct acpi_table_header *dmar_tbl;
 struct dmar_drhd_unit {
         struct list_head list;          /* list of drhd units   */
         struct  acpi_dmar_header *hdr;  /* ACPI header          */
@@ -76,7 +81,7 @@ static inline int enable_drhd_fault_handling(void)
 {
         return -1;
 }
-#endif /* !CONFIG_DMAR && !CONFIG_INTR_REMAP */
+#endif /* !CONFIG_DMAR_TABLE */
 
 struct irte {
         union {
@@ -107,10 +112,10 @@ struct irte {
         };
 };
 
-#ifdef CONFIG_INTR_REMAP
+#ifdef CONFIG_IRQ_REMAP
 extern int intr_remapping_enabled;
 extern int intr_remapping_supported(void);
-extern int enable_intr_remapping(int);
+extern int enable_intr_remapping(void);
 extern void disable_intr_remapping(void);
 extern int reenable_intr_remapping(int);
 
@@ -177,7 +182,7 @@ static inline int set_msi_sid(struct irte *irte, struct pci_dev *dev)
 
 #define intr_remapping_enabled          (0)
 
-static inline int enable_intr_remapping(int eim)
+static inline int enable_intr_remapping(void)
 {
         return -1;
 }
@@ -192,6 +197,11 @@ static inline int reenable_intr_remapping(int eim)
 }
 #endif
 
+enum {
+        IRQ_REMAP_XAPIC_MODE,
+        IRQ_REMAP_X2APIC_MODE,
+};
+
 /* Can't use the common MSI interrupt functions
  * since DMAR is not a pci device
  */
@@ -204,7 +214,7 @@ extern int dmar_set_interrupt(struct intel_iommu *iommu);
 extern irqreturn_t dmar_fault(int irq, void *dev_id);
 extern int arch_setup_dmar_msi(unsigned int irq);
 
-#ifdef CONFIG_DMAR
+#ifdef CONFIG_INTEL_IOMMU
 extern int iommu_detected, no_iommu;
 extern struct list_head dmar_rmrr_units;
 struct dmar_rmrr_unit {
@@ -227,9 +237,26 @@ struct dmar_atsr_unit {
         u8 include_all:1;               /* include all ports */
 };
 
+int dmar_parse_rmrr_atsr_dev(void);
+extern int dmar_parse_one_rmrr(struct acpi_dmar_header *header);
+extern int dmar_parse_one_atsr(struct acpi_dmar_header *header);
+extern int dmar_parse_dev_scope(void *start, void *end, int *cnt,
+                                struct pci_dev ***devices, u16 segment);
 extern int intel_iommu_init(void);
-#else /* !CONFIG_DMAR: */
+#else /* !CONFIG_INTEL_IOMMU: */
 static inline int intel_iommu_init(void) { return -ENODEV; }
-#endif /* CONFIG_DMAR */
+static inline int dmar_parse_one_rmrr(struct acpi_dmar_header *header)
+{
+        return 0;
+}
+static inline int dmar_parse_one_atsr(struct acpi_dmar_header *header)
+{
+        return 0;
+}
+static inline int dmar_parse_rmrr_atsr_dev(void)
+{
+        return 0;
+}
+#endif /* CONFIG_INTEL_IOMMU */
 
 #endif /* __DMAR_H__ */
diff --git a/include/linux/dvb/audio.h b/include/linux/dvb/audio.h
index fec66bd24f2..d47bccd604e 100644
--- a/include/linux/dvb/audio.h
+++ b/include/linux/dvb/audio.h
@@ -67,7 +67,7 @@ typedef struct audio_status {
 
 
 typedef
-struct audio_karaoke{  /* if Vocal1 or Vocal2 are non-zero, they get mixed  */
+struct audio_karaoke {  /* if Vocal1 or Vocal2 are non-zero, they get mixed  */
         int vocal1;    /* into left and right t at 70% each */
         int vocal2;    /* if both, Vocal1 and Vocal2 are non-zero, Vocal1 gets*/
         int melody;    /* mixed into the left channel and */
diff --git a/include/linux/dw_apb_timer.h b/include/linux/dw_apb_timer.h
new file mode 100644
index 00000000000..49638ea3b77
--- /dev/null
+++ b/include/linux/dw_apb_timer.h
@@ -0,0 +1,56 @@
+/*
+ * (C) Copyright 2009 Intel Corporation
+ * Author: Jacob Pan (jacob.jun.pan@intel.com)
+ *
+ * Shared with ARM platforms, Jamie Iles, Picochip 2011
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Support for the Synopsys DesignWare APB Timers.
+ */
+#ifndef __DW_APB_TIMER_H__
+#define __DW_APB_TIMER_H__
+
+#include <linux/clockchips.h>
+#include <linux/clocksource.h>
+#include <linux/interrupt.h>
+
+#define APBTMRS_REG_SIZE       0x14
+
+struct dw_apb_timer {
+        void __iomem                            *base;
+        unsigned long                           freq;
+        int                                     irq;
+};
+
+struct dw_apb_clock_event_device {
+        struct clock_event_device               ced;
+        struct dw_apb_timer                     timer;
+        struct irqaction                        irqaction;
+        void                                    (*eoi)(struct dw_apb_timer *);
+};
+
+struct dw_apb_clocksource {
+        struct dw_apb_timer                     timer;
+        struct clocksource                      cs;
+};
+
+void dw_apb_clockevent_register(struct dw_apb_clock_event_device *dw_ced);
+void dw_apb_clockevent_pause(struct dw_apb_clock_event_device *dw_ced);
+void dw_apb_clockevent_resume(struct dw_apb_clock_event_device *dw_ced);
+void dw_apb_clockevent_stop(struct dw_apb_clock_event_device *dw_ced);
+
+struct dw_apb_clock_event_device *
+dw_apb_clockevent_init(int cpu, const char *name, unsigned rating,
+                       void __iomem *base, int irq, unsigned long freq);
+struct dw_apb_clocksource *
+dw_apb_clocksource_init(unsigned rating, char *name, void __iomem *base,
+                        unsigned long freq);
+void dw_apb_clocksource_register(struct dw_apb_clocksource *dw_cs);
+void dw_apb_clocksource_start(struct dw_apb_clocksource *dw_cs);
+cycle_t dw_apb_clocksource_read(struct dw_apb_clocksource *dw_cs);
+void dw_apb_clocksource_unregister(struct dw_apb_clocksource *dw_cs);
+
+#endif /* __DW_APB_TIMER_H__ */
diff --git a/include/linux/earlysuspend.h b/include/linux/earlysuspend.h
new file mode 100644
index 00000000000..8343b817af3
--- /dev/null
+++ b/include/linux/earlysuspend.h
@@ -0,0 +1,56 @@
+/* include/linux/earlysuspend.h
+ *
+ * Copyright (C) 2007-2008 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _LINUX_EARLYSUSPEND_H
+#define _LINUX_EARLYSUSPEND_H
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+#include <linux/list.h>
+#endif
+
+/* The early_suspend structure defines suspend and resume hooks to be called
+ * when the user visible sleep state of the system changes, and a level to
+ * control the order. They can be used to turn off the screen and input
+ * devices that are not used for wakeup.
+ * Suspend handlers are called in low to high level order, resume handlers are
+ * called in the opposite order. If, when calling register_early_suspend,
+ * the suspend handlers have already been called without a matching call to the
+ * resume handlers, the suspend handler will be called directly from
+ * register_early_suspend. This direct call can violate the normal level order.
+ */
+enum {
+        EARLY_SUSPEND_LEVEL_BLANK_SCREEN = 50,
+        EARLY_SUSPEND_LEVEL_STOP_DRAWING = 100,
+        EARLY_SUSPEND_LEVEL_DISABLE_FB = 150,
+};
+struct early_suspend {
+#ifdef CONFIG_HAS_EARLYSUSPEND
+        struct list_head link;
+        int level;
+        void (*suspend)(struct early_suspend *h);
+        void (*resume)(struct early_suspend *h);
+#endif
+};
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+void register_early_suspend(struct early_suspend *handler);
+void unregister_early_suspend(struct early_suspend *handler);
+#else
+#define register_early_suspend(handler) do { } while (0)
+#define unregister_early_suspend(handler) do { } while (0)
+#endif
+
+#endif
+
diff --git a/include/linux/ecryptfs.h b/include/linux/ecryptfs.h
new file mode 100644
index 00000000000..2224a8c0cb6
--- /dev/null
+++ b/include/linux/ecryptfs.h
@@ -0,0 +1,113 @@
+#ifndef _LINUX_ECRYPTFS_H
+#define _LINUX_ECRYPTFS_H
+
+/* Version verification for shared data structures w/ userspace */
+#define ECRYPTFS_VERSION_MAJOR 0x00
+#define ECRYPTFS_VERSION_MINOR 0x04
+#define ECRYPTFS_SUPPORTED_FILE_VERSION 0x03
+/* These flags indicate which features are supported by the kernel
+ * module; userspace tools such as the mount helper read
+ * ECRYPTFS_VERSIONING_MASK from a sysfs handle in order to determine
+ * how to behave. */
+#define ECRYPTFS_VERSIONING_PASSPHRASE            0x00000001
+#define ECRYPTFS_VERSIONING_PUBKEY                0x00000002
+#define ECRYPTFS_VERSIONING_PLAINTEXT_PASSTHROUGH 0x00000004
+#define ECRYPTFS_VERSIONING_POLICY                0x00000008
+#define ECRYPTFS_VERSIONING_XATTR                 0x00000010
+#define ECRYPTFS_VERSIONING_MULTKEY               0x00000020
+#define ECRYPTFS_VERSIONING_DEVMISC               0x00000040
+#define ECRYPTFS_VERSIONING_HMAC                  0x00000080
+#define ECRYPTFS_VERSIONING_FILENAME_ENCRYPTION   0x00000100
+#define ECRYPTFS_VERSIONING_GCM                   0x00000200
+#define ECRYPTFS_VERSIONING_MASK (ECRYPTFS_VERSIONING_PASSPHRASE \
+                                  | ECRYPTFS_VERSIONING_PLAINTEXT_PASSTHROUGH \
+                                  | ECRYPTFS_VERSIONING_PUBKEY \
+                                  | ECRYPTFS_VERSIONING_XATTR \
+                                  | ECRYPTFS_VERSIONING_MULTKEY \
+                                  | ECRYPTFS_VERSIONING_DEVMISC \
+                                  | ECRYPTFS_VERSIONING_FILENAME_ENCRYPTION)
+#define ECRYPTFS_MAX_PASSWORD_LENGTH 64
+#define ECRYPTFS_MAX_PASSPHRASE_BYTES ECRYPTFS_MAX_PASSWORD_LENGTH
+#define ECRYPTFS_SALT_SIZE 8
+#define ECRYPTFS_SALT_SIZE_HEX (ECRYPTFS_SALT_SIZE*2)
+/* The original signature size is only for what is stored on disk; all
+ * in-memory representations are expanded hex, so it better adapted to
+ * be passed around or referenced on the command line */
+#define ECRYPTFS_SIG_SIZE 8
+#define ECRYPTFS_SIG_SIZE_HEX (ECRYPTFS_SIG_SIZE*2)
+#define ECRYPTFS_PASSWORD_SIG_SIZE ECRYPTFS_SIG_SIZE_HEX
+#define ECRYPTFS_MAX_KEY_BYTES 64
+#define ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES 512
+#define ECRYPTFS_FILE_VERSION 0x03
+#define ECRYPTFS_MAX_PKI_NAME_BYTES 16
+
+#define RFC2440_CIPHER_DES3_EDE 0x02
+#define RFC2440_CIPHER_CAST_5 0x03
+#define RFC2440_CIPHER_BLOWFISH 0x04
+#define RFC2440_CIPHER_AES_128 0x07
+#define RFC2440_CIPHER_AES_192 0x08
+#define RFC2440_CIPHER_AES_256 0x09
+#define RFC2440_CIPHER_TWOFISH 0x0a
+#define RFC2440_CIPHER_CAST_6 0x0b
+
+#define RFC2440_CIPHER_RSA 0x01
+
+/**
+ * For convenience, we may need to pass around the encrypted session
+ * key between kernel and userspace because the authentication token
+ * may not be extractable.  For example, the TPM may not release the
+ * private key, instead requiring the encrypted data and returning the
+ * decrypted data.
+ */
+struct ecryptfs_session_key {
+#define ECRYPTFS_USERSPACE_SHOULD_TRY_TO_DECRYPT 0x00000001
+#define ECRYPTFS_USERSPACE_SHOULD_TRY_TO_ENCRYPT 0x00000002
+#define ECRYPTFS_CONTAINS_DECRYPTED_KEY 0x00000004
+#define ECRYPTFS_CONTAINS_ENCRYPTED_KEY 0x00000008
+        u32 flags;
+        u32 encrypted_key_size;
+        u32 decrypted_key_size;
+        u8 encrypted_key[ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES];
+        u8 decrypted_key[ECRYPTFS_MAX_KEY_BYTES];
+};
+
+struct ecryptfs_password {
+        u32 password_bytes;
+        s32 hash_algo;
+        u32 hash_iterations;
+        u32 session_key_encryption_key_bytes;
+#define ECRYPTFS_PERSISTENT_PASSWORD 0x01
+#define ECRYPTFS_SESSION_KEY_ENCRYPTION_KEY_SET 0x02
+        u32 flags;
+        /* Iterated-hash concatenation of salt and passphrase */
+        u8 session_key_encryption_key[ECRYPTFS_MAX_KEY_BYTES];
+        u8 signature[ECRYPTFS_PASSWORD_SIG_SIZE + 1];
+        /* Always in expanded hex */
+        u8 salt[ECRYPTFS_SALT_SIZE];
+};
+
+enum ecryptfs_token_types {ECRYPTFS_PASSWORD, ECRYPTFS_PRIVATE_KEY};
+
+struct ecryptfs_private_key {
+        u32 key_size;
+        u32 data_len;
+        u8 signature[ECRYPTFS_PASSWORD_SIG_SIZE + 1];
+        char pki_type[ECRYPTFS_MAX_PKI_NAME_BYTES + 1];
+        u8 data[];
+};
+
+/* May be a password or a private key */
+struct ecryptfs_auth_tok {
+        u16 version; /* 8-bit major and 8-bit minor */
+        u16 token_type;
+#define ECRYPTFS_ENCRYPT_ONLY 0x00000001
+        u32 flags;
+        struct ecryptfs_session_key session_key;
+        u8 reserved[32];
+        union {
+                struct ecryptfs_password password;
+                struct ecryptfs_private_key private_key;
+        } token;
+} __attribute__ ((packed));
+
+#endif /* _LINUX_ECRYPTFS_H */
diff --git a/include/linux/edac.h b/include/linux/edac.h
index 36c66443bdf..4a73257b47d 100644
--- a/include/linux/edac.h
+++ b/include/linux/edac.h
@@ -12,7 +12,7 @@
 #ifndef _LINUX_EDAC_H_
 #define _LINUX_EDAC_H_
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <linux/sysdev.h>
 
 #define EDAC_OPSTATE_INVAL      -1
diff --git a/include/linux/eeprom_93xx46.h b/include/linux/eeprom_93xx46.h
new file mode 100644
index 00000000000..06791811e49
--- /dev/null
+++ b/include/linux/eeprom_93xx46.h
@@ -0,0 +1,18 @@
+/*
+ * Module: eeprom_93xx46
+ * platform description for 93xx46 EEPROMs.
+ */
+
+struct eeprom_93xx46_platform_data {
+        unsigned char   flags;
+#define EE_ADDR8        0x01            /*  8 bit addr. cfg */
+#define EE_ADDR16       0x02            /* 16 bit addr. cfg */
+#define EE_READONLY     0x08            /* forbid writing */
+
+        /*
+         * optional hooks to control additional logic
+         * before and after spi transfer.
+         */
+        void (*prepare)(void *);
+        void (*finish)(void *);
+};
diff --git a/include/linux/efi.h b/include/linux/efi.h
index e376270cd26..2362a0bc7f0 100644
--- a/include/linux/efi.h
+++ b/include/linux/efi.h
@@ -19,6 +19,7 @@
 #include <linux/rtc.h>
 #include <linux/ioport.h>
 #include <linux/pfn.h>
+#include <linux/pstore.h>
 
 #include <asm/page.h>
 #include <asm/system.h>
@@ -101,6 +102,13 @@ typedef struct {
         u64 attribute;
 } efi_memory_desc_t;
 
+typedef struct {
+        efi_guid_t guid;
+        u32 headersize;
+        u32 flags;
+        u32 imagesize;
+} efi_capsule_header_t;
+
 typedef int (*efi_freemem_callback_t) (u64 start, u64 end, void *arg);
 
 /*
@@ -156,6 +164,9 @@ typedef struct {
         unsigned long set_variable;
         unsigned long get_next_high_mono_count;
         unsigned long reset_system;
+        unsigned long update_capsule;
+        unsigned long query_capsule_caps;
+        unsigned long query_variable_info;
 } efi_runtime_services_t;
 
 typedef efi_status_t efi_get_time_t (efi_time_t *tm, efi_time_cap_t *tc);
@@ -168,7 +179,7 @@ typedef efi_status_t efi_get_variable_t (efi_char16_t *name, efi_guid_t *vendor,
 typedef efi_status_t efi_get_next_variable_t (unsigned long *name_size, efi_char16_t *name,
                                               efi_guid_t *vendor);
 typedef efi_status_t efi_set_variable_t (efi_char16_t *name, efi_guid_t *vendor, 
-                                         unsigned long attr, unsigned long data_size, 
+                                         u32 attr, unsigned long data_size,
                                          void *data);
 typedef efi_status_t efi_get_next_high_mono_count_t (u32 *count);
 typedef void efi_reset_system_t (int reset_type, efi_status_t status,
@@ -177,6 +188,17 @@ typedef efi_status_t efi_set_virtual_address_map_t (unsigned long memory_map_siz
                                                 unsigned long descriptor_size,
                                                 u32 descriptor_version,
                                                 efi_memory_desc_t *virtual_map);
+typedef efi_status_t efi_query_variable_info_t(u32 attr,
+                                               u64 *storage_space,
+                                               u64 *remaining_space,
+                                               u64 *max_variable_size);
+typedef efi_status_t efi_update_capsule_t(efi_capsule_header_t **capsules,
+                                          unsigned long count,
+                                          unsigned long sg_list);
+typedef efi_status_t efi_query_capsule_caps_t(efi_capsule_header_t **capsules,
+                                              unsigned long count,
+                                              u64 *max_size,
+                                              int *reset_type);
 
 /*
  *  EFI Configuration Table and GUID definitions
@@ -211,6 +233,9 @@ typedef efi_status_t efi_set_virtual_address_map_t (unsigned long memory_map_siz
 #define UV_SYSTEM_TABLE_GUID \
     EFI_GUID(  0x3b13a7d4, 0x633e, 0x11dd, 0x93, 0xec, 0xda, 0x25, 0x56, 0xd8, 0x95, 0x93 )
 
+#define LINUX_EFI_CRASH_GUID \
+    EFI_GUID(  0xcfc8fc79, 0xbe2e, 0x4ddc, 0x97, 0xf0, 0x9f, 0x98, 0xbf, 0xe2, 0x98, 0xa0 )
+
 typedef struct {
         efi_guid_t guid;
         unsigned long table;
@@ -218,6 +243,13 @@ typedef struct {
 
 #define EFI_SYSTEM_TABLE_SIGNATURE ((u64)0x5453595320494249ULL)
 
+#define EFI_2_30_SYSTEM_TABLE_REVISION  ((2 << 16) | (30))
+#define EFI_2_20_SYSTEM_TABLE_REVISION  ((2 << 16) | (20))
+#define EFI_2_10_SYSTEM_TABLE_REVISION  ((2 << 16) | (10))
+#define EFI_2_00_SYSTEM_TABLE_REVISION  ((2 << 16) | (00))
+#define EFI_1_10_SYSTEM_TABLE_REVISION  ((1 << 16) | (10))
+#define EFI_1_02_SYSTEM_TABLE_REVISION  ((1 << 16) | (02))
+
 typedef struct {
         efi_table_hdr_t hdr;
         unsigned long fw_vendor;        /* physical addr of CHAR16 vendor string */
@@ -250,6 +282,7 @@ struct efi_memory_map {
  */
 extern struct efi {
         efi_system_table_t *systab;     /* EFI system table */
+        unsigned int runtime_version;   /* Runtime services version */
         unsigned long mps;              /* MPS table */
         unsigned long acpi;             /* ACPI table  (IA64 ext 0.71) */
         unsigned long acpi20;           /* ACPI table  (ACPI 2.0) */
@@ -266,6 +299,9 @@ extern struct efi {
         efi_get_variable_t *get_variable;
         efi_get_next_variable_t *get_next_variable;
         efi_set_variable_t *set_variable;
+        efi_query_variable_info_t *query_variable_info;
+        efi_update_capsule_t *update_capsule;
+        efi_query_capsule_caps_t *query_capsule_caps;
         efi_get_next_high_mono_count_t *get_next_high_mono_count;
         efi_reset_system_t *reset_system;
         efi_set_virtual_address_map_t *set_virtual_address_map;
@@ -426,6 +462,8 @@ struct efivars {
         struct kset *kset;
         struct bin_attribute *new_var, *del_var;
         const struct efivar_operations *ops;
+        struct efivar_entry *walk_entry;
+        struct pstore_info efi_pstore_info;
 };
 
 int register_efivars(struct efivars *efivars,
diff --git a/include/linux/elevator.h b/include/linux/elevator.h
index 21a8ebf2dc3..d800d514218 100644
--- a/include/linux/elevator.h
+++ b/include/linux/elevator.h
@@ -146,7 +146,7 @@ extern struct request *elv_rb_latter_request(struct request_queue *, struct requ
 /*
  * rb support functions.
  */
-extern struct request *elv_rb_add(struct rb_root *, struct request *);
+extern void elv_rb_add(struct rb_root *, struct request *);
 extern void elv_rb_del(struct rb_root *, struct request *);
 extern struct request *elv_rb_find(struct rb_root *, sector_t);
 
diff --git a/include/linux/etherdevice.h b/include/linux/etherdevice.h
index ab68f785fd1..05955cf0993 100644
--- a/include/linux/etherdevice.h
+++ b/include/linux/etherdevice.h
@@ -38,7 +38,7 @@ extern int eth_header(struct sk_buff *skb, struct net_device *dev,
                       const void *daddr, const void *saddr, unsigned len);
 extern int eth_rebuild_header(struct sk_buff *skb);
 extern int eth_header_parse(const struct sk_buff *skb, unsigned char *haddr);
-extern int eth_header_cache(const struct neighbour *neigh, struct hh_cache *hh);
+extern int eth_header_cache(const struct neighbour *neigh, struct hh_cache *hh, __be16 type);
 extern void eth_header_cache_update(struct hh_cache *hh,
                                     const struct net_device *dev,
                                     const unsigned char *haddr);
diff --git a/include/linux/ethtool.h b/include/linux/ethtool.h
index 439b173c588..c6e427ab65f 100644
--- a/include/linux/ethtool.h
+++ b/include/linux/ethtool.h
@@ -287,7 +287,7 @@ enum ethtool_stringset {
         ETH_SS_TEST             = 0,
         ETH_SS_STATS,
         ETH_SS_PRIV_FLAGS,
-        ETH_SS_NTUPLE_FILTERS,
+        ETH_SS_NTUPLE_FILTERS,  /* Do not use, GRXNTUPLE is now deprecated */
         ETH_SS_FEATURES,
 };
 
@@ -310,9 +310,21 @@ struct ethtool_sset_info {
                                    __u32's, etc. */
 };
 
+/**
+ * enum ethtool_test_flags - flags definition of ethtool_test
+ * @ETH_TEST_FL_OFFLINE: if set perform online and offline tests, otherwise
+ *      only online tests.
+ * @ETH_TEST_FL_FAILED: Driver set this flag if test fails.
+ * @ETH_TEST_FL_EXTERNAL_LB: Application request to perform external loopback
+ *      test.
+ * @ETH_TEST_FL_EXTERNAL_LB_DONE: Driver performed the external loopback test
+ */
+
 enum ethtool_test_flags {
-        ETH_TEST_FL_OFFLINE     = (1 << 0),     /* online / offline */
-        ETH_TEST_FL_FAILED      = (1 << 1),     /* test passed / failed */
+        ETH_TEST_FL_OFFLINE     = (1 << 0),
+        ETH_TEST_FL_FAILED      = (1 << 1),
+        ETH_TEST_FL_EXTERNAL_LB = (1 << 2),
+        ETH_TEST_FL_EXTERNAL_LB_DONE    = (1 << 3),
 };
 
 /* for requesting NIC test and getting results*/
@@ -714,18 +726,6 @@ enum ethtool_sfeatures_retval_bits {
 /* needed by dev_disable_lro() */
 extern int __ethtool_set_flags(struct net_device *dev, u32 flags);
 
-struct ethtool_rx_ntuple_flow_spec_container {
-        struct ethtool_rx_ntuple_flow_spec fs;
-        struct list_head list;
-};
-
-struct ethtool_rx_ntuple_list {
-#define ETHTOOL_MAX_NTUPLE_LIST_ENTRY 1024
-#define ETHTOOL_MAX_NTUPLE_STRING_PER_ENTRY 14
-        struct list_head        list;
-        unsigned int            count;
-};
-
 /**
  * enum ethtool_phys_id_state - indicator state for physical identification
  * @ETHTOOL_ID_INACTIVE: Physical ID indicator should be deactivated
@@ -758,7 +758,6 @@ u32 ethtool_op_get_ufo(struct net_device *dev);
 int ethtool_op_set_ufo(struct net_device *dev, u32 data);
 u32 ethtool_op_get_flags(struct net_device *dev);
 int ethtool_op_set_flags(struct net_device *dev, u32 data, u32 supported);
-void ethtool_ntuple_flush(struct net_device *dev);
 bool ethtool_invalid_flags(struct net_device *dev, u32 data, u32 supported);
 
 /**
@@ -865,7 +864,6 @@ bool ethtool_invalid_flags(struct net_device *dev, u32 data, u32 supported);
  *      error code or zero.
  * @set_rx_ntuple: Set an RX n-tuple rule.  Returns a negative error code
  *      or zero.
- * @get_rx_ntuple: Deprecated.
  * @get_rxfh_indir: Get the contents of the RX flow hash indirection table.
  *      Returns a negative error code or zero.
  * @set_rxfh_indir: Set the contents of the RX flow hash indirection table.
@@ -944,7 +942,6 @@ struct ethtool_ops {
         int     (*reset)(struct net_device *, u32 *);
         int     (*set_rx_ntuple)(struct net_device *,
                                  struct ethtool_rx_ntuple *);
-        int     (*get_rx_ntuple)(struct net_device *, u32 stringset, void *);
         int     (*get_rxfh_indir)(struct net_device *,
                                   struct ethtool_rxfh_indir *);
         int     (*set_rxfh_indir)(struct net_device *,
@@ -1017,7 +1014,7 @@ struct ethtool_ops {
 #define ETHTOOL_FLASHDEV        0x00000033 /* Flash firmware to device */
 #define ETHTOOL_RESET           0x00000034 /* Reset hardware */
 #define ETHTOOL_SRXNTUPLE       0x00000035 /* Add an n-tuple filter to device */
-#define ETHTOOL_GRXNTUPLE       0x00000036 /* Get n-tuple filters from device */
+#define ETHTOOL_GRXNTUPLE       0x00000036 /* deprecated */
 #define ETHTOOL_GSSET_INFO      0x00000037 /* Get string set info */
 #define ETHTOOL_GRXFHINDIR      0x00000038 /* Get RX flow hash indir'n table */
 #define ETHTOOL_SRXFHINDIR      0x00000039 /* Set RX flow hash indir'n table */
diff --git a/include/linux/export.h b/include/linux/export.h
new file mode 100644
index 00000000000..696c0f48afc
--- /dev/null
+++ b/include/linux/export.h
@@ -0,0 +1,89 @@
+#ifndef _LINUX_EXPORT_H
+#define _LINUX_EXPORT_H
+/*
+ * Export symbols from the kernel to modules.  Forked from module.h
+ * to reduce the amount of pointless cruft we feed to gcc when only
+ * exporting a simple symbol or two.
+ *
+ * If you feel the need to add #include <linux/foo.h> to this file
+ * then you are doing something wrong and should go away silently.
+ */
+
+/* Some toolchains use a `_' prefix for all user symbols. */
+#ifdef CONFIG_SYMBOL_PREFIX
+#define MODULE_SYMBOL_PREFIX CONFIG_SYMBOL_PREFIX
+#else
+#define MODULE_SYMBOL_PREFIX ""
+#endif
+
+struct kernel_symbol
+{
+        unsigned long value;
+        const char *name;
+};
+
+#ifdef MODULE
+extern struct module __this_module;
+#define THIS_MODULE (&__this_module)
+#else
+#define THIS_MODULE ((struct module *)0)
+#endif
+
+#ifdef CONFIG_MODULES
+
+#ifndef __GENKSYMS__
+#ifdef CONFIG_MODVERSIONS
+/* Mark the CRC weak since genksyms apparently decides not to
+ * generate a checksums for some symbols */
+#define __CRC_SYMBOL(sym, sec)                                  \
+        extern void *__crc_##sym __attribute__((weak));         \
+        static const unsigned long __kcrctab_##sym              \
+        __used                                                  \
+        __attribute__((section("___kcrctab" sec "+" #sym), unused))     \
+        = (unsigned long) &__crc_##sym;
+#else
+#define __CRC_SYMBOL(sym, sec)
+#endif
+
+/* For every exported symbol, place a struct in the __ksymtab section */
+#define __EXPORT_SYMBOL(sym, sec)                               \
+        extern typeof(sym) sym;                                 \
+        __CRC_SYMBOL(sym, sec)                                  \
+        static const char __kstrtab_##sym[]                     \
+        __attribute__((section("__ksymtab_strings"), aligned(1))) \
+        = MODULE_SYMBOL_PREFIX #sym;                            \
+        static const struct kernel_symbol __ksymtab_##sym       \
+        __used                                                  \
+        __attribute__((section("___ksymtab" sec "+" #sym), unused))     \
+        = { (unsigned long)&sym, __kstrtab_##sym }
+
+#define EXPORT_SYMBOL(sym)                                      \
+        __EXPORT_SYMBOL(sym, "")
+
+#define EXPORT_SYMBOL_GPL(sym)                                  \
+        __EXPORT_SYMBOL(sym, "_gpl")
+
+#define EXPORT_SYMBOL_GPL_FUTURE(sym)                           \
+        __EXPORT_SYMBOL(sym, "_gpl_future")
+
+#ifdef CONFIG_UNUSED_SYMBOLS
+#define EXPORT_UNUSED_SYMBOL(sym) __EXPORT_SYMBOL(sym, "_unused")
+#define EXPORT_UNUSED_SYMBOL_GPL(sym) __EXPORT_SYMBOL(sym, "_unused_gpl")
+#else
+#define EXPORT_UNUSED_SYMBOL(sym)
+#define EXPORT_UNUSED_SYMBOL_GPL(sym)
+#endif
+
+#endif  /* __GENKSYMS__ */
+
+#else /* !CONFIG_MODULES... */
+
+#define EXPORT_SYMBOL(sym)
+#define EXPORT_SYMBOL_GPL(sym)
+#define EXPORT_SYMBOL_GPL_FUTURE(sym)
+#define EXPORT_UNUSED_SYMBOL(sym)
+#define EXPORT_UNUSED_SYMBOL_GPL(sym)
+
+#endif /* CONFIG_MODULES */
+
+#endif /* _LINUX_EXPORT_H */
diff --git a/include/linux/ext2_fs.h b/include/linux/ext2_fs.h
index 2dfa7076e8b..ce1b719e8bd 100644
--- a/include/linux/ext2_fs.h
+++ b/include/linux/ext2_fs.h
@@ -18,6 +18,7 @@
 
 #include <linux/types.h>
 #include <linux/magic.h>
+#include <linux/fs.h>
 
 /*
  * The second extended filesystem constants/structures
@@ -196,8 +197,8 @@ struct ext2_group_desc
 
 /* Flags that should be inherited by new inodes from their parent. */
 #define EXT2_FL_INHERITED (EXT2_SECRM_FL | EXT2_UNRM_FL | EXT2_COMPR_FL |\
-                           EXT2_SYNC_FL | EXT2_IMMUTABLE_FL | EXT2_APPEND_FL |\
-                           EXT2_NODUMP_FL | EXT2_NOATIME_FL | EXT2_COMPRBLK_FL|\
+                           EXT2_SYNC_FL | EXT2_NODUMP_FL |\
+                           EXT2_NOATIME_FL | EXT2_COMPRBLK_FL |\
                            EXT2_NOCOMP_FL | EXT2_JOURNAL_DATA_FL |\
                            EXT2_NOTAIL_FL | EXT2_DIRSYNC_FL)
 
diff --git a/include/linux/ext3_fs.h b/include/linux/ext3_fs.h
index 5e06acf95d0..0244611eb2b 100644
--- a/include/linux/ext3_fs.h
+++ b/include/linux/ext3_fs.h
@@ -180,8 +180,8 @@ struct ext3_group_desc
 
 /* Flags that should be inherited by new inodes from their parent. */
 #define EXT3_FL_INHERITED (EXT3_SECRM_FL | EXT3_UNRM_FL | EXT3_COMPR_FL |\
-                           EXT3_SYNC_FL | EXT3_IMMUTABLE_FL | EXT3_APPEND_FL |\
-                           EXT3_NODUMP_FL | EXT3_NOATIME_FL | EXT3_COMPRBLK_FL|\
+                           EXT3_SYNC_FL | EXT3_NODUMP_FL |\
+                           EXT3_NOATIME_FL | EXT3_COMPRBLK_FL |\
                            EXT3_NOCOMPR_FL | EXT3_JOURNAL_DATA_FL |\
                            EXT3_NOTAIL_FL | EXT3_DIRSYNC_FL)
 
@@ -418,12 +418,11 @@ struct ext3_inode {
 #define EXT2_MOUNT_DATA_FLAGS           EXT3_MOUNT_DATA_FLAGS
 #endif
 
-#define ext3_set_bit                    __test_and_set_bit_le
+#define ext3_set_bit                    __set_bit_le
 #define ext3_set_bit_atomic             ext2_set_bit_atomic
-#define ext3_clear_bit                  __test_and_clear_bit_le
+#define ext3_clear_bit                  __clear_bit_le
 #define ext3_clear_bit_atomic           ext2_clear_bit_atomic
 #define ext3_test_bit                   test_bit_le
-#define ext3_find_first_zero_bit        find_first_zero_bit_le
 #define ext3_find_next_zero_bit         find_next_zero_bit_le
 
 /*
@@ -877,7 +876,7 @@ extern int ext3_htree_store_dirent(struct file *dir_file, __u32 hash,
 extern void ext3_htree_free_dir_info(struct dir_private_info *p);
 
 /* fsync.c */
-extern int ext3_sync_file(struct file *, int);
+extern int ext3_sync_file(struct file *, loff_t, loff_t, int);
 
 /* hash.c */
 extern int ext3fs_dirhash(const char *name, int len, struct
@@ -913,7 +912,7 @@ extern void ext3_dirty_inode(struct inode *, int);
 extern int ext3_change_inode_journal_flag(struct inode *, int);
 extern int ext3_get_inode_loc(struct inode *, struct ext3_iloc *);
 extern int ext3_can_truncate(struct inode *inode);
-extern void ext3_truncate (struct inode *);
+extern void ext3_truncate(struct inode *inode);
 extern void ext3_set_inode_flags(struct inode *);
 extern void ext3_get_inode_flags(struct ext3_inode_info *);
 extern void ext3_set_aops(struct inode *inode);
diff --git a/include/linux/fault-inject.h b/include/linux/fault-inject.h
index 7b64ad40e4c..c6f996f2abb 100644
--- a/include/linux/fault-inject.h
+++ b/include/linux/fault-inject.h
@@ -5,7 +5,7 @@
 
 #include <linux/types.h>
 #include <linux/debugfs.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 /*
  * For explanation of the elements of this struct, see
@@ -25,26 +25,6 @@ struct fault_attr {
         unsigned long reject_end;
 
         unsigned long count;
-
-#ifdef CONFIG_FAULT_INJECTION_DEBUG_FS
-
-        struct {
-                struct dentry *dir;
-
-                struct dentry *probability_file;
-                struct dentry *interval_file;
-                struct dentry *times_file;
-                struct dentry *space_file;
-                struct dentry *verbose_file;
-                struct dentry *task_filter_file;
-                struct dentry *stacktrace_depth_file;
-                struct dentry *require_start_file;
-                struct dentry *require_end_file;
-                struct dentry *reject_start_file;
-                struct dentry *reject_end_file;
-        } dentries;
-
-#endif
 };
 
 #define FAULT_ATTR_INITIALIZER {                                \
@@ -57,24 +37,19 @@ struct fault_attr {
 
 #define DECLARE_FAULT_ATTR(name) struct fault_attr name = FAULT_ATTR_INITIALIZER
 int setup_fault_attr(struct fault_attr *attr, char *str);
-void should_fail_srandom(unsigned long entropy);
 bool should_fail(struct fault_attr *attr, ssize_t size);
 
 #ifdef CONFIG_FAULT_INJECTION_DEBUG_FS
 
-int init_fault_attr_dentries(struct fault_attr *attr, const char *name);
-void cleanup_fault_attr_dentries(struct fault_attr *attr);
+struct dentry *fault_create_debugfs_attr(const char *name,
+                        struct dentry *parent, struct fault_attr *attr);
 
 #else /* CONFIG_FAULT_INJECTION_DEBUG_FS */
 
-static inline int init_fault_attr_dentries(struct fault_attr *attr,
-                                          const char *name)
-{
-        return -ENODEV;
-}
-
-static inline void cleanup_fault_attr_dentries(struct fault_attr *attr)
+static inline struct dentry *fault_create_debugfs_attr(const char *name,
+                        struct dentry *parent, struct fault_attr *attr)
 {
+        return ERR_PTR(-ENODEV);
 }
 
 #endif /* CONFIG_FAULT_INJECTION_DEBUG_FS */
diff --git a/include/linux/fb.h b/include/linux/fb.h
index 6a827487717..bb565a4c2e1 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -226,6 +226,19 @@ struct fb_bitfield {
 #define FB_VMODE_SMOOTH_XPAN    512     /* smooth xpan possible (internally used) */
 #define FB_VMODE_CONUPDATE      512     /* don't update x/yoffset       */
 
+#define FB_FLAG_RATIO_4_3       64
+#define FB_FLAG_RATIO_16_9      128
+#define FB_FLAG_PIXEL_REPEAT    256
+
+/*
+ * Stereo modes
+ */
+#define FB_VMODE_STEREO_NONE        0x00000000  /* not stereo */
+#define FB_VMODE_STEREO_FRAME_PACK  0x01000000  /* frame packing */
+#define FB_VMODE_STEREO_TOP_BOTTOM  0x02000000  /* top-bottom */
+#define FB_VMODE_STEREO_LEFT_RIGHT  0x04000000  /* left-right */
+#define FB_VMODE_STEREO_MASK        0xFF000000
+
 /*
  * Display rotation support
  */
@@ -439,6 +452,8 @@ struct file;
 
 #define FB_MISC_PRIM_COLOR      1
 #define FB_MISC_1ST_DETAIL      2       /* First Detailed Timing is preferred */
+#define FB_MISC_HDMI            4       /* display supports HDMI signaling */
+
 struct fb_chroma {
         __u32 redx;     /* in fraction of 1024 */
         __u32 greenx;
@@ -1043,7 +1058,8 @@ extern void fb_deferred_io_open(struct fb_info *info,
                                 struct inode *inode,
                                 struct file *file);
 extern void fb_deferred_io_cleanup(struct fb_info *info);
-extern int fb_deferred_io_fsync(struct file *file, int datasync);
+extern int fb_deferred_io_fsync(struct file *file, loff_t start,
+                                loff_t end, int datasync);
 
 static inline bool fb_be_math(struct fb_info *info)
 {
@@ -1103,6 +1119,7 @@ extern unsigned char *fb_ddc_read(struct i2c_adapter *adapter);
 
 /* drivers/video/modedb.c */
 #define VESA_MODEDB_SIZE 34
+#define CEA_MODEDB_SIZE 65
 extern void fb_var_to_videomode(struct fb_videomode *mode,
                                 const struct fb_var_screeninfo *var);
 extern void fb_videomode_to_var(struct fb_var_screeninfo *var,
@@ -1155,7 +1172,7 @@ struct fb_videomode {
 
 extern const char *fb_mode_option;
 extern const struct fb_videomode vesa_modes[];
-extern const struct fb_videomode cea_modes[64];
+extern const struct fb_videomode cea_modes[];
 
 struct fb_modelist {
         struct list_head list;
diff --git a/include/linux/fd.h b/include/linux/fd.h
index f5d194af07a..72202b1b9a6 100644
--- a/include/linux/fd.h
+++ b/include/linux/fd.h
@@ -377,4 +377,26 @@ struct floppy_raw_cmd {
 #define FDEJECT _IO(2, 0x5a)
 /* eject the disk */
 
+
+#ifdef __KERNEL__
+#ifdef CONFIG_COMPAT
+#include <linux/compat.h>
+
+struct compat_floppy_struct {
+        compat_uint_t   size;
+        compat_uint_t   sect;
+        compat_uint_t   head;
+        compat_uint_t   track;
+        compat_uint_t   stretch;
+        unsigned char   gap;
+        unsigned char   rate;
+        unsigned char   spec1;
+        unsigned char   fmt_gap;
+        const compat_caddr_t name;
+};
+
+#define FDGETPRM32 _IOR(2, 0x04, struct compat_floppy_struct)
+#endif
+#endif
+
 #endif
diff --git a/include/linux/fdtable.h b/include/linux/fdtable.h
index 133c0ba25e3..82163c4b32c 100644
--- a/include/linux/fdtable.h
+++ b/include/linux/fdtable.h
@@ -13,7 +13,7 @@
 #include <linux/init.h>
 #include <linux/fs.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 /*
  * The default fd array needs to be at least BITS_PER_LONG,
@@ -60,7 +60,6 @@ struct files_struct {
 
 #define rcu_dereference_check_fdtable(files, fdtfd) \
         (rcu_dereference_check((fdtfd), \
-                               rcu_read_lock_held() || \
                                lockdep_is_held(&(files)->file_lock) || \
                                atomic_read(&(files)->count) == 1 || \
                                rcu_my_thread_group_empty()))
diff --git a/include/linux/filter.h b/include/linux/filter.h
index 9ee3f9fb0b4..741956fa5bf 100644
--- a/include/linux/filter.h
+++ b/include/linux/filter.h
@@ -9,7 +9,7 @@
 #include <linux/types.h>
 
 #ifdef __KERNEL__
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #endif
 
 /*
diff --git a/include/linux/firewire-cdev.h b/include/linux/firewire-cdev.h
index 4ff09889c5c..357dbfc2829 100644
--- a/include/linux/firewire-cdev.h
+++ b/include/linux/firewire-cdev.h
@@ -30,10 +30,13 @@
 #include <linux/types.h>
 #include <linux/firewire-constants.h>
 
+/* available since kernel version 2.6.22 */
 #define FW_CDEV_EVENT_BUS_RESET                         0x00
 #define FW_CDEV_EVENT_RESPONSE                          0x01
 #define FW_CDEV_EVENT_REQUEST                           0x02
 #define FW_CDEV_EVENT_ISO_INTERRUPT                     0x03
+
+/* available since kernel version 2.6.30 */
 #define FW_CDEV_EVENT_ISO_RESOURCE_ALLOCATED            0x04
 #define FW_CDEV_EVENT_ISO_RESOURCE_DEALLOCATED          0x05
 
@@ -120,24 +123,11 @@ struct fw_cdev_event_response {
 
 /**
  * struct fw_cdev_event_request - Old version of &fw_cdev_event_request2
- * @closure:    See &fw_cdev_event_common; set by %FW_CDEV_IOC_ALLOCATE ioctl
  * @type:       See &fw_cdev_event_common; always %FW_CDEV_EVENT_REQUEST
- * @tcode:      See &fw_cdev_event_request2
- * @offset:     See &fw_cdev_event_request2
- * @handle:     See &fw_cdev_event_request2
- * @length:     See &fw_cdev_event_request2
- * @data:       See &fw_cdev_event_request2
  *
  * This event is sent instead of &fw_cdev_event_request2 if the kernel or
- * the client implements ABI version <= 3.
- *
- * Unlike &fw_cdev_event_request2, the sender identity cannot be established,
- * broadcast write requests cannot be distinguished from unicast writes, and
- * @tcode of lock requests is %TCODE_LOCK_REQUEST.
- *
- * Requests to the FCP_REQUEST or FCP_RESPONSE register are responded to as
- * with &fw_cdev_event_request2, except in kernel 2.6.32 and older which send
- * the response packet of the client's %FW_CDEV_IOC_SEND_RESPONSE ioctl.
+ * the client implements ABI version <= 3.  &fw_cdev_event_request lacks
+ * essential information; use &fw_cdev_event_request2 instead.
  */
 struct fw_cdev_event_request {
         __u64 closure;
@@ -452,29 +442,31 @@ union fw_cdev_event {
  *                 %FW_CDEV_ISO_CONTEXT_RECEIVE_MULTICHANNEL, and
  *                 %FW_CDEV_IOC_SET_ISO_CHANNELS
  */
-#define FW_CDEV_VERSION 3 /* Meaningless; don't use this macro. */
 
 /**
  * struct fw_cdev_get_info - General purpose information ioctl
  * @version:    The version field is just a running serial number.  Both an
  *              input parameter (ABI version implemented by the client) and
  *              output parameter (ABI version implemented by the kernel).
- *              A client must not fill in an %FW_CDEV_VERSION defined from an
- *              included kernel header file but the actual version for which
- *              the client was implemented.  This is necessary for forward
- *              compatibility.  We never break backwards compatibility, but
- *              may add more structs, events, and ioctls in later revisions.
- * @rom_length: If @rom is non-zero, at most rom_length bytes of configuration
+ *              A client shall fill in the ABI @version for which the client
+ *              was implemented.  This is necessary for forward compatibility.
+ * @rom_length: If @rom is non-zero, up to @rom_length bytes of Configuration
  *              ROM will be copied into that user space address.  In either
  *              case, @rom_length is updated with the actual length of the
- *              configuration ROM.
+ *              Configuration ROM.
  * @rom:        If non-zero, address of a buffer to be filled by a copy of the
- *              device's configuration ROM
+ *              device's Configuration ROM
  * @bus_reset:  If non-zero, address of a buffer to be filled by a
  *              &struct fw_cdev_event_bus_reset with the current state
  *              of the bus.  This does not cause a bus reset to happen.
  * @bus_reset_closure: Value of &closure in this and subsequent bus reset events
  * @card:       The index of the card this device belongs to
+ *
+ * The %FW_CDEV_IOC_GET_INFO ioctl is usually the very first one which a client
+ * performs right after it opened a /dev/fw* file.
+ *
+ * As a side effect, reception of %FW_CDEV_EVENT_BUS_RESET events to be read(2)
+ * is started by this ioctl.
  */
 struct fw_cdev_get_info {
         __u32 version;
@@ -612,7 +604,7 @@ struct fw_cdev_initiate_bus_reset {
  * @handle:     Handle to the descriptor, written by the kernel
  *
  * Add a descriptor block and optionally a preceding immediate key to the local
- * node's configuration ROM.
+ * node's Configuration ROM.
  *
  * The @key field specifies the upper 8 bits of the descriptor root directory
  * pointer and the @data and @length fields specify the contents. The @key
@@ -627,9 +619,9 @@ struct fw_cdev_initiate_bus_reset {
  * If successful, the kernel adds the descriptor and writes back a @handle to
  * the kernel-side object to be used for later removal of the descriptor block
  * and immediate key.  The kernel will also generate a bus reset to signal the
- * change of the configuration ROM to other nodes.
+ * change of the Configuration ROM to other nodes.
  *
- * This ioctl affects the configuration ROMs of all local nodes.
+ * This ioctl affects the Configuration ROMs of all local nodes.
  * The ioctl only succeeds on device files which represent a local node.
  */
 struct fw_cdev_add_descriptor {
@@ -641,13 +633,13 @@ struct fw_cdev_add_descriptor {
 };
 
 /**
- * struct fw_cdev_remove_descriptor - Remove contents from the configuration ROM
+ * struct fw_cdev_remove_descriptor - Remove contents from the Configuration ROM
  * @handle:     Handle to the descriptor, as returned by the kernel when the
  *              descriptor was added
  *
  * Remove a descriptor block and accompanying immediate key from the local
- * nodes' configuration ROMs.  The kernel will also generate a bus reset to
- * signal the change of the configuration ROM to other nodes.
+ * nodes' Configuration ROMs.  The kernel will also generate a bus reset to
+ * signal the change of the Configuration ROM to other nodes.
  */
 struct fw_cdev_remove_descriptor {
         __u32 handle;
@@ -863,13 +855,8 @@ struct fw_cdev_stop_iso {
  * @local_time:   system time, in microseconds since the Epoch
  * @cycle_timer:  Cycle Time register contents
  *
- * The %FW_CDEV_IOC_GET_CYCLE_TIMER ioctl reads the isochronous cycle timer
- * and also the system clock (%CLOCK_REALTIME).  This allows to express the
- * receive time of an isochronous packet as a system time.
- *
- * @cycle_timer consists of 7 bits cycleSeconds, 13 bits cycleCount, and
- * 12 bits cycleOffset, in host byte order.  Cf. the Cycle Time register
- * per IEEE 1394 or Isochronous Cycle Timer register per OHCI-1394.
+ * Same as %FW_CDEV_IOC_GET_CYCLE_TIMER2, but fixed to use %CLOCK_REALTIME
+ * and only with microseconds resolution.
  *
  * In version 1 and 2 of the ABI, this ioctl returned unreliable (non-
  * monotonic) @cycle_timer values on certain controllers.
@@ -886,10 +873,17 @@ struct fw_cdev_get_cycle_timer {
  * @clk_id:       input parameter, clock from which to get the system time
  * @cycle_timer:  Cycle Time register contents
  *
- * The %FW_CDEV_IOC_GET_CYCLE_TIMER2 works like
- * %FW_CDEV_IOC_GET_CYCLE_TIMER but lets you choose a clock like with POSIX'
- * clock_gettime function.  Supported @clk_id values are POSIX' %CLOCK_REALTIME
- * and %CLOCK_MONOTONIC and Linux' %CLOCK_MONOTONIC_RAW.
+ * The %FW_CDEV_IOC_GET_CYCLE_TIMER2 ioctl reads the isochronous cycle timer
+ * and also the system clock.  This allows to correlate reception time of
+ * isochronous packets with system time.
+ *
+ * @clk_id lets you choose a clock like with POSIX' clock_gettime function.
+ * Supported @clk_id values are POSIX' %CLOCK_REALTIME and %CLOCK_MONOTONIC
+ * and Linux' %CLOCK_MONOTONIC_RAW.
+ *
+ * @cycle_timer consists of 7 bits cycleSeconds, 13 bits cycleCount, and
+ * 12 bits cycleOffset, in host byte order.  Cf. the Cycle Time register
+ * per IEEE 1394 or Isochronous Cycle Timer register per OHCI-1394.
  */
 struct fw_cdev_get_cycle_timer2 {
         __s64 tv_sec;
@@ -1011,4 +1005,6 @@ struct fw_cdev_receive_phy_packets {
         __u64 closure;
 };
 
+#define FW_CDEV_VERSION 3 /* Meaningless legacy macro; don't use it. */
+
 #endif /* _LINUX_FIREWIRE_CDEV_H */
diff --git a/include/linux/firewire.h b/include/linux/firewire.h
index 5e6f42789af..84ccf8e04fa 100644
--- a/include/linux/firewire.h
+++ b/include/linux/firewire.h
@@ -14,7 +14,7 @@
 #include <linux/types.h>
 #include <linux/workqueue.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <asm/byteorder.h>
 
 #define fw_notify(s, args...) printk(KERN_NOTICE KBUILD_MODNAME ": " s, ## args)
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 8d5834bcb89..78987e9a384 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -32,7 +32,9 @@
 #define SEEK_SET        0       /* seek relative to beginning of file */
 #define SEEK_CUR        1       /* seek relative to current file position */
 #define SEEK_END        2       /* seek relative to end of file */
-#define SEEK_MAX        SEEK_END
+#define SEEK_DATA       3       /* seek to the next data */
+#define SEEK_HOLE       4       /* seek to the next hole */
+#define SEEK_MAX        SEEK_HOLE
 
 struct fstrim_range {
         __u64 start;
@@ -63,6 +65,7 @@ struct inodes_stat_t {
 #define MAY_ACCESS 16
 #define MAY_OPEN 32
 #define MAY_CHDIR 64
+#define MAY_NOT_BLOCK 128       /* called from RCU mode, don't block */
 
 /*
  * flags in file.f_mode.  Note that FMODE_READ and FMODE_WRITE must correspond
@@ -159,10 +162,8 @@ struct inodes_stat_t {
 #define READA                   RWA_MASK
 
 #define READ_SYNC               (READ | REQ_SYNC)
-#define READ_META               (READ | REQ_META)
 #define WRITE_SYNC              (WRITE | REQ_SYNC | REQ_NOIDLE)
 #define WRITE_ODIRECT           (WRITE | REQ_SYNC)
-#define WRITE_META              (WRITE | REQ_META)
 #define WRITE_FLUSH             (WRITE | REQ_SYNC | REQ_NOIDLE | REQ_FLUSH)
 #define WRITE_FUA               (WRITE | REQ_SYNC | REQ_NOIDLE | REQ_FUA)
 #define WRITE_FLUSH_FUA         (WRITE | REQ_SYNC | REQ_NOIDLE | REQ_FLUSH | REQ_FUA)
@@ -376,7 +377,6 @@ struct inodes_stat_t {
 
 #include <linux/linkage.h>
 #include <linux/wait.h>
-#include <linux/types.h>
 #include <linux/kdev_t.h>
 #include <linux/dcache.h>
 #include <linux/path.h>
@@ -392,8 +392,9 @@ struct inodes_stat_t {
 #include <linux/semaphore.h>
 #include <linux/fiemap.h>
 #include <linux/rculist_bl.h>
+#include <linux/shrinker.h>
+#include <linux/atomic.h>
 
-#include <asm/atomic.h>
 #include <asm/byteorder.h>
 
 struct export_operations;
@@ -736,22 +737,54 @@ struct posix_acl;
 #define ACL_NOT_CACHED ((void *)(-1))
 struct inode_obj_id_table;
 
+#define IOP_FASTPERM    0x0001
+#define IOP_LOOKUP      0x0002
+#define IOP_NOFOLLOW    0x0004
+
+/*
+ * Keep mostly read-only and often accessed (especially for
+ * the RCU path lookup and 'stat' data) fields at the beginning
+ * of the 'struct inode'
+ */
 struct inode {
-        /* RCU path lookup touches following: */
         umode_t                 i_mode;
+        unsigned short          i_opflags;
         uid_t                   i_uid;
         gid_t                   i_gid;
+        unsigned int            i_flags;
+
+#ifdef CONFIG_FS_POSIX_ACL
+        struct posix_acl        *i_acl;
+        struct posix_acl        *i_default_acl;
+#endif
+
         const struct inode_operations   *i_op;
         struct super_block      *i_sb;
+        struct address_space    *i_mapping;
 
-        spinlock_t              i_lock; /* i_blocks, i_bytes, maybe i_size */
-        unsigned int            i_flags;
-        unsigned long           i_state;
 #ifdef CONFIG_SECURITY
         void                    *i_security;
 #endif
-        struct mutex            i_mutex;
 
+        /* Stat data, not accessed from path walking */
+        unsigned long           i_ino;
+        unsigned int            i_nlink;
+        dev_t                   i_rdev;
+        loff_t                  i_size;
+        struct timespec         i_atime;
+        struct timespec         i_mtime;
+        struct timespec         i_ctime;
+        unsigned int            i_blkbits;
+        blkcnt_t                i_blocks;
+
+#ifdef __NEED_I_SIZE_ORDERED
+        seqcount_t              i_size_seqcount;
+#endif
+
+        /* Misc */
+        unsigned long           i_state;
+        spinlock_t              i_lock; /* i_blocks, i_bytes, maybe i_size */
+        struct mutex            i_mutex;
 
         unsigned long           dirtied_when;   /* jiffies of first dirtying */
 
@@ -763,25 +796,12 @@ struct inode {
                 struct list_head        i_dentry;
                 struct rcu_head         i_rcu;
         };
-        unsigned long           i_ino;
         atomic_t                i_count;
-        unsigned int            i_nlink;
-        dev_t                   i_rdev;
-        unsigned int            i_blkbits;
         u64                     i_version;
-        loff_t                  i_size;
-#ifdef __NEED_I_SIZE_ORDERED
-        seqcount_t              i_size_seqcount;
-#endif
-        struct timespec         i_atime;
-        struct timespec         i_mtime;
-        struct timespec         i_ctime;
-        blkcnt_t                i_blocks;
         unsigned short          i_bytes;
-        struct rw_semaphore     i_alloc_sem;
+        atomic_t                i_dio_count;
         const struct file_operations    *i_fop; /* former ->i_op->default_file_ops */
         struct file_lock        *i_flock;
-        struct address_space    *i_mapping;
         struct address_space    i_data;
 #ifdef CONFIG_QUOTA
         struct dquot            *i_dquot[MAXQUOTAS];
@@ -804,12 +824,6 @@ struct inode {
         atomic_t                i_readcount; /* struct files open RO */
 #endif
         atomic_t                i_writecount;
-#ifdef CONFIG_FS_POSIX_ACL
-        struct posix_acl        *i_acl;
-        struct posix_acl        *i_default_acl;
-#endif
-        struct list_head        i_obj_list;
-        struct mutex            i_obj_mutex;
         void                    *i_private; /* fs or device private pointer */
 };
 
@@ -1072,12 +1086,12 @@ struct file_lock_operations {
 };
 
 struct lock_manager_operations {
-        int (*fl_compare_owner)(struct file_lock *, struct file_lock *);
-        void (*fl_notify)(struct file_lock *);  /* unblock callback */
-        int (*fl_grant)(struct file_lock *, struct file_lock *, int);
-        void (*fl_release_private)(struct file_lock *);
-        void (*fl_break)(struct file_lock *);
-        int (*fl_change)(struct file_lock **, int);
+        int (*lm_compare_owner)(struct file_lock *, struct file_lock *);
+        void (*lm_notify)(struct file_lock *);  /* unblock callback */
+        int (*lm_grant)(struct file_lock *, struct file_lock *, int);
+        void (*lm_release_private)(struct file_lock *);
+        void (*lm_break)(struct file_lock *);
+        int (*lm_change)(struct file_lock **, int);
 };
 
 struct lock_manager {
@@ -1399,6 +1413,11 @@ struct super_block {
         struct list_head        s_dentry_lru;   /* unused dentry lru */
         int                     s_nr_dentry_unused;     /* # of dentry on lru */
 
+        /* s_inode_lru_lock protects s_inode_lru and s_nr_inodes_unused */
+        spinlock_t              s_inode_lru_lock ____cacheline_aligned_in_smp;
+        struct list_head        s_inode_lru;            /* unused inode lru */
+        int                     s_nr_inodes_unused;     /* # of inodes on lru */
+
         struct block_device     *s_bdev;
         struct backing_dev_info *s_bdi;
         struct mtd_info         *s_mtd;
@@ -1441,8 +1460,14 @@ struct super_block {
          * Saved pool identifier for cleancache (-1 means none)
          */
         int cleancache_poolid;
+
+        struct shrinker s_shrink;       /* per-sb shrinker handle */
 };
 
+/* superblock cache pruning functions */
+extern void prune_icache_sb(struct super_block *sb, int nr_to_scan);
+extern void prune_dcache_sb(struct super_block *sb, int nr_to_scan);
+
 extern struct timespec current_fs_time(struct super_block *sb);
 
 /*
@@ -1457,10 +1482,6 @@ enum {
 #define vfs_check_frozen(sb, level) \
         wait_event((sb)->s_wait_unfrozen, ((sb)->s_frozen < (level)))
 
-#define get_fs_excl() atomic_inc(&current->fs_excl)
-#define put_fs_excl() atomic_dec(&current->fs_excl)
-#define has_fs_excl() atomic_read(&current->fs_excl)
-
 /*
  * until VFS tracks user namespaces for inodes, just make all files
  * belong to init_user_ns
@@ -1493,7 +1514,6 @@ extern void dentry_unhash(struct dentry *dentry);
 /*
  * VFS file helper functions.
  */
-extern int file_permission(struct file *, int);
 extern void inode_init_owner(struct inode *inode, const struct inode *dir,
                         mode_t mode);
 /*
@@ -1541,11 +1561,6 @@ struct block_device_operations;
 #define HAVE_COMPAT_IOCTL 1
 #define HAVE_UNLOCKED_IOCTL 1
 
-/*
- * NOTE:
- * all file operations except setlease can be called without
- * the big kernel lock held in all filesystems.
- */
 struct file_operations {
         struct module *owner;
         loff_t (*llseek) (struct file *, loff_t, int);
@@ -1561,7 +1576,7 @@ struct file_operations {
         int (*open) (struct inode *, struct file *);
         int (*flush) (struct file *, fl_owner_t id);
         int (*release) (struct inode *, struct file *);
-        int (*fsync) (struct file *, int datasync);
+        int (*fsync) (struct file *, loff_t, loff_t, int datasync);
         int (*aio_fsync) (struct kiocb *, int datasync);
         int (*fasync) (int, struct file *, int);
         int (*lock) (struct file *, int, struct file_lock *);
@@ -1576,13 +1591,11 @@ struct file_operations {
                           loff_t len);
 };
 
-#define IPERM_FLAG_RCU  0x0001
-
 struct inode_operations {
         struct dentry * (*lookup) (struct inode *,struct dentry *, struct nameidata *);
         void * (*follow_link) (struct dentry *, struct nameidata *);
-        int (*permission) (struct inode *, int, unsigned int);
-        int (*check_acl)(struct inode *, int, unsigned int);
+        int (*permission) (struct inode *, int);
+        struct posix_acl * (*get_acl)(struct inode *, int);
 
         int (*readlink) (struct dentry *, char __user *,int);
         void (*put_link) (struct dentry *, struct nameidata *, void *);
@@ -1648,6 +1661,8 @@ struct super_operations {
         ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
 #endif
         int (*bdev_try_to_free_page)(struct super_block*, struct page*, gfp_t);
+        int (*nr_cached_objects)(struct super_block *);
+        void (*free_cached_objects)(struct super_block *, int);
 };
 
 /*
@@ -1696,6 +1711,10 @@ struct super_operations {
  *                      set during data writeback, and cleared with a wakeup
  *                      on the bit address once it is done.
  *
+ * I_REFERENCED         Marks the inode as recently references on the LRU list.
+ *
+ * I_DIO_WAKEUP         Never set.  Only used as a key for wait_on_bit().
+ *
  * Q: What is the difference between I_WILL_FREE and I_FREEING?
  */
 #define I_DIRTY_SYNC            (1 << 0)
@@ -1709,6 +1728,8 @@ struct super_operations {
 #define __I_SYNC                7
 #define I_SYNC                  (1 << __I_SYNC)
 #define I_REFERENCED            (1 << 8)
+#define __I_DIO_WAKEUP          9
+#define I_DIO_WAKEUP            (1 << I_DIO_WAKEUP)
 
 #define I_DIRTY (I_DIRTY_SYNC | I_DIRTY_DATASYNC | I_DIRTY_PAGES)
 
@@ -1819,7 +1840,6 @@ struct file_system_type {
         struct lock_class_key i_lock_key;
         struct lock_class_key i_mutex_key;
         struct lock_class_key i_mutex_dir_key;
-        struct lock_class_key i_alloc_sem_key;
 };
 
 extern struct dentry *mount_ns(struct file_system_type *fs_type, int flags,
@@ -1840,6 +1860,8 @@ void kill_litter_super(struct super_block *sb);
 void deactivate_super(struct super_block *sb);
 void deactivate_locked_super(struct super_block *sb);
 int set_anon_super(struct super_block *s, void *data);
+int get_anon_bdev(dev_t *);
+void free_anon_bdev(dev_t);
 struct super_block *sget(struct file_system_type *type,
                         int (*test)(struct super_block *,void *),
                         int (*set)(struct super_block *,void *),
@@ -1872,6 +1894,7 @@ extern int register_filesystem(struct file_system_type *);
 extern int unregister_filesystem(struct file_system_type *);
 extern struct vfsmount *kern_mount_data(struct file_system_type *, void *data);
 #define kern_mount(type) kern_mount_data(type, NULL)
+extern void kern_unmount(struct vfsmount *mnt);
 extern int may_umount_tree(struct vfsmount *);
 extern int may_umount(struct vfsmount *);
 extern long do_mount(char *, char *, char *, unsigned long, void *);
@@ -1885,6 +1908,7 @@ extern int fd_statfs(int, struct kstatfs *);
 extern int statfs_by_dentry(struct dentry *, struct kstatfs *);
 extern int freeze_super(struct super_block *super);
 extern int thaw_super(struct super_block *super);
+extern bool our_mnt(struct vfsmount *mnt);
 
 extern int current_umask(void);
 
@@ -2191,16 +2215,38 @@ extern sector_t bmap(struct inode *, sector_t);
 #endif
 extern int notify_change(struct dentry *, struct iattr *);
 extern int inode_permission(struct inode *, int);
-extern int generic_permission(struct inode *, int, unsigned int,
-                int (*check_acl)(struct inode *, int, unsigned int));
+extern int generic_permission(struct inode *, int);
 
 static inline bool execute_ok(struct inode *inode)
 {
         return (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode);
 }
 
-extern int get_write_access(struct inode *);
-extern int deny_write_access(struct file *);
+/*
+ * get_write_access() gets write permission for a file.
+ * put_write_access() releases this write permission.
+ * This is used for regular files.
+ * We cannot support write (and maybe mmap read-write shared) accesses and
+ * MAP_DENYWRITE mmappings simultaneously. The i_writecount field of an inode
+ * can have the following values:
+ * 0: no writers, no VM_DENYWRITE mappings
+ * < 0: (-i_writecount) vm_area_structs with VM_DENYWRITE set exist
+ * > 0: (i_writecount) users are writing to the file.
+ *
+ * Normally we operate on that counter with atomic_{inc,dec} and it's safe
+ * except for the cases where we don't hold i_writecount yet. Then we need to
+ * use {get,deny}_write_access() - these functions check the sign and refuse
+ * to do the change if sign is wrong.
+ */
+static inline int get_write_access(struct inode *inode)
+{
+        return atomic_inc_unless_negative(&inode->i_writecount) ? 0 : -ETXTBSY;
+}
+static inline int deny_write_access(struct file *file)
+{
+        struct inode *inode = file->f_path.dentry->d_inode;
+        return atomic_dec_unless_positive(&inode->i_writecount) ? 0 : -ETXTBSY;
+}
 static inline void put_write_access(struct inode * inode)
 {
         atomic_dec(&inode->i_writecount);
@@ -2272,6 +2318,11 @@ extern struct inode * iget5_locked(struct super_block *, unsigned long, int (*te
 extern struct inode * iget_locked(struct super_block *, unsigned long);
 extern int insert_inode_locked4(struct inode *, unsigned long, int (*test)(struct inode *, void *), void *);
 extern int insert_inode_locked(struct inode *);
+#ifdef CONFIG_DEBUG_LOCK_ALLOC
+extern void lockdep_annotate_inode_mutex_key(struct inode *inode);
+#else
+static inline void lockdep_annotate_inode_mutex_key(struct inode *inode) { };
+#endif
 extern void unlock_new_inode(struct inode *);
 extern unsigned int get_next_ino(void);
 
@@ -2279,17 +2330,25 @@ extern void __iget(struct inode * inode);
 extern void iget_failed(struct inode *);
 extern void end_writeback(struct inode *);
 extern void __destroy_inode(struct inode *);
-extern struct inode *new_inode(struct super_block *);
+extern struct inode *new_inode_pseudo(struct super_block *sb);
+extern struct inode *new_inode(struct super_block *sb);
 extern void free_inode_nonrcu(struct inode *inode);
 extern int should_remove_suid(struct dentry *);
 extern int file_remove_suid(struct file *);
 
 extern void __insert_inode_hash(struct inode *, unsigned long hashval);
-extern void remove_inode_hash(struct inode *);
 static inline void insert_inode_hash(struct inode *inode)
 {
         __insert_inode_hash(inode, inode->i_ino);
 }
+
+extern void __remove_inode_hash(struct inode *);
+static inline void remove_inode_hash(struct inode *inode)
+{
+        if (!inode_unhashed(inode))
+                __remove_inode_hash(inode);
+}
+
 extern void inode_sb_list_add(struct inode *inode);
 
 #ifdef CONFIG_BLOCK
@@ -2320,7 +2379,8 @@ extern int generic_segment_checks(const struct iovec *iov,
 /* fs/block_dev.c */
 extern ssize_t blkdev_aio_write(struct kiocb *iocb, const struct iovec *iov,
                                 unsigned long nr_segs, loff_t pos);
-extern int blkdev_fsync(struct file *filp, int datasync);
+extern int blkdev_fsync(struct file *filp, loff_t start, loff_t end,
+                        int datasync);
 
 /* fs/splice.c */
 extern ssize_t generic_file_splice_read(struct file *, loff_t *,
@@ -2371,6 +2431,8 @@ enum {
 };
 
 void dio_end_io(struct bio *bio, int error);
+void inode_dio_wait(struct inode *inode);
+void inode_dio_done(struct inode *inode);
 
 ssize_t __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
         struct block_device *bdev, const struct iovec *iov, loff_t offset,
@@ -2378,14 +2440,17 @@ ssize_t __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
         dio_submit_t submit_io, int flags);
 
 static inline ssize_t blockdev_direct_IO(int rw, struct kiocb *iocb,
-        struct inode *inode, struct block_device *bdev, const struct iovec *iov,
-        loff_t offset, unsigned long nr_segs, get_block_t get_block,
-        dio_iodone_t end_io)
+                struct inode *inode, const struct iovec *iov, loff_t offset,
+                unsigned long nr_segs, get_block_t get_block)
 {
-        return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
-                                    nr_segs, get_block, end_io, NULL,
+        return __blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
+                                    offset, nr_segs, get_block, NULL, NULL,
                                     DIO_LOCKING | DIO_SKIP_HOLES);
 }
+#else
+static inline void inode_dio_wait(struct inode *inode)
+{
+}
 #endif
 
 extern const struct file_operations generic_ro_fops;
@@ -2435,6 +2500,8 @@ extern struct super_block *get_active_super(struct block_device *bdev);
 extern struct super_block *user_get_super(dev_t);
 extern void drop_super(struct super_block *sb);
 extern void iterate_supers(void (*)(struct super_block *, void *), void *);
+extern void iterate_supers_type(struct file_system_type *,
+                                void (*)(struct super_block *, void *), void *);
 
 extern int dcache_dir_open(struct inode *, struct file *);
 extern int dcache_dir_close(struct inode *, struct file *);
@@ -2447,7 +2514,7 @@ extern int simple_link(struct dentry *, struct inode *, struct dentry *);
 extern int simple_unlink(struct inode *, struct dentry *);
 extern int simple_rmdir(struct inode *, struct dentry *);
 extern int simple_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
-extern int noop_fsync(struct file *, int);
+extern int noop_fsync(struct file *, loff_t, loff_t, int);
 extern int simple_empty(struct dentry *);
 extern int simple_readpage(struct file *file, struct page *page);
 extern int simple_write_begin(struct file *file, struct address_space *mapping,
@@ -2472,7 +2539,7 @@ extern ssize_t simple_read_from_buffer(void __user *to, size_t count,
 extern ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos,
                 const void __user *from, size_t count);
 
-extern int generic_file_fsync(struct file *, int);
+extern int generic_file_fsync(struct file *, loff_t, loff_t, int);
 
 extern int generic_check_addressable(unsigned, u64);
 
diff --git a/include/linux/fsl_devices.h b/include/linux/fsl_devices.h
index fffdf00f87b..1962102d132 100644
--- a/include/linux/fsl_devices.h
+++ b/include/linux/fsl_devices.h
@@ -58,6 +58,13 @@ enum fsl_usb2_phy_modes {
         FSL_USB2_PHY_SERIAL,
 };
 
+enum fsl_usb2_phy_types {
+        FSL_USB2_PHY_TYPE_UTMIP = 1,
+        FSL_USB2_PHY_TYPE_ULPI = 2,
+        FSL_USB2_PHY_TYPE_HSIC = 3,
+        FSL_USB2_PHY_TYPE_ICUSB = 4,
+};
+
 struct clk;
 struct platform_device;
 
@@ -72,7 +79,6 @@ struct fsl_usb2_platform_data {
         void            (*exit)(struct platform_device *);
         void __iomem    *regs;          /* ioremap'd register base */
         struct clk      *clk;
-        unsigned        power_budget;   /* hcd->power_budget */
         unsigned        big_endian_mmio:1;
         unsigned        big_endian_desc:1;
         unsigned        es:1;           /* need USBMODE:ES */
@@ -95,6 +101,9 @@ struct fsl_usb2_platform_data {
         u32             pm_configured_flag;
         u32             pm_portsc;
         u32             pm_usbgenctrl;
+
+        void            *phy_config;
+        enum fsl_usb2_phy_types usb_phy_type;
 };
 
 /* Flags in fsl_usb2_mph_platform_data */
diff --git a/include/linux/fsl_hypervisor.h b/include/linux/fsl_hypervisor.h
new file mode 100644
index 00000000000..1cebaeeeef5
--- /dev/null
+++ b/include/linux/fsl_hypervisor.h
@@ -0,0 +1,241 @@
+/*
+ * Freescale hypervisor ioctl and kernel interface
+ *
+ * Copyright (C) 2008-2011 Freescale Semiconductor, Inc.
+ * Author: Timur Tabi <timur@freescale.com>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Freescale Semiconductor nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ *
+ * ALTERNATIVELY, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") as published by the Free Software
+ * Foundation, either version 2 of that License or (at your option) any
+ * later version.
+ *
+ * This software is provided by Freescale Semiconductor "as is" and any
+ * express or implied warranties, including, but not limited to, the implied
+ * warranties of merchantability and fitness for a particular purpose are
+ * disclaimed. In no event shall Freescale Semiconductor be liable for any
+ * direct, indirect, incidental, special, exemplary, or consequential damages
+ * (including, but not limited to, procurement of substitute goods or services;
+ * loss of use, data, or profits; or business interruption) however caused and
+ * on any theory of liability, whether in contract, strict liability, or tort
+ * (including negligence or otherwise) arising in any way out of the use of this
+ * software, even if advised of the possibility of such damage.
+ *
+ * This file is used by the Freescale hypervisor management driver.  It can
+ * also be included by applications that need to communicate with the driver
+ * via the ioctl interface.
+ */
+
+#ifndef FSL_HYPERVISOR_H
+#define FSL_HYPERVISOR_H
+
+#include <linux/types.h>
+
+/**
+ * struct fsl_hv_ioctl_restart - restart a partition
+ * @ret: return error code from the hypervisor
+ * @partition: the ID of the partition to restart, or -1 for the
+ *             calling partition
+ *
+ * Used by FSL_HV_IOCTL_PARTITION_RESTART
+ */
+struct fsl_hv_ioctl_restart {
+        __u32 ret;
+        __u32 partition;
+};
+
+/**
+ * struct fsl_hv_ioctl_status - get a partition's status
+ * @ret: return error code from the hypervisor
+ * @partition: the ID of the partition to query, or -1 for the
+ *             calling partition
+ * @status: The returned status of the partition
+ *
+ * Used by FSL_HV_IOCTL_PARTITION_GET_STATUS
+ *
+ * Values of 'status':
+ *    0 = Stopped
+ *    1 = Running
+ *    2 = Starting
+ *    3 = Stopping
+ */
+struct fsl_hv_ioctl_status {
+        __u32 ret;
+        __u32 partition;
+        __u32 status;
+};
+
+/**
+ * struct fsl_hv_ioctl_start - start a partition
+ * @ret: return error code from the hypervisor
+ * @partition: the ID of the partition to control
+ * @entry_point: The offset within the guest IMA to start execution
+ * @load: If non-zero, reload the partition's images before starting
+ *
+ * Used by FSL_HV_IOCTL_PARTITION_START
+ */
+struct fsl_hv_ioctl_start {
+        __u32 ret;
+        __u32 partition;
+        __u32 entry_point;
+        __u32 load;
+};
+
+/**
+ * struct fsl_hv_ioctl_stop - stop a partition
+ * @ret: return error code from the hypervisor
+ * @partition: the ID of the partition to stop, or -1 for the calling
+ *             partition
+ *
+ * Used by FSL_HV_IOCTL_PARTITION_STOP
+ */
+struct fsl_hv_ioctl_stop {
+        __u32 ret;
+        __u32 partition;
+};
+
+/**
+ * struct fsl_hv_ioctl_memcpy - copy memory between partitions
+ * @ret: return error code from the hypervisor
+ * @source: the partition ID of the source partition, or -1 for this
+ *          partition
+ * @target: the partition ID of the target partition, or -1 for this
+ *          partition
+ * @reserved: reserved, must be set to 0
+ * @local_addr: user-space virtual address of a buffer in the local
+ *              partition
+ * @remote_addr: guest physical address of a buffer in the
+ *           remote partition
+ * @count: the number of bytes to copy.  Both the local and remote
+ *         buffers must be at least 'count' bytes long
+ *
+ * Used by FSL_HV_IOCTL_MEMCPY
+ *
+ * The 'local' partition is the partition that calls this ioctl.  The
+ * 'remote' partition is a different partition.  The data is copied from
+ * the 'source' paritition' to the 'target' partition.
+ *
+ * The buffer in the remote partition must be guest physically
+ * contiguous.
+ *
+ * This ioctl does not support copying memory between two remote
+ * partitions or within the same partition, so either 'source' or
+ * 'target' (but not both) must be -1.  In other words, either
+ *
+ *      source == local and target == remote
+ * or
+ *      source == remote and target == local
+ */
+struct fsl_hv_ioctl_memcpy {
+        __u32 ret;
+        __u32 source;
+        __u32 target;
+        __u32 reserved; /* padding to ensure local_vaddr is aligned */
+        __u64 local_vaddr;
+        __u64 remote_paddr;
+        __u64 count;
+};
+
+/**
+ * struct fsl_hv_ioctl_doorbell - ring a doorbell
+ * @ret: return error code from the hypervisor
+ * @doorbell: the handle of the doorbell to ring doorbell
+ *
+ * Used by FSL_HV_IOCTL_DOORBELL
+ */
+struct fsl_hv_ioctl_doorbell {
+        __u32 ret;
+        __u32 doorbell;
+};
+
+/**
+ * struct fsl_hv_ioctl_prop - get/set a device tree property
+ * @ret: return error code from the hypervisor
+ * @handle: handle of partition whose tree to access
+ * @path: virtual address of path name of node to access
+ * @propname: virtual address of name of property to access
+ * @propval: virtual address of property data buffer
+ * @proplen: Size of property data buffer
+ * @reserved: reserved, must be set to 0
+ *
+ * Used by FSL_HV_IOCTL_DOORBELL
+ */
+struct fsl_hv_ioctl_prop {
+        __u32 ret;
+        __u32 handle;
+        __u64 path;
+        __u64 propname;
+        __u64 propval;
+        __u32 proplen;
+        __u32 reserved; /* padding to ensure structure is aligned */
+};
+
+/* The ioctl type, documented in ioctl-number.txt */
+#define FSL_HV_IOCTL_TYPE       0xAF
+
+/* Restart another partition */
+#define FSL_HV_IOCTL_PARTITION_RESTART \
+        _IOWR(FSL_HV_IOCTL_TYPE, 1, struct fsl_hv_ioctl_restart)
+
+/* Get a partition's status */
+#define FSL_HV_IOCTL_PARTITION_GET_STATUS \
+        _IOWR(FSL_HV_IOCTL_TYPE, 2, struct fsl_hv_ioctl_status)
+
+/* Boot another partition */
+#define FSL_HV_IOCTL_PARTITION_START \
+        _IOWR(FSL_HV_IOCTL_TYPE, 3, struct fsl_hv_ioctl_start)
+
+/* Stop this or another partition */
+#define FSL_HV_IOCTL_PARTITION_STOP \
+        _IOWR(FSL_HV_IOCTL_TYPE, 4, struct fsl_hv_ioctl_stop)
+
+/* Copy data from one partition to another */
+#define FSL_HV_IOCTL_MEMCPY \
+        _IOWR(FSL_HV_IOCTL_TYPE, 5, struct fsl_hv_ioctl_memcpy)
+
+/* Ring a doorbell */
+#define FSL_HV_IOCTL_DOORBELL \
+        _IOWR(FSL_HV_IOCTL_TYPE, 6, struct fsl_hv_ioctl_doorbell)
+
+/* Get a property from another guest's device tree */
+#define FSL_HV_IOCTL_GETPROP \
+        _IOWR(FSL_HV_IOCTL_TYPE, 7, struct fsl_hv_ioctl_prop)
+
+/* Set a property in another guest's device tree */
+#define FSL_HV_IOCTL_SETPROP \
+        _IOWR(FSL_HV_IOCTL_TYPE, 8, struct fsl_hv_ioctl_prop)
+
+#ifdef __KERNEL__
+
+/**
+ * fsl_hv_event_register() - register a callback for failover events
+ * @nb: pointer to caller-supplied notifier_block structure
+ *
+ * This function is called by device drivers to register their callback
+ * functions for fail-over events.
+ *
+ * The caller should allocate a notifier_block object and initialize the
+ * 'priority' and 'notifier_call' fields.
+ */
+int fsl_hv_failover_register(struct notifier_block *nb);
+
+/**
+ * fsl_hv_event_unregister() - unregister a callback for failover events
+ * @nb: the same 'nb' used in previous fsl_hv_failover_register call
+ */
+int fsl_hv_failover_unregister(struct notifier_block *nb);
+
+#endif
+
+#endif
diff --git a/include/linux/fsnotify_backend.h b/include/linux/fsnotify_backend.h
index 69ad89b5048..91d0e0a34ef 100644
--- a/include/linux/fsnotify_backend.h
+++ b/include/linux/fsnotify_backend.h
@@ -16,7 +16,7 @@
 #include <linux/spinlock.h>
 #include <linux/types.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 /*
  * IN_* from inotfy.h lines up EXACTLY with FS_*, this is so we can easily
diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h
index 9d88e1cb5db..f0c0e8a47ae 100644
--- a/include/linux/ftrace.h
+++ b/include/linux/ftrace.h
@@ -19,6 +19,8 @@
 
 #include <asm/ftrace.h>
 
+struct ftrace_hash;
+
 #ifdef CONFIG_FUNCTION_TRACER
 
 extern int ftrace_enabled;
@@ -29,8 +31,6 @@ ftrace_enable_sysctl(struct ctl_table *table, int write,
 
 typedef void (*ftrace_func_t)(unsigned long ip, unsigned long parent_ip);
 
-struct ftrace_hash;
-
 enum {
         FTRACE_OPS_FL_ENABLED           = 1 << 0,
         FTRACE_OPS_FL_GLOBAL            = 1 << 1,
@@ -123,7 +123,8 @@ stack_trace_sysctl(struct ctl_table *table, int write,
 struct ftrace_func_command {
         struct list_head        list;
         char                    *name;
-        int                     (*func)(char *func, char *cmd,
+        int                     (*func)(struct ftrace_hash *hash,
+                                        char *func, char *cmd,
                                         char *params, int enable);
 };
 
diff --git a/include/linux/ftrace_event.h b/include/linux/ftrace_event.h
index 59d3ef100eb..96efa6794ea 100644
--- a/include/linux/ftrace_event.h
+++ b/include/linux/ftrace_event.h
@@ -76,6 +76,7 @@ struct trace_iterator {
         struct trace_entry      *ent;
         unsigned long           lost_events;
         int                     leftover;
+        int                     ent_size;
         int                     cpu;
         u64                     ts;
 
@@ -129,6 +130,10 @@ void trace_current_buffer_unlock_commit(struct ring_buffer *buffer,
 void trace_nowake_buffer_unlock_commit(struct ring_buffer *buffer,
                                        struct ring_buffer_event *event,
                                         unsigned long flags, int pc);
+void trace_nowake_buffer_unlock_commit_regs(struct ring_buffer *buffer,
+                                            struct ring_buffer_event *event,
+                                            unsigned long flags, int pc,
+                                            struct pt_regs *regs);
 void trace_current_buffer_discard_commit(struct ring_buffer *buffer,
                                          struct ring_buffer_event *event);
 
diff --git a/include/linux/fuse.h b/include/linux/fuse.h
index d464de53db4..464cff52686 100644
--- a/include/linux/fuse.h
+++ b/include/linux/fuse.h
@@ -47,6 +47,9 @@
  *  - FUSE_IOCTL_UNRESTRICTED shall now return with array of 'struct
  *    fuse_ioctl_iovec' instead of ambiguous 'struct iovec'
  *  - add FUSE_IOCTL_32BIT flag
+ *
+ * 7.17
+ *  - add FUSE_FLOCK_LOCKS and FUSE_RELEASE_FLOCK_UNLOCK
  */
 
 #ifndef _LINUX_FUSE_H
@@ -78,7 +81,7 @@
 #define FUSE_KERNEL_VERSION 7
 
 /** Minor version number of this interface */
-#define FUSE_KERNEL_MINOR_VERSION 16
+#define FUSE_KERNEL_MINOR_VERSION 17
 
 /** The node ID of the root inode */
 #define FUSE_ROOT_ID 1
@@ -153,8 +156,10 @@ struct fuse_file_lock {
 /**
  * INIT request/reply flags
  *
+ * FUSE_POSIX_LOCKS: remote locking for POSIX file locks
  * FUSE_EXPORT_SUPPORT: filesystem handles lookups of "." and ".."
  * FUSE_DONT_MASK: don't apply umask to file mode on create operations
+ * FUSE_FLOCK_LOCKS: remote locking for BSD style file locks
  */
 #define FUSE_ASYNC_READ         (1 << 0)
 #define FUSE_POSIX_LOCKS        (1 << 1)
@@ -163,6 +168,7 @@ struct fuse_file_lock {
 #define FUSE_EXPORT_SUPPORT     (1 << 4)
 #define FUSE_BIG_WRITES         (1 << 5)
 #define FUSE_DONT_MASK          (1 << 6)
+#define FUSE_FLOCK_LOCKS        (1 << 10)
 
 /**
  * CUSE INIT request/reply flags
@@ -175,6 +181,7 @@ struct fuse_file_lock {
  * Release flags
  */
 #define FUSE_RELEASE_FLUSH      (1 << 0)
+#define FUSE_RELEASE_FLOCK_UNLOCK       (1 << 1)
 
 /**
  * Getattr flags
diff --git a/include/linux/genalloc.h b/include/linux/genalloc.h
index 5bbebda78b0..ae9daa29395 100644
--- a/include/linux/genalloc.h
+++ b/include/linux/genalloc.h
@@ -1,8 +1,26 @@
 /*
- * Basic general purpose allocator for managing special purpose memory
- * not managed by the regular kmalloc/kfree interface.
- * Uses for this includes on-device special memory, uncached memory
- * etc.
+ * Basic general purpose allocator for managing special purpose
+ * memory, for example, memory that is not managed by the regular
+ * kmalloc/kfree interface.  Uses for this includes on-device special
+ * memory, uncached memory etc.
+ *
+ * It is safe to use the allocator in NMI handlers and other special
+ * unblockable contexts that could otherwise deadlock on locks.  This
+ * is implemented by using atomic operations and retries on any
+ * conflicts.  The disadvantage is that there may be livelocks in
+ * extreme cases.  For better scalability, one allocator can be used
+ * for each CPU.
+ *
+ * The lockless operation only works if there is enough memory
+ * available.  If new memory is added to the pool a lock has to be
+ * still taken.  So any user relying on locklessness has to ensure
+ * that sufficient memory is preallocated.
+ *
+ * The basic atomic operation of this allocator is cmpxchg on long.
+ * On architectures that don't have NMI-safe cmpxchg implementation,
+ * the allocator can NOT be used in NMI handler.  So code uses the
+ * allocator in NMI handler should depend on
+ * CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG.
  *
  * This source code is licensed under the GNU General Public License,
  * Version 2.  See the file COPYING for more details.
@@ -15,7 +33,7 @@
  *  General purpose special memory pool descriptor.
  */
 struct gen_pool {
-        rwlock_t lock;
+        spinlock_t lock;
         struct list_head chunks;        /* list of chunks in this pool */
         int min_alloc_order;            /* minimum allocation order */
 };
@@ -24,8 +42,8 @@ struct gen_pool {
  *  General purpose special memory pool chunk descriptor.
  */
 struct gen_pool_chunk {
-        spinlock_t lock;
         struct list_head next_chunk;    /* next chunk in pool */
+        atomic_t avail;
         phys_addr_t phys_addr;          /* physical starting address of memory chunk */
         unsigned long start_addr;       /* starting address of memory chunk */
         unsigned long end_addr;         /* ending address of memory chunk */
@@ -54,6 +72,20 @@ static inline int gen_pool_add(struct gen_pool *pool, unsigned long addr,
         return gen_pool_add_virt(pool, addr, -1, size, nid);
 }
 extern void gen_pool_destroy(struct gen_pool *);
-extern unsigned long gen_pool_alloc(struct gen_pool *, size_t);
+extern unsigned long gen_pool_alloc_addr(struct gen_pool *,
+        size_t, unsigned long);
+/**
+ * gen_pool_alloc - allocate special memory from the pool
+ * @pool: pool to allocate from
+ * @size: number of bytes to allocate from the pool
+ */
+static inline unsigned long gen_pool_alloc(struct gen_pool *pool, size_t size)
+{
+        return gen_pool_alloc_addr(pool, size, 0);
+}
 extern void gen_pool_free(struct gen_pool *, unsigned long, size_t);
+extern void gen_pool_for_each_chunk(struct gen_pool *,
+        void (*)(struct gen_pool *, struct gen_pool_chunk *, void *), void *);
+extern size_t gen_pool_avail(struct gen_pool *);
+extern size_t gen_pool_size(struct gen_pool *);
 #endif /* __GENALLOC_H__ */
diff --git a/include/linux/generic_acl.h b/include/linux/generic_acl.h
index 0437e377b55..b6d657544ef 100644
--- a/include/linux/generic_acl.h
+++ b/include/linux/generic_acl.h
@@ -10,6 +10,5 @@ extern const struct xattr_handler generic_acl_default_handler;
 
 int generic_acl_init(struct inode *, struct inode *);
 int generic_acl_chmod(struct inode *);
-int generic_check_acl(struct inode *inode, int mask, unsigned int flags);
 
 #endif /* LINUX_GENERIC_ACL_H */
diff --git a/include/linux/genhd.h b/include/linux/genhd.h
index 300d7582006..02fa4697a0e 100644
--- a/include/linux/genhd.h
+++ b/include/linux/genhd.h
@@ -420,7 +420,7 @@ static inline int get_disk_ro(struct gendisk *disk)
 
 extern void disk_block_events(struct gendisk *disk);
 extern void disk_unblock_events(struct gendisk *disk);
-extern void disk_check_events(struct gendisk *disk);
+extern void disk_flush_events(struct gendisk *disk, unsigned int mask);
 extern unsigned int disk_clear_events(struct gendisk *disk, unsigned int mask);
 
 /* drivers/char/random.c */
diff --git a/include/linux/gfp.h b/include/linux/gfp.h
index cb4089254f0..3a76faf6a3e 100644
--- a/include/linux/gfp.h
+++ b/include/linux/gfp.h
@@ -92,7 +92,7 @@ struct vm_area_struct;
  */
 #define __GFP_NOTRACK_FALSE_POSITIVE (__GFP_NOTRACK)
 
-#define __GFP_BITS_SHIFT 23     /* Room for 23 __GFP_FOO bits */
+#define __GFP_BITS_SHIFT 24     /* Room for N __GFP_FOO bits */
 #define __GFP_BITS_MASK ((__force gfp_t)((1 << __GFP_BITS_SHIFT) - 1))
 
 /* This equals 0, but use constants in case they ever change */
diff --git a/include/linux/gpio.h b/include/linux/gpio.h
index 17b5a0d80e4..6e20df09927 100644
--- a/include/linux/gpio.h
+++ b/include/linux/gpio.h
@@ -14,6 +14,12 @@
 #define GPIOF_OUT_INIT_LOW      (GPIOF_DIR_OUT | GPIOF_INIT_LOW)
 #define GPIOF_OUT_INIT_HIGH     (GPIOF_DIR_OUT | GPIOF_INIT_HIGH)
 
+/* Gpio pin is open drain */
+#define GPIOF_OPEN_DRAIN        (1 << 2)
+
+/* Gpio pin is open source */
+#define GPIOF_OPEN_SOURCE       (1 << 3)
+
 #ifdef CONFIG_GENERIC_GPIO
 #include <asm/gpio.h>
 
diff --git a/include/linux/gpio_event.h b/include/linux/gpio_event.h
new file mode 100644
index 00000000000..2613fc5e4a9
--- /dev/null
+++ b/include/linux/gpio_event.h
@@ -0,0 +1,170 @@
+/* include/linux/gpio_event.h
+ *
+ * Copyright (C) 2007 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _LINUX_GPIO_EVENT_H
+#define _LINUX_GPIO_EVENT_H
+
+#include <linux/input.h>
+
+struct gpio_event_input_devs {
+        int count;
+        struct input_dev *dev[];
+};
+enum {
+        GPIO_EVENT_FUNC_UNINIT  = 0x0,
+        GPIO_EVENT_FUNC_INIT    = 0x1,
+        GPIO_EVENT_FUNC_SUSPEND = 0x2,
+        GPIO_EVENT_FUNC_RESUME  = 0x3,
+};
+struct gpio_event_info {
+        int (*func)(struct gpio_event_input_devs *input_devs,
+                    struct gpio_event_info *info,
+                    void **data, int func);
+        int (*event)(struct gpio_event_input_devs *input_devs,
+                     struct gpio_event_info *info,
+                     void **data, unsigned int dev, unsigned int type,
+                     unsigned int code, int value); /* out events */
+        bool no_suspend;
+};
+
+struct gpio_event_platform_data {
+        const char *name;
+        struct gpio_event_info **info;
+        size_t info_count;
+        int (*power)(const struct gpio_event_platform_data *pdata, bool on);
+        const char *names[]; /* If name is NULL, names contain a NULL */
+                             /* terminated list of input devices to create */
+};
+
+#define GPIO_EVENT_DEV_NAME "gpio-event"
+
+/* Key matrix */
+
+enum gpio_event_matrix_flags {
+        /* unset: drive active output low, set: drive active output high */
+        GPIOKPF_ACTIVE_HIGH              = 1U << 0,
+        GPIOKPF_DEBOUNCE                 = 1U << 1,
+        GPIOKPF_REMOVE_SOME_PHANTOM_KEYS = 1U << 2,
+        GPIOKPF_REMOVE_PHANTOM_KEYS      = GPIOKPF_REMOVE_SOME_PHANTOM_KEYS |
+                                           GPIOKPF_DEBOUNCE,
+        GPIOKPF_DRIVE_INACTIVE           = 1U << 3,
+        GPIOKPF_LEVEL_TRIGGERED_IRQ      = 1U << 4,
+        GPIOKPF_PRINT_UNMAPPED_KEYS      = 1U << 16,
+        GPIOKPF_PRINT_MAPPED_KEYS        = 1U << 17,
+        GPIOKPF_PRINT_PHANTOM_KEYS       = 1U << 18,
+};
+
+#define MATRIX_CODE_BITS (10)
+#define MATRIX_KEY_MASK ((1U << MATRIX_CODE_BITS) - 1)
+#define MATRIX_KEY(dev, code) \
+        (((dev) << MATRIX_CODE_BITS) | (code & MATRIX_KEY_MASK))
+
+extern int gpio_event_matrix_func(struct gpio_event_input_devs *input_devs,
+                        struct gpio_event_info *info, void **data, int func);
+struct gpio_event_matrix_info {
+        /* initialize to gpio_event_matrix_func */
+        struct gpio_event_info info;
+        /* size must be ninputs * noutputs */
+        const unsigned short *keymap;
+        unsigned int *input_gpios;
+        unsigned int *output_gpios;
+        unsigned int ninputs;
+        unsigned int noutputs;
+        /* time to wait before reading inputs after driving each output */
+        ktime_t settle_time;
+        /* time to wait before scanning the keypad a second time */
+        ktime_t debounce_delay;
+        ktime_t poll_time;
+        unsigned flags;
+};
+
+/* Directly connected inputs and outputs */
+
+enum gpio_event_direct_flags {
+        GPIOEDF_ACTIVE_HIGH         = 1U << 0,
+/*      GPIOEDF_USE_DOWN_IRQ        = 1U << 1, */
+/*      GPIOEDF_USE_IRQ             = (1U << 2) | GPIOIDF_USE_DOWN_IRQ, */
+        GPIOEDF_PRINT_KEYS          = 1U << 8,
+        GPIOEDF_PRINT_KEY_DEBOUNCE  = 1U << 9,
+        GPIOEDF_PRINT_KEY_UNSTABLE  = 1U << 10,
+};
+
+struct gpio_event_direct_entry {
+        uint32_t gpio:16;
+        uint32_t code:10;
+        uint32_t dev:6;
+};
+
+/* inputs */
+extern int gpio_event_input_func(struct gpio_event_input_devs *input_devs,
+                        struct gpio_event_info *info, void **data, int func);
+struct gpio_event_input_info {
+        /* initialize to gpio_event_input_func */
+        struct gpio_event_info info;
+        ktime_t debounce_time;
+        ktime_t poll_time;
+        uint16_t flags;
+        uint16_t type;
+        const struct gpio_event_direct_entry *keymap;
+        size_t keymap_size;
+};
+
+/* outputs */
+extern int gpio_event_output_func(struct gpio_event_input_devs *input_devs,
+                        struct gpio_event_info *info, void **data, int func);
+extern int gpio_event_output_event(struct gpio_event_input_devs *input_devs,
+                        struct gpio_event_info *info, void **data,
+                        unsigned int dev, unsigned int type,
+                        unsigned int code, int value);
+struct gpio_event_output_info {
+        /* initialize to gpio_event_output_func and gpio_event_output_event */
+        struct gpio_event_info info;
+        uint16_t flags;
+        uint16_t type;
+        const struct gpio_event_direct_entry *keymap;
+        size_t keymap_size;
+};
+
+
+/* axes */
+
+enum gpio_event_axis_flags {
+        GPIOEAF_PRINT_UNKNOWN_DIRECTION  = 1U << 16,
+        GPIOEAF_PRINT_RAW                = 1U << 17,
+        GPIOEAF_PRINT_EVENT              = 1U << 18,
+};
+
+extern int gpio_event_axis_func(struct gpio_event_input_devs *input_devs,
+                        struct gpio_event_info *info, void **data, int func);
+struct gpio_event_axis_info {
+        /* initialize to gpio_event_axis_func */
+        struct gpio_event_info info;
+        uint8_t  count; /* number of gpios for this axis */
+        uint8_t  dev; /* device index when using multiple input devices */
+        uint8_t  type; /* EV_REL or EV_ABS */
+        uint16_t code;
+        uint16_t decoded_size;
+        uint16_t (*map)(struct gpio_event_axis_info *info, uint16_t in);
+        uint32_t *gpio;
+        uint32_t flags;
+};
+#define gpio_axis_2bit_gray_map gpio_axis_4bit_gray_map
+#define gpio_axis_3bit_gray_map gpio_axis_4bit_gray_map
+uint16_t gpio_axis_4bit_gray_map(
+                        struct gpio_event_axis_info *info, uint16_t in);
+uint16_t gpio_axis_5bit_singletrack_map(
+                        struct gpio_event_axis_info *info, uint16_t in);
+
+#endif
diff --git a/include/linux/gpio_keys.h b/include/linux/gpio_keys.h
index b5ca4b2c08e..50f7ced738a 100644
--- a/include/linux/gpio_keys.h
+++ b/include/linux/gpio_keys.h
@@ -4,7 +4,7 @@
 struct gpio_keys_button {
         /* Configuration parameters */
         unsigned int code;      /* input event code (KEY_*, SW_*) */
-        int gpio;
+        int gpio;               /* -1 if this key does not support gpio */
         int active_low;
         const char *desc;
         unsigned int type;      /* input event type (EV_KEY, EV_SW, EV_ABS) */
@@ -12,6 +12,7 @@ struct gpio_keys_button {
         int debounce_interval;  /* debounce ticks interval in msecs */
         bool can_disable;
         int value;              /* axis value for EV_ABS */
+        unsigned int irq;       /* Irq number in case of interrupt keys */
 };
 
 struct gpio_keys_platform_data {
@@ -23,6 +24,7 @@ struct gpio_keys_platform_data {
         int (*enable)(struct device *dev);
         void (*disable)(struct device *dev);
         const char *name;               /* input device name */
+        int (*wakeup_key)(void);
 };
 
 #endif
diff --git a/include/linux/gpio_scrollwheel.h b/include/linux/gpio_scrollwheel.h
new file mode 100644
index 00000000000..33d17a0199e
--- /dev/null
+++ b/include/linux/gpio_scrollwheel.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2010, NVIDIA Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#ifndef _GPIO_SCROLLWHEEL_H
+#define _GPIO_SCROLLWHEEL_H
+
+#define GPIO_SCROLLWHEEL_PIN_ONOFF      0
+#define GPIO_SCROLLWHEEL_PIN_PRESS      1
+#define GPIO_SCROLLWHEEL_PIN_ROT1       2
+#define GPIO_SCROLLWHEEL_PIN_ROT2       3
+#define GPIO_SCROLLWHEEL_PIN_MAX        4
+
+struct gpio_scrollwheel_button {
+        /* Configuration parameters */
+        int pinaction;          /* GPIO_SCROLLWHEEL_PIN_* */
+        int gpio;
+        char *desc;
+        int active_low;
+        int debounce_interval;  /* debounce ticks interval in msecs */
+};
+
+struct gpio_scrollwheel_platform_data {
+        struct gpio_scrollwheel_button *buttons;
+        int nbuttons;
+        unsigned int rep:1;     /* enable input subsystem auto repeat */
+        int (*enable)(struct device *dev);
+        void (*disable)(struct device *dev);
+};
+
+#endif
+
diff --git a/include/linux/gsmmux.h b/include/linux/gsmmux.h
index 378de4195ca..c25e9477f7c 100644
--- a/include/linux/gsmmux.h
+++ b/include/linux/gsmmux.h
@@ -21,5 +21,16 @@ struct gsm_config
 #define GSMIOC_GETCONF          _IOR('G', 0, struct gsm_config)
 #define GSMIOC_SETCONF          _IOW('G', 1, struct gsm_config)
 
+struct gsm_netconfig {
+        unsigned int adaption;  /* Adaption to use in network mode */
+        unsigned short protocol;/* Protocol to use - only ETH_P_IP supported */
+        unsigned short unused2;
+        char if_name[IFNAMSIZ]; /* interface name format string */
+        __u8 unused[28];        /* For future use */
+};
+
+#define GSMIOC_ENABLE_NET      _IOW('G', 2, struct gsm_netconfig)
+#define GSMIOC_DISABLE_NET     _IO('G', 3)
+
 
 #endif
diff --git a/include/linux/hardirq.h b/include/linux/hardirq.h
index e6dd5a456ba..ef18786a7b4 100644
--- a/include/linux/hardirq.h
+++ b/include/linux/hardirq.h
@@ -95,7 +95,7 @@
  */
 #define in_nmi()        (preempt_count() & NMI_MASK)
 
-#if defined(CONFIG_PREEMPT)
+#if defined(CONFIG_PREEMPT_COUNT)
 # define PREEMPT_CHECK_OFFSET 1
 #else
 # define PREEMPT_CHECK_OFFSET 0
@@ -117,7 +117,7 @@
 #define in_atomic_preempt_off() \
                 ((preempt_count() & ~PREEMPT_ACTIVE) != PREEMPT_CHECK_OFFSET)
 
-#ifdef CONFIG_PREEMPT
+#ifdef CONFIG_PREEMPT_COUNT
 # define preemptible()  (preempt_count() == 0 && !irqs_disabled())
 # define IRQ_EXIT_OFFSET (HARDIRQ_OFFSET-1)
 #else
diff --git a/include/linux/hash.h b/include/linux/hash.h
index 06d25c189cc..b80506bdd73 100644
--- a/include/linux/hash.h
+++ b/include/linux/hash.h
@@ -63,7 +63,7 @@ static inline u32 hash_32(u32 val, unsigned int bits)
         return hash >> (32 - bits);
 }
 
-static inline unsigned long hash_ptr(void *ptr, unsigned int bits)
+static inline unsigned long hash_ptr(const void *ptr, unsigned int bits)
 {
         return hash_long((unsigned long)ptr, bits);
 }
diff --git a/include/linux/hid.h b/include/linux/hid.h
index 42f7e2fb501..ab64d4768f6 100644
--- a/include/linux/hid.h
+++ b/include/linux/hid.h
@@ -453,7 +453,8 @@ struct hid_input {
 
 enum hid_type {
         HID_TYPE_OTHER = 0,
-        HID_TYPE_USBMOUSE
+        HID_TYPE_USBMOUSE,
+        HID_TYPE_USBNONE
 };
 
 struct hid_driver;
@@ -597,6 +598,8 @@ struct hid_usage_id {
  * @input_mapping: invoked on input registering before mapping an usage
  * @input_mapped: invoked on input registering after mapping an usage
  * @feature_mapping: invoked on feature registering
+ * @input_register: called just before input device is registered after reports
+ *                  are parsed.
  * @suspend: invoked on suspend (NULL means nop)
  * @resume: invoked on resume if device was not reset (NULL means nop)
  * @reset_resume: invoked on resume if device was reset (NULL means nop)
@@ -643,6 +646,8 @@ struct hid_driver {
         void (*feature_mapping)(struct hid_device *hdev,
                         struct hid_field *field,
                         struct hid_usage *usage);
+        int (*input_register)(struct hid_device *hdev, struct hid_input
+                        *hidinput);
 #ifdef CONFIG_PM
         int (*suspend)(struct hid_device *hdev, pm_message_t message);
         int (*resume)(struct hid_device *hdev);
diff --git a/include/linux/hugetlb.h b/include/linux/hugetlb.h
index 59225ef27d1..19644e0016b 100644
--- a/include/linux/hugetlb.h
+++ b/include/linux/hugetlb.h
@@ -231,6 +231,9 @@ struct hstate {
 struct huge_bootmem_page {
         struct list_head list;
         struct hstate *hstate;
+#ifdef CONFIG_HIGHMEM
+        phys_addr_t phys;
+#endif
 };
 
 struct page *alloc_huge_page_node(struct hstate *h, int nid);
diff --git a/include/linux/hw_breakpoint.h b/include/linux/hw_breakpoint.h
index d1e55fed2c7..6ae9c631a1b 100644
--- a/include/linux/hw_breakpoint.h
+++ b/include/linux/hw_breakpoint.h
@@ -73,6 +73,7 @@ static inline unsigned long hw_breakpoint_len(struct perf_event *bp)
 extern struct perf_event *
 register_user_hw_breakpoint(struct perf_event_attr *attr,
                             perf_overflow_handler_t triggered,
+                            void *context,
                             struct task_struct *tsk);
 
 /* FIXME: only change from the attr, and don't unregister */
@@ -85,11 +86,13 @@ modify_user_hw_breakpoint(struct perf_event *bp, struct perf_event_attr *attr);
 extern struct perf_event *
 register_wide_hw_breakpoint_cpu(struct perf_event_attr *attr,
                                 perf_overflow_handler_t triggered,
+                                void *context,
                                 int cpu);
 
 extern struct perf_event * __percpu *
 register_wide_hw_breakpoint(struct perf_event_attr *attr,
-                            perf_overflow_handler_t triggered);
+                            perf_overflow_handler_t triggered,
+                            void *context);
 
 extern int register_perf_hw_breakpoint(struct perf_event *bp);
 extern int __register_perf_hw_breakpoint(struct perf_event *bp);
@@ -115,6 +118,7 @@ static inline int __init init_hw_breakpoint(void) { return 0; }
 static inline struct perf_event *
 register_user_hw_breakpoint(struct perf_event_attr *attr,
                             perf_overflow_handler_t triggered,
+                            void *context,
                             struct task_struct *tsk)    { return NULL; }
 static inline int
 modify_user_hw_breakpoint(struct perf_event *bp,
@@ -122,10 +126,12 @@ modify_user_hw_breakpoint(struct perf_event *bp,
 static inline struct perf_event *
 register_wide_hw_breakpoint_cpu(struct perf_event_attr *attr,
                                 perf_overflow_handler_t  triggered,
+                                void *context,
                                 int cpu)                { return NULL; }
 static inline struct perf_event * __percpu *
 register_wide_hw_breakpoint(struct perf_event_attr *attr,
-                            perf_overflow_handler_t triggered)  { return NULL; }
+                            perf_overflow_handler_t triggered,
+                            void *context)              { return NULL; }
 static inline int
 register_perf_hw_breakpoint(struct perf_event *bp)      { return -ENOSYS; }
 static inline int
diff --git a/include/linux/hw_random.h b/include/linux/hw_random.h
index 9bede7633f7..b4b0eef5fdd 100644
--- a/include/linux/hw_random.h
+++ b/include/linux/hw_random.h
@@ -25,7 +25,7 @@
  *                      there is always data available.  *OBSOLETE*
  * @data_read:          Read data from the RNG device.
  *                      Returns the number of lower random bytes in "data".
- *                      Must not be NULL.    *OSOLETE*
+ *                      Must not be NULL.    *OBSOLETE*
  * @read:               New API. drivers can fill up to max bytes of data
  *                      into the buffer. The buffer is aligned for any type.
  * @priv:               Private data, for use by the RNG driver.
diff --git a/include/linux/i2c-omap.h b/include/linux/i2c-omap.h
index 7472449cbb7..0aa0cbd676f 100644
--- a/include/linux/i2c-omap.h
+++ b/include/linux/i2c-omap.h
@@ -3,6 +3,33 @@
 
 #include <linux/platform_device.h>
 
+/*
+ * Version 2 of the I2C peripheral unit has a different register
+ * layout and extra registers.  The ID register in the V2 peripheral
+ * unit on the OMAP4430 reports the same ID as the V1 peripheral
+ * unit on the OMAP3530, so we must inform the driver which IP
+ * version we know it is running on from platform / cpu-specific
+ * code using these constants in the hwmod class definition.
+ */
+
+#define OMAP_I2C_IP_VERSION_1 1
+#define OMAP_I2C_IP_VERSION_2 2
+
+/* struct omap_i2c_bus_platform_data .flags meanings */
+
+#define OMAP_I2C_FLAG_NO_FIFO                   BIT(0)
+#define OMAP_I2C_FLAG_SIMPLE_CLOCK              BIT(1)
+#define OMAP_I2C_FLAG_16BIT_DATA_REG            BIT(2)
+#define OMAP_I2C_FLAG_RESET_REGS_POSTIDLE       BIT(3)
+#define OMAP_I2C_FLAG_APPLY_ERRATA_I207 BIT(4)
+#define OMAP_I2C_FLAG_ALWAYS_ARMXOR_CLK BIT(5)
+#define OMAP_I2C_FLAG_FORCE_19200_INT_CLK       BIT(6)
+/* how the CPU address bus must be translated for I2C unit access */
+#define OMAP_I2C_FLAG_BUS_SHIFT_NONE 0
+#define OMAP_I2C_FLAG_BUS_SHIFT_1               BIT(7)
+#define OMAP_I2C_FLAG_BUS_SHIFT_2               BIT(8)
+#define OMAP_I2C_FLAG_BUS_SHIFT__SHIFT 7
+
 struct omap_i2c_bus_platform_data {
         u32             clkrate;
         void            (*set_mpu_wkup_lat)(struct device *dev, long set);
diff --git a/include/linux/i2c-slave.h b/include/linux/i2c-slave.h
new file mode 100644
index 00000000000..34df64f73f6
--- /dev/null
+++ b/include/linux/i2c-slave.h
@@ -0,0 +1,259 @@
+/*
+ * i2c-slave.h - definitions for the i2c-slave-bus interface
+ *
+ * Copyright (c) 2009-2011, NVIDIA Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+/* ------------------------------------------------------------------------- */
+
+#ifndef _LINUX_I2C_SLAVE_H
+#define _LINUX_I2C_SLAVE_H
+
+#include <linux/types.h>
+#ifdef __KERNEL__
+/* --- General options ------------------------------------------------ */
+
+struct i2c_client;
+struct i2c_slave_algorithm;
+struct i2c_slave_adapter;
+#if defined(CONFIG_I2C_SLAVE) && defined(CONFIG_I2C)
+
+/**
+ * i2c_slave_send - Sends data to master. When master issues a read cycle, the
+ * data is sent by the slave.
+ * This function copies the client data into the slave tx buffer and return to
+ * client. This is not a blocking call. Data will be sent to master later once
+ * slave got the master-ready cycle transfer.
+ * if there is no sufficient space to write the client buffer, it will return
+ * error. it will not write partial data.
+ * @client: Handle to i2c-slave client.
+ * @buf: Data that will be written to the master
+ * @count: How many bytes to write.
+ *
+ * Returns negative errno, or else the number of bytes written.
+ */
+extern int i2c_slave_send(struct i2c_client *client, const char *buf,
+                        int count);
+
+/**
+ * i2c_slave_get_tx_status - Get amount of data available in tx buffer. If there
+ * is still data in tx buffer then wait for given time to transfer complete
+ * for a give timeout.
+ * @client: Handle to i2c-slave client.
+ * @timeout_ms: Time to wait for transfer to complete.
+ *
+ * Returns negative errno, or else the number of bytes remaining in tx buffer.
+ */
+extern int i2c_slave_get_tx_status(struct i2c_client *client, int timeout_ms);
+
+/**
+ * i2c_slave_recv - Receive data from master. The data received from master is
+ * stored on slave rx buffer. When this api will be called, the data will be
+ * copied from the slave rx buffer to client buffer. If requested amount (count)
+ * of data is not available then it will wait for either min_count to be receive
+ * or timeout whatever first.
+ *
+ * if timeout_ms = 0, then wait for min_count data to be read.
+ * if timoue_ms non zero then wait for the data till timeout happen.
+ * @client: Handle to i2c-slave client.
+ * @buf: Data that will be read from the master
+ * @count: How many bytes to read.
+ * @min_count: Block till read min_count of data.
+ * @timeout_ms: Time to wait for read to be complete.
+ *
+ * Returns negative errno, or else the number of bytes read.
+ */
+extern int i2c_slave_recv(struct i2c_client *client, char *buf, int count,
+                        int min_count, int timeout_ms);
+
+/**
+ * i2c_slave_start - Start the i2c slave to receive/transmit data.
+ * After this i2c controller starts responding master.
+ * The dummy-char will send to master if there is no data to send on slave tx
+ * buffer.
+ * @client: Handle to i2c-slave client.
+ * @dummy_char: Data which will be send to master if there is no data to be send
+ * in slave tx buffer.
+ *
+ * Returns negative errno, or else 0 for success.
+ */
+extern int i2c_slave_start(struct i2c_client *client, unsigned char dummy_char);
+
+/**
+ * i2c_slave_stop - Stop slave to receive/transmit data.
+ * After this i2c controller stops responding master.
+ * @client: Handle to i2c-slave client.
+ * @is_buffer_clear: Reset the tx and rx slave buffer or not.
+ */
+extern void i2c_slave_stop(struct i2c_client *client, int is_buffer_clear);
+
+/**
+ * i2c_slave_flush_buffer - Flush the receive and transmit buffer.
+ * @client: Handle to i2c-slave client.
+ * @is_flush_tx_buffer: Reset the tx slave buffer or not.
+ * @is_flush_rx_buffer: Reset the rx slave buffer or not.
+ *
+ * Returns negative errno, or else 0 for success.
+ */
+extern int i2c_slave_flush_buffer(struct i2c_client *client,
+                        int is_flush_tx_buffer, int is_flush_rx_buffer);
+
+/**
+ * i2c_slave_get_nack_cycle - Get the number of master read cycle on which
+ * dummy char sent. This is the way to find that how much cycle slave sent the
+ * NACK packet.
+ *
+ * @client: Handle to i2c-slave client.
+ * @is_cout_reset: Reset the nack count or not.
+ *
+ * Returns negative errno, or else 0 for success.
+ */
+extern int i2c_slave_get_nack_cycle(struct i2c_client *client,
+                        int is_cout_reset);
+
+
+/**
+ * i2c_add_slave_adapter - Add slave adapter.
+ *
+ * @slv_adap: Slave adapter.
+ * @force_nr: Adapter number.
+ *
+ * Returns negative errno, or else 0 for success.
+ */
+extern int i2c_add_slave_adapter(struct i2c_slave_adapter *slv_adap,
+                bool force_nr);
+
+/**
+ * i2c_del_slave_adapter - Delete slave adapter.
+ *
+ * @slv_adap: Slave adapter.
+ *
+ * Returns negative errno, or else 0 for success.
+ */
+extern int i2c_del_slave_adapter(struct i2c_slave_adapter *slv_adap);
+
+#endif /* I2C_SLAVE */
+
+/*
+ * i2c_slave_adapter is the structure used to identify a physical i2c bus along
+ * with the access algorithms necessary to access it.
+ */
+struct i2c_slave_adapter {
+        struct module *owner;
+        unsigned int id;
+        unsigned int class;               /* classes to allow probing for */
+        /* the algorithm to access the i2c-slave bus */
+        const struct i2c_slave_algorithm *slv_algo;
+        void *algo_data;
+        void *parent_data;
+
+        /* data fields that are valid for all devices   */
+        u8 level;                       /* nesting level for lockdep */
+        struct mutex bus_lock;
+
+        int timeout;                    /* in jiffies */
+        int retries;
+        struct device *dev;             /* the adapter device */
+        struct device *parent_dev;      /* the adapter device */
+
+        int nr;
+        char name[48];
+        struct completion dev_released;
+};
+
+static inline void *i2c_get_slave_adapdata(const struct i2c_slave_adapter *dev)
+{
+        return dev_get_drvdata(dev->dev);
+}
+
+static inline void i2c_set_slave_adapdata(struct i2c_slave_adapter *dev,
+                void *data)
+{
+        dev_set_drvdata(dev->dev, data);
+}
+
+/*
+ * The following struct are for those who like to implement new i2c slave
+ * bus drivers:
+ * i2c_slave_algorithm is the interface to a class of hardware solutions which
+ * can be addressed using the same bus algorithms.
+ */
+struct i2c_slave_algorithm {
+        /* Start the slave to receive/transmit data.
+         * The dummy-char will send to master if there is no data to send on
+         * slave tx buffer.
+         */
+        int (*slave_start)(struct i2c_slave_adapter *slv_adap, int addr,
+                int is_ten_bit_addr, unsigned char dummy_char);
+
+        /* Stop slave to receive/transmit data.
+         * Required information to reset the slave rx and tx buffer to reset
+         * or not.
+         */
+        void (*slave_stop)(struct i2c_slave_adapter *slv_adap,
+                        int is_buffer_clear);
+
+        /*
+         * Send data to master. The data will be copied on the slave tx buffer
+         * and will send to master once master initiates the master-read cycle.
+         * Function will return immediately once the buffer copied into slave
+         * tx buffer.
+         * Client will not wait till data is sent to master.
+         * This function will not copy data partially. If sufficient space is
+         * not available, it will return error.
+         */
+        int (*slave_send)(struct i2c_slave_adapter *slv_adap, const char *buf,
+                        int count);
+
+        /*
+         * Get amount of data available in tx buffer. If there is still data in
+         * tx buffer wait for given time to get slave tx buffer emptied.
+         * returns number of data available in slave tx buffer.
+         */
+        int (*slave_get_tx_status)(struct i2c_slave_adapter *slv_adap,
+                        int timeout_ms);
+
+        /*
+         * Receive data to master. The data received from master is stored on
+         * slave rx buffer. When this api will be called, the data will be
+         * coped from the slave rx buffer to client buffer. If requested (count)
+         * data is not available then it will wait for either min_count to be
+         * receive or timeout whatever first.
+         *
+         * if timeout_ms = 0, then wait for min_count data to be read.
+         * if timoue_ms non zero then wait for the data till timeout happen.
+         * returns number of bytes read as positive integer otherwise error.
+         */
+        int (*slave_recv)(struct i2c_slave_adapter *slv_adap, char *buf,
+                        int count, int min_count, int timeout_ms);
+
+        /* Flush the receive and transmit buffer.
+         */
+        int (*slave_flush_buffer)(struct i2c_slave_adapter *slv_adap,
+                        int is_flush_tx_buffer, int is_flush_rx_buffer);
+
+        /* Get the number of dummy char cycle.
+         * Get the number of master read cycle on which dummy character has
+         * been sent.
+         * This can be treat as NACK cycle from slave side.
+         * Pass option whether count need to be reset or not.
+         */
+        int (*slave_get_nack_cycle)(struct i2c_slave_adapter *slv_adap,
+                        int is_cout_reset);
+};
+#endif /* __KERNEL__ */
+#endif /* _LINUX_I2C_SLAVE_H */
diff --git a/include/linux/i2c-tegra.h b/include/linux/i2c-tegra.h
index 9c85da49857..2b200c49acf 100644
--- a/include/linux/i2c-tegra.h
+++ b/include/linux/i2c-tegra.h
@@ -4,6 +4,8 @@
  * Copyright (C) 2010 Google, Inc.
  * Author: Colin Cross <ccross@android.com>
  *
+ * Copyright (C) 2010-2011 NVIDIA Corporation
+ *
  * This software is licensed under the terms of the GNU General Public
  * License version 2, as published by the Free Software Foundation, and
  * may be copied, distributed, and modified under those terms.
@@ -18,8 +20,35 @@
 #ifndef _LINUX_I2C_TEGRA_H
 #define _LINUX_I2C_TEGRA_H
 
+#include <mach/pinmux.h>
+
+#define TEGRA_I2C_MAX_BUS 3
+
 struct tegra_i2c_platform_data {
+        int adapter_nr;
+        int bus_count;
+        const struct tegra_pingroup_config *bus_mux[TEGRA_I2C_MAX_BUS];
+        int bus_mux_len[TEGRA_I2C_MAX_BUS];
+        unsigned long bus_clk_rate[TEGRA_I2C_MAX_BUS];
+        bool is_dvc;
+        bool is_clkon_always;
+        int retries;
+        int timeout;    /* in jiffies */
+        u16 slave_addr;
+        int scl_gpio[TEGRA_I2C_MAX_BUS];
+        int sda_gpio[TEGRA_I2C_MAX_BUS];
+        int (*arb_recovery)(int scl_gpio, int sda_gpio);
+        bool is_high_speed_enable;
+        u16 hs_master_code;
+};
+
+struct tegra_i2c_slave_platform_data {
+        int adapter_nr;
+        const struct tegra_pingroup_config *pinmux;
+        int bus_mux_len;
         unsigned long bus_clk_rate;
+        int max_rx_buffer_size;
+        int max_tx_buffer_size;
 };
 
 #endif /* _LINUX_I2C_TEGRA_H */
diff --git a/include/linux/i2c.h b/include/linux/i2c.h
index a6c652ef516..0bd9ea2b62e 100644
--- a/include/linux/i2c.h
+++ b/include/linux/i2c.h
@@ -540,6 +540,7 @@ struct i2c_msg {
 #define I2C_FUNC_SMBUS_WRITE_BLOCK_DATA 0x02000000
 #define I2C_FUNC_SMBUS_READ_I2C_BLOCK   0x04000000 /* I2C-like block xfer  */
 #define I2C_FUNC_SMBUS_WRITE_I2C_BLOCK  0x08000000 /* w/ 1-byte reg. addr. */
+#define I2C_FUNC_I2C_SLAVE_SUPPORT      0x10000000 /* i2c slave support */
 
 #define I2C_FUNC_SMBUS_BYTE             (I2C_FUNC_SMBUS_READ_BYTE | \
                                          I2C_FUNC_SMBUS_WRITE_BYTE)
diff --git a/include/linux/i2c/atmel_mxt_ts.h b/include/linux/i2c/atmel_mxt_ts.h
index f027f7a6351..29550c11f6d 100644
--- a/include/linux/i2c/atmel_mxt_ts.h
+++ b/include/linux/i2c/atmel_mxt_ts.h
@@ -2,6 +2,8 @@
  * Atmel maXTouch Touchscreen driver
  *
  * Copyright (C) 2010 Samsung Electronics Co.Ltd
+ * Copyright (C) 2011 Atmel Corporation
+ * Copyright (C) 2011 NVIDIA Corporation
  * Author: Joonyoung Shim <jy0922.shim@samsung.com>
  *
  * This program is free software; you can redistribute  it and/or modify it
@@ -15,6 +17,16 @@
 
 #include <linux/types.h>
 
+/*
+ * Atmel I2C addresses
+ */
+#define MXT224_I2C_ADDR1        0x4A
+#define MXT224_I2C_ADDR2        0x4B
+#define MXT1386_I2C_ADDR1       0x4C
+#define MXT1386_I2C_ADDR2       0x4D
+#define MXT1386_I2C_ADDR3       0x5A
+#define MXT1386_I2C_ADDR4       0x5B
+
 /* Orient */
 #define MXT_NORMAL              0x0
 #define MXT_DIAGONAL            0x1
@@ -39,6 +51,10 @@ struct mxt_platform_data {
         unsigned int voltage;
         unsigned char orient;
         unsigned long irqflags;
+        u8(*read_chg) (void);
+        unsigned long config_crc;
+        unsigned int actv_cycle_time;
+        unsigned int idle_cycle_time;
 };
 
 #endif /* __LINUX_ATMEL_MXT_TS_H */
diff --git a/include/linux/i2c/panjit_ts.h b/include/linux/i2c/panjit_ts.h
new file mode 100644
index 00000000000..1dd51e1ecae
--- /dev/null
+++ b/include/linux/i2c/panjit_ts.h
@@ -0,0 +1,30 @@
+/*
+ * include/linux/i2c/panjit_ts.h
+ *
+ * Copyright (c) 2010, NVIDIA Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#ifndef _LINUX_I2C_PANJIT_TS_H
+#define _LINUX_I2C_PANJIT_TS_H
+
+struct device;
+
+struct panjit_i2c_ts_platform_data {
+        int gpio_reset;
+};
+
+#endif
diff --git a/include/linux/i2c/twl.h b/include/linux/i2c/twl.h
index ba4f88624fc..bb92f0b1328 100644
--- a/include/linux/i2c/twl.h
+++ b/include/linux/i2c/twl.h
@@ -82,6 +82,10 @@
 #define TWL_MODULE_RTC          TWL4030_MODULE_RTC
 #define TWL_MODULE_PWM          TWL4030_MODULE_PWM0
 
+#define TWL6030_MODULE_CHARGER  TWL4030_MODULE_MAIN_CHARGE
+#define TWL6025_MODULE_CHARGER  0x18
+
+#define TWL6030_MODULE_GASGAUGE 0x0B
 #define TWL6030_MODULE_ID0      0x0D
 #define TWL6030_MODULE_ID1      0x0E
 #define TWL6030_MODULE_ID2      0x0F
@@ -108,6 +112,7 @@
 #define GASGAUGE_INTR_OFFSET    17
 #define USBOTG_INTR_OFFSET      4
 #define CHARGER_INTR_OFFSET     2
+#define GPADCSW_INTR_OFFSET     1
 #define RSV_INTR_OFFSET         0
 
 /* INT register offsets */
@@ -172,6 +177,14 @@ TWL_CLASS_IS(4030, TWL4030_CLASS_ID)
 TWL_CLASS_IS(6030, TWL6030_CLASS_ID)
 
 #define TWL6025_SUBCLASS        BIT(4)  /* TWL6025 has changed registers */
+#define MPU80031_SUBCLASS       BIT(5)  /* MPU80031 has changed registers */
+
+/* So we can recover the features in other parts of twl stack */
+unsigned int twl_features(void);
+
+/* so we can get at the EPROM SMPS OFFSET/MULT stuff */
+u8 twl_get_smps_offset(void);
+u8 twl_get_smps_mult(void);
 
 /*
  * Read and write single 8-bit registers
@@ -179,6 +192,8 @@ TWL_CLASS_IS(6030, TWL6030_CLASS_ID)
 int twl_i2c_write_u8(u8 mod_no, u8 val, u8 reg);
 int twl_i2c_read_u8(u8 mod_no, u8 *val, u8 reg);
 
+void twl_reg_dump(int module, int start, int end);
+
 /*
  * Read and write several 8-bit registers at once.
  *
@@ -215,6 +230,10 @@ static inline int twl6030_mmc_card_detect(struct device *dev, int slot)
         return -EIO;
 }
 #endif
+
+int twl6030_set_usb_charge_enable(int enable);
+int twl6030_set_usb_in_current(int currentmA);
+
 /*----------------------------------------------------------------------*/
 
 /*
@@ -552,11 +571,27 @@ static inline int twl6030_mmc_card_detect(struct device *dev, int slot)
 
 struct twl4030_clock_init_data {
         bool ck32k_lowpwr_enable;
+        bool clk32_active_state_on;
 };
 
 struct twl4030_bci_platform_data {
         int *battery_tmp_tbl;
-        unsigned int tblsize;
+        unsigned int battery_tmp_tblsize;
+        int *battery_volt_tbl;
+        unsigned int battery_volt_tblsize;
+        unsigned int monitoring_interval;
+
+        unsigned int max_charger_currentmA;
+        unsigned int max_charger_voltagemV;
+        unsigned int termination_currentmA;
+
+        unsigned int max_bat_voltagemV;
+        unsigned int low_bat_voltagemV;
+
+        /* twl6025 */
+        unsigned int use_hw_charger;
+        unsigned int use_eeprom_config;
+        unsigned int power_path;
 };
 
 /* TWL4030_GPIO_MAX (18) GPIOs, with interrupts */
@@ -621,6 +656,7 @@ struct twl4030_usb_data {
         int             (*phy_set_clock)(struct device *dev, int on);
         /* suspend/resume of phy */
         int             (*phy_suspend)(struct device *dev, int suspend);
+        int             (*board_control_power)(struct device *dev, int on);
 };
 
 struct twl4030_ins {
@@ -657,32 +693,49 @@ struct twl4030_power_data {
 extern void twl4030_power_init(struct twl4030_power_data *triton2_scripts);
 extern int twl4030_remove_script(u8 flags);
 
-struct twl4030_codec_audio_data {
+struct twl4030_codec_data {
         unsigned int digimic_delay; /* in ms */
         unsigned int ramp_delay_value;
         unsigned int offset_cncl_path;
         unsigned int check_defaults:1;
         unsigned int reset_registers:1;
         unsigned int hs_extmute:1;
+        u16 hs_left_step;
+        u16 hs_right_step;
+        u16 hf_left_step;
+        u16 hf_right_step;
         void (*set_hs_extmute)(int mute);
 };
 
-struct twl4030_codec_vibra_data {
+struct twl4030_vibra_data {
         unsigned int    coexist;
+
+        /* twl6040 */
+        unsigned int vibldrv_res;       /* left driver resistance */
+        unsigned int vibrdrv_res;       /* right driver resistance */
+        unsigned int viblmotor_res;     /* left motor resistance */
+        unsigned int vibrmotor_res;     /* right motor resistance */
+        int vddvibl_uV;                 /* VDDVIBL volt, set 0 for fixed reg */
+        int vddvibr_uV;                 /* VDDVIBR volt, set 0 for fixed reg */
 };
 
-struct twl4030_codec_data {
+struct twl4030_audio_data {
         unsigned int    audio_mclk;
-        struct twl4030_codec_audio_data         *audio;
-        struct twl4030_codec_vibra_data         *vibra;
+        struct twl4030_codec_data *codec;
+        struct twl4030_vibra_data *vibra;
 
         /* twl6040 */
         int audpwron_gpio;      /* audio power-on gpio */
         int naudint_irq;        /* audio interrupt */
+        unsigned int irq_base;
 };
 
 struct twl4030_platform_data {
         unsigned                                irq_base, irq_end;
+
+        /* Callback for boar regulator initialisation */
+        int (*init)(void);
+
         struct twl4030_clock_init_data          *clock;
         struct twl4030_bci_platform_data        *bci;
         struct twl4030_gpio_platform_data       *gpio;
@@ -690,7 +743,7 @@ struct twl4030_platform_data {
         struct twl4030_keypad_data              *keypad;
         struct twl4030_usb_data                 *usb;
         struct twl4030_power_data               *power;
-        struct twl4030_codec_data               *codec;
+        struct twl4030_audio_data               *audio;
 
         /* Common LDO regulators for TWL4030/TWL6030 */
         struct regulator_init_data              *vdac;
@@ -809,6 +862,22 @@ static inline int twl4030charger_usb_en(int enable) { return 0; }
 #define TWL6030_REG_VDAC        45
 #define TWL6030_REG_VUSB        46
 
+/* These are renamed in 6025 but same registers */
+#define TWL6025_REG_LDO2        48
+#define TWL6025_REG_LDO4        49
+#define TWL6025_REG_LDO3        50
+#define TWL6025_REG_LDO5        51
+#define TWL6025_REG_LDO1        52
+#define TWL6025_REG_LDO7        53
+#define TWL6025_REG_LDO6        54
+#define TWL6025_REG_LDOLN       55
+#define TWL6025_REG_LDOUSB      56
+
+/* 6025 DCDC supplies */
+#define TWL6025_REG_SMPS3       57
+#define TWL6025_REG_SMPS4       58
+#define TWL6025_REG_VIO         59
+
 /* INTERNAL LDOs */
 #define TWL6030_REG_VRTC        47
 #define TWL6030_REG_CLK32KG     48
diff --git a/include/linux/i2c/twl4030-madc.h b/include/linux/i2c/twl4030-madc.h
index 6427d298fbf..530e11ba073 100644
--- a/include/linux/i2c/twl4030-madc.h
+++ b/include/linux/i2c/twl4030-madc.h
@@ -129,6 +129,10 @@ enum sample_type {
 #define REG_BCICTL2             0x024
 #define TWL4030_BCI_ITHSENS     0x007
 
+/* Register and bits for GPBR1 register */
+#define TWL4030_REG_GPBR1               0x0c
+#define TWL4030_GPBR1_MADC_HFCLK_EN     (1 << 7)
+
 struct twl4030_madc_user_parms {
         int channel;
         int average;
diff --git a/include/linux/i8253.h b/include/linux/i8253.h
new file mode 100644
index 00000000000..e6bb36a9751
--- /dev/null
+++ b/include/linux/i8253.h
@@ -0,0 +1,29 @@
+/*
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ *  Machine specific IO port address definition for generic.
+ *  Written by Osamu Tomita <tomita@cinet.co.jp>
+ */
+#ifndef __LINUX_I8253_H
+#define __LINUX_I8253_H
+
+#include <linux/param.h>
+#include <linux/spinlock.h>
+#include <linux/timex.h>
+
+/* i8253A PIT registers */
+#define PIT_MODE        0x43
+#define PIT_CH0         0x40
+#define PIT_CH2         0x42
+
+#define PIT_LATCH       ((PIT_TICK_RATE + HZ/2) / HZ)
+
+extern raw_spinlock_t i8253_lock;
+extern struct clock_event_device i8253_clockevent;
+extern void clockevent_i8253_init(bool oneshot);
+
+extern void setup_pit_timer(void);
+
+#endif /* __LINUX_I8253_H */
diff --git a/include/linux/idr.h b/include/linux/idr.h
index 13a801f3d02..255491cf522 100644
--- a/include/linux/idr.h
+++ b/include/linux/idr.h
@@ -146,6 +146,10 @@ void ida_remove(struct ida *ida, int id);
 void ida_destroy(struct ida *ida);
 void ida_init(struct ida *ida);
 
+int ida_simple_get(struct ida *ida, unsigned int start, unsigned int end,
+                   gfp_t gfp_mask);
+void ida_simple_remove(struct ida *ida, unsigned int id);
+
 void __init idr_init_cache(void);
 
 #endif /* __IDR_H__ */
diff --git a/include/linux/ieee80211.h b/include/linux/ieee80211.h
index bf56b6f7827..54c87896087 100644
--- a/include/linux/ieee80211.h
+++ b/include/linux/ieee80211.h
@@ -117,8 +117,19 @@
 #define IEEE80211_MAX_MESH_ID_LEN       32
 
 #define IEEE80211_QOS_CTL_LEN           2
-#define IEEE80211_QOS_CTL_TID_MASK      0x000F
-#define IEEE80211_QOS_CTL_TAG1D_MASK    0x0007
+/* 1d tag mask */
+#define IEEE80211_QOS_CTL_TAG1D_MASK            0x0007
+/* TID mask */
+#define IEEE80211_QOS_CTL_TID_MASK              0x000f
+/* EOSP */
+#define IEEE80211_QOS_CTL_EOSP                  0x0010
+/* ACK policy */
+#define IEEE80211_QOS_CTL_ACK_POLICY_NORMAL     0x0000
+#define IEEE80211_QOS_CTL_ACK_POLICY_NOACK      0x0020
+#define IEEE80211_QOS_CTL_ACK_POLICY_NO_EXPL    0x0040
+#define IEEE80211_QOS_CTL_ACK_POLICY_BLOCKACK   0x0060
+/* A-MSDU 802.11n */
+#define IEEE80211_QOS_CTL_A_MSDU_PRESENT        0x0080
 
 /* U-APSD queue for WMM IEs sent by AP */
 #define IEEE80211_WMM_IE_AP_QOSINFO_UAPSD       (1<<7)
@@ -1423,9 +1434,6 @@ enum ieee80211_sa_query_action {
 };
 
 
-/* A-MSDU 802.11n */
-#define IEEE80211_QOS_CONTROL_A_MSDU_PRESENT 0x0080
-
 /* cipher suite selectors */
 #define WLAN_CIPHER_SUITE_USE_GROUP     0x000FAC00
 #define WLAN_CIPHER_SUITE_WEP40         0x000FAC01
@@ -1445,6 +1453,43 @@ enum ieee80211_sa_query_action {
 
 #define WLAN_PMKID_LEN                  16
 
+/*
+ * WMM/802.11e Tspec Element
+ */
+#define IEEE80211_WMM_IE_TSPEC_TID_MASK         0x0F
+#define IEEE80211_WMM_IE_TSPEC_TID_SHIFT        1
+
+enum ieee80211_tspec_status_code {
+        IEEE80211_TSPEC_STATUS_ADMISS_ACCEPTED = 0,
+        IEEE80211_TSPEC_STATUS_ADDTS_INVAL_PARAMS = 0x1,
+};
+
+struct ieee80211_tspec_ie {
+        u8 element_id;
+        u8 len;
+        u8 oui[3];
+        u8 oui_type;
+        u8 oui_subtype;
+        u8 version;
+        __le16 tsinfo;
+        u8 tsinfo_resvd;
+        __le16 nominal_msdu;
+        __le16 max_msdu;
+        __le32 min_service_int;
+        __le32 max_service_int;
+        __le32 inactivity_int;
+        __le32 suspension_int;
+        __le32 service_start_time;
+        __le32 min_data_rate;
+        __le32 mean_data_rate;
+        __le32 peak_data_rate;
+        __le32 max_burst_size;
+        __le32 delay_bound;
+        __le32 min_phy_rate;
+        __le16 sba;
+        __le16 medium_time;
+} __packed;
+
 /**
  * ieee80211_get_qos_ctl - get pointer to qos control bytes
  * @hdr: the frame
diff --git a/include/linux/if.h b/include/linux/if.h
index 3bc63e6a02f..03489ca92de 100644
--- a/include/linux/if.h
+++ b/include/linux/if.h
@@ -76,6 +76,8 @@
 #define IFF_BRIDGE_PORT 0x4000          /* device used as bridge port */
 #define IFF_OVS_DATAPATH        0x8000  /* device used as Open vSwitch
                                          * datapath port */
+#define IFF_TX_SKB_SHARING      0x10000 /* The interface supports sharing
+                                         * skbs on transmit */
 
 #define IF_GET_IFACE    0x0001          /* for querying only */
 #define IF_GET_PROTO    0x0002
diff --git a/include/linux/if_ether.h b/include/linux/if_ether.h
index 0065ffd3226..a3d99ff6e3b 100644
--- a/include/linux/if_ether.h
+++ b/include/linux/if_ether.h
@@ -78,10 +78,15 @@
                                          */
 #define ETH_P_PAE       0x888E          /* Port Access Entity (IEEE 802.1X) */
 #define ETH_P_AOE       0x88A2          /* ATA over Ethernet            */
+#define ETH_P_8021AD    0x88A8          /* 802.1ad Service VLAN         */
 #define ETH_P_TIPC      0x88CA          /* TIPC                         */
+#define ETH_P_8021AH    0x88E7          /* 802.1ah Backbone Service Tag */
 #define ETH_P_1588      0x88F7          /* IEEE 1588 Timesync */
 #define ETH_P_FCOE      0x8906          /* Fibre Channel over Ethernet  */
 #define ETH_P_FIP       0x8914          /* FCoE Initialization Protocol */
+#define ETH_P_QINQ1     0x9100          /* deprecated QinQ VLAN [ NOT AN OFFICIALLY REGISTERED ID ] */
+#define ETH_P_QINQ2     0x9200          /* deprecated QinQ VLAN [ NOT AN OFFICIALLY REGISTERED ID ] */
+#define ETH_P_QINQ3     0x9300          /* deprecated QinQ VLAN [ NOT AN OFFICIALLY REGISTERED ID ] */
 #define ETH_P_EDSA      0xDADA          /* Ethertype DSA [ NOT AN OFFICIALLY REGISTERED ID ] */
 
 /*
diff --git a/include/linux/if_packet.h b/include/linux/if_packet.h
index 7b318630139..c1486060f5e 100644
--- a/include/linux/if_packet.h
+++ b/include/linux/if_packet.h
@@ -49,6 +49,12 @@ struct sockaddr_ll {
 #define PACKET_VNET_HDR                 15
 #define PACKET_TX_TIMESTAMP             16
 #define PACKET_TIMESTAMP                17
+#define PACKET_FANOUT                   18
+
+#define PACKET_FANOUT_HASH              0
+#define PACKET_FANOUT_LB                1
+#define PACKET_FANOUT_CPU               2
+#define PACKET_FANOUT_FLAG_DEFRAG       0x8000
 
 struct tpacket_stats {
         unsigned int    tp_packets;
diff --git a/include/linux/if_pppolac.h b/include/linux/if_pppolac.h
new file mode 100644
index 00000000000..c06bd6c8ba2
--- /dev/null
+++ b/include/linux/if_pppolac.h
@@ -0,0 +1,33 @@
+/* include/linux/if_pppolac.h
+ *
+ * Header for PPP on L2TP Access Concentrator / PPPoLAC Socket (RFC 2661)
+ *
+ * Copyright (C) 2009 Google, Inc.
+ * Author: Chia-chi Yeh <chiachi@android.com>
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef __LINUX_IF_PPPOLAC_H
+#define __LINUX_IF_PPPOLAC_H
+
+#include <linux/socket.h>
+#include <linux/types.h>
+
+struct sockaddr_pppolac {
+        sa_family_t     sa_family;      /* AF_PPPOX */
+        unsigned int    sa_protocol;    /* PX_PROTO_OLAC */
+        int             udp_socket;
+        struct __attribute__((packed)) {
+                __u16   tunnel, session;
+        } local, remote;
+} __attribute__((packed));
+
+#endif /* __LINUX_IF_PPPOLAC_H */
diff --git a/include/linux/if_pppopns.h b/include/linux/if_pppopns.h
new file mode 100644
index 00000000000..0cf34b4d551
--- /dev/null
+++ b/include/linux/if_pppopns.h
@@ -0,0 +1,32 @@
+/* include/linux/if_pppopns.h
+ *
+ * Header for PPP on PPTP Network Server / PPPoPNS Socket (RFC 2637)
+ *
+ * Copyright (C) 2009 Google, Inc.
+ * Author: Chia-chi Yeh <chiachi@android.com>
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef __LINUX_IF_PPPOPNS_H
+#define __LINUX_IF_PPPOPNS_H
+
+#include <linux/socket.h>
+#include <linux/types.h>
+
+struct sockaddr_pppopns {
+        sa_family_t     sa_family;      /* AF_PPPOX */
+        unsigned int    sa_protocol;    /* PX_PROTO_OPNS */
+        int             tcp_socket;
+        __u16           local;
+        __u16           remote;
+} __attribute__((packed));
+
+#endif /* __LINUX_IF_PPPOPNS_H */
diff --git a/include/linux/if_pppox.h b/include/linux/if_pppox.h
index 397921b09ef..999ccd3fff3 100644
--- a/include/linux/if_pppox.h
+++ b/include/linux/if_pppox.h
@@ -27,6 +27,8 @@
 #include <linux/ppp_channel.h>
 #endif /* __KERNEL__ */
 #include <linux/if_pppol2tp.h>
+#include <linux/if_pppolac.h>
+#include <linux/if_pppopns.h>
 
 /* For user-space programs to pick up these definitions
  * which they wouldn't get otherwise without defining __KERNEL__
@@ -60,7 +62,9 @@ struct pptp_addr {
 #define PX_PROTO_OE    0 /* Currently just PPPoE */
 #define PX_PROTO_OL2TP 1 /* Now L2TP also */
 #define PX_PROTO_PPTP  2
-#define PX_MAX_PROTO   3
+#define PX_PROTO_OLAC  3
+#define PX_PROTO_OPNS  4
+#define PX_MAX_PROTO   5
 
 struct sockaddr_pppox {
         sa_family_t     sa_family;            /* address family, AF_PPPOX */
@@ -167,6 +171,25 @@ struct pptp_opt {
         u32 seq_sent, seq_recv;
         int ppp_flags;
 };
+
+struct pppolac_opt {
+        __u32           local;
+        __u32           remote;
+        __u32           recv_sequence;
+        __u32           xmit_sequence;
+        atomic_t        sequencing;
+        int             (*backlog_rcv)(struct sock *sk_udp, struct sk_buff *skb);
+};
+
+struct pppopns_opt {
+        __u16           local;
+        __u16           remote;
+        __u32           recv_sequence;
+        __u32           xmit_sequence;
+        void            (*data_ready)(struct sock *sk_raw, int length);
+        int             (*backlog_rcv)(struct sock *sk_raw, struct sk_buff *skb);
+};
+
 #include <net/sock.h>
 
 struct pppox_sock {
@@ -177,6 +200,8 @@ struct pppox_sock {
         union {
                 struct pppoe_opt pppoe;
                 struct pptp_opt  pptp;
+                struct pppolac_opt lac;
+                struct pppopns_opt pns;
         } proto;
         __be16                  num;
 };
diff --git a/include/linux/if_vlan.h b/include/linux/if_vlan.h
index affa27380b7..44da4822bca 100644
--- a/include/linux/if_vlan.h
+++ b/include/linux/if_vlan.h
@@ -91,25 +91,6 @@ struct vlan_group {
         struct rcu_head         rcu;
 };
 
-static inline struct net_device *vlan_group_get_device(struct vlan_group *vg,
-                                                       u16 vlan_id)
-{
-        struct net_device **array;
-        array = vg->vlan_devices_arrays[vlan_id / VLAN_GROUP_ARRAY_PART_LEN];
-        return array ? array[vlan_id % VLAN_GROUP_ARRAY_PART_LEN] : NULL;
-}
-
-static inline void vlan_group_set_device(struct vlan_group *vg,
-                                         u16 vlan_id,
-                                         struct net_device *dev)
-{
-        struct net_device **array;
-        if (!vg)
-                return;
-        array = vg->vlan_devices_arrays[vlan_id / VLAN_GROUP_ARRAY_PART_LEN];
-        array[vlan_id % VLAN_GROUP_ARRAY_PART_LEN] = dev;
-}
-
 static inline int is_vlan_dev(struct net_device *dev)
 {
         return dev->priv_flags & IFF_802_1Q_VLAN;
@@ -119,35 +100,18 @@ static inline int is_vlan_dev(struct net_device *dev)
 #define vlan_tx_tag_get(__skb)          ((__skb)->vlan_tci & ~VLAN_TAG_PRESENT)
 
 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
-/* Must be invoked with rcu_read_lock or with RTNL. */
-static inline struct net_device *vlan_find_dev(struct net_device *real_dev,
-                                               u16 vlan_id)
-{
-        struct vlan_group *grp = rcu_dereference_rtnl(real_dev->vlgrp);
-
-        if (grp)
-                return vlan_group_get_device(grp, vlan_id);
-
-        return NULL;
-}
 
+extern struct net_device *__vlan_find_dev_deep(struct net_device *real_dev,
+                                               u16 vlan_id);
 extern struct net_device *vlan_dev_real_dev(const struct net_device *dev);
 extern u16 vlan_dev_vlan_id(const struct net_device *dev);
 
-extern int __vlan_hwaccel_rx(struct sk_buff *skb, struct vlan_group *grp,
-                             u16 vlan_tci, int polling);
 extern bool vlan_do_receive(struct sk_buff **skb);
 extern struct sk_buff *vlan_untag(struct sk_buff *skb);
-extern gro_result_t
-vlan_gro_receive(struct napi_struct *napi, struct vlan_group *grp,
-                 unsigned int vlan_tci, struct sk_buff *skb);
-extern gro_result_t
-vlan_gro_frags(struct napi_struct *napi, struct vlan_group *grp,
-               unsigned int vlan_tci);
 
 #else
-static inline struct net_device *vlan_find_dev(struct net_device *real_dev,
-                                               u16 vlan_id)
+static inline struct net_device *
+__vlan_find_dev_deep(struct net_device *real_dev, u16 vlan_id)
 {
         return NULL;
 }
@@ -164,13 +128,6 @@ static inline u16 vlan_dev_vlan_id(const struct net_device *dev)
         return 0;
 }
 
-static inline int __vlan_hwaccel_rx(struct sk_buff *skb, struct vlan_group *grp,
-                                    u16 vlan_tci, int polling)
-{
-        BUG();
-        return NET_XMIT_SUCCESS;
-}
-
 static inline bool vlan_do_receive(struct sk_buff **skb)
 {
         if ((*skb)->vlan_tci & VLAN_VID_MASK)
@@ -182,49 +139,9 @@ static inline struct sk_buff *vlan_untag(struct sk_buff *skb)
 {
         return skb;
 }
-
-static inline gro_result_t
-vlan_gro_receive(struct napi_struct *napi, struct vlan_group *grp,
-                 unsigned int vlan_tci, struct sk_buff *skb)
-{
-        return GRO_DROP;
-}
-
-static inline gro_result_t
-vlan_gro_frags(struct napi_struct *napi, struct vlan_group *grp,
-               unsigned int vlan_tci)
-{
-        return GRO_DROP;
-}
 #endif
 
 /**
- * vlan_hwaccel_rx - netif_rx wrapper for VLAN RX acceleration
- * @skb: buffer
- * @grp: vlan group
- * @vlan_tci: VLAN TCI as received from the card
- */
-static inline int vlan_hwaccel_rx(struct sk_buff *skb,
-                                  struct vlan_group *grp,
-                                  u16 vlan_tci)
-{
-        return __vlan_hwaccel_rx(skb, grp, vlan_tci, 0);
-}
-
-/**
- * vlan_hwaccel_receive_skb - netif_receive_skb wrapper for VLAN RX acceleration
- * @skb: buffer
- * @grp: vlan group
- * @vlan_tci: VLAN TCI as received from the card
- */
-static inline int vlan_hwaccel_receive_skb(struct sk_buff *skb,
-                                           struct vlan_group *grp,
-                                           u16 vlan_tci)
-{
-        return __vlan_hwaccel_rx(skb, grp, vlan_tci, 1);
-}
-
-/**
  * vlan_insert_tag - regular VLAN tag inserting
  * @skb: skbuff to tag
  * @vlan_tci: VLAN TCI to insert
diff --git a/include/linux/ina219.h b/include/linux/ina219.h
new file mode 100644
index 00000000000..c27fa26c575
--- /dev/null
+++ b/include/linux/ina219.h
@@ -0,0 +1,34 @@
+/*
+ * linux/include/linux/ina219.h
+ *
+ * Copyright (c) 2011, NVIDIA Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#ifndef _INA219_H
+#define _INA219_H
+
+#include <linux/types.h>
+
+struct ina219_platform_data {
+        u8 divisor; /*divisor needed to get current value */
+        u32 calibration_data;
+        u32 power_lsb;
+        char rail_name[20];
+};
+
+#endif /* _LINUX_INA219_H */
+
diff --git a/include/linux/inet_lro.h b/include/linux/inet_lro.h
index c4335faebb6..2cf55afbcd4 100644
--- a/include/linux/inet_lro.h
+++ b/include/linux/inet_lro.h
@@ -50,7 +50,6 @@ struct net_lro_desc {
         struct skb_frag_struct *next_frag;
         struct iphdr *iph;
         struct tcphdr *tcph;
-        struct vlan_group *vgrp;
         __wsum  data_csum;
         __be32 tcp_rcv_tsecr;
         __be32 tcp_rcv_tsval;
@@ -60,7 +59,6 @@ struct net_lro_desc {
         u16 ip_tot_len;
         u16 tcp_saw_tstamp;             /* timestamps enabled */
         __be16 tcp_window;
-        u16 vlan_tag;
         int pkt_aggr_cnt;               /* counts aggregated packets */
         int vlan_packet;
         int mss;
@@ -137,16 +135,6 @@ void lro_receive_skb(struct net_lro_mgr *lro_mgr,
                      void *priv);
 
 /*
- * Processes a SKB with VLAN HW acceleration support
- */
-
-void lro_vlan_hwaccel_receive_skb(struct net_lro_mgr *lro_mgr,
-                                  struct sk_buff *skb,
-                                  struct vlan_group *vgrp,
-                                  u16 vlan_tag,
-                                  void *priv);
-
-/*
  * Processes a fragment list
  *
  * This functions aggregate fragments and generate SKBs do pass
@@ -165,13 +153,6 @@ void lro_receive_frags(struct net_lro_mgr *lro_mgr,
                        struct skb_frag_struct *frags,
                        int len, int true_size, void *priv, __wsum sum);
 
-void lro_vlan_hwaccel_receive_frags(struct net_lro_mgr *lro_mgr,
-                                    struct skb_frag_struct *frags,
-                                    int len, int true_size,
-                                    struct vlan_group *vgrp,
-                                    u16 vlan_tag,
-                                    void *priv, __wsum sum);
-
 /*
  * Forward all aggregated SKBs held by lro_mgr to network stack
  */
diff --git a/include/linux/init_task.h b/include/linux/init_task.h
index 580f70c0239..d14e058aaee 100644
--- a/include/linux/init_task.h
+++ b/include/linux/init_task.h
@@ -176,7 +176,6 @@ extern struct cred init_cred;
         .alloc_lock     = __SPIN_LOCK_UNLOCKED(tsk.alloc_lock),         \
         .journal_info   = NULL,                                         \
         .cpu_timers     = INIT_CPU_TIMERS(tsk.cpu_timers),              \
-        .fs_excl        = ATOMIC_INIT(0),                               \
         .pi_lock        = __RAW_SPIN_LOCK_UNLOCKED(tsk.pi_lock),        \
         .timer_slack_ns = 50000, /* 50 usec default slack */            \
         .pids = {                                                       \
diff --git a/include/linux/input.h b/include/linux/input.h
index 771d6d85667..48857fddf9a 100644
--- a/include/linux/input.h
+++ b/include/linux/input.h
@@ -119,9 +119,9 @@ struct input_keymap_entry {
 #define EVIOCGSND(len)          _IOC(_IOC_READ, 'E', 0x1a, len)         /* get all sounds status */
 #define EVIOCGSW(len)           _IOC(_IOC_READ, 'E', 0x1b, len)         /* get all switch states */
 
-#define EVIOCGBIT(ev,len)       _IOC(_IOC_READ, 'E', 0x20 + ev, len)    /* get event bits */
-#define EVIOCGABS(abs)          _IOR('E', 0x40 + abs, struct input_absinfo)     /* get abs value/limits */
-#define EVIOCSABS(abs)          _IOW('E', 0xc0 + abs, struct input_absinfo)     /* set abs value/limits */
+#define EVIOCGBIT(ev,len)       _IOC(_IOC_READ, 'E', 0x20 + (ev), len)  /* get event bits */
+#define EVIOCGABS(abs)          _IOR('E', 0x40 + (abs), struct input_absinfo)   /* get abs value/limits */
+#define EVIOCSABS(abs)          _IOW('E', 0xc0 + (abs), struct input_absinfo)   /* set abs value/limits */
 
 #define EVIOCSFF                _IOC(_IOC_WRITE, 'E', 0x80, sizeof(struct ff_effect))   /* send a force effect to a force feedback device */
 #define EVIOCRMFF               _IOW('E', 0x81, int)                    /* Erase a force effect */
@@ -129,6 +129,9 @@ struct input_keymap_entry {
 
 #define EVIOCGRAB               _IOW('E', 0x90, int)                    /* Grab/Release device */
 
+#define EVIOCGSUSPENDBLOCK      _IOR('E', 0x91, int)                    /* get suspend block enable */
+#define EVIOCSSUSPENDBLOCK      _IOW('E', 0x91, int)                    /* set suspend block enable */
+
 /*
  * Device properties and quirks
  */
@@ -438,6 +441,8 @@ struct input_keymap_entry {
 #define KEY_WIMAX               246
 #define KEY_RFKILL              247     /* Key that controls all radios */
 
+#define KEY_MICMUTE             248     /* Mute / unmute the microphone */
+
 /* Code 255 is reserved for special needs of AT keyboard driver */
 
 #define BTN_MISC                0x100
diff --git a/include/linux/input/kxtj9.h b/include/linux/input/kxtj9.h
new file mode 100644
index 00000000000..f6bac89537b
--- /dev/null
+++ b/include/linux/input/kxtj9.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2011 Kionix, Inc.
+ * Written by Chris Hudson <chudson@kionix.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ * 02111-1307, USA
+ */
+
+#ifndef __KXTJ9_H__
+#define __KXTJ9_H__
+
+#define KXTJ9_I2C_ADDR          0x0F
+
+struct kxtj9_platform_data {
+        unsigned int min_interval;      /* minimum poll interval (in milli-seconds) */
+
+        /*
+         * By default, x is axis 0, y is axis 1, z is axis 2; these can be
+         * changed to account for sensor orientation within the host device.
+         */
+        u8 axis_map_x;
+        u8 axis_map_y;
+        u8 axis_map_z;
+
+        /*
+         * Each axis can be negated to account for sensor orientation within
+         * the host device.
+         */
+        bool negate_x;
+        bool negate_y;
+        bool negate_z;
+
+        /* CTRL_REG1: set resolution, g-range, data ready enable */
+        /* Output resolution: 8-bit valid or 12-bit valid */
+        #define RES_8BIT                0
+        #define RES_12BIT               (1 << 6)
+        u8 res_12bit;
+        /* Output g-range: +/-2g, 4g, or 8g */
+        #define KXTJ9_G_2G              0
+        #define KXTJ9_G_4G              (1 << 3)
+        #define KXTJ9_G_8G              (1 << 4)
+        u8 g_range;
+
+        /* DATA_CTRL_REG: controls the output data rate of the part */
+        #define ODR12_5F                0
+        #define ODR25F                  1
+        #define ODR50F                  2
+        #define ODR100F                 3
+        #define ODR200F                 4
+        #define ODR400F                 5
+        #define ODR800F                 6
+        u8 data_odr_init;
+
+        int (*init)(void);
+        void (*exit)(void);
+        int (*power_on)(void);
+        int (*power_off)(void);
+};
+#endif  /* __KXTJ9_H__ */
diff --git a/include/linux/intel-iommu.h b/include/linux/intel-iommu.h
index 9310c699a37..e6ca56de993 100644
--- a/include/linux/intel-iommu.h
+++ b/include/linux/intel-iommu.h
@@ -271,7 +271,7 @@ struct qi_desc {
 };
 
 struct q_inval {
-        spinlock_t      q_lock;
+        raw_spinlock_t  q_lock;
         struct qi_desc  *desc;          /* invalidation queue */
         int             *desc_status;   /* desc status */
         int             free_head;      /* first free entry */
@@ -279,7 +279,7 @@ struct q_inval {
         int             free_cnt;
 };
 
-#ifdef CONFIG_INTR_REMAP
+#ifdef CONFIG_IRQ_REMAP
 /* 1MB - maximum possible interrupt remapping table size */
 #define INTR_REMAP_PAGE_ORDER   8
 #define INTR_REMAP_TABLE_REG_SIZE       0xf
@@ -311,14 +311,14 @@ struct intel_iommu {
         u64             cap;
         u64             ecap;
         u32             gcmd; /* Holds TE, EAFL. Don't need SRTP, SFL, WBF */
-        spinlock_t      register_lock; /* protect register handling */
+        raw_spinlock_t  register_lock; /* protect register handling */
         int             seq_id; /* sequence id of the iommu */
         int             agaw; /* agaw of this iommu */
         int             msagaw; /* max sagaw of this iommu */
         unsigned int    irq;
         unsigned char   name[13];    /* Device Name */
 
-#ifdef CONFIG_DMAR
+#ifdef CONFIG_INTEL_IOMMU
         unsigned long   *domain_ids; /* bitmap of domains */
         struct dmar_domain **domains; /* ptr to domains */
         spinlock_t      lock; /* protect context, domain ids */
@@ -329,7 +329,7 @@ struct intel_iommu {
         struct q_inval  *qi;            /* Queued invalidation info */
         u32 *iommu_state; /* Store iommu states between suspend and resume.*/
 
-#ifdef CONFIG_INTR_REMAP
+#ifdef CONFIG_IRQ_REMAP
         struct ir_table *ir_table;      /* Interrupt remapping info */
 #endif
         int             node;
diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h
index f6efed0039e..f51a81bc46d 100644
--- a/include/linux/interrupt.h
+++ b/include/linux/interrupt.h
@@ -17,7 +17,7 @@
 #include <linux/kref.h>
 #include <linux/workqueue.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <asm/ptrace.h>
 #include <asm/system.h>
 #include <trace/events/irq.h>
@@ -59,6 +59,8 @@
  * IRQF_NO_SUSPEND - Do not disable this IRQ during suspend
  * IRQF_FORCE_RESUME - Force enable it on resume even if IRQF_NO_SUSPEND is set
  * IRQF_NO_THREAD - Interrupt cannot be threaded
+ * IRQF_EARLY_RESUME - Resume IRQ early during syscore instead of at device
+ *                resume time.
  */
 #define IRQF_DISABLED           0x00000020
 #define IRQF_SAMPLE_RANDOM      0x00000040
@@ -72,6 +74,7 @@
 #define IRQF_NO_SUSPEND         0x00004000
 #define IRQF_FORCE_RESUME       0x00008000
 #define IRQF_NO_THREAD          0x00010000
+#define IRQF_EARLY_RESUME       0x00020000
 
 #define IRQF_TIMER              (__IRQF_TIMER | IRQF_NO_SUSPEND | IRQF_NO_THREAD)
 
diff --git a/include/linux/interrupt_keys.h b/include/linux/interrupt_keys.h
new file mode 100644
index 00000000000..8be6e9a6b0a
--- /dev/null
+++ b/include/linux/interrupt_keys.h
@@ -0,0 +1,47 @@
+/*
+ * include/linux/interrupt_keys.h
+ *
+ * Key driver for keys directly connected to intrrupt lines.
+ *
+ * Copyright (c) 2011, NVIDIA Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#ifndef _INTERRUPT_KEYS_H
+#define _INTERRUPT_KEYS_H
+
+struct interrupt_keys_button {
+        /* Configuration parameters */
+        int code;               /* input event code (KEY_*, SW_*) */
+        int irq;
+        int active_low;
+        char *desc;
+        int type;               /* input event type (EV_KEY, EV_SW) */
+        int wakeup;             /* configure the interrupt source as a wake-up
+                                 * source */
+        int debounce_interval;  /* debounce ticks interval in msecs */
+        bool can_disable;
+};
+
+struct interrupt_keys_platform_data {
+        struct interrupt_keys_button *int_buttons;
+        int nbuttons;
+        unsigned int rep:1;             /* enable input subsystem auto repeat */
+        int (*enable)(struct device *dev);
+        void (*disable)(struct device *dev);
+};
+
+#endif
diff --git a/include/linux/io-mapping.h b/include/linux/io-mapping.h
index 8cdcc2a199a..1feeb526356 100644
--- a/include/linux/io-mapping.h
+++ b/include/linux/io-mapping.h
@@ -117,6 +117,8 @@ io_mapping_unmap(void __iomem *vaddr)
 
 #else
 
+#include <linux/uaccess.h>
+
 /* this struct isn't actually defined anywhere */
 struct io_mapping;
 
@@ -138,12 +140,14 @@ static inline void __iomem *
 io_mapping_map_atomic_wc(struct io_mapping *mapping,
                          unsigned long offset)
 {
+        pagefault_disable();
         return ((char __force __iomem *) mapping) + offset;
 }
 
 static inline void
 io_mapping_unmap_atomic(void __iomem *vaddr)
 {
+        pagefault_enable();
 }
 
 /* Non-atomic map/unmap */
diff --git a/include/linux/iocontext.h b/include/linux/iocontext.h
index b2eee896dcb..5037a0ad231 100644
--- a/include/linux/iocontext.h
+++ b/include/linux/iocontext.h
@@ -5,6 +5,14 @@
 #include <linux/rcupdate.h>
 
 struct cfq_queue;
+struct cfq_ttime {
+        unsigned long last_end_request;
+
+        unsigned long ttime_total;
+        unsigned long ttime_samples;
+        unsigned long ttime_mean;
+};
+
 struct cfq_io_context {
         void *key;
 
@@ -12,11 +20,7 @@ struct cfq_io_context {
 
         struct io_context *ioc;
 
-        unsigned long last_end_request;
-
-        unsigned long ttime_total;
-        unsigned long ttime_samples;
-        unsigned long ttime_mean;
+        struct cfq_ttime ttime;
 
         struct list_head queue_list;
         struct hlist_node cic_list;
diff --git a/include/linux/iommu.h b/include/linux/iommu.h
index 0a2ba409899..d937580417b 100644
--- a/include/linux/iommu.h
+++ b/include/linux/iommu.h
@@ -19,65 +19,134 @@
 #ifndef __LINUX_IOMMU_H
 #define __LINUX_IOMMU_H
 
+#include <linux/errno.h>
+
 #define IOMMU_READ      (1)
 #define IOMMU_WRITE     (2)
 #define IOMMU_CACHE     (4) /* DMA cache coherency */
 
+struct iommu_ops;
+struct bus_type;
 struct device;
+struct iommu_domain;
+
+/* iommu fault flags */
+#define IOMMU_FAULT_READ        0x0
+#define IOMMU_FAULT_WRITE       0x1
+
+typedef int (*iommu_fault_handler_t)(struct iommu_domain *,
+                                struct device *, unsigned long, int);
 
 struct iommu_domain {
+        struct iommu_ops *ops;
         void *priv;
+        iommu_fault_handler_t handler;
 };
 
 #define IOMMU_CAP_CACHE_COHERENCY       0x1
 #define IOMMU_CAP_INTR_REMAP            0x2     /* isolates device intrs */
 
+#ifdef CONFIG_IOMMU_API
+
+/**
+ * struct iommu_ops - iommu ops and capabilities
+ * @domain_init: init iommu domain
+ * @domain_destroy: destroy iommu domain
+ * @attach_dev: attach device to an iommu domain
+ * @detach_dev: detach device from an iommu domain
+ * @map: map a physically contiguous memory region to an iommu domain
+ * @unmap: unmap a physically contiguous memory region from an iommu domain
+ * @iova_to_phys: translate iova to physical address
+ * @domain_has_cap: domain capabilities query
+ * @commit: commit iommu domain
+ * @pgsize_bitmap: bitmap of supported page sizes
+ */
 struct iommu_ops {
         int (*domain_init)(struct iommu_domain *domain);
         void (*domain_destroy)(struct iommu_domain *domain);
         int (*attach_dev)(struct iommu_domain *domain, struct device *dev);
         void (*detach_dev)(struct iommu_domain *domain, struct device *dev);
         int (*map)(struct iommu_domain *domain, unsigned long iova,
-                   phys_addr_t paddr, int gfp_order, int prot);
-        int (*unmap)(struct iommu_domain *domain, unsigned long iova,
-                     int gfp_order);
+                   phys_addr_t paddr, size_t size, int prot);
+        size_t (*unmap)(struct iommu_domain *domain, unsigned long iova,
+                     size_t size);
         phys_addr_t (*iova_to_phys)(struct iommu_domain *domain,
                                     unsigned long iova);
         int (*domain_has_cap)(struct iommu_domain *domain,
                               unsigned long cap);
+        int (*device_group)(struct device *dev, unsigned int *groupid);
+        unsigned long pgsize_bitmap;
 };
 
-#ifdef CONFIG_IOMMU_API
-
-extern void register_iommu(struct iommu_ops *ops);
-extern bool iommu_found(void);
-extern struct iommu_domain *iommu_domain_alloc(void);
+extern int bus_set_iommu(struct bus_type *bus, struct iommu_ops *ops);
+extern bool iommu_present(struct bus_type *bus);
+extern struct iommu_domain *iommu_domain_alloc(struct bus_type *bus);
 extern void iommu_domain_free(struct iommu_domain *domain);
 extern int iommu_attach_device(struct iommu_domain *domain,
                                struct device *dev);
 extern void iommu_detach_device(struct iommu_domain *domain,
                                 struct device *dev);
 extern int iommu_map(struct iommu_domain *domain, unsigned long iova,
-                     phys_addr_t paddr, int gfp_order, int prot);
-extern int iommu_unmap(struct iommu_domain *domain, unsigned long iova,
-                       int gfp_order);
+                     phys_addr_t paddr, size_t size, int prot);
+extern size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova,
+                       size_t size);
 extern phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain,
                                       unsigned long iova);
 extern int iommu_domain_has_cap(struct iommu_domain *domain,
                                 unsigned long cap);
+extern void iommu_set_fault_handler(struct iommu_domain *domain,
+                                        iommu_fault_handler_t handler);
+extern int iommu_device_group(struct device *dev, unsigned int *groupid);
+
+/**
+ * report_iommu_fault() - report about an IOMMU fault to the IOMMU framework
+ * @domain: the iommu domain where the fault has happened
+ * @dev: the device where the fault has happened
+ * @iova: the faulting address
+ * @flags: mmu fault flags (e.g. IOMMU_FAULT_READ/IOMMU_FAULT_WRITE/...)
+ *
+ * This function should be called by the low-level IOMMU implementations
+ * whenever IOMMU faults happen, to allow high-level users, that are
+ * interested in such events, to know about them.
+ *
+ * This event may be useful for several possible use cases:
+ * - mere logging of the event
+ * - dynamic TLB/PTE loading
+ * - if restarting of the faulting device is required
+ *
+ * Returns 0 on success and an appropriate error code otherwise (if dynamic
+ * PTE/TLB loading will one day be supported, implementations will be able
+ * to tell whether it succeeded or not according to this return value).
+ *
+ * Specifically, -ENOSYS is returned if a fault handler isn't installed
+ * (though fault handlers can also return -ENOSYS, in case they want to
+ * elicit the default behavior of the IOMMU drivers).
+ */
+static inline int report_iommu_fault(struct iommu_domain *domain,
+                struct device *dev, unsigned long iova, int flags)
+{
+        int ret = -ENOSYS;
 
-#else /* CONFIG_IOMMU_API */
+        /*
+         * if upper layers showed interest and installed a fault handler,
+         * invoke it.
+         */
+        if (domain->handler)
+                ret = domain->handler(domain, dev, iova, flags);
 
-static inline void register_iommu(struct iommu_ops *ops)
-{
+        return ret;
 }
 
-static inline bool iommu_found(void)
+#else /* CONFIG_IOMMU_API */
+
+struct iommu_ops {};
+
+static inline bool iommu_present(struct bus_type *bus)
 {
         return false;
 }
 
-static inline struct iommu_domain *iommu_domain_alloc(void)
+static inline struct iommu_domain *iommu_domain_alloc(struct bus_type *bus)
 {
         return NULL;
 }
@@ -121,6 +190,16 @@ static inline int domain_has_cap(struct iommu_domain *domain,
         return 0;
 }
 
+static inline void iommu_set_fault_handler(struct iommu_domain *domain,
+                                        iommu_fault_handler_t handler)
+{
+}
+
+static inline int iommu_device_group(struct device *dev, unsigned int *groupid)
+{
+        return -ENODEV;
+}
+
 #endif /* CONFIG_IOMMU_API */
 
 #endif /* __LINUX_IOMMU_H */
diff --git a/include/linux/ion.h b/include/linux/ion.h
new file mode 100644
index 00000000000..9a322437a97
--- /dev/null
+++ b/include/linux/ion.h
@@ -0,0 +1,347 @@
+/*
+ * include/linux/ion.h
+ *
+ * Copyright (C) 2011 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _LINUX_ION_H
+#define _LINUX_ION_H
+
+#include <linux/types.h>
+
+struct ion_handle;
+/**
+ * enum ion_heap_types - list of all possible types of heaps
+ * @ION_HEAP_TYPE_SYSTEM:        memory allocated via vmalloc
+ * @ION_HEAP_TYPE_SYSTEM_CONTIG: memory allocated via kmalloc
+ * @ION_HEAP_TYPE_CARVEOUT:      memory allocated from a prereserved
+ *                               carveout heap, allocations are physically
+ *                               contiguous
+ * @ION_HEAP_END:                helper for iterating over heaps
+ */
+enum ion_heap_type {
+        ION_HEAP_TYPE_SYSTEM,
+        ION_HEAP_TYPE_SYSTEM_CONTIG,
+        ION_HEAP_TYPE_CARVEOUT,
+        ION_HEAP_TYPE_IOMMU,
+        ION_HEAP_TYPE_CUSTOM, /* must be last so device specific heaps always
+                                 are at the end of this enum */
+        ION_NUM_HEAPS,
+};
+
+#define ION_HEAP_SYSTEM_MASK            (1 << ION_HEAP_TYPE_SYSTEM)
+#define ION_HEAP_SYSTEM_CONTIG_MASK     (1 << ION_HEAP_TYPE_SYSTEM_CONTIG)
+#define ION_HEAP_CARVEOUT_MASK          (1 << ION_HEAP_TYPE_CARVEOUT)
+
+#ifdef __KERNEL__
+struct ion_device;
+struct ion_heap;
+struct ion_mapper;
+struct ion_client;
+struct ion_buffer;
+
+/* This should be removed some day when phys_addr_t's are fully
+   plumbed in the kernel, and all instances of ion_phys_addr_t should
+   be converted to phys_addr_t.  For the time being many kernel interfaces
+   do not accept phys_addr_t's that would have to */
+#define ion_phys_addr_t unsigned long
+
+/**
+ * struct ion_platform_heap - defines a heap in the given platform
+ * @type:       type of the heap from ion_heap_type enum
+ * @id:         unique identifier for heap.  When allocating (lower numbers 
+ *              will be allocated from first)
+ * @name:       used for debug purposes
+ * @base:       base address of heap in physical memory if applicable
+ * @size:       size of the heap in bytes if applicable
+ * @priv:       heap specific data
+ *
+ * Provided by the board file.
+ */
+struct ion_platform_heap {
+        enum ion_heap_type type;
+        unsigned int id;
+        const char *name;
+        ion_phys_addr_t base;
+        size_t size;
+        void *priv;
+};
+
+/**
+ * struct ion_platform_data - array of platform heaps passed from board file
+ * @nr:         number of structures in the array
+ * @heaps:      array of platform_heap structions
+ *
+ * Provided by the board file in the form of platform data to a platform device.
+ */
+struct ion_platform_data {
+        int nr;
+        struct ion_platform_heap heaps[];
+};
+
+/**
+ * ion_client_create() -  allocate a client and returns it
+ * @dev:        the global ion device
+ * @heap_mask:  mask of heaps this client can allocate from
+ * @name:       used for debugging
+ */
+struct ion_client *ion_client_create(struct ion_device *dev,
+                                     unsigned int heap_mask, const char *name);
+
+/**
+ * ion_client_destroy() -  free's a client and all it's handles
+ * @client:     the client
+ *
+ * Free the provided client and all it's resources including
+ * any handles it is holding.
+ */
+void ion_client_destroy(struct ion_client *client);
+
+/**
+ * ion_alloc - allocate ion memory
+ * @client:     the client
+ * @len:        size of the allocation
+ * @align:      requested allocation alignment, lots of hardware blocks have
+ *              alignment requirements of some kind
+ * @flags:      mask of heaps to allocate from, if multiple bits are set
+ *              heaps will be tried in order from lowest to highest order bit
+ *
+ * Allocate memory in one of the heaps provided in heap mask and return
+ * an opaque handle to it.
+ */
+struct ion_handle *ion_alloc(struct ion_client *client, size_t len,
+                             size_t align, unsigned int flags);
+
+/**
+ * ion_free - free a handle
+ * @client:     the client
+ * @handle:     the handle to free
+ *
+ * Free the provided handle.
+ */
+void ion_free(struct ion_client *client, struct ion_handle *handle);
+
+/**
+ * ion_phys - returns the physical address and len of a handle
+ * @client:     the client
+ * @handle:     the handle
+ * @addr:       a pointer to put the address in
+ * @len:        a pointer to put the length in
+ *
+ * This function queries the heap for a particular handle to get the
+ * handle's physical address.  It't output is only correct if
+ * a heap returns physically contiguous memory -- in other cases
+ * this api should not be implemented -- ion_map_dma should be used
+ * instead.  Returns -EINVAL if the handle is invalid.  This has
+ * no implications on the reference counting of the handle --
+ * the returned value may not be valid if the caller is not
+ * holding a reference.
+ */
+int ion_phys(struct ion_client *client, struct ion_handle *handle,
+             ion_phys_addr_t *addr, size_t *len);
+
+/**
+ * ion_map_kernel - create mapping for the given handle
+ * @client:     the client
+ * @handle:     handle to map
+ *
+ * Map the given handle into the kernel and return a kernel address that
+ * can be used to access this address.
+ */
+void *ion_map_kernel(struct ion_client *client, struct ion_handle *handle);
+
+/**
+ * ion_unmap_kernel() - destroy a kernel mapping for a handle
+ * @client:     the client
+ * @handle:     handle to unmap
+ */
+void ion_unmap_kernel(struct ion_client *client, struct ion_handle *handle);
+
+/**
+ * ion_map_dma - create a dma mapping for a given handle
+ * @client:     the client
+ * @handle:     handle to map
+ *
+ * Return an sglist describing the given handle
+ */
+struct scatterlist *ion_map_dma(struct ion_client *client,
+                                struct ion_handle *handle);
+
+/**
+ * ion_unmap_dma() - destroy a dma mapping for a handle
+ * @client:     the client
+ * @handle:     handle to unmap
+ */
+void ion_unmap_dma(struct ion_client *client, struct ion_handle *handle);
+
+/**
+ * ion_share() - given a handle, obtain a buffer to pass to other clients
+ * @client:     the client
+ * @handle:     the handle to share
+ *
+ * Given a handle, return a buffer, which exists in a global name
+ * space, and can be passed to other clients.  Should be passed into ion_import
+ * to obtain a new handle for this buffer.
+ *
+ * NOTE: This function does do not an extra reference.  The burden is on the
+ * caller to make sure the buffer doesn't go away while it's being passed to
+ * another client.  That is, ion_free should not be called on this handle until
+ * the buffer has been imported into the other client.
+ */
+struct ion_buffer *ion_share(struct ion_client *client,
+                             struct ion_handle *handle);
+
+/**
+ * ion_import() - given an buffer in another client, import it
+ * @client:     this blocks client
+ * @buffer:     the buffer to import (as obtained from ion_share)
+ *
+ * Given a buffer, add it to the client and return the handle to use to refer
+ * to it further.  This is called to share a handle from one kernel client to
+ * another.
+ */
+struct ion_handle *ion_import(struct ion_client *client,
+                              struct ion_buffer *buffer);
+
+/**
+ * ion_import_fd() - given an fd obtained via ION_IOC_SHARE ioctl, import it
+ * @client:     this blocks client
+ * @fd:         the fd
+ *
+ * A helper function for drivers that will be recieving ion buffers shared
+ * with them from userspace.  These buffers are represented by a file
+ * descriptor obtained as the return from the ION_IOC_SHARE ioctl.
+ * This function coverts that fd into the underlying buffer, and returns
+ * the handle to use to refer to it further.
+ */
+struct ion_handle *ion_import_fd(struct ion_client *client, int fd);
+#endif /* __KERNEL__ */
+
+/**
+ * DOC: Ion Userspace API
+ *
+ * create a client by opening /dev/ion
+ * most operations handled via following ioctls
+ *
+ */
+
+/**
+ * struct ion_allocation_data - metadata passed from userspace for allocations
+ * @len:        size of the allocation
+ * @align:      required alignment of the allocation
+ * @flags:      flags passed to heap
+ * @handle:     pointer that will be populated with a cookie to use to refer
+ *              to this allocation
+ *
+ * Provided by userspace as an argument to the ioctl
+ */
+struct ion_allocation_data {
+        size_t len;
+        size_t align;
+        unsigned int flags;
+        struct ion_handle *handle;
+};
+
+/**
+ * struct ion_fd_data - metadata passed to/from userspace for a handle/fd pair
+ * @handle:     a handle
+ * @fd:         a file descriptor representing that handle
+ *
+ * For ION_IOC_SHARE or ION_IOC_MAP userspace populates the handle field with
+ * the handle returned from ion alloc, and the kernel returns the file
+ * descriptor to share or map in the fd field.  For ION_IOC_IMPORT, userspace
+ * provides the file descriptor and the kernel returns the handle.
+ */
+struct ion_fd_data {
+        struct ion_handle *handle;
+        int fd;
+};
+
+/**
+ * struct ion_handle_data - a handle passed to/from the kernel
+ * @handle:     a handle
+ */
+struct ion_handle_data {
+        struct ion_handle *handle;
+};
+
+/**
+ * struct ion_custom_data - metadata passed to/from userspace for a custom ioctl
+ * @cmd:        the custom ioctl function to call
+ * @arg:        additional data to pass to the custom ioctl, typically a user
+ *              pointer to a predefined structure
+ *
+ * This works just like the regular cmd and arg fields of an ioctl.
+ */
+struct ion_custom_data {
+        unsigned int cmd;
+        unsigned long arg;
+};
+
+#define ION_IOC_MAGIC           'I'
+
+/**
+ * DOC: ION_IOC_ALLOC - allocate memory
+ *
+ * Takes an ion_allocation_data struct and returns it with the handle field
+ * populated with the opaque handle for the allocation.
+ */
+#define ION_IOC_ALLOC           _IOWR(ION_IOC_MAGIC, 0, \
+                                      struct ion_allocation_data)
+
+/**
+ * DOC: ION_IOC_FREE - free memory
+ *
+ * Takes an ion_handle_data struct and frees the handle.
+ */
+#define ION_IOC_FREE            _IOWR(ION_IOC_MAGIC, 1, struct ion_handle_data)
+
+/**
+ * DOC: ION_IOC_MAP - get a file descriptor to mmap
+ *
+ * Takes an ion_fd_data struct with the handle field populated with a valid
+ * opaque handle.  Returns the struct with the fd field set to a file
+ * descriptor open in the current address space.  This file descriptor
+ * can then be used as an argument to mmap.
+ */
+#define ION_IOC_MAP             _IOWR(ION_IOC_MAGIC, 2, struct ion_fd_data)
+
+/**
+ * DOC: ION_IOC_SHARE - creates a file descriptor to use to share an allocation
+ *
+ * Takes an ion_fd_data struct with the handle field populated with a valid
+ * opaque handle.  Returns the struct with the fd field set to a file
+ * descriptor open in the current address space.  This file descriptor
+ * can then be passed to another process.  The corresponding opaque handle can
+ * be retrieved via ION_IOC_IMPORT.
+ */
+#define ION_IOC_SHARE           _IOWR(ION_IOC_MAGIC, 4, struct ion_fd_data)
+
+/**
+ * DOC: ION_IOC_IMPORT - imports a shared file descriptor
+ *
+ * Takes an ion_fd_data struct with the fd field populated with a valid file
+ * descriptor obtained from ION_IOC_SHARE and returns the struct with the handle
+ * filed set to the corresponding opaque handle.
+ */
+#define ION_IOC_IMPORT          _IOWR(ION_IOC_MAGIC, 5, int)
+
+/**
+ * DOC: ION_IOC_CUSTOM - call architecture specific ion ioctl
+ *
+ * Takes the argument of the architecture specific ioctl to call and
+ * passes appropriate userdata for that ioctl
+ */
+#define ION_IOC_CUSTOM          _IOWR(ION_IOC_MAGIC, 6, struct ion_custom_data)
+
+#endif /* _LINUX_ION_H */
diff --git a/include/linux/ioport.h b/include/linux/ioport.h
index e9bb22cba76..9d57a71775b 100644
--- a/include/linux/ioport.h
+++ b/include/linux/ioport.h
@@ -109,6 +109,36 @@ struct resource_list {
 /* PCI control bits.  Shares IORESOURCE_BITS with above PCI ROM.  */
 #define IORESOURCE_PCI_FIXED            (1<<4)  /* Do not move resource */
 
+
+/* helpers to define resources */
+#define DEFINE_RES_NAMED(_start, _size, _name, _flags)                  \
+        {                                                               \
+                .start = (_start),                                      \
+                .end = (_start) + (_size) - 1,                          \
+                .name = (_name),                                        \
+                .flags = (_flags),                                      \
+        }
+
+#define DEFINE_RES_IO_NAMED(_start, _size, _name)                       \
+        DEFINE_RES_NAMED((_start), (_size), (_name), IORESOURCE_IO)
+#define DEFINE_RES_IO(_start, _size)                                    \
+        DEFINE_RES_IO_NAMED((_start), (_size), NULL)
+
+#define DEFINE_RES_MEM_NAMED(_start, _size, _name)                      \
+        DEFINE_RES_NAMED((_start), (_size), (_name), IORESOURCE_MEM)
+#define DEFINE_RES_MEM(_start, _size)                                   \
+        DEFINE_RES_MEM_NAMED((_start), (_size), NULL)
+
+#define DEFINE_RES_IRQ_NAMED(_irq, _name)                               \
+        DEFINE_RES_NAMED((_irq), 1, (_name), IORESOURCE_IRQ)
+#define DEFINE_RES_IRQ(_irq)                                            \
+        DEFINE_RES_IRQ_NAMED((_irq), NULL)
+
+#define DEFINE_RES_DMA_NAMED(_dma, _name)                               \
+        DEFINE_RES_NAMED((_dma), 1, (_name), IORESOURCE_DMA)
+#define DEFINE_RES_DMA(_dma)                                            \
+        DEFINE_RES_DMA_NAMED((_dma), NULL)
+
 /* PC/ISA/whatever - the normal PC address spaces: IO and memory */
 extern struct resource ioport_resource;
 extern struct resource iomem_resource;
@@ -132,6 +162,7 @@ extern int allocate_resource(struct resource *root, struct resource *new,
                                                        resource_size_t,
                                                        resource_size_t),
                              void *alignf_data);
+struct resource *lookup_resource(struct resource *root, resource_size_t start);
 int adjust_resource(struct resource *res, resource_size_t start,
                     resource_size_t size);
 resource_size_t resource_alignment(struct resource *res);
diff --git a/include/linux/ipc_namespace.h b/include/linux/ipc_namespace.h
index a6d1655f960..8a297a5e794 100644
--- a/include/linux/ipc_namespace.h
+++ b/include/linux/ipc_namespace.h
@@ -44,6 +44,11 @@ struct ipc_namespace {
         size_t          shm_ctlall;
         int             shm_ctlmni;
         int             shm_tot;
+        /*
+         * Defines whether IPC_RMID is forced for _all_ shm segments regardless
+         * of shmctl()
+         */
+        int             shm_rmid_forced;
 
         struct notifier_block ipcns_nb;
 
@@ -72,6 +77,7 @@ extern int register_ipcns_notifier(struct ipc_namespace *);
 extern int cond_register_ipcns_notifier(struct ipc_namespace *);
 extern void unregister_ipcns_notifier(struct ipc_namespace *);
 extern int ipcns_notify(unsigned long);
+extern void shm_destroy_orphaned(struct ipc_namespace *ns);
 #else /* CONFIG_SYSVIPC */
 static inline int register_ipcns_notifier(struct ipc_namespace *ns)
 { return 0; }
@@ -79,6 +85,7 @@ static inline int cond_register_ipcns_notifier(struct ipc_namespace *ns)
 { return 0; }
 static inline void unregister_ipcns_notifier(struct ipc_namespace *ns) { }
 static inline int ipcns_notify(unsigned long l) { return 0; }
+static inline void shm_destroy_orphaned(struct ipc_namespace *ns) {}
 #endif /* CONFIG_SYSVIPC */
 
 #ifdef CONFIG_POSIX_MQUEUE
diff --git a/include/linux/irq.h b/include/linux/irq.h
index baa397eb9c3..59517300a31 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -23,6 +23,7 @@
 #include <linux/errno.h>
 #include <linux/topology.h>
 #include <linux/wait.h>
+#include <linux/module.h>
 
 #include <asm/irq.h>
 #include <asm/ptrace.h>
@@ -96,11 +97,6 @@ enum {
 
 #define IRQ_NO_BALANCING_MASK   (IRQ_PER_CPU | IRQ_NO_BALANCING)
 
-static inline __deprecated bool CHECK_IRQ_PER_CPU(unsigned int status)
-{
-        return status & IRQ_PER_CPU;
-}
-
 /*
  * Return value for chip->irq_set_affinity()
  *
@@ -113,14 +109,18 @@ enum {
 };
 
 struct msi_desc;
+struct irq_domain;
 
 /**
  * struct irq_data - per irq and irq chip data passed down to chip functions
  * @irq:                interrupt number
+ * @hwirq:              hardware interrupt number, local to the interrupt domain
  * @node:               node index useful for balancing
  * @state_use_accessors: status information for irq chip functions.
  *                      Use accessor functions to deal with it
  * @chip:               low level interrupt hardware access
+ * @domain:             Interrupt translation domain; responsible for mapping
+ *                      between hwirq number and linux irq number.
  * @handler_data:       per-IRQ data for the irq_chip methods
  * @chip_data:          platform-specific per-chip private data for the chip
  *                      methods, to allow shared chip implementations
@@ -133,9 +133,11 @@ struct msi_desc;
  */
 struct irq_data {
         unsigned int            irq;
+        unsigned long           hwirq;
         unsigned int            node;
         unsigned int            state_use_accessors;
         struct irq_chip         *chip;
+        struct irq_domain       *domain;
         void                    *handler_data;
         void                    *chip_data;
         struct msi_desc         *msi_desc;
@@ -546,7 +548,15 @@ static inline struct msi_desc *irq_data_get_msi(struct irq_data *d)
         return d->msi_desc;
 }
 
-int irq_alloc_descs(int irq, unsigned int from, unsigned int cnt, int node);
+int __irq_alloc_descs(int irq, unsigned int from, unsigned int cnt, int node,
+                struct module *owner);
+
+static inline int irq_alloc_descs(int irq, unsigned int from, unsigned int cnt,
+                int node)
+{
+        return __irq_alloc_descs(irq, from, cnt, node, THIS_MODULE);
+}
+
 void irq_free_descs(unsigned int irq, unsigned int cnt);
 int irq_reserve_irqs(unsigned int from, unsigned int cnt);
 
diff --git a/include/linux/irqdesc.h b/include/linux/irqdesc.h
index 2d921b35212..150134ac709 100644
--- a/include/linux/irqdesc.h
+++ b/include/linux/irqdesc.h
@@ -66,6 +66,7 @@ struct irq_desc {
 #ifdef CONFIG_PROC_FS
         struct proc_dir_entry   *dir;
 #endif
+        struct module           *owner;
         const char              *name;
 } ____cacheline_internodealigned_in_smp;
 
diff --git a/include/linux/irqdomain.h b/include/linux/irqdomain.h
new file mode 100644
index 00000000000..3ad553e8eae
--- /dev/null
+++ b/include/linux/irqdomain.h
@@ -0,0 +1,92 @@
+/*
+ * irq_domain - IRQ translation domains
+ *
+ * Translation infrastructure between hw and linux irq numbers.  This is
+ * helpful for interrupt controllers to implement mapping between hardware
+ * irq numbers and the Linux irq number space.
+ *
+ * irq_domains also have a hook for translating device tree interrupt
+ * representation into a hardware irq number that can be mapped back to a
+ * Linux irq number without any extra platform support code.
+ *
+ * irq_domain is expected to be embedded in an interrupt controller's private
+ * data structure.
+ */
+#ifndef _LINUX_IRQDOMAIN_H
+#define _LINUX_IRQDOMAIN_H
+
+#include <linux/irq.h>
+#include <linux/mod_devicetable.h>
+
+#ifdef CONFIG_IRQ_DOMAIN
+struct device_node;
+struct irq_domain;
+
+/**
+ * struct irq_domain_ops - Methods for irq_domain objects
+ * @to_irq: (optional) given a local hardware irq number, return the linux
+ *          irq number.  If to_irq is not implemented, then the irq_domain
+ *          will use this translation: irq = (domain->irq_base + hwirq)
+ * @dt_translate: Given a device tree node and interrupt specifier, decode
+ *                the hardware irq number and linux irq type value.
+ */
+struct irq_domain_ops {
+        unsigned int (*to_irq)(struct irq_domain *d, unsigned long hwirq);
+
+#ifdef CONFIG_OF
+        int (*dt_translate)(struct irq_domain *d, struct device_node *node,
+                            const u32 *intspec, unsigned int intsize,
+                            unsigned long *out_hwirq, unsigned int *out_type);
+#endif /* CONFIG_OF */
+};
+
+/**
+ * struct irq_domain - Hardware interrupt number translation object
+ * @list: Element in global irq_domain list.
+ * @irq_base: Start of irq_desc range assigned to the irq_domain.  The creator
+ *            of the irq_domain is responsible for allocating the array of
+ *            irq_desc structures.
+ * @nr_irq: Number of irqs managed by the irq domain
+ * @ops: pointer to irq_domain methods
+ * @priv: private data pointer for use by owner.  Not touched by irq_domain
+ *        core code.
+ * @of_node: (optional) Pointer to device tree nodes associated with the
+ *           irq_domain.  Used when decoding device tree interrupt specifiers.
+ */
+struct irq_domain {
+        struct list_head list;
+        unsigned int irq_base;
+        unsigned int nr_irq;
+        const struct irq_domain_ops *ops;
+        void *priv;
+        struct device_node *of_node;
+};
+
+/**
+ * irq_domain_to_irq() - Translate from a hardware irq to a linux irq number
+ *
+ * Returns the linux irq number associated with a hardware irq.  By default,
+ * the mapping is irq == domain->irq_base + hwirq, but this mapping can
+ * be overridden if the irq_domain implements a .to_irq() hook.
+ */
+static inline unsigned int irq_domain_to_irq(struct irq_domain *d,
+                                             unsigned long hwirq)
+{
+        return d->ops->to_irq ? d->ops->to_irq(d, hwirq) : d->irq_base + hwirq;
+}
+
+extern void irq_domain_add(struct irq_domain *domain);
+extern void irq_domain_del(struct irq_domain *domain);
+#endif /* CONFIG_IRQ_DOMAIN */
+
+#if defined(CONFIG_IRQ_DOMAIN) && defined(CONFIG_OF_IRQ)
+extern struct irq_domain_ops irq_domain_simple_ops;
+extern void irq_domain_add_simple(struct device_node *controller, int irq_base);
+extern void irq_domain_generate_simple(const struct of_device_id *match,
+                                        u64 phys_base, unsigned int irq_start);
+#else /* CONFIG_IRQ_DOMAIN && CONFIG_OF_IRQ */
+static inline void irq_domain_generate_simple(const struct of_device_id *match,
+                                        u64 phys_base, unsigned int irq_start) { }
+#endif /* CONFIG_IRQ_DOMAIN && CONFIG_OF_IRQ */
+
+#endif /* _LINUX_IRQDOMAIN_H */
diff --git a/include/linux/iscsi_boot_sysfs.h b/include/linux/iscsi_boot_sysfs.h
index f1e6c184f14..f0a2f8b0aa1 100644
--- a/include/linux/iscsi_boot_sysfs.h
+++ b/include/linux/iscsi_boot_sysfs.h
@@ -92,6 +92,13 @@ struct iscsi_boot_kobj {
          * properties.
          */
         mode_t (*is_visible) (void *data, int type);
+
+        /*
+         * Driver specific release function.
+         *
+         * The function should free the data passed in.
+         */
+        void (*release) (void *data);
 };
 
 struct iscsi_boot_kset {
@@ -103,18 +110,21 @@ struct iscsi_boot_kobj *
 iscsi_boot_create_initiator(struct iscsi_boot_kset *boot_kset, int index,
                             void *data,
                             ssize_t (*show) (void *data, int type, char *buf),
-                            mode_t (*is_visible) (void *data, int type));
+                            mode_t (*is_visible) (void *data, int type),
+                            void (*release) (void *data));
 
 struct iscsi_boot_kobj *
 iscsi_boot_create_ethernet(struct iscsi_boot_kset *boot_kset, int index,
                            void *data,
                            ssize_t (*show) (void *data, int type, char *buf),
-                           mode_t (*is_visible) (void *data, int type));
+                           mode_t (*is_visible) (void *data, int type),
+                           void (*release) (void *data));
 struct iscsi_boot_kobj *
 iscsi_boot_create_target(struct iscsi_boot_kset *boot_kset, int index,
                          void *data,
                          ssize_t (*show) (void *data, int type, char *buf),
-                         mode_t (*is_visible) (void *data, int type));
+                         mode_t (*is_visible) (void *data, int type),
+                         void (*release) (void *data));
 
 struct iscsi_boot_kset *iscsi_boot_create_kset(const char *set_name);
 struct iscsi_boot_kset *iscsi_boot_create_host_kset(unsigned int hostno);
diff --git a/include/linux/jbd.h b/include/linux/jbd.h
index e06965081ba..e6a5e34bed4 100644
--- a/include/linux/jbd.h
+++ b/include/linux/jbd.h
@@ -940,7 +940,6 @@ extern int	   journal_force_commit(journal_t *);
  */
 struct journal_head *journal_add_journal_head(struct buffer_head *bh);
 struct journal_head *journal_grab_journal_head(struct buffer_head *bh);
-void journal_remove_journal_head(struct buffer_head *bh);
 void journal_put_journal_head(struct journal_head *jh);
 
 /*
diff --git a/include/linux/jbd2.h b/include/linux/jbd2.h
index d087c2e7b2a..38f307b8c33 100644
--- a/include/linux/jbd2.h
+++ b/include/linux/jbd2.h
@@ -1329,12 +1329,6 @@ extern int jbd_blocks_per_page(struct inode *inode);
 #define BUFFER_TRACE2(bh, bh2, info)    do {} while (0)
 #define JBUFFER_TRACE(jh, info) do {} while (0)
 
-/* 
- * jbd2_dev_to_name is a utility function used by the jbd2 and ext4 
- * tracing infrastructure to map a dev_t to a device name.
- */
-extern const char *jbd2_dev_to_name(dev_t device);
-
 #endif  /* __KERNEL__ */
 
 #endif  /* _LINUX_JBD2_H */
diff --git a/include/linux/jiffies.h b/include/linux/jiffies.h
index f97672a36fa..265e2c3cbd1 100644
--- a/include/linux/jiffies.h
+++ b/include/linux/jiffies.h
@@ -303,7 +303,7 @@ extern void jiffies_to_timespec(const unsigned long jiffies,
 extern unsigned long timeval_to_jiffies(const struct timeval *value);
 extern void jiffies_to_timeval(const unsigned long jiffies,
                                struct timeval *value);
-extern clock_t jiffies_to_clock_t(long x);
+extern clock_t jiffies_to_clock_t(unsigned long x);
 extern unsigned long clock_t_to_jiffies(unsigned long x);
 extern u64 jiffies_64_to_clock_t(u64 x);
 extern u64 nsec_to_clock_t(u64 x);
diff --git a/include/linux/journal-head.h b/include/linux/journal-head.h
index 44e95d0a721..423cb6d78ee 100644
--- a/include/linux/journal-head.h
+++ b/include/linux/journal-head.h
@@ -45,7 +45,7 @@ struct journal_head {
          * has been cowed
          * [jbd_lock_bh_state()]
          */
-        unsigned b_cow_tid;
+        tid_t b_cow_tid;
 
         /*
          * Copy of the buffer data frozen for writing to the log.
diff --git a/include/linux/jump_label.h b/include/linux/jump_label.h
index 83e745f3ead..66f23dc5e76 100644
--- a/include/linux/jump_label.h
+++ b/include/linux/jump_label.h
@@ -54,7 +54,7 @@ extern void jump_label_apply_nops(struct module *mod);
 
 #else
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 #define JUMP_LABEL_INIT {ATOMIC_INIT(0)}
 
diff --git a/include/linux/kconfig.h b/include/linux/kconfig.h
new file mode 100644
index 00000000000..067eda0e4b3
--- /dev/null
+++ b/include/linux/kconfig.h
@@ -0,0 +1,32 @@
+#ifndef __LINUX_KCONFIG_H
+#define __LINUX_KCONFIG_H
+
+#include <generated/autoconf.h>
+
+/*
+ * Helper macros to use CONFIG_ options in C expressions. Note that
+ * these only work with boolean and tristate options.
+ */
+
+/*
+ * IS_ENABLED(CONFIG_FOO) evaluates to 1 if CONFIG_FOO is set to 'y' or 'm',
+ * 0 otherwise.
+ *
+ */
+#define IS_ENABLED(option) \
+        (__enabled_ ## option || __enabled_ ## option ## _MODULE)
+
+/*
+ * IS_BUILTIN(CONFIG_FOO) evaluates to 1 if CONFIG_FOO is set to 'y', 0
+ * otherwise. For boolean options, this is equivalent to
+ * IS_ENABLED(CONFIG_FOO).
+ */
+#define IS_BUILTIN(option) __enabled_ ## option
+
+/*
+ * IS_MODULE(CONFIG_FOO) evaluates to 1 if CONFIG_FOO is set to 'm', 0
+ * otherwise.
+ */
+#define IS_MODULE(option) __enabled_ ## option ## _MODULE
+
+#endif /* __LINUX_KCONFIG_H */
diff --git a/include/linux/kdb.h b/include/linux/kdb.h
index aadff7cc2b8..529d9a0c75a 100644
--- a/include/linux/kdb.h
+++ b/include/linux/kdb.h
@@ -16,7 +16,7 @@
 #ifdef  CONFIG_KGDB_KDB
 #include <linux/init.h>
 #include <linux/sched.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 #define KDB_POLL_FUNC_MAX       5
 extern int kdb_poll_idx;
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 953352a8833..54bf5a471e1 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -56,6 +56,14 @@
 
 #define FIELD_SIZEOF(t, f) (sizeof(((t*)0)->f))
 #define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
+#define DIV_ROUND_UP_ULL(ll,d) \
+        ({ unsigned long long _tmp = (ll)+(d)-1; do_div(_tmp, d); _tmp; })
+
+#if BITS_PER_LONG == 32
+# define DIV_ROUND_UP_SECTOR_T(ll,d) DIV_ROUND_UP_ULL(ll, d)
+#else
+# define DIV_ROUND_UP_SECTOR_T(ll,d) DIV_ROUND_UP(ll,d)
+#endif
 
 /* The `const' in roundup() prevents gcc-3.3 from calling __divdi3 */
 #define roundup(x, y) (                                 \
@@ -121,7 +129,7 @@ extern int _cond_resched(void);
 # define might_resched() do { } while (0)
 #endif
 
-#ifdef CONFIG_DEBUG_SPINLOCK_SLEEP
+#ifdef CONFIG_DEBUG_ATOMIC_SLEEP
   void __might_sleep(const char *file, int line, int preempt_offset);
 /**
  * might_sleep - annotation for functions that can sleep
@@ -646,29 +654,6 @@ static inline void ftrace_dump(enum ftrace_dump_mode oops_dump_mode) { }
         const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
         (type *)( (char *)__mptr - offsetof(type,member) );})
 
-struct sysinfo;
-extern int do_sysinfo(struct sysinfo *info);
-
-#endif /* __KERNEL__ */
-
-#define SI_LOAD_SHIFT   16
-struct sysinfo {
-        long uptime;                    /* Seconds since boot */
-        unsigned long loads[3];         /* 1, 5, and 15 minute load averages */
-        unsigned long totalram;         /* Total usable main memory size */
-        unsigned long freeram;          /* Available memory size */
-        unsigned long sharedram;        /* Amount of shared memory */
-        unsigned long bufferram;        /* Memory used by buffers */
-        unsigned long totalswap;        /* Total swap space size */
-        unsigned long freeswap;         /* swap space still available */
-        unsigned short procs;           /* Number of current processes */
-        unsigned short pad;             /* explicit padding for m68k */
-        unsigned long totalhigh;        /* Total high memory size */
-        unsigned long freehigh;         /* Available high memory size */
-        unsigned int mem_unit;          /* Memory unit size in bytes */
-        char _f[20-2*sizeof(long)-sizeof(int)]; /* Padding: libc5 uses this.. */
-};
-
 #ifdef __CHECKER__
 #define BUILD_BUG_ON_NOT_POWER_OF_2(n)
 #define BUILD_BUG_ON_ZERO(e) (0)
@@ -736,4 +721,30 @@ extern int __build_bug_on_failed;
 # define REBUILD_DUE_TO_FTRACE_MCOUNT_RECORD
 #endif
 
+struct sysinfo;
+extern int do_sysinfo(struct sysinfo *info);
+
+#endif /* __KERNEL__ */
+
+#define SI_LOAD_SHIFT   16
+struct sysinfo {
+        long uptime;                    /* Seconds since boot */
+        unsigned long loads[3];         /* 1, 5, and 15 minute load averages */
+        unsigned long totalram;         /* Total usable main memory size */
+        unsigned long freeram;          /* Available memory size */
+        unsigned long sharedram;        /* Amount of shared memory */
+        unsigned long bufferram;        /* Memory used by buffers */
+        unsigned long totalswap;        /* Total swap space size */
+        unsigned long freeswap;         /* swap space still available */
+        unsigned short procs;           /* Number of current processes */
+        unsigned short pad;             /* explicit padding for m68k */
+        unsigned long totalhigh;        /* Total high memory size */
+        unsigned long freehigh;         /* Available high memory size */
+        unsigned int mem_unit;          /* Memory unit size in bytes */
+        char _f[20-2*sizeof(long)-sizeof(int)]; /* Padding: libc5 uses this.. */
+};
+
+/* To identify board information in panic logs, set this */
+extern char *mach_panic_string;
+
 #endif
diff --git a/include/linux/key.h b/include/linux/key.h
index 6ea4eebd346..183a6af7715 100644
--- a/include/linux/key.h
+++ b/include/linux/key.h
@@ -21,7 +21,7 @@
 #include <linux/rcupdate.h>
 #include <linux/sysctl.h>
 #include <linux/rwsem.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 #ifdef __KERNEL__
 
diff --git a/include/linux/keychord.h b/include/linux/keychord.h
new file mode 100644
index 00000000000..856a5850217
--- /dev/null
+++ b/include/linux/keychord.h
@@ -0,0 +1,52 @@
+/*
+ *  Key chord input driver
+ *
+ * Copyright (C) 2008 Google, Inc.
+ * Author: Mike Lockwood <lockwood@android.com>
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+*/
+
+#ifndef __LINUX_KEYCHORD_H_
+#define __LINUX_KEYCHORD_H_
+
+#include <linux/input.h>
+
+#define KEYCHORD_VERSION                1
+
+/*
+ * One or more input_keychord structs are written to /dev/keychord
+ * at once to specify the list of keychords to monitor.
+ * Reading /dev/keychord returns the id of a keychord when the
+ * keychord combination is pressed.  A keychord is signalled when
+ * all of the keys in the keycode list are in the pressed state.
+ * The order in which the keys are pressed does not matter.
+ * The keychord will not be signalled if keys not in the keycode
+ * list are pressed.
+ * Keychords will not be signalled on key release events.
+ */
+struct input_keychord {
+        /* should be KEYCHORD_VERSION */
+        __u16 version;
+        /*
+         * client specified ID, returned from read()
+         * when this keychord is pressed.
+         */
+        __u16 id;
+
+        /* number of keycodes in this keychord */
+        __u16 count;
+
+        /* variable length array of keycodes */
+        __u16 keycodes[];
+};
+
+#endif  /* __LINUX_KEYCHORD_H_ */
diff --git a/include/linux/keyreset.h b/include/linux/keyreset.h
new file mode 100644
index 00000000000..a2ac49e5b68
--- /dev/null
+++ b/include/linux/keyreset.h
@@ -0,0 +1,28 @@
+/*
+ * include/linux/keyreset.h - platform data structure for resetkeys driver
+ *
+ * Copyright (C) 2008 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _LINUX_KEYRESET_H
+#define _LINUX_KEYRESET_H
+
+#define KEYRESET_NAME "keyreset"
+
+struct keyreset_platform_data {
+        int (*reset_fn)(void);
+        int *keys_up;
+        int keys_down[]; /* 0 terminated */
+};
+
+#endif /* _LINUX_KEYRESET_H */
diff --git a/include/linux/kgdb.h b/include/linux/kgdb.h
index 10ca03d0a25..fa391835508 100644
--- a/include/linux/kgdb.h
+++ b/include/linux/kgdb.h
@@ -16,7 +16,7 @@
 #include <linux/serial_8250.h>
 #include <linux/linkage.h>
 #include <linux/init.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #ifdef CONFIG_HAVE_ARCH_KGDB
 #include <asm/kgdb.h>
 #endif
diff --git a/include/linux/kobject.h b/include/linux/kobject.h
index 9229b64ee3a..668729cc0fe 100644
--- a/include/linux/kobject.h
+++ b/include/linux/kobject.h
@@ -25,7 +25,7 @@
 #include <linux/kobject_ns.h>
 #include <linux/kernel.h>
 #include <linux/wait.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 #define UEVENT_HELPER_PATH_LEN          256
 #define UEVENT_NUM_ENVP                 32      /* number of env pointers */
diff --git a/include/linux/kvm.h b/include/linux/kvm.h
index 55ef181521f..aace6b8691a 100644
--- a/include/linux/kvm.h
+++ b/include/linux/kvm.h
@@ -161,6 +161,7 @@ struct kvm_pit_config {
 #define KVM_EXIT_NMI              16
 #define KVM_EXIT_INTERNAL_ERROR   17
 #define KVM_EXIT_OSI              18
+#define KVM_EXIT_PAPR_HCALL       19
 
 /* For KVM_EXIT_INTERNAL_ERROR */
 #define KVM_INTERNAL_ERROR_EMULATION 1
@@ -264,6 +265,11 @@ struct kvm_run {
                 struct {
                         __u64 gprs[32];
                 } osi;
+                struct {
+                        __u64 nr;
+                        __u64 ret;
+                        __u64 args[9];
+                } papr_hcall;
                 /* Fix the size of the union. */
                 char padding[256];
         };
@@ -544,6 +550,10 @@ struct kvm_ppc_pvinfo {
 #define KVM_CAP_TSC_CONTROL 60
 #define KVM_CAP_GET_TSC_KHZ 61
 #define KVM_CAP_PPC_BOOKE_SREGS 62
+#define KVM_CAP_SPAPR_TCE 63
+#define KVM_CAP_PPC_SMT 64
+#define KVM_CAP_PPC_RMA 65
+#define KVM_CAP_S390_GMAP 71
 
 #ifdef KVM_CAP_IRQ_ROUTING
 
@@ -746,6 +756,9 @@ struct kvm_clock_data {
 /* Available with KVM_CAP_XCRS */
 #define KVM_GET_XCRS              _IOR(KVMIO,  0xa6, struct kvm_xcrs)
 #define KVM_SET_XCRS              _IOW(KVMIO,  0xa7, struct kvm_xcrs)
+#define KVM_CREATE_SPAPR_TCE      _IOW(KVMIO,  0xa8, struct kvm_create_spapr_tce)
+/* Available with KVM_CAP_RMA */
+#define KVM_ALLOCATE_RMA          _IOR(KVMIO,  0xa9, struct kvm_allocate_rma)
 
 #define KVM_DEV_ASSIGN_ENABLE_IOMMU     (1 << 0)
 
@@ -773,20 +786,14 @@ struct kvm_assigned_pci_dev {
 
 struct kvm_assigned_irq {
         __u32 assigned_dev_id;
-        __u32 host_irq;
+        __u32 host_irq; /* ignored (legacy field) */
         __u32 guest_irq;
         __u32 flags;
         union {
-                struct {
-                        __u32 addr_lo;
-                        __u32 addr_hi;
-                        __u32 data;
-                } guest_msi;
                 __u32 reserved[12];
         };
 };
 
-
 struct kvm_assigned_msix_nr {
         __u32 assigned_dev_id;
         __u16 entry_nr;
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
index 31ebb59cbd2..eabb21a30c3 100644
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@ -47,6 +47,7 @@
 #define KVM_REQ_DEACTIVATE_FPU    10
 #define KVM_REQ_EVENT             11
 #define KVM_REQ_APF_HALT          12
+#define KVM_REQ_STEAL_UPDATE      13
 
 #define KVM_USERSPACE_IRQ_SOURCE_ID     0
 
@@ -326,12 +327,17 @@ static inline struct kvm_memslots *kvm_memslots(struct kvm *kvm)
 static inline int is_error_hpa(hpa_t hpa) { return hpa >> HPA_MSB; }
 
 extern struct page *bad_page;
+extern struct page *fault_page;
+
 extern pfn_t bad_pfn;
+extern pfn_t fault_pfn;
 
 int is_error_page(struct page *page);
 int is_error_pfn(pfn_t pfn);
 int is_hwpoison_pfn(pfn_t pfn);
 int is_fault_pfn(pfn_t pfn);
+int is_noslot_pfn(pfn_t pfn);
+int is_invalid_pfn(pfn_t pfn);
 int kvm_is_error_hva(unsigned long addr);
 int kvm_set_memory_region(struct kvm *kvm,
                           struct kvm_userspace_memory_region *mem,
@@ -381,6 +387,8 @@ int kvm_read_guest_page(struct kvm *kvm, gfn_t gfn, void *data, int offset,
 int kvm_read_guest_atomic(struct kvm *kvm, gpa_t gpa, void *data,
                           unsigned long len);
 int kvm_read_guest(struct kvm *kvm, gpa_t gpa, void *data, unsigned long len);
+int kvm_read_guest_cached(struct kvm *kvm, struct gfn_to_hva_cache *ghc,
+                           void *data, unsigned long len);
 int kvm_write_guest_page(struct kvm *kvm, gfn_t gfn, const void *data,
                          int offset, int len);
 int kvm_write_guest(struct kvm *kvm, gpa_t gpa, const void *data,
diff --git a/include/linux/led-lm3530.h b/include/linux/led-lm3530.h
index 58592fa67d2..8eb12357a11 100644
--- a/include/linux/led-lm3530.h
+++ b/include/linux/led-lm3530.h
@@ -84,6 +84,8 @@ enum lm3530_als_mode {
  * @brt_ramp_rise: rate of rise of led current
  * @als1_resistor_sel: internal resistance from ALS1 input to ground
  * @als2_resistor_sel: internal resistance from ALS2 input to ground
+ * @als_vmin: als input voltage calibrated for max brightness in mV
+ * @als_vmax: als input voltage calibrated for min brightness in mV
  * @brt_val: brightness value (0-255)
  */
 struct lm3530_platform_data {
@@ -101,6 +103,9 @@ struct lm3530_platform_data {
         u8 als1_resistor_sel;
         u8 als2_resistor_sel;
 
+        u32 als_vmin;
+        u32 als_vmax;
+
         u8 brt_val;
 };
 
diff --git a/include/linux/lglock.h b/include/linux/lglock.h
index f549056fb20..87f402ccec5 100644
--- a/include/linux/lglock.h
+++ b/include/linux/lglock.h
@@ -22,6 +22,7 @@
 #include <linux/spinlock.h>
 #include <linux/lockdep.h>
 #include <linux/percpu.h>
+#include <linux/cpu.h>
 
 /* can make br locks by using local lock for read side, global lock for write */
 #define br_lock_init(name)      name##_lock_init()
@@ -72,9 +73,31 @@
 
 #define DEFINE_LGLOCK(name)                                             \
                                                                         \
+ DEFINE_SPINLOCK(name##_cpu_lock);                                      \
+ cpumask_t name##_cpus __read_mostly;                                   \
  DEFINE_PER_CPU(arch_spinlock_t, name##_lock);                          \
  DEFINE_LGLOCK_LOCKDEP(name);                                           \
                                                                         \
+ static int                                                             \
+ name##_lg_cpu_callback(struct notifier_block *nb,                      \
+                                unsigned long action, void *hcpu)       \
+ {                                                                      \
+        switch (action & ~CPU_TASKS_FROZEN) {                           \
+        case CPU_UP_PREPARE:                                            \
+                spin_lock(&name##_cpu_lock);                            \
+                cpu_set((unsigned long)hcpu, name##_cpus);              \
+                spin_unlock(&name##_cpu_lock);                          \
+                break;                                                  \
+        case CPU_UP_CANCELED: case CPU_DEAD:                            \
+                spin_lock(&name##_cpu_lock);                            \
+                cpu_clear((unsigned long)hcpu, name##_cpus);            \
+                spin_unlock(&name##_cpu_lock);                          \
+        }                                                               \
+        return NOTIFY_OK;                                               \
+ }                                                                      \
+ static struct notifier_block name##_lg_cpu_notifier = {                \
+        .notifier_call = name##_lg_cpu_callback,                        \
+ };                                                                     \
  void name##_lock_init(void) {                                          \
         int i;                                                          \
         LOCKDEP_INIT_MAP(&name##_lock_dep_map, #name, &name##_lock_key, 0); \
@@ -83,6 +106,11 @@
                 lock = &per_cpu(name##_lock, i);                        \
                 *lock = (arch_spinlock_t)__ARCH_SPIN_LOCK_UNLOCKED;     \
         }                                                               \
+        register_hotcpu_notifier(&name##_lg_cpu_notifier);              \
+        get_online_cpus();                                              \
+        for_each_online_cpu(i)                                          \
+                cpu_set(i, name##_cpus);                                \
+        put_online_cpus();                                              \
  }                                                                      \
  EXPORT_SYMBOL(name##_lock_init);                                       \
                                                                         \
@@ -124,9 +152,9 @@
                                                                         \
  void name##_global_lock_online(void) {                                 \
         int i;                                                          \
-        preempt_disable();                                              \
+        spin_lock(&name##_cpu_lock);                                    \
         rwlock_acquire(&name##_lock_dep_map, 0, 0, _RET_IP_);           \
-        for_each_online_cpu(i) {                                        \
+        for_each_cpu(i, &name##_cpus) {                                 \
                 arch_spinlock_t *lock;                                  \
                 lock = &per_cpu(name##_lock, i);                        \
                 arch_spin_lock(lock);                                   \
@@ -137,12 +165,12 @@
  void name##_global_unlock_online(void) {                               \
         int i;                                                          \
         rwlock_release(&name##_lock_dep_map, 1, _RET_IP_);              \
-        for_each_online_cpu(i) {                                        \
+        for_each_cpu(i, &name##_cpus) {                                 \
                 arch_spinlock_t *lock;                                  \
                 lock = &per_cpu(name##_lock, i);                        \
                 arch_spin_unlock(lock);                                 \
         }                                                               \
-        preempt_enable();                                               \
+        spin_unlock(&name##_cpu_lock);                                  \
  }                                                                      \
  EXPORT_SYMBOL(name##_global_unlock_online);                            \
                                                                         \
diff --git a/include/linux/lguest.h b/include/linux/lguest.h
index 2fb1dcbcb5a..9962c6bb131 100644
--- a/include/linux/lguest.h
+++ b/include/linux/lguest.h
@@ -59,8 +59,6 @@ struct lguest_data {
         unsigned long reserve_mem;
         /* KHz for the TSC clock. */
         u32 tsc_khz;
-        /* Page where the top-level pagetable is */
-        unsigned long pgdir;
 
 /* Fields initialized by the Guest at boot: */
         /* Instruction range to suppress interrupts even if enabled */
diff --git a/include/linux/libata.h b/include/linux/libata.h
index 5a9926b3407..efd6f980076 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -74,6 +74,16 @@
 
 #define BPRINTK(fmt, args...) if (ap->flags & ATA_FLAG_DEBUGMSG) printk(KERN_ERR "%s: " fmt, __func__, ## args)
 
+#define ata_print_version_once(dev, version)                    \
+({                                                              \
+        static bool __print_once;                               \
+                                                                \
+        if (!__print_once) {                                    \
+                __print_once = true;                            \
+                ata_print_version(dev, version);                \
+        }                                                       \
+})
+
 /* NEW: debug levels */
 #define HAVE_LIBATA_MSG 1
 
@@ -1244,20 +1254,50 @@ static inline int sata_srst_pmp(struct ata_link *link)
 /*
  * printk helpers
  */
-#define ata_port_printk(ap, lv, fmt, args...) \
-        printk("%sata%u: "fmt, lv, (ap)->print_id , ##args)
-
-#define ata_link_printk(link, lv, fmt, args...) do { \
-        if (sata_pmp_attached((link)->ap) || (link)->ap->slave_link)    \
-                printk("%sata%u.%02u: "fmt, lv, (link)->ap->print_id,   \
-                       (link)->pmp , ##args); \
-        else \
-                printk("%sata%u: "fmt, lv, (link)->ap->print_id , ##args); \
-        } while(0)
-
-#define ata_dev_printk(dev, lv, fmt, args...) \
-        printk("%sata%u.%02u: "fmt, lv, (dev)->link->ap->print_id,      \
-               (dev)->link->pmp + (dev)->devno , ##args)
+__attribute__((format (printf, 3, 4)))
+int ata_port_printk(const struct ata_port *ap, const char *level,
+                    const char *fmt, ...);
+__attribute__((format (printf, 3, 4)))
+int ata_link_printk(const struct ata_link *link, const char *level,
+                    const char *fmt, ...);
+__attribute__((format (printf, 3, 4)))
+int ata_dev_printk(const struct ata_device *dev, const char *level,
+                   const char *fmt, ...);
+
+#define ata_port_err(ap, fmt, ...)                              \
+        ata_port_printk(ap, KERN_ERR, fmt, ##__VA_ARGS__)
+#define ata_port_warn(ap, fmt, ...)                             \
+        ata_port_printk(ap, KERN_WARNING, fmt, ##__VA_ARGS__)
+#define ata_port_notice(ap, fmt, ...)                           \
+        ata_port_printk(ap, KERN_NOTICE, fmt, ##__VA_ARGS__)
+#define ata_port_info(ap, fmt, ...)                             \
+        ata_port_printk(ap, KERN_INFO, fmt, ##__VA_ARGS__)
+#define ata_port_dbg(ap, fmt, ...)                              \
+        ata_port_printk(ap, KERN_DEBUG, fmt, ##__VA_ARGS__)
+
+#define ata_link_err(link, fmt, ...)                            \
+        ata_link_printk(link, KERN_ERR, fmt, ##__VA_ARGS__)
+#define ata_link_warn(link, fmt, ...)                           \
+        ata_link_printk(link, KERN_WARNING, fmt, ##__VA_ARGS__)
+#define ata_link_notice(link, fmt, ...)                         \
+        ata_link_printk(link, KERN_NOTICE, fmt, ##__VA_ARGS__)
+#define ata_link_info(link, fmt, ...)                           \
+        ata_link_printk(link, KERN_INFO, fmt, ##__VA_ARGS__)
+#define ata_link_dbg(link, fmt, ...)                            \
+        ata_link_printk(link, KERN_DEBUG, fmt, ##__VA_ARGS__)
+
+#define ata_dev_err(dev, fmt, ...)                              \
+        ata_dev_printk(dev, KERN_ERR, fmt, ##__VA_ARGS__)
+#define ata_dev_warn(dev, fmt, ...)                             \
+        ata_dev_printk(dev, KERN_WARNING, fmt, ##__VA_ARGS__)
+#define ata_dev_notice(dev, fmt, ...)                           \
+        ata_dev_printk(dev, KERN_NOTICE, fmt, ##__VA_ARGS__)
+#define ata_dev_info(dev, fmt, ...)                             \
+        ata_dev_printk(dev, KERN_INFO, fmt, ##__VA_ARGS__)
+#define ata_dev_dbg(dev, fmt, ...)                              \
+        ata_dev_printk(dev, KERN_DEBUG, fmt, ##__VA_ARGS__)
+
+void ata_print_version(const struct device *dev, const char *version);
 
 /*
  * ata_eh_info helpers
diff --git a/include/linux/lightsensor.h b/include/linux/lightsensor.h
new file mode 100644
index 00000000000..7a87853ac06
--- /dev/null
+++ b/include/linux/lightsensor.h
@@ -0,0 +1,28 @@
+/* include/linux/lightsensor.h
+ *
+ * Copyright (C) 2011 Capella Microsystems Inc.
+ * Author: Frank Hsieh <pengyueh@gmail.com>
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef __LINUX_LIGHTSENSOR_H
+#define __LINUX_LIGHTSENSOR_H
+
+#include <linux/types.h>
+#include <linux/ioctl.h>
+
+#define LIGHTSENSOR_IOCTL_MAGIC         'l'
+
+#define LIGHTSENSOR_IOCTL_GET_ENABLED   _IOR(LIGHTSENSOR_IOCTL_MAGIC, 1, int *)
+#define LIGHTSENSOR_IOCTL_ENABLE        _IOW(LIGHTSENSOR_IOCTL_MAGIC, 2, int *)
+
+#endif
diff --git a/include/linux/llist.h b/include/linux/llist.h
new file mode 100644
index 00000000000..aa0c8b5b3cd
--- /dev/null
+++ b/include/linux/llist.h
@@ -0,0 +1,126 @@
+#ifndef LLIST_H
+#define LLIST_H
+/*
+ * Lock-less NULL terminated single linked list
+ *
+ * If there are multiple producers and multiple consumers, llist_add
+ * can be used in producers and llist_del_all can be used in
+ * consumers.  They can work simultaneously without lock.  But
+ * llist_del_first can not be used here.  Because llist_del_first
+ * depends on list->first->next does not changed if list->first is not
+ * changed during its operation, but llist_del_first, llist_add,
+ * llist_add (or llist_del_all, llist_add, llist_add) sequence in
+ * another consumer may violate that.
+ *
+ * If there are multiple producers and one consumer, llist_add can be
+ * used in producers and llist_del_all or llist_del_first can be used
+ * in the consumer.
+ *
+ * This can be summarized as follow:
+ *
+ *           |   add    | del_first |  del_all
+ * add       |    -     |     -     |     -
+ * del_first |          |     L     |     L
+ * del_all   |          |           |     -
+ *
+ * Where "-" stands for no lock is needed, while "L" stands for lock
+ * is needed.
+ *
+ * The list entries deleted via llist_del_all can be traversed with
+ * traversing function such as llist_for_each etc.  But the list
+ * entries can not be traversed safely before deleted from the list.
+ * The order of deleted entries is from the newest to the oldest added
+ * one.  If you want to traverse from the oldest to the newest, you
+ * must reverse the order by yourself before traversing.
+ *
+ * The basic atomic operation of this list is cmpxchg on long.  On
+ * architectures that don't have NMI-safe cmpxchg implementation, the
+ * list can NOT be used in NMI handler.  So code uses the list in NMI
+ * handler should depend on CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG.
+ */
+
+struct llist_head {
+        struct llist_node *first;
+};
+
+struct llist_node {
+        struct llist_node *next;
+};
+
+#define LLIST_HEAD_INIT(name)   { NULL }
+#define LLIST_HEAD(name)        struct llist_head name = LLIST_HEAD_INIT(name)
+
+/**
+ * init_llist_head - initialize lock-less list head
+ * @head:       the head for your lock-less list
+ */
+static inline void init_llist_head(struct llist_head *list)
+{
+        list->first = NULL;
+}
+
+/**
+ * llist_entry - get the struct of this entry
+ * @ptr:        the &struct llist_node pointer.
+ * @type:       the type of the struct this is embedded in.
+ * @member:     the name of the llist_node within the struct.
+ */
+#define llist_entry(ptr, type, member)          \
+        container_of(ptr, type, member)
+
+/**
+ * llist_for_each - iterate over some deleted entries of a lock-less list
+ * @pos:        the &struct llist_node to use as a loop cursor
+ * @node:       the first entry of deleted list entries
+ *
+ * In general, some entries of the lock-less list can be traversed
+ * safely only after being deleted from list, so start with an entry
+ * instead of list head.
+ *
+ * If being used on entries deleted from lock-less list directly, the
+ * traverse order is from the newest to the oldest added entry.  If
+ * you want to traverse from the oldest to the newest, you must
+ * reverse the order by yourself before traversing.
+ */
+#define llist_for_each(pos, node)                       \
+        for ((pos) = (node); pos; (pos) = (pos)->next)
+
+/**
+ * llist_for_each_entry - iterate over some deleted entries of lock-less list of given type
+ * @pos:        the type * to use as a loop cursor.
+ * @node:       the fist entry of deleted list entries.
+ * @member:     the name of the llist_node with the struct.
+ *
+ * In general, some entries of the lock-less list can be traversed
+ * safely only after being removed from list, so start with an entry
+ * instead of list head.
+ *
+ * If being used on entries deleted from lock-less list directly, the
+ * traverse order is from the newest to the oldest added entry.  If
+ * you want to traverse from the oldest to the newest, you must
+ * reverse the order by yourself before traversing.
+ */
+#define llist_for_each_entry(pos, node, member)                         \
+        for ((pos) = llist_entry((node), typeof(*(pos)), member);       \
+             &(pos)->member != NULL;                                    \
+             (pos) = llist_entry((pos)->member.next, typeof(*(pos)), member))
+
+/**
+ * llist_empty - tests whether a lock-less list is empty
+ * @head:       the list to test
+ *
+ * Not guaranteed to be accurate or up to date.  Just a quick way to
+ * test whether the list is empty without deleting something from the
+ * list.
+ */
+static inline int llist_empty(const struct llist_head *head)
+{
+        return ACCESS_ONCE(head->first) == NULL;
+}
+
+void llist_add(struct llist_node *new, struct llist_head *head);
+void llist_add_batch(struct llist_node *new_first, struct llist_node *new_last,
+                     struct llist_head *head);
+struct llist_node *llist_del_first(struct llist_head *head);
+struct llist_node *llist_del_all(struct llist_head *head);
+#endif /* LLIST_H */
diff --git a/include/linux/log2.h b/include/linux/log2.h
index 25b808631cd..fd7ff3d91e6 100644
--- a/include/linux/log2.h
+++ b/include/linux/log2.h
@@ -185,7 +185,6 @@ unsigned long __rounddown_pow_of_two(unsigned long n)
 #define rounddown_pow_of_two(n)                 \
 (                                               \
         __builtin_constant_p(n) ? (             \
-                (n == 1) ? 0 :                  \
                 (1UL << ilog2(n))) :            \
         __rounddown_pow_of_two(n)               \
  )
diff --git a/include/linux/loop.h b/include/linux/loop.h
index 66c194e2d9b..683d6989011 100644
--- a/include/linux/loop.h
+++ b/include/linux/loop.h
@@ -64,7 +64,6 @@ struct loop_device {
 
         struct request_queue    *lo_queue;
         struct gendisk          *lo_disk;
-        struct list_head        lo_list;
 };
 
 #endif /* __KERNEL__ */
@@ -161,4 +160,8 @@ int loop_unregister_transfer(int number);
 #define LOOP_CHANGE_FD          0x4C06
 #define LOOP_SET_CAPACITY       0x4C07
 
+/* /dev/loop-control interface */
+#define LOOP_CTL_ADD            0x4C80
+#define LOOP_CTL_REMOVE         0x4C81
+#define LOOP_CTL_GET_FREE       0x4C82
 #endif
diff --git a/include/linux/max17048_battery.h b/include/linux/max17048_battery.h
new file mode 100644
index 00000000000..d997082fb5a
--- /dev/null
+++ b/include/linux/max17048_battery.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2009 Samsung Electronics
+ * Copyright (C) 2012 Nvidia Cooperation
+ * Minkyu Kang <mk7.kang@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef __MAX17048_BATTERY_H_
+#define __MAX17048_BATTERY_H_
+#include <linux/smb349-charger.h>
+
+struct max17048_battery_model {
+        uint8_t rcomp;
+        uint8_t soccheck_A;
+        uint8_t soccheck_B;
+        uint8_t bits;
+        uint8_t alert_threshold;
+        uint8_t one_percent_alerts;
+        uint8_t alert_on_reset;
+        uint16_t rcomp_seg;
+        uint16_t hibernate;
+        uint16_t vreset;
+        uint16_t valert;
+        uint16_t ocvtest;
+};
+
+struct max17048_platform_data {
+        int (*battery_online)(void);
+        int (*charging_status)(void);
+        int (*charger_online)(void);
+};
+#endif
diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h
index 50940da6adf..b9c1c06cd7a 100644
--- a/include/linux/memcontrol.h
+++ b/include/linux/memcontrol.h
@@ -76,8 +76,6 @@ extern void mem_cgroup_uncharge_end(void);
 
 extern void mem_cgroup_uncharge_page(struct page *page);
 extern void mem_cgroup_uncharge_cache_page(struct page *page);
-extern int mem_cgroup_shmem_charge_fallback(struct page *page,
-                        struct mm_struct *mm, gfp_t gfp_mask);
 
 extern void mem_cgroup_out_of_memory(struct mem_cgroup *mem, gfp_t gfp_mask);
 int task_in_mem_cgroup(struct task_struct *task, const struct mem_cgroup *mem);
@@ -111,14 +109,15 @@ int mem_cgroup_inactive_anon_is_low(struct mem_cgroup *memcg);
 int mem_cgroup_inactive_file_is_low(struct mem_cgroup *memcg);
 int mem_cgroup_select_victim_node(struct mem_cgroup *memcg);
 unsigned long mem_cgroup_zone_nr_lru_pages(struct mem_cgroup *memcg,
-                                                struct zone *zone,
-                                                enum lru_list lru);
+                                        int nid, int zid, unsigned int lrumask);
 struct zone_reclaim_stat *mem_cgroup_get_reclaim_stat(struct mem_cgroup *memcg,
                                                       struct zone *zone);
 struct zone_reclaim_stat*
 mem_cgroup_get_reclaim_stat_from_page(struct page *page);
 extern void mem_cgroup_print_oom_info(struct mem_cgroup *memcg,
                                         struct task_struct *p);
+extern void mem_cgroup_replace_page_cache(struct page *oldpage,
+                                        struct page *newpage);
 
 #ifdef CONFIG_CGROUP_MEM_RES_CTLR_SWAP
 extern int do_swap_account;
@@ -207,12 +206,6 @@ static inline void mem_cgroup_uncharge_cache_page(struct page *page)
 {
 }
 
-static inline int mem_cgroup_shmem_charge_fallback(struct page *page,
-                        struct mm_struct *mm, gfp_t gfp_mask)
-{
-        return 0;
-}
-
 static inline void mem_cgroup_add_lru_list(struct page *page, int lru)
 {
 }
@@ -313,8 +306,8 @@ mem_cgroup_inactive_file_is_low(struct mem_cgroup *memcg)
 }
 
 static inline unsigned long
-mem_cgroup_zone_nr_lru_pages(struct mem_cgroup *memcg, struct zone *zone,
-                             enum lru_list lru)
+mem_cgroup_zone_nr_lru_pages(struct mem_cgroup *memcg, int nid, int zid,
+                                unsigned int lru_mask)
 {
         return 0;
 }
@@ -370,6 +363,10 @@ static inline
 void mem_cgroup_count_vm_event(struct mm_struct *mm, enum vm_event_item idx)
 {
 }
+static inline void mem_cgroup_replace_page_cache(struct page *oldpage,
+                                struct page *newpage)
+{
+}
 #endif /* CONFIG_CGROUP_MEM_CONT */
 
 #if !defined(CONFIG_CGROUP_MEM_RES_CTLR) || !defined(CONFIG_DEBUG_VM)
diff --git a/include/linux/memory_hotplug.h b/include/linux/memory_hotplug.h
index 8122018d300..0b8e2a74260 100644
--- a/include/linux/memory_hotplug.h
+++ b/include/linux/memory_hotplug.h
@@ -68,12 +68,19 @@ static inline void zone_seqlock_init(struct zone *zone)
 extern int zone_grow_free_lists(struct zone *zone, unsigned long new_nr_pages);
 extern int zone_grow_waitqueues(struct zone *zone, unsigned long nr_pages);
 extern int add_one_highpage(struct page *page, int pfn, int bad_ppro);
-/* need some defines for these for archs that don't support it */
-extern void online_page(struct page *page);
 /* VM interface that may be used by firmware interface */
 extern int online_pages(unsigned long, unsigned long);
 extern void __offline_isolated_pages(unsigned long, unsigned long);
 
+typedef void (*online_page_callback_t)(struct page *page);
+
+extern int set_online_page_callback(online_page_callback_t callback);
+extern int restore_online_page_callback(online_page_callback_t callback);
+
+extern void __online_page_set_limits(struct page *page);
+extern void __online_page_increment_counters(struct page *page);
+extern void __online_page_free(struct page *page);
+
 #ifdef CONFIG_MEMORY_HOTREMOVE
 extern bool is_pageblock_removable_nolock(struct page *page);
 #endif /* CONFIG_MEMORY_HOTREMOVE */
diff --git a/include/linux/mfd/aat2870.h b/include/linux/mfd/aat2870.h
new file mode 100644
index 00000000000..f7316c29bde
--- /dev/null
+++ b/include/linux/mfd/aat2870.h
@@ -0,0 +1,181 @@
+/*
+ * linux/include/linux/mfd/aat2870.h
+ *
+ * Copyright (c) 2011, NVIDIA Corporation.
+ * Author: Jin Park <jinyoungp@nvidia.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ */
+
+#ifndef __LINUX_MFD_AAT2870_H
+#define __LINUX_MFD_AAT2870_H
+
+#include <linux/debugfs.h>
+#include <linux/i2c.h>
+
+/* Register offsets */
+#define AAT2870_BL_CH_EN        0x00
+#define AAT2870_BLM             0x01
+#define AAT2870_BLS             0x02
+#define AAT2870_BL1             0x03
+#define AAT2870_BL2             0x04
+#define AAT2870_BL3             0x05
+#define AAT2870_BL4             0x06
+#define AAT2870_BL5             0x07
+#define AAT2870_BL6             0x08
+#define AAT2870_BL7             0x09
+#define AAT2870_BL8             0x0A
+#define AAT2870_FLR             0x0B
+#define AAT2870_FM              0x0C
+#define AAT2870_FS              0x0D
+#define AAT2870_ALS_CFG0        0x0E
+#define AAT2870_ALS_CFG1        0x0F
+#define AAT2870_ALS_CFG2        0x10
+#define AAT2870_AMB             0x11
+#define AAT2870_ALS0            0x12
+#define AAT2870_ALS1            0x13
+#define AAT2870_ALS2            0x14
+#define AAT2870_ALS3            0x15
+#define AAT2870_ALS4            0x16
+#define AAT2870_ALS5            0x17
+#define AAT2870_ALS6            0x18
+#define AAT2870_ALS7            0x19
+#define AAT2870_ALS8            0x1A
+#define AAT2870_ALS9            0x1B
+#define AAT2870_ALSA            0x1C
+#define AAT2870_ALSB            0x1D
+#define AAT2870_ALSC            0x1E
+#define AAT2870_ALSD            0x1F
+#define AAT2870_ALSE            0x20
+#define AAT2870_ALSF            0x21
+#define AAT2870_SUB_SET         0x22
+#define AAT2870_SUB_CTRL        0x23
+#define AAT2870_LDO_AB          0x24
+#define AAT2870_LDO_CD          0x25
+#define AAT2870_LDO_EN          0x26
+#define AAT2870_REG_NUM         0x27
+
+/* Device IDs */
+enum aat2870_id {
+        AAT2870_ID_BL,
+        AAT2870_ID_LDOA,
+        AAT2870_ID_LDOB,
+        AAT2870_ID_LDOC,
+        AAT2870_ID_LDOD
+};
+
+/* Backlight channels */
+#define AAT2870_BL_CH1          0x01
+#define AAT2870_BL_CH2          0x02
+#define AAT2870_BL_CH3          0x04
+#define AAT2870_BL_CH4          0x08
+#define AAT2870_BL_CH5          0x10
+#define AAT2870_BL_CH6          0x20
+#define AAT2870_BL_CH7          0x40
+#define AAT2870_BL_CH8          0x80
+#define AAT2870_BL_CH_ALL       0xFF
+
+/* Backlight current magnitude (mA) */
+enum aat2870_current {
+        AAT2870_CURRENT_0_45 = 1,
+        AAT2870_CURRENT_0_90,
+        AAT2870_CURRENT_1_80,
+        AAT2870_CURRENT_2_70,
+        AAT2870_CURRENT_3_60,
+        AAT2870_CURRENT_4_50,
+        AAT2870_CURRENT_5_40,
+        AAT2870_CURRENT_6_30,
+        AAT2870_CURRENT_7_20,
+        AAT2870_CURRENT_8_10,
+        AAT2870_CURRENT_9_00,
+        AAT2870_CURRENT_9_90,
+        AAT2870_CURRENT_10_8,
+        AAT2870_CURRENT_11_7,
+        AAT2870_CURRENT_12_6,
+        AAT2870_CURRENT_13_5,
+        AAT2870_CURRENT_14_4,
+        AAT2870_CURRENT_15_3,
+        AAT2870_CURRENT_16_2,
+        AAT2870_CURRENT_17_1,
+        AAT2870_CURRENT_18_0,
+        AAT2870_CURRENT_18_9,
+        AAT2870_CURRENT_19_8,
+        AAT2870_CURRENT_20_7,
+        AAT2870_CURRENT_21_6,
+        AAT2870_CURRENT_22_5,
+        AAT2870_CURRENT_23_4,
+        AAT2870_CURRENT_24_3,
+        AAT2870_CURRENT_25_2,
+        AAT2870_CURRENT_26_1,
+        AAT2870_CURRENT_27_0,
+        AAT2870_CURRENT_27_9
+};
+
+struct aat2870_register {
+        bool readable;
+        bool writeable;
+        u8 value;
+};
+
+struct aat2870_data {
+        struct device *dev;
+        struct i2c_client *client;
+
+        struct mutex io_lock;
+        struct aat2870_register *reg_cache; /* register cache */
+        int en_pin; /* enable GPIO pin (if < 0, ignore this value) */
+        bool is_enable;
+
+        /* init and uninit for platform specified */
+        int (*init)(struct aat2870_data *aat2870);
+        void (*uninit)(struct aat2870_data *aat2870);
+
+        /* i2c io funcntions */
+        int (*read)(struct aat2870_data *aat2870, u8 addr, u8 *val);
+        int (*write)(struct aat2870_data *aat2870, u8 addr, u8 val);
+        int (*update)(struct aat2870_data *aat2870, u8 addr, u8 mask, u8 val);
+
+        /* for debugfs */
+        struct dentry *dentry_root;
+        struct dentry *dentry_reg;
+};
+
+struct aat2870_subdev_info {
+        int id;
+        const char *name;
+        void *platform_data;
+};
+
+struct aat2870_platform_data {
+        int en_pin; /* enable GPIO pin (if < 0, ignore this value) */
+
+        struct aat2870_subdev_info *subdevs;
+        int num_subdevs;
+
+        /* init and uninit for platform specified */
+        int (*init)(struct aat2870_data *aat2870);
+        void (*uninit)(struct aat2870_data *aat2870);
+};
+
+struct aat2870_bl_platform_data {
+        /* backlight channels, default is AAT2870_BL_CH_ALL */
+        int channels;
+        /* backlight current magnitude, default is AAT2870_CURRENT_27_9 */
+        int max_current;
+        /* maximum brightness, default is 255 */
+        int max_brightness;
+};
+
+#endif /* __LINUX_MFD_AAT2870_H */
diff --git a/include/linux/mfd/ab8500.h b/include/linux/mfd/ab8500.h
index b3184307519..838c6b487cc 100644
--- a/include/linux/mfd/ab8500.h
+++ b/include/linux/mfd/ab8500.h
@@ -28,6 +28,7 @@
 #define AB8500_INTERRUPT        0xE
 #define AB8500_RTC              0xF
 #define AB8500_MISC             0x10
+#define AB8500_DEVELOPMENT      0x11
 #define AB8500_DEBUG            0x12
 #define AB8500_PROD_TEST        0x13
 #define AB8500_OTP_EMUL         0x15
@@ -74,13 +75,6 @@
 #define AB8500_INT_ACC_DETECT_21DB_F    37
 #define AB8500_INT_ACC_DETECT_21DB_R    38
 #define AB8500_INT_GP_SW_ADC_CONV_END   39
-#define AB8500_INT_ACC_DETECT_1DB_F     33
-#define AB8500_INT_ACC_DETECT_1DB_R     34
-#define AB8500_INT_ACC_DETECT_22DB_F    35
-#define AB8500_INT_ACC_DETECT_22DB_R    36
-#define AB8500_INT_ACC_DETECT_21DB_F    37
-#define AB8500_INT_ACC_DETECT_21DB_R    38
-#define AB8500_INT_GP_SW_ADC_CONV_END   39
 #define AB8500_INT_GPIO6R               40
 #define AB8500_INT_GPIO7R               41
 #define AB8500_INT_GPIO8R               42
diff --git a/include/linux/mfd/max77663-core.h b/include/linux/mfd/max77663-core.h
new file mode 100644
index 00000000000..acfe22aac53
--- /dev/null
+++ b/include/linux/mfd/max77663-core.h
@@ -0,0 +1,178 @@
+/*
+ * include/linux/mfd/max77663-core.h
+ *
+ * Copyright 2011 Maxim Integrated Products, Inc.
+ * Copyright (C) 2011-2012 NVIDIA Corporation
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ */
+
+#ifndef __LINUX_MFD_MAX77663_CORE_H__
+#define __LINUX_MFD_MAX77663_CORE_H__
+
+#include <linux/irq.h>
+#include <linux/mfd/core.h>
+
+/*
+ * Interrupts
+ */
+enum {
+        MAX77663_IRQ_LBT_LB,            /* Low-Battery */
+        MAX77663_IRQ_LBT_THERM_ALRM1,   /* Thermal alarm status, > 120C */
+        MAX77663_IRQ_LBT_THERM_ALRM2,   /* Thermal alarm status, > 140C */
+
+        MAX77663_IRQ_GPIO0,             /* GPIO0 edge detection */
+        MAX77663_IRQ_GPIO1,             /* GPIO1 edge detection */
+        MAX77663_IRQ_GPIO2,             /* GPIO2 edge detection */
+        MAX77663_IRQ_GPIO3,             /* GPIO3 edge detection */
+        MAX77663_IRQ_GPIO4,             /* GPIO4 edge detection */
+        MAX77663_IRQ_GPIO5,             /* GPIO5 edge detection */
+        MAX77663_IRQ_GPIO6,             /* GPIO6 edge detection */
+        MAX77663_IRQ_GPIO7,             /* GPIO7 edge detection */
+
+        MAX77663_IRQ_ONOFF_HRDPOWRN,    /* Hard power off warnning */
+        MAX77663_IRQ_ONOFF_EN0_1SEC,    /* EN0 active for 1s */
+        MAX77663_IRQ_ONOFF_EN0_FALLING, /* EN0 falling */
+        MAX77663_IRQ_ONOFF_EN0_RISING,  /* EN0 rising */
+        MAX77663_IRQ_ONOFF_LID_FALLING, /* LID falling */
+        MAX77663_IRQ_ONOFF_LID_RISING,  /* LID rising */
+        MAX77663_IRQ_ONOFF_ACOK_FALLING,/* ACOK falling */
+        MAX77663_IRQ_ONOFF_ACOK_RISING, /* ACOK rising */
+
+        MAX77663_IRQ_RTC,               /* RTC */
+        MAX77663_IRQ_SD_PF,             /* SD power fail */
+        MAX77663_IRQ_LDO_PF,            /* LDO power fail */
+        MAX77663_IRQ_32K,               /* 32kHz oscillator */
+        MAX77663_IRQ_NVER,              /* Non-Volatile Event Recorder */
+
+        MAX77663_IRQ_NR,
+};
+
+/*
+ *GPIOs
+ */
+enum {
+        MAX77663_GPIO0,
+        MAX77663_GPIO1,
+        MAX77663_GPIO2,
+        MAX77663_GPIO3,
+        MAX77663_GPIO4,
+        MAX77663_GPIO5,
+        MAX77663_GPIO6,
+        MAX77663_GPIO7,
+
+        MAX77663_GPIO_NR,
+};
+
+/* Direction */
+enum max77663_gpio_dir {
+        GPIO_DIR_DEF,
+        GPIO_DIR_IN,
+        GPIO_DIR_OUT,
+};
+
+/* Data output */
+enum max77663_gpio_data_out {
+        GPIO_DOUT_DEF,
+        GPIO_DOUT_HIGH,
+        GPIO_DOUT_LOW,
+};
+
+/* Output drive */
+enum max77663_gpio_out_drv {
+        GPIO_OUT_DRV_DEF,
+        GPIO_OUT_DRV_PUSH_PULL,
+        GPIO_OUT_DRV_OPEN_DRAIN,
+};
+
+/* Pull-up */
+enum max77663_gpio_pull_up {
+        GPIO_PU_DEF,
+        GPIO_PU_ENABLE,
+        GPIO_PU_DISABLE,
+};
+
+/* Pull-down */
+enum max77663_gpio_pull_down {
+        GPIO_PD_DEF,
+        GPIO_PD_ENABLE,
+        GPIO_PD_DISABLE,
+};
+
+/* Alternate */
+enum max77663_gpio_alt {
+        GPIO_ALT_DEF,
+        GPIO_ALT_ENABLE,
+        GPIO_ALT_DISABLE,
+};
+
+/*
+ * Flags
+ */
+#define SLP_LPM_ENABLE          0x01
+
+struct max77663_gpio_config {
+        int gpio;       /* gpio number */
+        enum max77663_gpio_dir dir;
+        enum max77663_gpio_data_out dout;
+        enum max77663_gpio_out_drv out_drv;
+        enum max77663_gpio_pull_up pull_up;
+        enum max77663_gpio_pull_down pull_down;
+        enum max77663_gpio_alt alternate;
+};
+
+struct max77663_platform_data {
+        int irq_base;
+        int gpio_base;
+
+        int num_gpio_cfgs;
+        struct max77663_gpio_config *gpio_cfgs;
+
+        int num_subdevs;
+        struct mfd_cell *sub_devices;
+
+        unsigned int flags;
+
+        unsigned char rtc_i2c_addr;
+
+        bool use_power_off;
+};
+
+#if defined(CONFIG_MFD_MAX77663)
+int max77663_read(struct device *dev, u8 addr, void *values, u32 len,
+                  bool is_rtc);
+int max77663_write(struct device *dev, u8 addr, void *values, u32 len,
+                   bool is_rtc);
+int max77663_set_bits(struct device *dev, u8 addr, u8 mask, u8 value,
+                      bool is_rtc);
+int max77663_gpio_set_alternate(int gpio, int alternate);
+#else
+static inline int max77663_read(struct device *dev, u8 addr, void *values,
+                                u32 len, bool is_rtc)
+{
+        return 0;
+}
+
+static inline int max77663_write(struct device *dev, u8 addr, void *values,
+                                 u32 len, bool is_rtc)
+{
+        return 0;
+}
+
+static inline int max77663_set_bits(struct device *dev, u8 addr, u8 mask,
+                                    u8 value, bool is_rtc)
+{
+        return 0;
+}
+
+static inline int max77663_gpio_set_alternate(int gpio, int alternate)
+{
+        return 0;
+}
+#endif /* defined(CONFIG_MFD_MAX77663) */
+
+#endif /* __LINUX_MFD_MAX77663_CORE_H__ */
diff --git a/include/linux/mfd/max8907c.h b/include/linux/mfd/max8907c.h
new file mode 100644
index 00000000000..48014b0485c
--- /dev/null
+++ b/include/linux/mfd/max8907c.h
@@ -0,0 +1,259 @@
+/* linux/mfd/max8907c.h
+ *
+ * Functions to access MAX8907C power management chip.
+ *
+ * Copyright (C) 2010 Gyungoh Yoo <jack.yoo@maxim-ic.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef __LINUX_MFD_MAX8907C_H
+#define __LINUX_MFD_MAX8907C_H
+
+/* MAX8907C register map */
+#define MAX8907C_REG_SYSENSEL               0x00
+#define MAX8907C_REG_ON_OFF_IRQ1            0x01
+#define MAX8907C_REG_ON_OFF_IRQ1_MASK       0x02
+#define MAX8907C_REG_ON_OFF_STAT            0x03
+#define MAX8907C_REG_SDCTL1                 0x04
+#define MAX8907C_REG_SDSEQCNT1              0x05
+#define MAX8907C_REG_SDV1                   0x06
+#define MAX8907C_REG_SDCTL2                 0x07
+#define MAX8907C_REG_SDSEQCNT2              0x08
+#define MAX8907C_REG_SDV2                   0x09
+#define MAX8907C_REG_SDCTL3                 0x0A
+#define MAX8907C_REG_SDSEQCNT3              0x0B
+#define MAX8907C_REG_SDV3                   0x0C
+#define MAX8907C_REG_ON_OFF_IRQ2            0x0D
+#define MAX8907C_REG_ON_OFF_IRQ2_MASK       0x0E
+#define MAX8907C_REG_RESET_CNFG             0x0F
+#define MAX8907C_REG_LDOCTL16               0x10
+#define MAX8907C_REG_LDOSEQCNT16            0x11
+#define MAX8907C_REG_LDO16VOUT              0x12
+#define MAX8907C_REG_SDBYSEQCNT             0x13
+#define MAX8907C_REG_LDOCTL17               0x14
+#define MAX8907C_REG_LDOSEQCNT17            0x15
+#define MAX8907C_REG_LDO17VOUT              0x16
+#define MAX8907C_REG_LDOCTL1                0x18
+#define MAX8907C_REG_LDOSEQCNT1             0x19
+#define MAX8907C_REG_LDO1VOUT               0x1A
+#define MAX8907C_REG_LDOCTL2                0x1C
+#define MAX8907C_REG_LDOSEQCNT2             0x1D
+#define MAX8907C_REG_LDO2VOUT               0x1E
+#define MAX8907C_REG_LDOCTL3                0x20
+#define MAX8907C_REG_LDOSEQCNT3             0x21
+#define MAX8907C_REG_LDO3VOUT               0x22
+#define MAX8907C_REG_LDOCTL4                0x24
+#define MAX8907C_REG_LDOSEQCNT4             0x25
+#define MAX8907C_REG_LDO4VOUT               0x26
+#define MAX8907C_REG_LDOCTL5                0x28
+#define MAX8907C_REG_LDOSEQCNT5             0x29
+#define MAX8907C_REG_LDO5VOUT               0x2A
+#define MAX8907C_REG_LDOCTL6                0x2C
+#define MAX8907C_REG_LDOSEQCNT6             0x2D
+#define MAX8907C_REG_LDO6VOUT               0x2E
+#define MAX8907C_REG_LDOCTL7                0x30
+#define MAX8907C_REG_LDOSEQCNT7             0x31
+#define MAX8907C_REG_LDO7VOUT               0x32
+#define MAX8907C_REG_LDOCTL8                0x34
+#define MAX8907C_REG_LDOSEQCNT8             0x35
+#define MAX8907C_REG_LDO8VOUT               0x36
+#define MAX8907C_REG_LDOCTL9                0x38
+#define MAX8907C_REG_LDOSEQCNT9             0x39
+#define MAX8907C_REG_LDO9VOUT               0x3A
+#define MAX8907C_REG_LDOCTL10               0x3C
+#define MAX8907C_REG_LDOSEQCNT10            0x3D
+#define MAX8907C_REG_LDO10VOUT              0x3E
+#define MAX8907C_REG_LDOCTL11               0x40
+#define MAX8907C_REG_LDOSEQCNT11            0x41
+#define MAX8907C_REG_LDO11VOUT              0x42
+#define MAX8907C_REG_LDOCTL12               0x44
+#define MAX8907C_REG_LDOSEQCNT12            0x45
+#define MAX8907C_REG_LDO12VOUT              0x46
+#define MAX8907C_REG_LDOCTL13               0x48
+#define MAX8907C_REG_LDOSEQCNT13            0x49
+#define MAX8907C_REG_LDO13VOUT              0x4A
+#define MAX8907C_REG_LDOCTL14               0x4C
+#define MAX8907C_REG_LDOSEQCNT14            0x4D
+#define MAX8907C_REG_LDO14VOUT              0x4E
+#define MAX8907C_REG_LDOCTL15               0x50
+#define MAX8907C_REG_LDOSEQCNT15            0x51
+#define MAX8907C_REG_LDO15VOUT              0x52
+#define MAX8907C_REG_OUT5VEN                0x54
+#define MAX8907C_REG_OUT5VSEQ               0x55
+#define MAX8907C_REG_OUT33VEN               0x58
+#define MAX8907C_REG_OUT33VSEQ              0x59
+#define MAX8907C_REG_LDOCTL19               0x5C
+#define MAX8907C_REG_LDOSEQCNT19            0x5D
+#define MAX8907C_REG_LDO19VOUT              0x5E
+#define MAX8907C_REG_LBCNFG                 0x60
+#define MAX8907C_REG_SEQ1CNFG               0x64
+#define MAX8907C_REG_SEQ2CNFG               0x65
+#define MAX8907C_REG_SEQ3CNFG               0x66
+#define MAX8907C_REG_SEQ4CNFG               0x67
+#define MAX8907C_REG_SEQ5CNFG               0x68
+#define MAX8907C_REG_SEQ6CNFG               0x69
+#define MAX8907C_REG_SEQ7CNFG               0x6A
+#define MAX8907C_REG_LDOCTL18               0x72
+#define MAX8907C_REG_LDOSEQCNT18            0x73
+#define MAX8907C_REG_LDO18VOUT              0x74
+#define MAX8907C_REG_BBAT_CNFG              0x78
+#define MAX8907C_REG_CHG_CNTL1              0x7C
+#define MAX8907C_REG_CHG_CNTL2              0x7D
+#define MAX8907C_REG_CHG_IRQ1               0x7E
+#define MAX8907C_REG_CHG_IRQ2               0x7F
+#define MAX8907C_REG_CHG_IRQ1_MASK          0x80
+#define MAX8907C_REG_CHG_IRQ2_MASK          0x81
+#define MAX8907C_REG_CHG_STAT               0x82
+#define MAX8907C_REG_WLED_MODE_CNTL         0x84
+#define MAX8907C_REG_ILED_CNTL              0x84
+#define MAX8907C_REG_II1RR                  0x8E
+#define MAX8907C_REG_II2RR                  0x8F
+#define MAX8907C_REG_LDOCTL20               0x9C
+#define MAX8907C_REG_LDOSEQCNT20            0x9D
+#define MAX8907C_REG_LDO20VOUT              0x9E
+
+/* RTC register */
+#define MAX8907C_REG_RTC_SEC                0x00
+#define MAX8907C_REG_RTC_MIN                0x01
+#define MAX8907C_REG_RTC_HOURS              0x02
+#define MAX8907C_REG_RTC_WEEKDAY            0x03
+#define MAX8907C_REG_RTC_DATE               0x04
+#define MAX8907C_REG_RTC_MONTH              0x05
+#define MAX8907C_REG_RTC_YEAR1              0x06
+#define MAX8907C_REG_RTC_YEAR2              0x07
+#define MAX8907C_REG_ALARM0_SEC             0x08
+#define MAX8907C_REG_ALARM0_MIN             0x09
+#define MAX8907C_REG_ALARM0_HOURS           0x0A
+#define MAX8907C_REG_ALARM0_WEEKDAY         0x0B
+#define MAX8907C_REG_ALARM0_DATE            0x0C
+#define MAX8907C_REG_ALARM0_MONTH           0x0D
+#define MAX8907C_REG_ALARM0_YEAR1           0x0E
+#define MAX8907C_REG_ALARM0_YEAR2           0x0F
+#define MAX8907C_REG_ALARM1_SEC             0x10
+#define MAX8907C_REG_ALARM1_MIN             0x11
+#define MAX8907C_REG_ALARM1_HOURS           0x12
+#define MAX8907C_REG_ALARM1_WEEKDAY         0x13
+#define MAX8907C_REG_ALARM1_DATE            0x14
+#define MAX8907C_REG_ALARM1_MONTH           0x15
+#define MAX8907C_REG_ALARM1_YEAR1           0x16
+#define MAX8907C_REG_ALARM1_YEAR2           0x17
+#define MAX8907C_REG_ALARM0_CNTL            0x18
+#define MAX8907C_REG_ALARM1_CNTL            0x19
+#define MAX8907C_REG_RTC_STATUS             0x1A
+#define MAX8907C_REG_RTC_CNTL               0x1B
+#define MAX8907C_REG_RTC_IRQ                0x1C
+#define MAX8907C_REG_RTC_IRQ_MASK           0x1D
+#define MAX8907C_REG_MPL_CNTL               0x1E
+
+/* ADC and Touch Screen Controller register map */
+
+#define MAX8907C_CTL     0
+#define MAX8907C_SEQCNT  1
+#define MAX8907C_VOUT    2
+
+/* mask bit fields */
+#define MAX8907C_MASK_LDO_SEQ           0x1C
+#define MAX8907C_MASK_LDO_EN            0x01
+#define MAX8907C_MASK_VBBATTCV          0x03
+#define MAX8907C_MASK_OUT5V_VINEN       0x10
+#define MAX8907C_MASK_OUT5V_ENSRC       0x0E
+#define MAX8907C_MASK_OUT5V_EN          0x01
+
+/* Power off bit in RESET_CNFG reg */
+#define MAX8907C_MASK_POWER_OFF         0x40
+
+#define MAX8907C_MASK_PWR_EN            0x80
+#define MAX8907C_MASK_CTL_SEQ           0x1C
+
+#define MAX8907C_PWR_EN                 0x80
+#define MAX8907C_CTL_SEQ                0x04
+
+#define MAX8907C_SD_SEQ1                0x02
+#define MAX8907C_SD_SEQ2                0x06
+
+#define MAX8907C_DELAY_CNT0             0x00
+
+#define MAX8907C_POWER_UP_DELAY_CNT1    0x10
+#define MAX8907C_POWER_UP_DELAY_CNT12   0xC0
+
+#define MAX8907C_POWER_DOWN_DELAY_CNT12 0x0C
+
+#define RTC_I2C_ADDR                    0x68
+
+/*
+ * MAX8907B revision requires s/w WAR to connect PWREN input to
+ * sequencer 2 because of the bug in the silicon.
+ */
+#define MAX8907B_II2RR_PWREN_WAR                (0x12)
+
+/* Defines common for all supplies PWREN  sequencer selection */
+#define MAX8907B_SEQSEL_PWREN_LXX               1 /* SEQ2 (PWREN) */
+
+/* IRQ definitions */
+enum {
+        MAX8907C_IRQ_VCHG_DC_OVP,
+        MAX8907C_IRQ_VCHG_DC_F,
+        MAX8907C_IRQ_VCHG_DC_R,
+        MAX8907C_IRQ_VCHG_THM_OK_R,
+        MAX8907C_IRQ_VCHG_THM_OK_F,
+        MAX8907C_IRQ_VCHG_MBATTLOW_F,
+        MAX8907C_IRQ_VCHG_MBATTLOW_R,
+        MAX8907C_IRQ_VCHG_RST,
+        MAX8907C_IRQ_VCHG_DONE,
+        MAX8907C_IRQ_VCHG_TOPOFF,
+        MAX8907C_IRQ_VCHG_TMR_FAULT,
+        MAX8907C_IRQ_GPM_RSTIN,
+        MAX8907C_IRQ_GPM_MPL,
+        MAX8907C_IRQ_GPM_SW_3SEC,
+        MAX8907C_IRQ_GPM_EXTON_F,
+        MAX8907C_IRQ_GPM_EXTON_R,
+        MAX8907C_IRQ_GPM_SW_1SEC,
+        MAX8907C_IRQ_GPM_SW_F,
+        MAX8907C_IRQ_GPM_SW_R,
+        MAX8907C_IRQ_GPM_SYSCKEN_F,
+        MAX8907C_IRQ_GPM_SYSCKEN_R,
+        MAX8907C_IRQ_RTC_ALARM1,
+        MAX8907C_IRQ_RTC_ALARM0,
+        MAX8907C_NR_IRQS,
+};
+
+struct max8907c {
+        struct device           *dev;
+        struct mutex            io_lock;
+        struct mutex            irq_lock;
+        struct i2c_client       *i2c_power;
+        struct i2c_client       *i2c_rtc;
+        int                     irq_base;
+        int                     core_irq;
+
+        unsigned char           cache_chg[2];
+        unsigned char           cache_on[2];
+        unsigned char           cache_rtc;
+
+};
+
+struct max8907c_platform_data {
+        int num_subdevs;
+        struct platform_device **subdevs;
+        int irq_base;
+        int (*max8907c_setup)(void);
+        bool use_power_off;
+};
+
+int max8907c_reg_read(struct i2c_client *i2c, u8 reg);
+int max8907c_reg_bulk_read(struct i2c_client *i2c, u8 reg, u8 count, u8 *val);
+int max8907c_reg_write(struct i2c_client *i2c, u8 reg, u8 val);
+int max8907c_reg_bulk_write(struct i2c_client *i2c, u8 reg, u8 count, u8 *val);
+int max8907c_set_bits(struct i2c_client *i2c, u8 reg, u8 mask, u8 val);
+
+int max8907c_irq_init(struct max8907c *chip, int irq, int irq_base);
+void max8907c_irq_free(struct max8907c *chip);
+int max8907c_suspend(struct i2c_client *i2c, pm_message_t state);
+int max8907c_resume(struct i2c_client *i2c);
+void max8907c_deep_sleep(int enter);
+int max8907c_pwr_en_config(void);
+int max8907c_pwr_en_attach(void);
+#endif
diff --git a/include/linux/mfd/max8997.h b/include/linux/mfd/max8997.h
index 60931d08942..0bbd13dbe33 100644
--- a/include/linux/mfd/max8997.h
+++ b/include/linux/mfd/max8997.h
@@ -107,11 +107,16 @@ struct max8997_platform_data {
         unsigned int buck5_voltage[8];
         bool buck5_gpiodvs;
 
+        /* ---- Charger control ---- */
+        /* eoc stands for 'end of charge' */
+        int eoc_mA; /* 50 ~ 200mA by 10mA step */
+        /* charge Full Timeout */
+        int timeout; /* 0 (no timeout), 5, 6, 7 hours */
+
         /* MUIC: Not implemented */
         /* HAPTIC: Not implemented */
         /* RTC: Not implemented */
         /* Flash: Not implemented */
-        /* Charger control: Not implemented */
 };
 
 #endif /* __LINUX_MFD_MAX8998_H */
diff --git a/include/linux/mfd/max8998.h b/include/linux/mfd/max8998.h
index 61daa167b57..f4f0dfa4698 100644
--- a/include/linux/mfd/max8998.h
+++ b/include/linux/mfd/max8998.h
@@ -87,6 +87,15 @@ struct max8998_regulator_data {
  * @wakeup: Allow to wake up from suspend
  * @rtc_delay: LP3974 RTC chip bug that requires delay after a register
  * write before reading it.
+ * @eoc: End of Charge Level in percent: 10% ~ 45% by 5% step
+ *   If it equals 0, leave it unchanged.
+ *   Otherwise, it is a invalid value.
+ * @restart: Restart Level in mV: 100, 150, 200, and -1 for disable.
+ *   If it equals 0, leave it unchanged.
+ *   Otherwise, it is a invalid value.
+ * @timeout: Full Timeout in hours: 5, 6, 7, and -1 for disable.
+ *   If it equals 0, leave it unchanged.
+ *   Otherwise, leave it unchanged.
  */
 struct max8998_platform_data {
         struct max8998_regulator_data   *regulators;
@@ -107,6 +116,9 @@ struct max8998_platform_data {
         int                             buck2_default_idx;
         bool                            wakeup;
         bool                            rtc_delay;
+        int                             eoc;
+        int                             restart;
+        int                             timeout;
 };
 
 #endif /*  __LINUX_MFD_MAX8998_H */
diff --git a/include/linux/mfd/pm8xxx/rtc.h b/include/linux/mfd/pm8xxx/rtc.h
new file mode 100644
index 00000000000..14f1983eaec
--- /dev/null
+++ b/include/linux/mfd/pm8xxx/rtc.h
@@ -0,0 +1,25 @@
+/* Copyright (c) 2010-2011, Code Aurora Forum. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef __RTC_PM8XXX_H__
+#define __RTC_PM8XXX_H__
+
+#define PM8XXX_RTC_DEV_NAME     "rtc-pm8xxx"
+/**
+ * struct pm8xxx_rtc_pdata - RTC driver platform data
+ * @rtc_write_enable: variable stating RTC write capability
+ */
+struct pm8xxx_rtc_platform_data {
+        bool rtc_write_enable;
+};
+
+#endif /* __RTC_PM8XXX_H__ */
diff --git a/include/linux/mfd/rc5t583.h b/include/linux/mfd/rc5t583.h
new file mode 100644
index 00000000000..a2c61609d21
--- /dev/null
+++ b/include/linux/mfd/rc5t583.h
@@ -0,0 +1,295 @@
+/*
+ * Core driver interface to access RICOH_RC5T583 power management chip.
+ *
+ * Copyright (c) 2011-2012, NVIDIA CORPORATION.  All rights reserved.
+ * Author: Laxman dewangan <ldewangan@nvidia.com>
+ *
+ * Based on code
+ *      Copyright (C) 2011 RICOH COMPANY,LTD
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef __LINUX_MFD_RC5T583_H
+#define __LINUX_MFD_RC5T583_H
+
+#include <linux/mutex.h>
+#include <linux/types.h>
+
+#define RC5T583_MAX_REGS                0xF8
+
+/* Maximum number of main interrupts */
+#define MAX_MAIN_INTERRUPT              5
+#define RC5T583_MAX_GPEDGE_REG          2
+#define RC5T583_MAX_INTERRUPT_MASK_REGS 9
+
+/* Interrupt enable register */
+#define RC5T583_INT_EN_SYS1     0x19
+#define RC5T583_INT_EN_SYS2     0x1D
+#define RC5T583_INT_EN_DCDC     0x41
+#define RC5T583_INT_EN_RTC      0xED
+#define RC5T583_INT_EN_ADC1     0x90
+#define RC5T583_INT_EN_ADC2     0x91
+#define RC5T583_INT_EN_ADC3     0x92
+
+/* Interrupt status registers (monitor regs in Ricoh)*/
+#define RC5T583_INTC_INTPOL     0xAD
+#define RC5T583_INTC_INTEN      0xAE
+#define RC5T583_INTC_INTMON     0xAF
+
+#define RC5T583_INT_MON_GRP     0xAF
+#define RC5T583_INT_MON_SYS1    0x1B
+#define RC5T583_INT_MON_SYS2    0x1F
+#define RC5T583_INT_MON_DCDC    0x43
+#define RC5T583_INT_MON_RTC     0xEE
+
+/* Interrupt clearing registers */
+#define RC5T583_INT_IR_SYS1     0x1A
+#define RC5T583_INT_IR_SYS2     0x1E
+#define RC5T583_INT_IR_DCDC     0x42
+#define RC5T583_INT_IR_RTC      0xEE
+#define RC5T583_INT_IR_ADCL     0x94
+#define RC5T583_INT_IR_ADCH     0x95
+#define RC5T583_INT_IR_ADCEND   0x96
+#define RC5T583_INT_IR_GPIOR    0xA9
+#define RC5T583_INT_IR_GPIOF    0xAA
+
+/* Sleep sequence registers */
+#define RC5T583_SLPSEQ1         0x21
+#define RC5T583_SLPSEQ2         0x22
+#define RC5T583_SLPSEQ3         0x23
+#define RC5T583_SLPSEQ4         0x24
+#define RC5T583_SLPSEQ5         0x25
+#define RC5T583_SLPSEQ6         0x26
+#define RC5T583_SLPSEQ7         0x27
+#define RC5T583_SLPSEQ8         0x28
+#define RC5T583_SLPSEQ9         0x29
+#define RC5T583_SLPSEQ10        0x2A
+#define RC5T583_SLPSEQ11        0x2B
+
+/* Regulator registers */
+#define RC5T583_REG_DC0CTL      0x30
+#define RC5T583_REG_DC0DAC      0x31
+#define RC5T583_REG_DC0LATCTL   0x32
+#define RC5T583_REG_SR0CTL      0x33
+
+#define RC5T583_REG_DC1CTL      0x34
+#define RC5T583_REG_DC1DAC      0x35
+#define RC5T583_REG_DC1LATCTL   0x36
+#define RC5T583_REG_SR1CTL      0x37
+
+#define RC5T583_REG_DC2CTL      0x38
+#define RC5T583_REG_DC2DAC      0x39
+#define RC5T583_REG_DC2LATCTL   0x3A
+#define RC5T583_REG_SR2CTL      0x3B
+
+#define RC5T583_REG_DC3CTL      0x3C
+#define RC5T583_REG_DC3DAC      0x3D
+#define RC5T583_REG_DC3LATCTL   0x3E
+#define RC5T583_REG_SR3CTL      0x3F
+
+
+#define RC5T583_REG_LDOEN1      0x50
+#define RC5T583_REG_LDOEN2      0x51
+#define RC5T583_REG_LDODIS1     0x52
+#define RC5T583_REG_LDODIS2     0x53
+
+#define RC5T583_REG_LDO0DAC     0x54
+#define RC5T583_REG_LDO1DAC     0x55
+#define RC5T583_REG_LDO2DAC     0x56
+#define RC5T583_REG_LDO3DAC     0x57
+#define RC5T583_REG_LDO4DAC     0x58
+#define RC5T583_REG_LDO5DAC     0x59
+#define RC5T583_REG_LDO6DAC     0x5A
+#define RC5T583_REG_LDO7DAC     0x5B
+#define RC5T583_REG_LDO8DAC     0x5C
+#define RC5T583_REG_LDO9DAC     0x5D
+
+#define RC5T583_REG_DC0DAC_DS   0x60
+#define RC5T583_REG_DC1DAC_DS   0x61
+#define RC5T583_REG_DC2DAC_DS   0x62
+#define RC5T583_REG_DC3DAC_DS   0x63
+
+#define RC5T583_REG_LDO0DAC_DS  0x64
+#define RC5T583_REG_LDO1DAC_DS  0x65
+#define RC5T583_REG_LDO2DAC_DS  0x66
+#define RC5T583_REG_LDO3DAC_DS  0x67
+#define RC5T583_REG_LDO4DAC_DS  0x68
+#define RC5T583_REG_LDO5DAC_DS  0x69
+#define RC5T583_REG_LDO6DAC_DS  0x6A
+#define RC5T583_REG_LDO7DAC_DS  0x6B
+#define RC5T583_REG_LDO8DAC_DS  0x6C
+#define RC5T583_REG_LDO9DAC_DS  0x6D
+
+/* GPIO register base address */
+#define RC5T583_GPIO_IOSEL      0xA0
+#define RC5T583_GPIO_PDEN       0xA1
+#define RC5T583_GPIO_IOOUT      0xA2
+#define RC5T583_GPIO_PGSEL      0xA3
+#define RC5T583_GPIO_GPINV      0xA4
+#define RC5T583_GPIO_GPDEB      0xA5
+#define RC5T583_GPIO_GPEDGE1    0xA6
+#define RC5T583_GPIO_GPEDGE2    0xA7
+#define RC5T583_GPIO_EN_INT     0xA8
+#define RC5T583_GPIO_MON_IOIN   0xAB
+#define RC5T583_GPIO_GPOFUNC    0xAC
+
+/* RICOH_RC5T583 IRQ definitions */
+enum {
+        RC5T583_IRQ_ONKEY,
+        RC5T583_IRQ_ACOK,
+        RC5T583_IRQ_LIDOPEN,
+        RC5T583_IRQ_PREOT,
+        RC5T583_IRQ_CLKSTP,
+        RC5T583_IRQ_ONKEY_OFF,
+        RC5T583_IRQ_WD,
+        RC5T583_IRQ_EN_PWRREQ1,
+        RC5T583_IRQ_EN_PWRREQ2,
+        RC5T583_IRQ_PRE_VINDET,
+
+        RC5T583_IRQ_DC0LIM,
+        RC5T583_IRQ_DC1LIM,
+        RC5T583_IRQ_DC2LIM,
+        RC5T583_IRQ_DC3LIM,
+
+        RC5T583_IRQ_CTC,
+        RC5T583_IRQ_YALE,
+        RC5T583_IRQ_DALE,
+        RC5T583_IRQ_WALE,
+
+        RC5T583_IRQ_AIN1L,
+        RC5T583_IRQ_AIN2L,
+        RC5T583_IRQ_AIN3L,
+        RC5T583_IRQ_VBATL,
+        RC5T583_IRQ_VIN3L,
+        RC5T583_IRQ_VIN8L,
+        RC5T583_IRQ_AIN1H,
+        RC5T583_IRQ_AIN2H,
+        RC5T583_IRQ_AIN3H,
+        RC5T583_IRQ_VBATH,
+        RC5T583_IRQ_VIN3H,
+        RC5T583_IRQ_VIN8H,
+        RC5T583_IRQ_ADCEND,
+
+        RC5T583_IRQ_GPIO0,
+        RC5T583_IRQ_GPIO1,
+        RC5T583_IRQ_GPIO2,
+        RC5T583_IRQ_GPIO3,
+        RC5T583_IRQ_GPIO4,
+        RC5T583_IRQ_GPIO5,
+        RC5T583_IRQ_GPIO6,
+        RC5T583_IRQ_GPIO7,
+
+        /* Should be last entry */
+        RC5T583_MAX_IRQS,
+};
+
+/* Ricoh583 gpio definitions */
+enum {
+        RC5T583_GPIO0,
+        RC5T583_GPIO1,
+        RC5T583_GPIO2,
+        RC5T583_GPIO3,
+        RC5T583_GPIO4,
+        RC5T583_GPIO5,
+        RC5T583_GPIO6,
+        RC5T583_GPIO7,
+
+        /* Should be last entry */
+        RC5T583_MAX_GPIO,
+};
+
+enum {
+        RC5T583_DS_NONE,
+        RC5T583_DS_DC0,
+        RC5T583_DS_DC1,
+        RC5T583_DS_DC2,
+        RC5T583_DS_DC3,
+        RC5T583_DS_LDO0,
+        RC5T583_DS_LDO1,
+        RC5T583_DS_LDO2,
+        RC5T583_DS_LDO3,
+        RC5T583_DS_LDO4,
+        RC5T583_DS_LDO5,
+        RC5T583_DS_LDO6,
+        RC5T583_DS_LDO7,
+        RC5T583_DS_LDO8,
+        RC5T583_DS_LDO9,
+        RC5T583_DS_PSO0,
+        RC5T583_DS_PSO1,
+        RC5T583_DS_PSO2,
+        RC5T583_DS_PSO3,
+        RC5T583_DS_PSO4,
+        RC5T583_DS_PSO5,
+        RC5T583_DS_PSO6,
+        RC5T583_DS_PSO7,
+
+        /* Should be last entry */
+        RC5T583_DS_MAX,
+};
+
+/*
+ * Ricoh pmic RC5T583 supports sleep through two external controls.
+ * The output of gpios and regulator can be enable/disable through
+ * this external signals.
+ */
+enum {
+        RC5T583_EXT_PWRREQ1_CONTROL = 0x1,
+        RC5T583_EXT_PWRREQ2_CONTROL = 0x2,
+};
+
+struct rc5t583 {
+        struct device   *dev;
+        struct regmap   *regmap;
+        int             chip_irq;
+        int             irq_base;
+        struct mutex    irq_lock;
+        unsigned long   group_irq_en[MAX_MAIN_INTERRUPT];
+
+        /* For main interrupt bits in INTC */
+        uint8_t         intc_inten_reg;
+
+        /* For group interrupt bits and address */
+        uint8_t         irq_en_reg[RC5T583_MAX_INTERRUPT_MASK_REGS];
+
+        /* For gpio edge */
+        uint8_t         gpedge_reg[RC5T583_MAX_GPEDGE_REG];
+};
+
+/*
+ * rc5t583_platform_data: Platform data for ricoh rc5t583 pmu.
+ * The board specific data is provided through this structure.
+ * @irq_base: Irq base number on which this device registers their interrupts.
+ * @enable_shutdown: Enable shutdown through the input pin "shutdown".
+ */
+
+struct rc5t583_platform_data {
+        int             irq_base;
+        bool            enable_shutdown;
+};
+
+int rc5t583_write(struct device *dev, u8 reg, uint8_t val);
+int rc5t583_read(struct device *dev, uint8_t reg, uint8_t *val);
+int rc5t583_set_bits(struct device *dev, unsigned int reg,
+                unsigned int bit_mask);
+int rc5t583_clear_bits(struct device *dev, unsigned int reg,
+                unsigned int bit_mask);
+int rc5t583_update(struct device *dev, unsigned int reg,
+                unsigned int val, unsigned int mask);
+int rc5t583_ext_power_req_config(struct device *dev, int deepsleep_id,
+        int ext_pwr_req, int deepsleep_slot_nr);
+int rc5t583_irq_init(struct rc5t583 *rc5t583, int irq, int irq_base);
+int rc5t583_irq_exit(struct rc5t583 *rc5t583);
+
+#endif
diff --git a/include/linux/mfd/ricoh583.h b/include/linux/mfd/ricoh583.h
new file mode 100644
index 00000000000..4e38cded0fa
--- /dev/null
+++ b/include/linux/mfd/ricoh583.h
@@ -0,0 +1,164 @@
+/* include/linux/mfd/ricoh583.h
+ *
+ * Core driver interface to access RICOH583 power management chip.
+ *
+ * Copyright (C) 2011 NVIDIA Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#ifndef __LINUX_MFD_RICOH583_H
+#define __LINUX_MFD_RICOH583_H
+
+#include <linux/rtc.h>
+/* RICOH583 IRQ definitions */
+enum {
+        RICOH583_IRQ_ONKEY,
+        RICOH583_IRQ_ACOK,
+        RICOH583_IRQ_LIDOPEN,
+        RICOH583_IRQ_PREOT,
+        RICOH583_IRQ_CLKSTP,
+        RICOH583_IRQ_ONKEY_OFF,
+        RICOH583_IRQ_WD,
+        RICOH583_IRQ_EN_PWRREQ1,
+        RICOH583_IRQ_EN_PWRREQ2,
+        RICOH583_IRQ_PRE_VINDET,
+
+        RICOH583_IRQ_DC0LIM,
+        RICOH583_IRQ_DC1LIM,
+        RICOH583_IRQ_DC2LIM,
+        RICOH583_IRQ_DC3LIM,
+
+        RICOH583_IRQ_CTC,
+        RICOH583_IRQ_YALE,
+        RICOH583_IRQ_DALE,
+        RICOH583_IRQ_WALE,
+
+        RICOH583_IRQ_AIN1L,
+        RICOH583_IRQ_AIN2L,
+        RICOH583_IRQ_AIN3L,
+        RICOH583_IRQ_VBATL,
+        RICOH583_IRQ_VIN3L,
+        RICOH583_IRQ_VIN8L,
+        RICOH583_IRQ_AIN1H,
+        RICOH583_IRQ_AIN2H,
+        RICOH583_IRQ_AIN3H,
+        RICOH583_IRQ_VBATH,
+        RICOH583_IRQ_VIN3H,
+        RICOH583_IRQ_VIN8H,
+        RICOH583_IRQ_ADCEND,
+
+        RICOH583_IRQ_GPIO0,
+        RICOH583_IRQ_GPIO1,
+        RICOH583_IRQ_GPIO2,
+        RICOH583_IRQ_GPIO3,
+        RICOH583_IRQ_GPIO4,
+        RICOH583_IRQ_GPIO5,
+        RICOH583_IRQ_GPIO6,
+        RICOH583_IRQ_GPIO7,
+        RICOH583_NR_IRQS,
+};
+
+/* Ricoh583 gpio definitions */
+enum {
+        RICOH583_GPIO0,
+        RICOH583_GPIO1,
+        RICOH583_GPIO2,
+        RICOH583_GPIO3,
+        RICOH583_GPIO4,
+        RICOH583_GPIO5,
+        RICOH583_GPIO6,
+        RICOH583_GPIO7,
+
+        RICOH583_NR_GPIO,
+};
+
+enum ricoh583_deepsleep_control_id {
+        RICOH583_DS_NONE,
+        RICOH583_DS_DC0,
+        RICOH583_DS_DC1,
+        RICOH583_DS_DC2,
+        RICOH583_DS_DC3,
+        RICOH583_DS_LDO0,
+        RICOH583_DS_LDO1,
+        RICOH583_DS_LDO2,
+        RICOH583_DS_LDO3,
+        RICOH583_DS_LDO4,
+        RICOH583_DS_LDO5,
+        RICOH583_DS_LDO6,
+        RICOH583_DS_LDO7,
+        RICOH583_DS_LDO8,
+        RICOH583_DS_LDO9,
+        RICOH583_DS_PSO0,
+        RICOH583_DS_PSO1,
+        RICOH583_DS_PSO2,
+        RICOH583_DS_PSO3,
+        RICOH583_DS_PSO4,
+        RICOH583_DS_PSO5,
+        RICOH583_DS_PSO6,
+        RICOH583_DS_PSO7,
+};
+enum ricoh583_ext_pwrreq_control {
+        RICOH583_EXT_PWRREQ1_CONTROL = 0x1,
+        RICOH583_EXT_PWRREQ2_CONTROL = 0x2,
+};
+
+struct ricoh583_subdev_info {
+        int             id;
+        const char      *name;
+        void            *platform_data;
+};
+
+struct ricoh583_rtc_platform_data {
+        int irq;
+        struct rtc_time time;
+};
+
+struct ricoh583_gpio_init_data {
+        unsigned pulldn_en:1;   /* Enable pull down */
+        unsigned output_mode_en:1; /* Enable output mode during init */
+        unsigned output_val:1;  /* Output value if it is in output mode */
+        unsigned init_apply:1;  /* Apply init data on configuring gpios*/
+};
+
+struct ricoh583_platform_data {
+        int             num_subdevs;
+        struct  ricoh583_subdev_info *subdevs;
+        int             gpio_base;
+        int             irq_base;
+
+        struct ricoh583_gpio_init_data *gpio_init_data;
+        int num_gpioinit_data;
+        bool enable_shutdown_pin;
+};
+
+extern int ricoh583_read(struct device *dev, uint8_t reg, uint8_t *val);
+extern int ricoh583_bulk_reads(struct device *dev, u8 reg, u8 count,
+                                uint8_t *val);
+extern int ricoh583_write(struct device *dev, u8 reg, uint8_t val);
+extern int ricoh583_bulk_writes(struct device *dev, u8 reg, u8 count,
+                                uint8_t *val);
+extern int ricoh583_set_bits(struct device *dev, u8 reg, uint8_t bit_mask);
+extern int ricoh583_clr_bits(struct device *dev, u8 reg, uint8_t bit_mask);
+extern int ricoh583_update(struct device *dev, u8 reg, uint8_t val,
+                                        uint8_t mask);
+extern int ricoh583_ext_power_req_config(struct device *dev,
+                enum ricoh583_deepsleep_control_id control_id,
+                enum ricoh583_ext_pwrreq_control ext_pwr_req,
+                int deepsleep_slot_nr);
+extern int ricoh583_power_off(void);
+
+#endif
diff --git a/include/linux/mfd/stmpe.h b/include/linux/mfd/stmpe.h
index e762c270d8d..be1af7c42e5 100644
--- a/include/linux/mfd/stmpe.h
+++ b/include/linux/mfd/stmpe.h
@@ -57,6 +57,7 @@ struct stmpe_variant_info;
  * @irq_lock: IRQ bus lock
  * @dev: device, mostly for dev_dbg()
  * @i2c: i2c client
+ * @partnum: part number
  * @variant: the detected STMPE model number
  * @regs: list of addresses of registers which are at different addresses on
  *        different variants.  Indexed by one of STMPE_IDX_*.
@@ -121,6 +122,8 @@ struct stmpe_keypad_platform_data {
  * @norequest_mask: bitmask specifying which GPIOs should _not_ be
  *                  requestable due to different usage (e.g. touch, keypad)
  *                  STMPE_GPIO_NOREQ_* macros can be used here.
+ * @setup: board specific setup callback.
+ * @remove: board specific remove callback
  */
 struct stmpe_gpio_platform_data {
         int gpio_base;
diff --git a/include/linux/mfd/tmio.h b/include/linux/mfd/tmio.h
index 5a90266c3a5..0dc98044d8b 100644
--- a/include/linux/mfd/tmio.h
+++ b/include/linux/mfd/tmio.h
@@ -68,6 +68,11 @@
  * controller and report the event to the driver.
  */
 #define TMIO_MMC_HAS_COLD_CD            (1 << 3)
+/*
+ * Some controllers require waiting for the SD bus to become
+ * idle before writing to some registers.
+ */
+#define TMIO_MMC_HAS_IDLE_WAIT          (1 << 4)
 
 int tmio_core_mmc_enable(void __iomem *cnf, int shift, unsigned long base);
 int tmio_core_mmc_resume(void __iomem *cnf, int shift, unsigned long base);
@@ -80,6 +85,8 @@ struct tmio_mmc_dma {
         int alignment_shift;
 };
 
+struct tmio_mmc_host;
+
 /*
  * data for the MMC controller
  */
@@ -94,6 +101,7 @@ struct tmio_mmc_data {
         void (*set_pwr)(struct platform_device *host, int state);
         void (*set_clk_div)(struct platform_device *host, int state);
         int (*get_cd)(struct platform_device *host);
+        int (*write16_hook)(struct tmio_mmc_host *host, int addr);
 };
 
 static inline void tmio_mmc_cd_wakeup(struct tmio_mmc_data *pdata)
diff --git a/include/linux/mfd/tps65090.h b/include/linux/mfd/tps65090.h
new file mode 100644
index 00000000000..511ced59ef1
--- /dev/null
+++ b/include/linux/mfd/tps65090.h
@@ -0,0 +1,53 @@
+/*
+ * include/linux/mfd/tps65090.h
+ * Core driver interface for TI TPS65090 PMIC family
+ *
+ * Copyright (C) 2012 NVIDIA Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#ifndef __LINUX_MFD_TPS65090_H
+#define __LINUX_MFD_TPS65090_H
+
+#include <linux/rtc.h>
+
+struct tps65090_subdev_info {
+        int             id;
+        const char      *name;
+        void            *platform_data;
+};
+
+struct tps65090_platform_data {
+        int irq_base;
+        int num_subdevs;
+        struct tps65090_subdev_info *subdevs;
+};
+
+/*
+ * NOTE: the functions below are not intended for use outside
+ * of the TPS65090 sub-device drivers
+ */
+extern int tps65090_write(struct device *dev, int reg, uint8_t val);
+extern int tps65090_writes(struct device *dev, int reg, int len, uint8_t *val);
+extern int tps65090_read(struct device *dev, int reg, uint8_t *val);
+extern int tps65090_reads(struct device *dev, int reg, int len, uint8_t *val);
+extern int tps65090_set_bits(struct device *dev, int reg, uint8_t bit_num);
+extern int tps65090_clr_bits(struct device *dev, int reg, uint8_t bit_num);
+extern int tps65090_update(struct device *dev, int reg, uint8_t val,
+                           uint8_t bit_num);
+
+#endif /*__LINUX_MFD_TPS65090_H */
diff --git a/include/linux/mfd/tps6586x.h b/include/linux/mfd/tps6586x.h
index b6bab1b04e2..702cee59cc7 100644
--- a/include/linux/mfd/tps6586x.h
+++ b/include/linux/mfd/tps6586x.h
@@ -1,6 +1,10 @@
 #ifndef __LINUX_MFD_TPS6586X_H
 #define __LINUX_MFD_TPS6586X_H
 
+#define SM0_PWM_BIT 0
+#define SM1_PWM_BIT 1
+#define SM2_PWM_BIT 2
+
 enum {
         TPS6586X_ID_SM_0,
         TPS6586X_ID_SM_1,
@@ -48,18 +52,68 @@ enum {
         TPS6586X_INT_RTC_ALM2,
 };
 
+enum pwm_pfm_mode {
+        PWM_ONLY,
+        AUTO_PWM_PFM,
+        PWM_DEFAULT_VALUE,
+
+};
+
+enum slew_rate_settings {
+        SLEW_RATE_INSTANTLY = 0,
+        SLEW_RATE_0110UV_PER_SEC = 0x1,
+        SLEW_RATE_0220UV_PER_SEC = 0x2,
+        SLEW_RATE_0440UV_PER_SEC = 0x3,
+        SLEW_RATE_0880UV_PER_SEC = 0x4,
+        SLEW_RATE_1760UV_PER_SEC = 0x5,
+        SLEW_RATE_3520UV_PER_SEC = 0x6,
+        SLEW_RATE_7040UV_PER_SEC = 0x7,
+        SLEW_RATE_DEFAULT_VALUE,
+};
+
+struct tps6586x_settings {
+        /* SM0, SM1 and SM2 have PWM-only and auto PWM/PFM mode */
+        enum pwm_pfm_mode sm_pwm_mode;
+        /* SM0 and SM1 have slew rate settings */
+        enum slew_rate_settings slew_rate;
+};
+
+enum {
+        TPS6586X_RTC_CL_SEL_1_5PF  = 0x0,
+        TPS6586X_RTC_CL_SEL_6_5PF  = 0x1,
+        TPS6586X_RTC_CL_SEL_7_5PF  = 0x2,
+        TPS6586X_RTC_CL_SEL_12_5PF = 0x3,
+};
+
 struct tps6586x_subdev_info {
         int             id;
         const char      *name;
         void            *platform_data;
 };
 
+struct tps6586x_epoch_start {
+        int year;
+        int month;
+        int day;
+        int hour;
+        int min;
+        int sec;
+};
+
+struct tps6586x_rtc_platform_data {
+        int irq;
+        struct tps6586x_epoch_start start;
+        int cl_sel; /* internal XTAL capacitance, see TPS6586X_RTC_CL_SEL* */
+};
+
 struct tps6586x_platform_data {
         int num_subdevs;
         struct tps6586x_subdev_info *subdevs;
 
         int gpio_base;
         int irq_base;
+
+        bool use_power_off;
 };
 
 /*
diff --git a/include/linux/mfd/tps65910.h b/include/linux/mfd/tps65910.h
index 8bb85b930c0..f6021cc9d91 100644
--- a/include/linux/mfd/tps65910.h
+++ b/include/linux/mfd/tps65910.h
@@ -243,7 +243,8 @@
 
 
 /*Registers VDD1, VDD2 voltage values definitions */
-#define VDD1_2_NUM_VOLTS                                73
+#define VDD1_2_NUM_VOLT_FINE                            73
+#define VDD1_2_NUM_VOLT_COARSE                          3
 #define VDD1_2_MIN_VOLT                                 6000
 #define VDD1_2_OFFSET                                   125
 
@@ -269,7 +270,7 @@
 #define LDO1_SEL_MASK                                   0xFC
 #define LDO3_SEL_MASK                                   0x7C
 #define LDO_MIN_VOLT                                    1000
-#define LDO_MAX_VOLT                                    3300;
+#define LDO_MAX_VOLT                                    3300
 
 
 /*Register VDIG1  (0x80) register.RegisterDescription */
@@ -656,6 +657,8 @@
 
 
 /*Register GPIO  (0x80) register.RegisterDescription */
+#define GPIO_SLEEP_MASK                         0x80
+#define GPIO_SLEEP_SHIFT                        7
 #define GPIO_DEB_MASK                           0x10
 #define GPIO_DEB_SHIFT                          4
 #define GPIO_PUEN_MASK                          0x08
@@ -739,6 +742,45 @@
 #define TPS65910_GPIO_STS                               BIT(1)
 #define TPS65910_GPIO_SET                               BIT(0)
 
+/* Max number of TPS65910/11 GPIOs */
+#define TPS65910_NUM_GPIO                               6
+#define TPS65911_NUM_GPIO                               9
+#define TPS6591X_MAX_NUM_GPIO                           9
+
+/* Regulator Index Definitions */
+#define TPS65910_REG_VRTC                               0
+#define TPS65910_REG_VIO                                1
+#define TPS65910_REG_VDD1                               2
+#define TPS65910_REG_VDD2                               3
+#define TPS65910_REG_VDD3                               4
+#define TPS65910_REG_VDIG1                              5
+#define TPS65910_REG_VDIG2                              6
+#define TPS65910_REG_VPLL                               7
+#define TPS65910_REG_VDAC                               8
+#define TPS65910_REG_VAUX1                              9
+#define TPS65910_REG_VAUX2                              10
+#define TPS65910_REG_VAUX33                             11
+#define TPS65910_REG_VMMC                               12
+
+#define TPS65911_REG_VDDCTRL                            4
+#define TPS65911_REG_LDO1                               5
+#define TPS65911_REG_LDO2                               6
+#define TPS65911_REG_LDO3                               7
+#define TPS65911_REG_LDO4                               8
+#define TPS65911_REG_LDO5                               9
+#define TPS65911_REG_LDO6                               10
+#define TPS65911_REG_LDO7                               11
+#define TPS65911_REG_LDO8                               12
+
+/* Max number of TPS65910/11 regulators */
+#define TPS65910_NUM_REGS                               13
+
+/* External sleep controls through EN1/EN2/EN3/SLEEP inputs */
+#define TPS65910_SLEEP_CONTROL_EXT_INPUT_EN1            0x1
+#define TPS65910_SLEEP_CONTROL_EXT_INPUT_EN2            0x2
+#define TPS65910_SLEEP_CONTROL_EXT_INPUT_EN3            0x4
+#define TPS65911_SLEEP_CONTROL_EXT_INPUT_SLEEP          0x8
+
 /**
  * struct tps65910_board
  * Board platform data may be used to initialize regulators.
@@ -750,7 +792,9 @@ struct tps65910_board {
         int irq_base;
         int vmbch_threshold;
         int vmbch2_threshold;
-        struct regulator_init_data *tps65910_pmic_init_data;
+        unsigned long regulator_ext_sleep_control[TPS65910_NUM_REGS];
+        bool en_gpio_sleep[TPS6591X_MAX_NUM_GPIO];
+        struct regulator_init_data *tps65910_pmic_init_data[TPS65910_NUM_REGS];
 };
 
 /**
@@ -760,6 +804,7 @@ struct tps65910_board {
 struct tps65910 {
         struct device *dev;
         struct i2c_client *i2c_client;
+        struct regmap *regmap;
         struct mutex io_mutex;
         unsigned int id;
         int (*read)(struct tps65910 *tps65910, u8 reg, int size, void *dest);
@@ -791,6 +836,7 @@ int tps65910_clear_bits(struct tps65910 *tps65910, u8 reg, u8 mask);
 void tps65910_gpio_init(struct tps65910 *tps65910, int gpio_base);
 int tps65910_irq_init(struct tps65910 *tps65910, int irq,
                 struct tps65910_platform_data *pdata);
+int tps65910_irq_exit(struct tps65910 *tps65910);
 
 static inline int tps65910_chip_id(struct tps65910 *tps65910)
 {
diff --git a/include/linux/mfd/tps65912.h b/include/linux/mfd/tps65912.h
new file mode 100644
index 00000000000..aaceab402ec
--- /dev/null
+++ b/include/linux/mfd/tps65912.h
@@ -0,0 +1,327 @@
+/*
+ * tps65912.h  --  TI TPS6591x
+ *
+ * Copyright 2011 Texas Instruments Inc.
+ *
+ * Author: Margarita Olaya <magi@slimlogic.co.uk>
+ *
+ *  This program is free software; you can redistribute it and/or modify it
+ *  under  the terms of the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the License, or (at your
+ *  option) any later version.
+ *
+ */
+
+#ifndef __LINUX_MFD_TPS65912_H
+#define __LINUX_MFD_TPS65912_H
+
+/* TPS regulator type list */
+#define REGULATOR_LDO           0
+#define REGULATOR_DCDC          1
+
+/*
+ * List of registers for TPS65912
+ */
+
+#define TPS65912_DCDC1_CTRL             0x00
+#define TPS65912_DCDC2_CTRL             0x01
+#define TPS65912_DCDC3_CTRL             0x02
+#define TPS65912_DCDC4_CTRL             0x03
+#define TPS65912_DCDC1_OP               0x04
+#define TPS65912_DCDC1_AVS              0x05
+#define TPS65912_DCDC1_LIMIT            0x06
+#define TPS65912_DCDC2_OP               0x07
+#define TPS65912_DCDC2_AVS              0x08
+#define TPS65912_DCDC2_LIMIT            0x09
+#define TPS65912_DCDC3_OP               0x0A
+#define TPS65912_DCDC3_AVS              0x0B
+#define TPS65912_DCDC3_LIMIT            0x0C
+#define TPS65912_DCDC4_OP               0x0D
+#define TPS65912_DCDC4_AVS              0x0E
+#define TPS65912_DCDC4_LIMIT            0x0F
+#define TPS65912_LDO1_OP                0x10
+#define TPS65912_LDO1_AVS               0x11
+#define TPS65912_LDO1_LIMIT             0x12
+#define TPS65912_LDO2_OP                0x13
+#define TPS65912_LDO2_AVS               0x14
+#define TPS65912_LDO2_LIMIT             0x15
+#define TPS65912_LDO3_OP                0x16
+#define TPS65912_LDO3_AVS               0x17
+#define TPS65912_LDO3_LIMIT             0x18
+#define TPS65912_LDO4_OP                0x19
+#define TPS65912_LDO4_AVS               0x1A
+#define TPS65912_LDO4_LIMIT             0x1B
+#define TPS65912_LDO5                   0x1C
+#define TPS65912_LDO6                   0x1D
+#define TPS65912_LDO7                   0x1E
+#define TPS65912_LDO8                   0x1F
+#define TPS65912_LDO9                   0x20
+#define TPS65912_LDO10                  0x21
+#define TPS65912_THRM                   0x22
+#define TPS65912_CLK32OUT               0x23
+#define TPS65912_DEVCTRL                0x24
+#define TPS65912_DEVCTRL2               0x25
+#define TPS65912_I2C_SPI_CFG            0x26
+#define TPS65912_KEEP_ON                0x27
+#define TPS65912_KEEP_ON2               0x28
+#define TPS65912_SET_OFF1               0x29
+#define TPS65912_SET_OFF2               0x2A
+#define TPS65912_DEF_VOLT               0x2B
+#define TPS65912_DEF_VOLT_MAPPING       0x2C
+#define TPS65912_DISCHARGE              0x2D
+#define TPS65912_DISCHARGE2             0x2E
+#define TPS65912_EN1_SET1               0x2F
+#define TPS65912_EN1_SET2               0x30
+#define TPS65912_EN2_SET1               0x31
+#define TPS65912_EN2_SET2               0x32
+#define TPS65912_EN3_SET1               0x33
+#define TPS65912_EN3_SET2               0x34
+#define TPS65912_EN4_SET1               0x35
+#define TPS65912_EN4_SET2               0x36
+#define TPS65912_PGOOD                  0x37
+#define TPS65912_PGOOD2                 0x38
+#define TPS65912_INT_STS                0x39
+#define TPS65912_INT_MSK                0x3A
+#define TPS65912_INT_STS2               0x3B
+#define TPS65912_INT_MSK2               0x3C
+#define TPS65912_INT_STS3               0x3D
+#define TPS65912_INT_MSK3               0x3E
+#define TPS65912_INT_STS4               0x3F
+#define TPS65912_INT_MSK4               0x40
+#define TPS65912_GPIO1                  0x41
+#define TPS65912_GPIO2                  0x42
+#define TPS65912_GPIO3                  0x43
+#define TPS65912_GPIO4                  0x44
+#define TPS65912_GPIO5                  0x45
+#define TPS65912_VMON                   0x46
+#define TPS65912_LEDA_CTRL1             0x47
+#define TPS65912_LEDA_CTRL2             0x48
+#define TPS65912_LEDA_CTRL3             0x49
+#define TPS65912_LEDA_CTRL4             0x4A
+#define TPS65912_LEDA_CTRL5             0x4B
+#define TPS65912_LEDA_CTRL6             0x4C
+#define TPS65912_LEDA_CTRL7             0x4D
+#define TPS65912_LEDA_CTRL8             0x4E
+#define TPS65912_LEDB_CTRL1             0x4F
+#define TPS65912_LEDB_CTRL2             0x50
+#define TPS65912_LEDB_CTRL3             0x51
+#define TPS65912_LEDB_CTRL4             0x52
+#define TPS65912_LEDB_CTRL5             0x53
+#define TPS65912_LEDB_CTRL6             0x54
+#define TPS65912_LEDB_CTRL7             0x55
+#define TPS65912_LEDB_CTRL8             0x56
+#define TPS65912_LEDC_CTRL1             0x57
+#define TPS65912_LEDC_CTRL2             0x58
+#define TPS65912_LEDC_CTRL3             0x59
+#define TPS65912_LEDC_CTRL4             0x5A
+#define TPS65912_LEDC_CTRL5             0x5B
+#define TPS65912_LEDC_CTRL6             0x5C
+#define TPS65912_LEDC_CTRL7             0x5D
+#define TPS65912_LEDC_CTRL8             0x5E
+#define TPS65912_LED_RAMP_UP_TIME       0x5F
+#define TPS65912_LED_RAMP_DOWN_TIME     0x60
+#define TPS65912_LED_SEQ_EN             0x61
+#define TPS65912_LOADSWITCH             0x62
+#define TPS65912_SPARE                  0x63
+#define TPS65912_VERNUM                 0x64
+#define TPS6591X_MAX_REGISTER           0x64
+
+/* IRQ Definitions */
+#define TPS65912_IRQ_PWRHOLD_F          0
+#define TPS65912_IRQ_VMON               1
+#define TPS65912_IRQ_PWRON              2
+#define TPS65912_IRQ_PWRON_LP           3
+#define TPS65912_IRQ_PWRHOLD_R          4
+#define TPS65912_IRQ_HOTDIE             5
+#define TPS65912_IRQ_GPIO1_R            6
+#define TPS65912_IRQ_GPIO1_F            7
+#define TPS65912_IRQ_GPIO2_R            8
+#define TPS65912_IRQ_GPIO2_F            9
+#define TPS65912_IRQ_GPIO3_R            10
+#define TPS65912_IRQ_GPIO3_F            11
+#define TPS65912_IRQ_GPIO4_R            12
+#define TPS65912_IRQ_GPIO4_F            13
+#define TPS65912_IRQ_GPIO5_R            14
+#define TPS65912_IRQ_GPIO5_F            15
+#define TPS65912_IRQ_PGOOD_DCDC1        16
+#define TPS65912_IRQ_PGOOD_DCDC2        17
+#define TPS65912_IRQ_PGOOD_DCDC3        18
+#define TPS65912_IRQ_PGOOD_DCDC4        19
+#define TPS65912_IRQ_PGOOD_LDO1         20
+#define TPS65912_IRQ_PGOOD_LDO2         21
+#define TPS65912_IRQ_PGOOD_LDO3         22
+#define TPS65912_IRQ_PGOOD_LDO4         23
+#define TPS65912_IRQ_PGOOD_LDO5         24
+#define TPS65912_IRQ_PGOOD_LDO6         25
+#define TPS65912_IRQ_PGOOD_LDO7         26
+#define TPS65912_IRQ_PGOOD_LD08         27
+#define TPS65912_IRQ_PGOOD_LDO9         28
+#define TPS65912_IRQ_PGOOD_LDO10        29
+
+#define TPS65912_NUM_IRQ                30
+
+/* GPIO 1 and 2 Register Definitions */
+#define GPIO_SLEEP_MASK                 0x80
+#define GPIO_SLEEP_SHIFT                7
+#define GPIO_DEB_MASK                   0x10
+#define GPIO_DEB_SHIFT                  4
+#define GPIO_CFG_MASK                   0x04
+#define GPIO_CFG_SHIFT                  2
+#define GPIO_STS_MASK                   0x02
+#define GPIO_STS_SHIFT                  1
+#define GPIO_SET_MASK                   0x01
+#define GPIO_SET_SHIFT                  0
+
+/* GPIO 3 Register Definitions */
+#define GPIO3_SLEEP_MASK                0x80
+#define GPIO3_SLEEP_SHIFT               7
+#define GPIO3_SEL_MASK                  0x40
+#define GPIO3_SEL_SHIFT                 6
+#define GPIO3_ODEN_MASK                 0x20
+#define GPIO3_ODEN_SHIFT                5
+#define GPIO3_DEB_MASK                  0x10
+#define GPIO3_DEB_SHIFT                 4
+#define GPIO3_PDEN_MASK                 0x08
+#define GPIO3_PDEN_SHIFT                3
+#define GPIO3_CFG_MASK                  0x04
+#define GPIO3_CFG_SHIFT                 2
+#define GPIO3_STS_MASK                  0x02
+#define GPIO3_STS_SHIFT                 1
+#define GPIO3_SET_MASK                  0x01
+#define GPIO3_SET_SHIFT                 0
+
+/* GPIO 4 Register Definitions */
+#define GPIO4_SLEEP_MASK                0x80
+#define GPIO4_SLEEP_SHIFT               7
+#define GPIO4_SEL_MASK                  0x40
+#define GPIO4_SEL_SHIFT                 6
+#define GPIO4_ODEN_MASK                 0x20
+#define GPIO4_ODEN_SHIFT                5
+#define GPIO4_DEB_MASK                  0x10
+#define GPIO4_DEB_SHIFT                 4
+#define GPIO4_PDEN_MASK                 0x08
+#define GPIO4_PDEN_SHIFT                3
+#define GPIO4_CFG_MASK                  0x04
+#define GPIO4_CFG_SHIFT                 2
+#define GPIO4_STS_MASK                  0x02
+#define GPIO4_STS_SHIFT                 1
+#define GPIO4_SET_MASK                  0x01
+#define GPIO4_SET_SHIFT                 0
+
+/* Register THERM  (0x80) register.RegisterDescription */
+#define THERM_THERM_HD_MASK             0x20
+#define THERM_THERM_HD_SHIFT            5
+#define THERM_THERM_TS_MASK             0x10
+#define THERM_THERM_TS_SHIFT            4
+#define THERM_THERM_HDSEL_MASK          0x0C
+#define THERM_THERM_HDSEL_SHIFT         2
+#define THERM_RSVD1_MASK                0x02
+#define THERM_RSVD1_SHIFT               1
+#define THERM_THERM_STATE_MASK          0x01
+#define THERM_THERM_STATE_SHIFT         0
+
+/* Register DCDCCTRL1 register.RegisterDescription */
+#define DCDCCTRL_VCON_ENABLE_MASK       0x80
+#define DCDCCTRL_VCON_ENABLE_SHIFT      7
+#define DCDCCTRL_VCON_RANGE1_MASK       0x40
+#define DCDCCTRL_VCON_RANGE1_SHIFT      6
+#define DCDCCTRL_VCON_RANGE0_MASK       0x20
+#define DCDCCTRL_VCON_RANGE0_SHIFT      5
+#define DCDCCTRL_TSTEP2_MASK            0x10
+#define DCDCCTRL_TSTEP2_SHIFT           4
+#define DCDCCTRL_TSTEP1_MASK            0x08
+#define DCDCCTRL_TSTEP1_SHIFT           3
+#define DCDCCTRL_TSTEP0_MASK            0x04
+#define DCDCCTRL_TSTEP0_SHIFT           2
+#define DCDCCTRL_DCDC1_MODE_MASK        0x02
+#define DCDCCTRL_DCDC1_MODE_SHIFT       1
+
+/* Register DCDCCTRL2 and DCDCCTRL3 register.RegisterDescription */
+#define DCDCCTRL_TSTEP2_MASK            0x10
+#define DCDCCTRL_TSTEP2_SHIFT           4
+#define DCDCCTRL_TSTEP1_MASK            0x08
+#define DCDCCTRL_TSTEP1_SHIFT           3
+#define DCDCCTRL_TSTEP0_MASK            0x04
+#define DCDCCTRL_TSTEP0_SHIFT           2
+#define DCDCCTRL_DCDC_MODE_MASK         0x02
+#define DCDCCTRL_DCDC_MODE_SHIFT        1
+#define DCDCCTRL_RSVD0_MASK             0x01
+#define DCDCCTRL_RSVD0_SHIFT            0
+
+/* Register DCDCCTRL4 register.RegisterDescription */
+#define DCDCCTRL_RAMP_TIME_MASK         0x01
+#define DCDCCTRL_RAMP_TIME_SHIFT        0
+
+/* Register DCDCx_AVS */
+#define DCDC_AVS_ENABLE_MASK            0x80
+#define DCDC_AVS_ENABLE_SHIFT           7
+#define DCDC_AVS_ECO_MASK               0x40
+#define DCDC_AVS_ECO_SHIFT              6
+
+/* Register DCDCx_LIMIT */
+#define DCDC_LIMIT_RANGE_MASK           0xC0
+#define DCDC_LIMIT_RANGE_SHIFT          6
+#define DCDC_LIMIT_MAX_SEL_MASK         0x3F
+#define DCDC_LIMIT_MAX_SEL_SHIFT        0
+
+/**
+ * struct tps65912_board
+ * Board platform dat may be used to initialize regulators.
+ */
+struct tps65912_board {
+        int is_dcdc1_avs;
+        int is_dcdc2_avs;
+        int is_dcdc3_avs;
+        int is_dcdc4_avs;
+        int irq;
+        int irq_base;
+        int gpio_base;
+        struct regulator_init_data *tps65912_pmic_init_data;
+};
+
+/**
+ * struct tps65912 - tps65912 sub-driver chip access routines
+ */
+
+struct tps65912 {
+        struct device *dev;
+        /* for read/write acces */
+        struct mutex io_mutex;
+
+        /* For device IO interfaces: I2C or SPI */
+        void *control_data;
+
+        int (*read)(struct tps65912 *tps65912, u8 reg, int size, void *dest);
+        int (*write)(struct tps65912 *tps65912, u8 reg, int size, void *src);
+
+        /* Client devices */
+        struct tps65912_pmic *pmic;
+
+        /* GPIO Handling */
+        struct gpio_chip gpio;
+
+        /* IRQ Handling */
+        struct mutex irq_lock;
+        int chip_irq;
+        int irq_base;
+        int irq_num;
+        u32 irq_mask;
+};
+
+struct tps65912_platform_data {
+        int irq;
+        int irq_base;
+};
+
+unsigned int tps_chip(void);
+
+int tps65912_set_bits(struct tps65912 *tps65912, u8 reg, u8 mask);
+int tps65912_clear_bits(struct tps65912 *tps65912, u8 reg, u8 mask);
+int tps65912_reg_read(struct tps65912 *tps65912, u8 reg);
+int tps65912_reg_write(struct tps65912 *tps65912, u8 reg, u8 val);
+int tps65912_device_init(struct tps65912 *tps65912);
+void tps65912_device_exit(struct tps65912 *tps65912);
+int tps65912_irq_init(struct tps65912 *tps65912, int irq,
+                        struct tps65912_platform_data *pdata);
+
+#endif /*  __LINUX_MFD_TPS65912_H */
diff --git a/include/linux/mfd/tps6591x.h b/include/linux/mfd/tps6591x.h
new file mode 100644
index 00000000000..d0d829fc8ab
--- /dev/null
+++ b/include/linux/mfd/tps6591x.h
@@ -0,0 +1,124 @@
+/*
+ * include/linux/mfd/tps6591x.c
+ * Core driver interface for TI TPS6591x PMIC family
+ *
+ * Copyright (C) 2011 NVIDIA Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#ifndef __LINUX_MFD_TPS6591X_H
+#define __LINUX_MFD_TPS6591X_H
+
+#include <linux/rtc.h>
+
+enum {
+        TPS6591X_INT_PWRHOLD_F,
+        TPS6591X_INT_VMBHI,
+        TPS6591X_INT_PWRON,
+        TPS6591X_INT_PWRON_LP,
+        TPS6591X_INT_PWRHOLD_R,
+        TPS6591X_INT_HOTDIE,
+        TPS6591X_INT_RTC_ALARM,
+        TPS6591X_INT_RTC_PERIOD,
+        TPS6591X_INT_GPIO0,
+        TPS6591X_INT_GPIO1,
+        TPS6591X_INT_GPIO2,
+        TPS6591X_INT_GPIO3,
+        TPS6591X_INT_GPIO4,
+        TPS6591X_INT_GPIO5,
+        TPS6591X_INT_WTCHDG,
+        TPS6591X_INT_VMBCH2_H,
+        TPS6591X_INT_VMBCH2_L,
+        TPS6591X_INT_PWRDN,
+
+        /* Last entry */
+        TPS6591X_INT_NR,
+};
+
+/* Gpio definitions */
+enum {
+        TPS6591X_GPIO_GP0 = 0,
+        TPS6591X_GPIO_GP1 = 1,
+        TPS6591X_GPIO_GP2 = 2,
+        TPS6591X_GPIO_GP3 = 3,
+        TPS6591X_GPIO_GP4 = 4,
+        TPS6591X_GPIO_GP5 = 5,
+        TPS6591X_GPIO_GP6 = 6,
+        TPS6591X_GPIO_GP7 = 7,
+        TPS6591X_GPIO_GP8 = 8,
+
+        /* Last entry */
+        TPS6591X_GPIO_NR,
+};
+
+struct tps6591x_subdev_info {
+        int             id;
+        const char      *name;
+        void            *platform_data;
+};
+
+struct tps6591x_rtc_platform_data {
+        int irq;
+        struct rtc_time time;
+};
+
+struct tps6591x_sleep_keepon_data {
+        /* set 1 to maintain the following on sleep mode */
+        unsigned therm_keepon:1;        /* themal monitoring */
+        unsigned clkout32k_keepon:1;    /* CLK32KOUT */
+        unsigned vrtc_keepon:1;         /* LD0 full load capability */
+        unsigned i2chs_keepon:1;        /* high speed internal clock */
+};
+
+struct tps6591x_gpio_init_data {
+        unsigned sleep_en:1;    /* Enable sleep mode */
+        unsigned pulldn_en:1;   /* Enable pull down */
+        unsigned output_mode_en:1; /* Enable output mode during init */
+        unsigned output_val:1;  /* Output value if it is in output mode */
+        unsigned init_apply:1;  /* Apply init data on configuring gpios*/
+};
+
+struct tps6591x_platform_data {
+        int gpio_base;
+        int irq_base;
+
+        int num_subdevs;
+        struct tps6591x_subdev_info *subdevs;
+
+        bool dev_slp_en;
+        struct tps6591x_sleep_keepon_data *slp_keepon;
+
+        struct tps6591x_gpio_init_data *gpio_init_data;
+        int num_gpioinit_data;
+
+        bool use_power_off;
+};
+
+/*
+ * NOTE: the functions below are not intended for use outside
+ * of the TPS6591X sub-device drivers
+ */
+extern int tps6591x_write(struct device *dev, int reg, uint8_t val);
+extern int tps6591x_writes(struct device *dev, int reg, int len, uint8_t *val);
+extern int tps6591x_read(struct device *dev, int reg, uint8_t *val);
+extern int tps6591x_reads(struct device *dev, int reg, int len, uint8_t *val);
+extern int tps6591x_set_bits(struct device *dev, int reg, uint8_t bit_mask);
+extern int tps6591x_clr_bits(struct device *dev, int reg, uint8_t bit_mask);
+extern int tps6591x_update(struct device *dev, int reg, uint8_t val,
+                           uint8_t mask);
+
+#endif /*__LINUX_MFD_TPS6591X_H */
diff --git a/include/linux/mfd/tps80031.h b/include/linux/mfd/tps80031.h
new file mode 100644
index 00000000000..1802dfefef0
--- /dev/null
+++ b/include/linux/mfd/tps80031.h
@@ -0,0 +1,203 @@
+/*
+ * include/linux/mfd/tps80031.c
+ *
+ * Core driver interface for TI TPS80031 PMIC
+ *
+ * Copyright (C) 2011 NVIDIA Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#ifndef __LINUX_MFD_TPS80031_H
+#define __LINUX_MFD_TPS80031_H
+
+#include <linux/rtc.h>
+
+/* Supported chips */
+enum chips {
+        TPS80031 = 0x00000001,
+        TPS80032 = 0x00000002,
+};
+
+enum {
+        TPS80031_INT_PWRON,
+        TPS80031_INT_RPWRON,
+        TPS80031_INT_SYS_VLOW,
+        TPS80031_INT_RTC_ALARM,
+        TPS80031_INT_RTC_PERIOD,
+        TPS80031_INT_HOT_DIE,
+        TPS80031_INT_VXX_SHORT,
+        TPS80031_INT_SPDURATION,
+        TPS80031_INT_WATCHDOG,
+        TPS80031_INT_BAT,
+        TPS80031_INT_SIM,
+        TPS80031_INT_MMC,
+        TPS80031_INT_RES,
+        TPS80031_INT_GPADC_RT,
+        TPS80031_INT_GPADC_SW2_EOC,
+        TPS80031_INT_CC_AUTOCAL,
+        TPS80031_INT_ID_WKUP,
+        TPS80031_INT_VBUSS_WKUP,
+        TPS80031_INT_ID,
+        TPS80031_INT_VBUS,
+        TPS80031_INT_CHRG_CTRL,
+        TPS80031_INT_EXT_CHRG,
+        TPS80031_INT_INT_CHRG,
+        TPS80031_INT_RES2,
+        TPS80031_INT_BAT_TEMP_OVRANGE,
+        TPS80031_INT_BAT_REMOVED,
+        TPS80031_INT_VBUS_DET,
+        TPS80031_INT_VAC_DET,
+        TPS80031_INT_FAULT_WDG,
+        TPS80031_INT_LINCH_GATED,
+
+        /* Last interrupt id to get the end number */
+        TPS80031_INT_NR,
+};
+
+enum adc_channel {
+        BATTERY_TYPE                    = 0,  /* External ADC */
+        BATTERY_TEMPERATURE             = 1,  /* External ADC */
+        AUDIO_ACCESSORY                 = 2,  /* External ADC */
+        TEMPERATURE_EXTERNAL_DIODE      = 3,  /* External ADC */
+        TEMPERATURE_MEASUREMENT         = 4,  /* External ADC */
+        GENERAL_PURPOSE_1               = 5,  /* External ADC */
+        GENERAL_PURPOSE_2               = 6,  /* External ADC */
+        SYSTEM_SUPPLY                   = 7,  /* Internal ADC */
+        BACKUP_BATTERY                  = 8,  /* Internal ADC */
+        EXTERNAL_CHARGER_INPUT          = 9,  /* Internal ADC */
+        VBUS                            = 10, /* Internal ADC */
+        VBUS_DCDC_OUTPUT_CURRENT        = 11, /* Internal ADC */
+        DIE_TEMPERATURE_1               = 12, /* Internal ADC */
+        DIE_TEMPERATURE_2               = 13, /* Internal ADC */
+        USB_ID_LINE                     = 14, /* Internal ADC */
+        TEST_NETWORK_1                  = 15, /* Internal ADC */
+        TEST_NETWORK_2                  = 16, /* Internal ADC */
+        BATTERY_CHARGING_CURRENT        = 17, /* Internal ADC */
+        BATTERY_VOLTAGE                 = 18, /* Internal ADC */
+};
+
+enum TPS80031_GPIO {
+        TPS80031_GPIO_REGEN1,
+        TPS80031_GPIO_REGEN2,
+        TPS80031_GPIO_SYSEN,
+
+        /* Last entry */
+        TPS80031_GPIO_NR,
+};
+
+enum TPS80031_CLOCK32K {
+        TPS80031_CLOCK32K_AO,
+        TPS80031_CLOCK32K_G,
+        TPS80031_CLOCK32K_AUDIO,
+
+        /* Last entry */
+        TPS80031_CLOCK32K_NR,
+};
+
+enum {
+        SLAVE_ID0 = 0,
+        SLAVE_ID1 = 1,
+        SLAVE_ID2 = 2,
+        SLAVE_ID3 = 3,
+};
+
+enum {
+        I2C_ID0_ADDR = 0x12,
+        I2C_ID1_ADDR = 0x48,
+        I2C_ID2_ADDR = 0x49,
+        I2C_ID3_ADDR = 0x4A,
+};
+
+/* External controls requests */
+enum tps80031_ext_control {
+        PWR_REQ_INPUT_NONE      = 0x00000000,
+        PWR_REQ_INPUT_PREQ1     = 0x00000001,
+        PWR_REQ_INPUT_PREQ2     = 0x00000002,
+        PWR_REQ_INPUT_PREQ3     = 0x00000004,
+        PWR_OFF_ON_SLEEP        = 0x00000008,
+        PWR_ON_ON_SLEEP         = 0x00000010,
+};
+
+struct tps80031_subdev_info {
+        int             id;
+        const char      *name;
+        void            *platform_data;
+};
+
+struct tps80031_rtc_platform_data {
+        int irq;
+        struct rtc_time time;
+};
+
+struct tps80031_clk32k_init_data {
+        int clk32k_nr;
+        bool enable;
+        unsigned long ext_ctrl_flag;
+};
+
+struct tps80031_gpio_init_data {
+        int gpio_nr;
+        unsigned long ext_ctrl_flag;
+};
+
+struct tps80031_platform_data {
+        int num_subdevs;
+        struct tps80031_subdev_info *subdevs;
+        int gpio_base;
+        int irq_base;
+        struct tps80031_32kclock_plat_data *clk32k_pdata;
+        struct tps80031_gpio_init_data *gpio_init_data;
+        int gpio_init_data_size;
+        struct tps80031_clk32k_init_data *clk32k_init_data;
+        int clk32k_init_data_size;
+        bool use_power_off;
+};
+
+struct tps80031_bg_platform_data {
+        int irq_base;
+        int battery_present;
+};
+
+/*
+ * NOTE: the functions below are not intended for use outside
+ * of the TPS80031 sub-device drivers
+ */
+extern int tps80031_write(struct device *dev, int sid, int reg, uint8_t val);
+extern int tps80031_writes(struct device *dev, int sid, int reg, int len,
+                                uint8_t *val);
+extern int tps80031_read(struct device *dev, int sid, int reg, uint8_t *val);
+extern int tps80031_reads(struct device *dev, int sid, int reg, int len,
+                                uint8_t *val);
+extern int tps80031_set_bits(struct device *dev, int sid, int reg,
+                                uint8_t bit_mask);
+extern int tps80031_clr_bits(struct device *dev, int sid, int reg,
+                                uint8_t bit_mask);
+extern int tps80031_update(struct device *dev, int sid, int reg, uint8_t val,
+                           uint8_t mask);
+extern int tps80031_force_update(struct device *dev, int sid, int reg,
+                                 uint8_t val, uint8_t mask);
+extern int tps80031_ext_power_req_config(struct device *dev,
+                unsigned long ext_ctrl_flag, int preq_bit,
+                int state_reg_add, int trans_reg_add);
+
+extern unsigned long tps80031_get_chip_info(struct device *dev);
+
+extern int tps80031_gpadc_conversion(int channle_no);
+
+extern int tps80031_get_pmu_version(struct device *dev);
+
+#endif /*__LINUX_MFD_TPS80031_H */
diff --git a/include/linux/mfd/twl4030-codec.h b/include/linux/mfd/twl4030-audio.h
index 5cc16bbd1da..3d22b72df07 100644
--- a/include/linux/mfd/twl4030-codec.h
+++ b/include/linux/mfd/twl4030-audio.h
@@ -1,5 +1,5 @@
 /*
- * MFD driver for twl4030 codec submodule
+ * MFD driver for twl4030 audio submodule
  *
  * Author: Peter Ujfalusi <peter.ujfalusi@ti.com>
  *
@@ -259,14 +259,14 @@
 #define TWL4030_VIBRA_DIR_SEL           0x20
 
 /* TWL4030 codec resource IDs */
-enum twl4030_codec_res {
-        TWL4030_CODEC_RES_POWER = 0,
-        TWL4030_CODEC_RES_APLL,
-        TWL4030_CODEC_RES_MAX,
+enum twl4030_audio_res {
+        TWL4030_AUDIO_RES_POWER = 0,
+        TWL4030_AUDIO_RES_APLL,
+        TWL4030_AUDIO_RES_MAX,
 };
 
-int twl4030_codec_disable_resource(enum twl4030_codec_res id);
-int twl4030_codec_enable_resource(enum twl4030_codec_res id);
-unsigned int twl4030_codec_get_mclk(void);
+int twl4030_audio_disable_resource(enum twl4030_audio_res id);
+int twl4030_audio_enable_resource(enum twl4030_audio_res id);
+unsigned int twl4030_audio_get_mclk(void);
 
 #endif  /* End of __TWL4030_CODEC_H__ */
diff --git a/include/linux/mfd/twl6040.h b/include/linux/mfd/twl6040.h
new file mode 100644
index 00000000000..4c806f6d663
--- /dev/null
+++ b/include/linux/mfd/twl6040.h
@@ -0,0 +1,228 @@
+/*
+ * MFD driver for twl6040
+ *
+ * Authors:     Jorge Eduardo Candelaria <jorge.candelaria@ti.com>
+ *              Misael Lopez Cruz <misael.lopez@ti.com>
+ *
+ * Copyright:   (C) 2011 Texas Instruments, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef __TWL6040_CODEC_H__
+#define __TWL6040_CODEC_H__
+
+#include <linux/interrupt.h>
+#include <linux/mfd/core.h>
+
+#define TWL6040_REG_ASICID              0x01
+#define TWL6040_REG_ASICREV             0x02
+#define TWL6040_REG_INTID               0x03
+#define TWL6040_REG_INTMR               0x04
+#define TWL6040_REG_NCPCTL              0x05
+#define TWL6040_REG_LDOCTL              0x06
+#define TWL6040_REG_HPPLLCTL            0x07
+#define TWL6040_REG_LPPLLCTL            0x08
+#define TWL6040_REG_LPPLLDIV            0x09
+#define TWL6040_REG_AMICBCTL            0x0A
+#define TWL6040_REG_DMICBCTL            0x0B
+#define TWL6040_REG_MICLCTL             0x0C
+#define TWL6040_REG_MICRCTL             0x0D
+#define TWL6040_REG_MICGAIN             0x0E
+#define TWL6040_REG_LINEGAIN            0x0F
+#define TWL6040_REG_HSLCTL              0x10
+#define TWL6040_REG_HSRCTL              0x11
+#define TWL6040_REG_HSGAIN              0x12
+#define TWL6040_REG_EARCTL              0x13
+#define TWL6040_REG_HFLCTL              0x14
+#define TWL6040_REG_HFLGAIN             0x15
+#define TWL6040_REG_HFRCTL              0x16
+#define TWL6040_REG_HFRGAIN             0x17
+#define TWL6040_REG_VIBCTLL             0x18
+#define TWL6040_REG_VIBDATL             0x19
+#define TWL6040_REG_VIBCTLR             0x1A
+#define TWL6040_REG_VIBDATR             0x1B
+#define TWL6040_REG_HKCTL1              0x1C
+#define TWL6040_REG_HKCTL2              0x1D
+#define TWL6040_REG_GPOCTL              0x1E
+#define TWL6040_REG_ALB                 0x1F
+#define TWL6040_REG_DLB                 0x20
+#define TWL6040_REG_TRIM1               0x28
+#define TWL6040_REG_TRIM2               0x29
+#define TWL6040_REG_TRIM3               0x2A
+#define TWL6040_REG_HSOTRIM             0x2B
+#define TWL6040_REG_HFOTRIM             0x2C
+#define TWL6040_REG_ACCCTL              0x2D
+#define TWL6040_REG_STATUS              0x2E
+
+#define TWL6040_CACHEREGNUM             (TWL6040_REG_STATUS + 1)
+
+#define TWL6040_VIOREGNUM               18
+#define TWL6040_VDDREGNUM               21
+
+/* INTID (0x03) fields */
+
+#define TWL6040_THINT                   0x01
+#define TWL6040_PLUGINT                 0x02
+#define TWL6040_UNPLUGINT               0x04
+#define TWL6040_HOOKINT                 0x08
+#define TWL6040_HFINT                   0x10
+#define TWL6040_VIBINT                  0x20
+#define TWL6040_READYINT                0x40
+
+/* INTMR (0x04) fields */
+
+#define TWL6040_THMSK                   0x01
+#define TWL6040_PLUGMSK                 0x02
+#define TWL6040_HOOKMSK                 0x08
+#define TWL6040_HFMSK                   0x10
+#define TWL6040_VIBMSK                  0x20
+#define TWL6040_READYMSK                0x40
+#define TWL6040_ALLINT_MSK              0x7B
+
+/* NCPCTL (0x05) fields */
+
+#define TWL6040_NCPENA                  0x01
+#define TWL6040_NCPOPEN                 0x40
+
+/* LDOCTL (0x06) fields */
+
+#define TWL6040_LSLDOENA                0x01
+#define TWL6040_HSLDOENA                0x04
+#define TWL6040_REFENA                  0x40
+#define TWL6040_OSCENA                  0x80
+
+/* HPPLLCTL (0x07) fields */
+
+#define TWL6040_HPLLENA                 0x01
+#define TWL6040_HPLLRST                 0x02
+#define TWL6040_HPLLBP                  0x04
+#define TWL6040_HPLLSQRENA              0x08
+#define TWL6040_MCLK_12000KHZ           (0 << 5)
+#define TWL6040_MCLK_19200KHZ           (1 << 5)
+#define TWL6040_MCLK_26000KHZ           (2 << 5)
+#define TWL6040_MCLK_38400KHZ           (3 << 5)
+#define TWL6040_MCLK_MSK                0x60
+
+/* LPPLLCTL (0x08) fields */
+
+#define TWL6040_LPLLENA                 0x01
+#define TWL6040_LPLLRST                 0x02
+#define TWL6040_LPLLSEL                 0x04
+#define TWL6040_LPLLFIN                 0x08
+#define TWL6040_HPLLSEL                 0x10
+
+/* HSLCTL (0x10) fields */
+
+#define TWL6040_HSDACMODEL              0x02
+#define TWL6040_HSDRVMODEL              0x08
+
+/* HSRCTL (0x11) fields */
+
+#define TWL6040_HSDACMODER              0x02
+#define TWL6040_HSDRVMODER              0x08
+
+/* VIBCTLL (0x18) fields */
+
+#define TWL6040_VIBENAL                 0x01
+#define TWL6040_VIBCTRLL                0x04
+#define TWL6040_VIBCTRLLP               0x08
+#define TWL6040_VIBCTRLLN               0x10
+
+/* VIBDATL (0x19) fields */
+
+#define TWL6040_VIBDAT_MAX              0x64
+
+/* VIBCTLR (0x1A) fields */
+
+#define TWL6040_VIBENAR                 0x01
+#define TWL6040_VIBCTRLR                0x04
+#define TWL6040_VIBCTRLRP               0x08
+#define TWL6040_VIBCTRLRN               0x10
+
+/* GPOCTL (0x1E) fields */
+
+#define TWL6040_GPO1                    0x01
+#define TWL6040_GPO2                    0x02
+#define TWL6040_GPO3                    0x03
+
+/* ACCCTL (0x2D) fields */
+
+#define TWL6040_I2CSEL                  0x01
+#define TWL6040_RESETSPLIT              0x04
+#define TWL6040_INTCLRMODE              0x08
+
+/* STATUS (0x2E) fields */
+
+#define TWL6040_PLUGCOMP                0x02
+#define TWL6040_VIBLOCDET               0x10
+#define TWL6040_VIBROCDET               0x20
+#define TWL6040_TSHUTDET                0x40
+
+#define TWL6040_CELLS                   2
+
+#define TWL6040_REV_ES1_0               0x00
+#define TWL6040_REV_ES1_1               0x01
+#define TWL6040_REV_ES1_2               0x02
+
+#define TWL6040_IRQ_TH                  0
+#define TWL6040_IRQ_PLUG                1
+#define TWL6040_IRQ_HOOK                2
+#define TWL6040_IRQ_HF                  3
+#define TWL6040_IRQ_VIB                 4
+#define TWL6040_IRQ_READY               5
+
+/* PLL selection */
+#define TWL6040_SYSCLK_SEL_LPPLL        0
+#define TWL6040_SYSCLK_SEL_HPPLL        1
+
+struct twl6040 {
+        struct device *dev;
+        struct mutex mutex;
+        struct mutex io_mutex;
+        struct mutex irq_mutex;
+        struct mfd_cell cells[TWL6040_CELLS];
+        struct completion ready;
+
+        int audpwron;
+        int power_count;
+        int rev;
+
+        int pll;
+        unsigned int sysclk;
+
+        unsigned int irq;
+        unsigned int irq_base;
+        u8 irq_masks_cur;
+        u8 irq_masks_cache;
+};
+
+int twl6040_reg_read(struct twl6040 *twl6040, unsigned int reg);
+int twl6040_reg_write(struct twl6040 *twl6040, unsigned int reg,
+                      u8 val);
+int twl6040_set_bits(struct twl6040 *twl6040, unsigned int reg,
+                     u8 mask);
+int twl6040_clear_bits(struct twl6040 *twl6040, unsigned int reg,
+                       u8 mask);
+int twl6040_power(struct twl6040 *twl6040, int on);
+int twl6040_set_pll(struct twl6040 *twl6040, int pll_id,
+                    unsigned int freq_in, unsigned int freq_out);
+int twl6040_get_pll(struct twl6040 *twl6040);
+unsigned int twl6040_get_sysclk(struct twl6040 *twl6040);
+int twl6040_irq_init(struct twl6040 *twl6040);
+void twl6040_irq_exit(struct twl6040 *twl6040);
+
+#endif  /* End of __TWL6040_CODEC_H__ */
diff --git a/include/linux/mfd/wm831x/core.h b/include/linux/mfd/wm831x/core.h
index 0d515ee1c24..ed8fe0d0409 100644
--- a/include/linux/mfd/wm831x/core.h
+++ b/include/linux/mfd/wm831x/core.h
@@ -17,6 +17,8 @@
 
 #include <linux/completion.h>
 #include <linux/interrupt.h>
+#include <linux/list.h>
+#include <linux/regmap.h>
 
 /*
  * Register values.
@@ -234,9 +236,111 @@
 #define WM831X_ON_PIN_TO_SHIFT                       0  /* ON_PIN_TO - [1:0] */
 #define WM831X_ON_PIN_TO_WIDTH                       2  /* ON_PIN_TO - [1:0] */
 
+/*
+ * R16528 (0x4090) - Clock Control 1
+ */
+#define WM831X_CLKOUT_ENA                       0x8000  /* CLKOUT_ENA */
+#define WM831X_CLKOUT_ENA_MASK                  0x8000  /* CLKOUT_ENA */
+#define WM831X_CLKOUT_ENA_SHIFT                     15  /* CLKOUT_ENA */
+#define WM831X_CLKOUT_ENA_WIDTH                      1  /* CLKOUT_ENA */
+#define WM831X_CLKOUT_OD                        0x2000  /* CLKOUT_OD */
+#define WM831X_CLKOUT_OD_MASK                   0x2000  /* CLKOUT_OD */
+#define WM831X_CLKOUT_OD_SHIFT                      13  /* CLKOUT_OD */
+#define WM831X_CLKOUT_OD_WIDTH                       1  /* CLKOUT_OD */
+#define WM831X_CLKOUT_SLOT_MASK                 0x0700  /* CLKOUT_SLOT - [10:8] */
+#define WM831X_CLKOUT_SLOT_SHIFT                     8  /* CLKOUT_SLOT - [10:8] */
+#define WM831X_CLKOUT_SLOT_WIDTH                     3  /* CLKOUT_SLOT - [10:8] */
+#define WM831X_CLKOUT_SLPSLOT_MASK              0x0070  /* CLKOUT_SLPSLOT - [6:4] */
+#define WM831X_CLKOUT_SLPSLOT_SHIFT                  4  /* CLKOUT_SLPSLOT - [6:4] */
+#define WM831X_CLKOUT_SLPSLOT_WIDTH                  3  /* CLKOUT_SLPSLOT - [6:4] */
+#define WM831X_CLKOUT_SRC                       0x0001  /* CLKOUT_SRC */
+#define WM831X_CLKOUT_SRC_MASK                  0x0001  /* CLKOUT_SRC */
+#define WM831X_CLKOUT_SRC_SHIFT                      0  /* CLKOUT_SRC */
+#define WM831X_CLKOUT_SRC_WIDTH                      1  /* CLKOUT_SRC */
+
+/*
+ * R16529 (0x4091) - Clock Control 2
+ */
+#define WM831X_XTAL_INH                         0x8000  /* XTAL_INH */
+#define WM831X_XTAL_INH_MASK                    0x8000  /* XTAL_INH */
+#define WM831X_XTAL_INH_SHIFT                       15  /* XTAL_INH */
+#define WM831X_XTAL_INH_WIDTH                        1  /* XTAL_INH */
+#define WM831X_XTAL_ENA                         0x2000  /* XTAL_ENA */
+#define WM831X_XTAL_ENA_MASK                    0x2000  /* XTAL_ENA */
+#define WM831X_XTAL_ENA_SHIFT                       13  /* XTAL_ENA */
+#define WM831X_XTAL_ENA_WIDTH                        1  /* XTAL_ENA */
+#define WM831X_XTAL_BKUPENA                     0x1000  /* XTAL_BKUPENA */
+#define WM831X_XTAL_BKUPENA_MASK                0x1000  /* XTAL_BKUPENA */
+#define WM831X_XTAL_BKUPENA_SHIFT                   12  /* XTAL_BKUPENA */
+#define WM831X_XTAL_BKUPENA_WIDTH                    1  /* XTAL_BKUPENA */
+#define WM831X_FLL_AUTO                         0x0080  /* FLL_AUTO */
+#define WM831X_FLL_AUTO_MASK                    0x0080  /* FLL_AUTO */
+#define WM831X_FLL_AUTO_SHIFT                        7  /* FLL_AUTO */
+#define WM831X_FLL_AUTO_WIDTH                        1  /* FLL_AUTO */
+#define WM831X_FLL_AUTO_FREQ_MASK               0x0007  /* FLL_AUTO_FREQ - [2:0] */
+#define WM831X_FLL_AUTO_FREQ_SHIFT                   0  /* FLL_AUTO_FREQ - [2:0] */
+#define WM831X_FLL_AUTO_FREQ_WIDTH                   3  /* FLL_AUTO_FREQ - [2:0] */
+
+/*
+ * R16530 (0x4092) - FLL Control 1
+ */
+#define WM831X_FLL_FRAC                         0x0004  /* FLL_FRAC */
+#define WM831X_FLL_FRAC_MASK                    0x0004  /* FLL_FRAC */
+#define WM831X_FLL_FRAC_SHIFT                        2  /* FLL_FRAC */
+#define WM831X_FLL_FRAC_WIDTH                        1  /* FLL_FRAC */
+#define WM831X_FLL_OSC_ENA                      0x0002  /* FLL_OSC_ENA */
+#define WM831X_FLL_OSC_ENA_MASK                 0x0002  /* FLL_OSC_ENA */
+#define WM831X_FLL_OSC_ENA_SHIFT                     1  /* FLL_OSC_ENA */
+#define WM831X_FLL_OSC_ENA_WIDTH                     1  /* FLL_OSC_ENA */
+#define WM831X_FLL_ENA                          0x0001  /* FLL_ENA */
+#define WM831X_FLL_ENA_MASK                     0x0001  /* FLL_ENA */
+#define WM831X_FLL_ENA_SHIFT                         0  /* FLL_ENA */
+#define WM831X_FLL_ENA_WIDTH                         1  /* FLL_ENA */
+
+/*
+ * R16531 (0x4093) - FLL Control 2
+ */
+#define WM831X_FLL_OUTDIV_MASK                  0x3F00  /* FLL_OUTDIV - [13:8] */
+#define WM831X_FLL_OUTDIV_SHIFT                      8  /* FLL_OUTDIV - [13:8] */
+#define WM831X_FLL_OUTDIV_WIDTH                      6  /* FLL_OUTDIV - [13:8] */
+#define WM831X_FLL_CTRL_RATE_MASK               0x0070  /* FLL_CTRL_RATE - [6:4] */
+#define WM831X_FLL_CTRL_RATE_SHIFT                   4  /* FLL_CTRL_RATE - [6:4] */
+#define WM831X_FLL_CTRL_RATE_WIDTH                   3  /* FLL_CTRL_RATE - [6:4] */
+#define WM831X_FLL_FRATIO_MASK                  0x0007  /* FLL_FRATIO - [2:0] */
+#define WM831X_FLL_FRATIO_SHIFT                      0  /* FLL_FRATIO - [2:0] */
+#define WM831X_FLL_FRATIO_WIDTH                      3  /* FLL_FRATIO - [2:0] */
+
+/*
+ * R16532 (0x4094) - FLL Control 3
+ */
+#define WM831X_FLL_K_MASK                       0xFFFF  /* FLL_K - [15:0] */
+#define WM831X_FLL_K_SHIFT                           0  /* FLL_K - [15:0] */
+#define WM831X_FLL_K_WIDTH                          16  /* FLL_K - [15:0] */
+
+/*
+ * R16533 (0x4095) - FLL Control 4
+ */
+#define WM831X_FLL_N_MASK                       0x7FE0  /* FLL_N - [14:5] */
+#define WM831X_FLL_N_SHIFT                           5  /* FLL_N - [14:5] */
+#define WM831X_FLL_N_WIDTH                          10  /* FLL_N - [14:5] */
+#define WM831X_FLL_GAIN_MASK                    0x000F  /* FLL_GAIN - [3:0] */
+#define WM831X_FLL_GAIN_SHIFT                        0  /* FLL_GAIN - [3:0] */
+#define WM831X_FLL_GAIN_WIDTH                        4  /* FLL_GAIN - [3:0] */
+
+/*
+ * R16534 (0x4096) - FLL Control 5
+ */
+#define WM831X_FLL_CLK_REF_DIV_MASK             0x0018  /* FLL_CLK_REF_DIV - [4:3] */
+#define WM831X_FLL_CLK_REF_DIV_SHIFT                 3  /* FLL_CLK_REF_DIV - [4:3] */
+#define WM831X_FLL_CLK_REF_DIV_WIDTH                 2  /* FLL_CLK_REF_DIV - [4:3] */
+#define WM831X_FLL_CLK_SRC_MASK                 0x0003  /* FLL_CLK_SRC - [1:0] */
+#define WM831X_FLL_CLK_SRC_SHIFT                     0  /* FLL_CLK_SRC - [1:0] */
+#define WM831X_FLL_CLK_SRC_WIDTH                     2  /* FLL_CLK_SRC - [1:0] */
+
 struct regulator_dev;
 
 #define WM831X_NUM_IRQ_REGS 5
+#define WM831X_NUM_GPIO_REGS 16
 
 enum wm831x_parent {
         WM8310 = 0x8310,
@@ -248,23 +352,27 @@ enum wm831x_parent {
         WM8326 = 0x8326,
 };
 
+struct wm831x;
+enum wm831x_auxadc;
+
+typedef int (*wm831x_auxadc_read_fn)(struct wm831x *wm831x,
+                                     enum wm831x_auxadc input);
+
 struct wm831x {
         struct mutex io_lock;
 
         struct device *dev;
-        int (*read_dev)(struct wm831x *wm831x, unsigned short reg,
-                        int bytes, void *dest);
-        int (*write_dev)(struct wm831x *wm831x, unsigned short reg,
-                         int bytes, void *src);
 
-        void *control_data;
+        struct regmap *regmap;
 
         int irq;  /* Our chip IRQ */
         struct mutex irq_lock;
-        unsigned int irq_base;
+        int irq_base;
         int irq_masks_cur[WM831X_NUM_IRQ_REGS];   /* Currently active value */
         int irq_masks_cache[WM831X_NUM_IRQ_REGS]; /* Cached hardware value */
 
+        bool soft_shutdown;
+
         /* Chip revision based flags */
         unsigned has_gpio_ena:1;         /* Has GPIO enable bit */
         unsigned has_cs_sts:1;           /* Has current sink status bit */
@@ -272,8 +380,13 @@ struct wm831x {
 
         int num_gpio;
 
+        /* Used by the interrupt controller code to post writes */
+        int gpio_update[WM831X_NUM_GPIO_REGS];
+
         struct mutex auxadc_lock;
-        struct completion auxadc_done;
+        struct list_head auxadc_pending;
+        u16 auxadc_active;
+        wm831x_auxadc_read_fn auxadc_read;
 
         /* The WM831x has a security key blocking access to certain
          * registers.  The mutex is taken by the accessors for locking
@@ -298,7 +411,11 @@ int wm831x_bulk_read(struct wm831x *wm831x, unsigned short reg,
 int wm831x_device_init(struct wm831x *wm831x, unsigned long id, int irq);
 void wm831x_device_exit(struct wm831x *wm831x);
 int wm831x_device_suspend(struct wm831x *wm831x);
+void wm831x_device_shutdown(struct wm831x *wm831x);
 int wm831x_irq_init(struct wm831x *wm831x, int irq);
 void wm831x_irq_exit(struct wm831x *wm831x);
+void wm831x_auxadc_init(struct wm831x *wm831x);
+
+extern struct regmap_config wm831x_regmap_config;
 
 #endif
diff --git a/include/linux/mfd/wm831x/pdata.h b/include/linux/mfd/wm831x/pdata.h
index ff42d700293..1d7a3f7b3b5 100644
--- a/include/linux/mfd/wm831x/pdata.h
+++ b/include/linux/mfd/wm831x/pdata.h
@@ -120,6 +120,12 @@ struct wm831x_pdata {
         /** Put the /IRQ line into CMOS mode */
         bool irq_cmos;
 
+        /** Disable the touchscreen */
+        bool disable_touch;
+
+        /** The driver should initiate a power off sequence during shutdown */
+        bool soft_shutdown;
+
         int irq_base;
         int gpio_base;
         int gpio_defaults[WM831X_GPIO_NUM];
diff --git a/include/linux/mfd/wm8400-private.h b/include/linux/mfd/wm8400-private.h
index 2aab4e93a5c..0147b696851 100644
--- a/include/linux/mfd/wm8400-private.h
+++ b/include/linux/mfd/wm8400-private.h
@@ -25,16 +25,15 @@
 #include <linux/mutex.h>
 #include <linux/platform_device.h>
 
+struct regmap;
+
 #define WM8400_REGISTER_COUNT 0x55
 
 struct wm8400 {
         struct device *dev;
 
-        int (*read_dev)(void *data, char reg, int count, u16 *dst);
-        int (*write_dev)(void *data, char reg, int count, const u16 *src);
-
         struct mutex io_lock;
-        void *io_data;
+        struct regmap *regmap;
 
         u16 reg_cache[WM8400_REGISTER_COUNT];
 
diff --git a/include/linux/mfd/wm8994/core.h b/include/linux/mfd/wm8994/core.h
index f0b69cdae41..45df450d869 100644
--- a/include/linux/mfd/wm8994/core.h
+++ b/include/linux/mfd/wm8994/core.h
@@ -24,6 +24,7 @@ enum wm8994_type {
 
 struct regulator_dev;
 struct regulator_bulk_data;
+struct regmap;
 
 #define WM8994_NUM_GPIO_REGS 11
 #define WM8994_NUM_LDO_REGS   2
@@ -50,18 +51,12 @@ struct regulator_bulk_data;
 #define WM8994_IRQ_GPIO(x) (x + WM8994_IRQ_TEMP_WARN)
 
 struct wm8994 {
-        struct mutex io_lock;
         struct mutex irq_lock;
 
         enum wm8994_type type;
 
         struct device *dev;
-        int (*read_dev)(struct wm8994 *wm8994, unsigned short reg,
-                        int bytes, void *dest);
-        int (*write_dev)(struct wm8994 *wm8994, unsigned short reg,
-                         int bytes, const void *src);
-
-        void *control_data;
+        struct regmap *regmap;
 
         int gpio_base;
         int irq_base;
diff --git a/include/linux/mfd/wm8994/pdata.h b/include/linux/mfd/wm8994/pdata.h
index d12f8d635a8..97cf4f27d64 100644
--- a/include/linux/mfd/wm8994/pdata.h
+++ b/include/linux/mfd/wm8994/pdata.h
@@ -26,7 +26,7 @@ struct wm8994_ldo_pdata {
         struct regulator_init_data *init_data;
 };
 
-#define WM8994_CONFIGURE_GPIO 0x8000
+#define WM8994_CONFIGURE_GPIO 0x10000
 
 #define WM8994_DRC_REGS 5
 #define WM8994_EQ_REGS  20
diff --git a/include/linux/mii.h b/include/linux/mii.h
index 359fba88027..103113a2fd1 100644
--- a/include/linux/mii.h
+++ b/include/linux/mii.h
@@ -128,6 +128,8 @@
 /* 1000BASE-T Control register */
 #define ADVERTISE_1000FULL      0x0200  /* Advertise 1000BASE-T full duplex */
 #define ADVERTISE_1000HALF      0x0100  /* Advertise 1000BASE-T half duplex */
+#define CTL1000_AS_MASTER       0x0800
+#define CTL1000_ENABLE_MASTER   0x1000
 
 /* 1000BASE-T Status register */
 #define LPA_1000LOCALRXOK       0x2000  /* Link partner local receiver status */
diff --git a/include/linux/miscdevice.h b/include/linux/miscdevice.h
index 18fd13028ba..c309b1ecdc1 100644
--- a/include/linux/miscdevice.h
+++ b/include/linux/miscdevice.h
@@ -40,6 +40,7 @@
 #define BTRFS_MINOR             234
 #define AUTOFS_MINOR            235
 #define MAPPER_CTRL_MINOR       236
+#define LOOP_CTRL_MINOR         237
 #define MISC_DYNAMIC_MINOR      255
 
 struct device;
diff --git a/include/linux/mlx4/cmd.h b/include/linux/mlx4/cmd.h
index 9a18667c13c..b56e4587208 100644
--- a/include/linux/mlx4/cmd.h
+++ b/include/linux/mlx4/cmd.h
@@ -123,6 +123,9 @@ enum {
         /* debug commands */
         MLX4_CMD_QUERY_DEBUG_MSG = 0x2a,
         MLX4_CMD_SET_DEBUG_MSG   = 0x2b,
+
+        /* statistics commands */
+        MLX4_CMD_QUERY_IF_STAT   = 0X54,
 };
 
 enum {
diff --git a/include/linux/mlx4/device.h b/include/linux/mlx4/device.h
index 8985768e2c0..53ef894bfa0 100644
--- a/include/linux/mlx4/device.h
+++ b/include/linux/mlx4/device.h
@@ -37,7 +37,7 @@
 #include <linux/completion.h>
 #include <linux/radix-tree.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 #define MAX_MSIX_P_PORT         17
 #define MAX_MSIX                64
@@ -58,22 +58,28 @@ enum {
 };
 
 enum {
-        MLX4_DEV_CAP_FLAG_RC            = 1 <<  0,
-        MLX4_DEV_CAP_FLAG_UC            = 1 <<  1,
-        MLX4_DEV_CAP_FLAG_UD            = 1 <<  2,
-        MLX4_DEV_CAP_FLAG_SRQ           = 1 <<  6,
-        MLX4_DEV_CAP_FLAG_IPOIB_CSUM    = 1 <<  7,
-        MLX4_DEV_CAP_FLAG_BAD_PKEY_CNTR = 1 <<  8,
-        MLX4_DEV_CAP_FLAG_BAD_QKEY_CNTR = 1 <<  9,
-        MLX4_DEV_CAP_FLAG_DPDP          = 1 << 12,
-        MLX4_DEV_CAP_FLAG_BLH           = 1 << 15,
-        MLX4_DEV_CAP_FLAG_MEM_WINDOW    = 1 << 16,
-        MLX4_DEV_CAP_FLAG_APM           = 1 << 17,
-        MLX4_DEV_CAP_FLAG_ATOMIC        = 1 << 18,
-        MLX4_DEV_CAP_FLAG_RAW_MCAST     = 1 << 19,
-        MLX4_DEV_CAP_FLAG_UD_AV_PORT    = 1 << 20,
-        MLX4_DEV_CAP_FLAG_UD_MCAST      = 1 << 21,
-        MLX4_DEV_CAP_FLAG_IBOE          = 1 << 30
+        MLX4_DEV_CAP_FLAG_RC            = 1LL <<  0,
+        MLX4_DEV_CAP_FLAG_UC            = 1LL <<  1,
+        MLX4_DEV_CAP_FLAG_UD            = 1LL <<  2,
+        MLX4_DEV_CAP_FLAG_SRQ           = 1LL <<  6,
+        MLX4_DEV_CAP_FLAG_IPOIB_CSUM    = 1LL <<  7,
+        MLX4_DEV_CAP_FLAG_BAD_PKEY_CNTR = 1LL <<  8,
+        MLX4_DEV_CAP_FLAG_BAD_QKEY_CNTR = 1LL <<  9,
+        MLX4_DEV_CAP_FLAG_DPDP          = 1LL << 12,
+        MLX4_DEV_CAP_FLAG_BLH           = 1LL << 15,
+        MLX4_DEV_CAP_FLAG_MEM_WINDOW    = 1LL << 16,
+        MLX4_DEV_CAP_FLAG_APM           = 1LL << 17,
+        MLX4_DEV_CAP_FLAG_ATOMIC        = 1LL << 18,
+        MLX4_DEV_CAP_FLAG_RAW_MCAST     = 1LL << 19,
+        MLX4_DEV_CAP_FLAG_UD_AV_PORT    = 1LL << 20,
+        MLX4_DEV_CAP_FLAG_UD_MCAST      = 1LL << 21,
+        MLX4_DEV_CAP_FLAG_IBOE          = 1LL << 30,
+        MLX4_DEV_CAP_FLAG_UC_LOOPBACK   = 1LL << 32,
+        MLX4_DEV_CAP_FLAG_WOL           = 1LL << 38,
+        MLX4_DEV_CAP_FLAG_UDP_RSS       = 1LL << 40,
+        MLX4_DEV_CAP_FLAG_VEP_UC_STEER  = 1LL << 41,
+        MLX4_DEV_CAP_FLAG_VEP_MC_STEER  = 1LL << 42,
+        MLX4_DEV_CAP_FLAG_COUNTERS      = 1LL << 48
 };
 
 enum {
@@ -253,15 +259,10 @@ struct mlx4_caps {
         int                     mtt_entry_sz;
         u32                     max_msg_sz;
         u32                     page_size_cap;
-        u32                     flags;
+        u64                     flags;
         u32                     bmme_flags;
         u32                     reserved_lkey;
         u16                     stat_rate_support;
-        int                     udp_rss;
-        int                     loopback_support;
-        int                     vep_uc_steering;
-        int                     vep_mc_steering;
-        int                     wol;
         u8                      port_width_cap[MLX4_MAX_PORTS + 1];
         int                     max_gso_sz;
         int                     reserved_qps_cnt[MLX4_NUM_QP_REGION];
@@ -274,6 +275,7 @@ struct mlx4_caps {
         u8                      supported_type[MLX4_MAX_PORTS + 1];
         u32                     port_mask;
         enum mlx4_port_type     possible_type[MLX4_MAX_PORTS + 1];
+        u32                     max_counters;
 };
 
 struct mlx4_buf_list {
@@ -438,6 +440,17 @@ union mlx4_ext_av {
         struct mlx4_eth_av      eth;
 };
 
+struct mlx4_counter {
+        u8      reserved1[3];
+        u8      counter_mode;
+        __be32  num_ifc;
+        u32     reserved2[2];
+        __be64  rx_frames;
+        __be64  rx_bytes;
+        __be64  tx_frames;
+        __be64  tx_bytes;
+};
+
 struct mlx4_dev {
         struct pci_dev         *pdev;
         unsigned long           flags;
@@ -568,4 +581,7 @@ void mlx4_release_eq(struct mlx4_dev *dev, int vec);
 int mlx4_wol_read(struct mlx4_dev *dev, u64 *config, int port);
 int mlx4_wol_write(struct mlx4_dev *dev, u64 config, int port);
 
+int mlx4_counter_alloc(struct mlx4_dev *dev, u32 *idx);
+void mlx4_counter_free(struct mlx4_dev *dev, u32 idx);
+
 #endif /* MLX4_DEVICE_H */
diff --git a/include/linux/mlx4/qp.h b/include/linux/mlx4/qp.h
index 9e9eb21056c..4001c8249db 100644
--- a/include/linux/mlx4/qp.h
+++ b/include/linux/mlx4/qp.h
@@ -54,7 +54,8 @@ enum mlx4_qp_optpar {
         MLX4_QP_OPTPAR_RETRY_COUNT              = 1 << 12,
         MLX4_QP_OPTPAR_RNR_RETRY                = 1 << 13,
         MLX4_QP_OPTPAR_ACK_TIMEOUT              = 1 << 14,
-        MLX4_QP_OPTPAR_SCHED_QUEUE              = 1 << 16
+        MLX4_QP_OPTPAR_SCHED_QUEUE              = 1 << 16,
+        MLX4_QP_OPTPAR_COUNTER_INDEX            = 1 << 20
 };
 
 enum mlx4_qp_state {
@@ -99,7 +100,7 @@ struct mlx4_qp_path {
         u8                      fl;
         u8                      reserved1[2];
         u8                      pkey_index;
-        u8                      reserved2;
+        u8                      counter_index;
         u8                      grh_mylmc;
         __be16                  rlid;
         u8                      ackto;
@@ -111,8 +112,7 @@ struct mlx4_qp_path {
         u8                      sched_queue;
         u8                      vlan_index;
         u8                      reserved3[2];
-        u8                      counter_index;
-        u8                      reserved4;
+        u8                      reserved4[2];
         u8                      dmac[6];
 };
 
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 9670f71d7be..d1d9840093f 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -15,6 +15,7 @@
 #include <linux/range.h>
 #include <linux/pfn.h>
 #include <linux/bit_spinlock.h>
+#include <linux/shrinker.h>
 
 struct mempolicy;
 struct anon_vma;
@@ -355,36 +356,50 @@ static inline struct page *compound_head(struct page *page)
         return page;
 }
 
+/*
+ * The atomic page->_mapcount, starts from -1: so that transitions
+ * both from it and to it can be tracked, using atomic_inc_and_test
+ * and atomic_add_negative(-1).
+ */
+static inline void reset_page_mapcount(struct page *page)
+{
+        atomic_set(&(page)->_mapcount, -1);
+}
+
+static inline int page_mapcount(struct page *page)
+{
+        return atomic_read(&(page)->_mapcount) + 1;
+}
+
 static inline int page_count(struct page *page)
 {
         return atomic_read(&compound_head(page)->_count);
 }
 
+static inline void get_huge_page_tail(struct page *page)
+{
+        /*
+         * __split_huge_page_refcount() cannot run
+         * from under us.
+         */
+        VM_BUG_ON(page_mapcount(page) < 0);
+        VM_BUG_ON(atomic_read(&page->_count) != 0);
+        atomic_inc(&page->_mapcount);
+}
+
+extern bool __get_page_tail(struct page *page);
+
 static inline void get_page(struct page *page)
 {
+        if (unlikely(PageTail(page)))
+                if (likely(__get_page_tail(page)))
+                        return;
         /*
          * Getting a normal page or the head of a compound page
-         * requires to already have an elevated page->_count. Only if
-         * we're getting a tail page, the elevated page->_count is
-         * required only in the head page, so for tail pages the
-         * bugcheck only verifies that the page->_count isn't
-         * negative.
+         * requires to already have an elevated page->_count.
          */
-        VM_BUG_ON(atomic_read(&page->_count) < !PageTail(page));
+        VM_BUG_ON(atomic_read(&page->_count) <= 0);
         atomic_inc(&page->_count);
-        /*
-         * Getting a tail page will elevate both the head and tail
-         * page->_count(s).
-         */
-        if (unlikely(PageTail(page))) {
-                /*
-                 * This is safe only because
-                 * __split_huge_page_refcount can't run under
-                 * get_page().
-                 */
-                VM_BUG_ON(atomic_read(&page->first_page->_count) <= 0);
-                atomic_inc(&page->first_page->_count);
-        }
 }
 
 static inline struct page *virt_to_head_page(const void *x)
@@ -636,7 +651,7 @@ static inline pte_t maybe_mkwrite(pte_t pte, struct vm_area_struct *vma)
 #define SECTIONS_MASK           ((1UL << SECTIONS_WIDTH) - 1)
 #define ZONEID_MASK             ((1UL << ZONEID_SHIFT) - 1)
 
-static inline enum zone_type page_zonenum(struct page *page)
+static inline enum zone_type page_zonenum(const struct page *page)
 {
         return (page->flags >> ZONES_PGSHIFT) & ZONES_MASK;
 }
@@ -664,15 +679,15 @@ static inline int zone_to_nid(struct zone *zone)
 }
 
 #ifdef NODE_NOT_IN_PAGE_FLAGS
-extern int page_to_nid(struct page *page);
+extern int page_to_nid(const struct page *page);
 #else
-static inline int page_to_nid(struct page *page)
+static inline int page_to_nid(const struct page *page)
 {
         return (page->flags >> NODES_PGSHIFT) & NODES_MASK;
 }
 #endif
 
-static inline struct zone *page_zone(struct page *page)
+static inline struct zone *page_zone(const struct page *page)
 {
         return &NODE_DATA(page_to_nid(page))->node_zones[page_zonenum(page)];
 }
@@ -684,7 +699,7 @@ static inline void set_page_section(struct page *page, unsigned long section)
         page->flags |= (section & SECTIONS_MASK) << SECTIONS_PGSHIFT;
 }
 
-static inline unsigned long page_to_section(struct page *page)
+static inline unsigned long page_to_section(const struct page *page)
 {
         return (page->flags >> SECTIONS_PGSHIFT) & SECTIONS_MASK;
 }
@@ -717,7 +732,7 @@ static inline void set_page_links(struct page *page, enum zone_type zone,
  */
 #include <linux/vmstat.h>
 
-static __always_inline void *lowmem_page_address(struct page *page)
+static __always_inline void *lowmem_page_address(const struct page *page)
 {
         return __va(PFN_PHYS(page_to_pfn(page)));
 }
@@ -736,7 +751,7 @@ static __always_inline void *lowmem_page_address(struct page *page)
 #endif
 
 #if defined(HASHED_PAGE_VIRTUAL)
-void *page_address(struct page *page);
+void *page_address(const struct page *page);
 void set_page_address(struct page *page, void *virtual);
 void page_address_init(void);
 #endif
@@ -803,21 +818,6 @@ static inline pgoff_t page_index(struct page *page)
 }
 
 /*
- * The atomic page->_mapcount, like _count, starts from -1:
- * so that transitions both from it and to it can be tracked,
- * using atomic_inc_and_test and atomic_add_negative(-1).
- */
-static inline void reset_page_mapcount(struct page *page)
-{
-        atomic_set(&(page)->_mapcount, -1);
-}
-
-static inline int page_mapcount(struct page *page)
-{
-        return atomic_read(&(page)->_mapcount) + 1;
-}
-
-/*
  * Return true if this page is mapped into pagetables.
  */
 static inline int page_mapped(struct page *page)
@@ -871,6 +871,7 @@ extern bool skip_free_areas_node(unsigned int flags, int nid);
 
 int shmem_lock(struct file *file, int lock, struct user_struct *user);
 struct file *shmem_file_setup(const char *name, loff_t size, unsigned long flags);
+void shmem_set_file(struct vm_area_struct *vma, struct file *file);
 int shmem_zero_setup(struct vm_area_struct *);
 
 extern int can_do_mlock(void);
@@ -910,6 +911,8 @@ unsigned long unmap_vmas(struct mmu_gather *tlb,
  * @pte_entry: if set, called for each non-empty PTE (4th-level) entry
  * @pte_hole: if set, called for each hole at all levels
  * @hugetlb_entry: if set, called for each hugetlb entry
+ *                 *Caution*: The caller must hold mmap_sem() if @hugetlb_entry
+ *                            is used.
  *
  * (see walk_page_range for more details)
  */
@@ -959,6 +962,8 @@ int invalidate_inode_page(struct page *page);
 #ifdef CONFIG_MMU
 extern int handle_mm_fault(struct mm_struct *mm, struct vm_area_struct *vma,
                         unsigned long address, unsigned int flags);
+extern int fixup_user_fault(struct task_struct *tsk, struct mm_struct *mm,
+                            unsigned long address, unsigned int fault_flags);
 #else
 static inline int handle_mm_fault(struct mm_struct *mm,
                         struct vm_area_struct *vma, unsigned long address,
@@ -968,6 +973,14 @@ static inline int handle_mm_fault(struct mm_struct *mm,
         BUG();
         return VM_FAULT_SIGBUS;
 }
+static inline int fixup_user_fault(struct task_struct *tsk,
+                struct mm_struct *mm, unsigned long address,
+                unsigned int fault_flags)
+{
+        /* should never happen if there's no MMU */
+        BUG();
+        return -EFAULT;
+}
 #endif
 
 extern int make_pages_present(unsigned long addr, unsigned long end);
@@ -1121,44 +1134,6 @@ static inline void sync_mm_rss(struct task_struct *task, struct mm_struct *mm)
 }
 #endif
 
-/*
- * This struct is used to pass information from page reclaim to the shrinkers.
- * We consolidate the values for easier extention later.
- */
-struct shrink_control {
-        gfp_t gfp_mask;
-
-        /* How many slab objects shrinker() should scan and try to reclaim */
-        unsigned long nr_to_scan;
-};
-
-/*
- * A callback you can register to apply pressure to ageable caches.
- *
- * 'sc' is passed shrink_control which includes a count 'nr_to_scan'
- * and a 'gfpmask'.  It should look through the least-recently-used
- * 'nr_to_scan' entries and attempt to free them up.  It should return
- * the number of objects which remain in the cache.  If it returns -1, it means
- * it cannot do any scanning at this time (eg. there is a risk of deadlock).
- *
- * The 'gfpmask' refers to the allocation we are currently trying to
- * fulfil.
- *
- * Note that 'shrink' will be passed nr_to_scan == 0 when the VM is
- * querying the cache size, so a fastpath for that case is appropriate.
- */
-struct shrinker {
-        int (*shrink)(struct shrinker *, struct shrink_control *sc);
-        int seeks;      /* seeks to recreate an obj */
-
-        /* These are for internal use */
-        struct list_head list;
-        long nr;        /* objs pending delete */
-};
-#define DEFAULT_SEEKS 2 /* A good number if you don't know better. */
-extern void register_shrinker(struct shrinker *);
-extern void unregister_shrinker(struct shrinker *);
-
 int vma_wants_writenotify(struct vm_area_struct *vma);
 
 extern pte_t *__get_locked_pte(struct mm_struct *mm, unsigned long addr,
@@ -1313,6 +1288,7 @@ extern void remove_active_range(unsigned int nid, unsigned long start_pfn,
                                         unsigned long end_pfn);
 extern void remove_all_active_ranges(void);
 void sort_node_map(void);
+unsigned long node_map_pfn_alignment(void);
 unsigned long __absent_pages_in_range(int nid, unsigned long start_pfn,
                                                 unsigned long end_pfn);
 extern unsigned long absent_pages_in_range(unsigned long start_pfn,
@@ -1445,8 +1421,7 @@ extern int do_munmap(struct mm_struct *, unsigned long, size_t);
 
 extern unsigned long do_brk(unsigned long, unsigned long);
 
-/* filemap.c */
-extern unsigned long page_unuse(struct page *);
+/* truncate.c */
 extern void truncate_inode_pages(struct address_space *, loff_t);
 extern void truncate_inode_pages_range(struct address_space *,
                                        loff_t lstart, loff_t lend);
@@ -1633,6 +1608,7 @@ enum mf_flags {
 };
 extern void memory_failure(unsigned long pfn, int trapno);
 extern int __memory_failure(unsigned long pfn, int trapno, int flags);
+extern void memory_failure_queue(unsigned long pfn, int trapno, int flags);
 extern int unpoison_memory(unsigned long pfn);
 extern int sysctl_memory_failure_early_kill;
 extern int sysctl_memory_failure_recovery;
diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
index 027935c86c6..10a2f62cd56 100644
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -30,23 +30,74 @@ struct address_space;
  * moment. Note that we have no way to track which tasks are using
  * a page, though if it is a pagecache page, rmap structures can tell us
  * who is mapping it.
+ *
+ * The objects in struct page are organized in double word blocks in
+ * order to allows us to use atomic double word operations on portions
+ * of struct page. That is currently only used by slub but the arrangement
+ * allows the use of atomic double word operations on the flags/mapping
+ * and lru list pointers also.
  */
 struct page {
+        /* First double word block */
         unsigned long flags;            /* Atomic flags, some possibly
                                          * updated asynchronously */
-        atomic_t _count;                /* Usage count, see below. */
-        union {
-                atomic_t _mapcount;     /* Count of ptes mapped in mms,
-                                         * to show when page is mapped
-                                         * & limit reverse map searches.
+        struct address_space *mapping;  /* If low bit clear, points to
+                                         * inode address_space, or NULL.
+                                         * If page mapped as anonymous
+                                         * memory, low bit is set, and
+                                         * it points to anon_vma object:
+                                         * see PAGE_MAPPING_ANON below.
+                                         */
+        /* Second double word */
+        struct {
+                union {
+                        pgoff_t index;          /* Our offset within mapping. */
+                        void *freelist;         /* slub first free object */
+                };
+
+                union {
+                        /* Used for cmpxchg_double in slub */
+                        unsigned long counters;
+
+                        struct {
+
+                                union {
+                                        /*
+                                         * Count of ptes mapped in
+                                         * mms, to show when page is
+                                         * mapped & limit reverse map
+                                         * searches.
+                                         *
+                                         * Used also for tail pages
+                                         * refcounting instead of
+                                         * _count. Tail pages cannot
+                                         * be mapped and keeping the
+                                         * tail page _count zero at
+                                         * all times guarantees
+                                         * get_page_unless_zero() will
+                                         * never succeed on tail
+                                         * pages.
                                          */
-                struct {                /* SLUB */
-                        u16 inuse;
-                        u16 objects;
+                                        atomic_t _mapcount;
+
+                                        struct {
+                                                unsigned inuse:16;
+                                                unsigned objects:15;
+                                                unsigned frozen:1;
+                                        };
+                                };
+                                atomic_t _count;                /* Usage count, see below. */
+                        };
                 };
         };
+
+        /* Third double word block */
+        struct list_head lru;           /* Pageout list, eg. active_list
+                                         * protected by zone->lru_lock !
+                                         */
+
+        /* Remainder is not double word aligned */
         union {
-            struct {
                 unsigned long private;          /* Mapping-private opaque data:
                                                  * usually used for buffer_heads
                                                  * if PagePrivate set; used for
@@ -54,27 +105,13 @@ struct page {
                                                  * indicates order in the buddy
                                                  * system if PG_buddy is set.
                                                  */
-                struct address_space *mapping;  /* If low bit clear, points to
-                                                 * inode address_space, or NULL.
-                                                 * If page mapped as anonymous
-                                                 * memory, low bit is set, and
-                                                 * it points to anon_vma object:
-                                                 * see PAGE_MAPPING_ANON below.
-                                                 */
-            };
 #if USE_SPLIT_PTLOCKS
-            spinlock_t ptl;
+                spinlock_t ptl;
 #endif
-            struct kmem_cache *slab;    /* SLUB: Pointer to slab */
-            struct page *first_page;    /* Compound tail pages */
+                struct kmem_cache *slab;        /* SLUB: Pointer to slab */
+                struct page *first_page;        /* Compound tail pages */
         };
-        union {
-                pgoff_t index;          /* Our offset within mapping. */
-                void *freelist;         /* SLUB: freelist req. slab lock */
-        };
-        struct list_head lru;           /* Pageout list, eg. active_list
-                                         * protected by zone->lru_lock !
-                                         */
+
         /*
          * On machines where all RAM is mapped into kernel address space,
          * we can simply calculate the virtual address. On machines with
@@ -100,7 +137,16 @@ struct page {
          */
         void *shadow;
 #endif
-};
+}
+/*
+ * If another subsystem starts using the double word pairing for atomic
+ * operations on struct page then it must change the #if to ensure
+ * proper alignment of the page struct.
+ */
+#if defined(CONFIG_SLUB) && defined(CONFIG_CMPXCHG_LOCAL)
+        __attribute__((__aligned__(2*sizeof(unsigned long))))
+#endif
+;
 
 typedef unsigned long __nocast vm_flags_t;
 
diff --git a/include/linux/mman.h b/include/linux/mman.h
index 9872d6ca58a..8b74e9b1d0a 100644
--- a/include/linux/mman.h
+++ b/include/linux/mman.h
@@ -14,7 +14,7 @@
 #include <linux/mm.h>
 #include <linux/percpu_counter.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 extern int sysctl_overcommit_memory;
 extern int sysctl_overcommit_ratio;
diff --git a/include/linux/mmc/boot.h b/include/linux/mmc/boot.h
index 39d787c229c..23acc3baa07 100644
--- a/include/linux/mmc/boot.h
+++ b/include/linux/mmc/boot.h
@@ -1,7 +1,7 @@
-#ifndef MMC_BOOT_H
-#define MMC_BOOT_H
+#ifndef LINUX_MMC_BOOT_H
+#define LINUX_MMC_BOOT_H
 
 enum { MMC_PROGRESS_ENTER, MMC_PROGRESS_INIT,
        MMC_PROGRESS_LOAD, MMC_PROGRESS_DONE };
 
-#endif
+#endif /* LINUX_MMC_BOOT_H */
diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
index 6ad43554ac0..9178aa48209 100644
--- a/include/linux/mmc/card.h
+++ b/include/linux/mmc/card.h
@@ -77,6 +77,12 @@ struct mmc_ext_csd {
         u8                      raw_sec_feature_support;/* 231 */
         u8                      raw_trim_mult;          /* 232 */
         u8                      raw_sectors[4];         /* 212 - 4 bytes */
+        bool                    hpi_en;                 /* HPI enablebit */
+        bool                    hpi;                    /* HPI support bit */
+        unsigned int            hpi_cmd;                /* cmd used as HPI */
+        u8                      out_of_int_time;        /* out of int time */
+        bool                    bk_ops;                 /* BK ops support bit */
+        bool                    bk_ops_en;              /* BK ops enable bit */
 };
 
 struct sd_scr {
@@ -176,6 +182,8 @@ struct mmc_card {
 #define MMC_STATE_BLOCKADDR     (1<<3)          /* card uses block-addressing */
 #define MMC_STATE_HIGHSPEED_DDR (1<<4)          /* card is in high speed mode */
 #define MMC_STATE_ULTRAHIGHSPEED (1<<5)         /* card is in ultra high speed mode */
+#define MMC_STATE_DOING_BKOPS   (1<<6)          /* Card doing bkops */
+#define MMC_STATE_NEED_BKOPS    (1<<7)          /* Card needs to do bkops */
 #define MMC_CARD_SDXC           (1<<6)          /* card is SDXC */
         unsigned int            quirks;         /* card quirks */
 #define MMC_QUIRK_LENIENT_FN0   (1<<0)          /* allow SDIO FN0 writes outside of the VS CCCR range */
@@ -312,9 +320,10 @@ static inline void __maybe_unused remove_quirk(struct mmc_card *card, int data)
 #define mmc_card_highspeed(c)   ((c)->state & MMC_STATE_HIGHSPEED)
 #define mmc_card_blockaddr(c)   ((c)->state & MMC_STATE_BLOCKADDR)
 #define mmc_card_ddr_mode(c)    ((c)->state & MMC_STATE_HIGHSPEED_DDR)
-#define mmc_sd_card_uhs(c) ((c)->state & MMC_STATE_ULTRAHIGHSPEED)
+#define mmc_sd_card_uhs(c)      ((c)->state & MMC_STATE_ULTRAHIGHSPEED)
 #define mmc_card_ext_capacity(c) ((c)->state & MMC_CARD_SDXC)
-
+#define mmc_card_doing_bkops(c) ((c)->state & MMC_STATE_DOING_BKOPS)
+#define mmc_card_need_bkops(c) ((c)->state & MMC_STATE_NEED_BKOPS)
 #define mmc_card_set_present(c) ((c)->state |= MMC_STATE_PRESENT)
 #define mmc_card_set_readonly(c) ((c)->state |= MMC_STATE_READONLY)
 #define mmc_card_set_highspeed(c) ((c)->state |= MMC_STATE_HIGHSPEED)
@@ -356,6 +365,11 @@ static inline void __maybe_unused remove_quirk_sd(struct mmc_card *card,
         if (mmc_card_sd(card))
                 card->quirks &= ~data;
 }
+#define mmc_card_set_doing_bkops(c) ((c)->state |= MMC_STATE_DOING_BKOPS)
+#define mmc_card_set_need_bkops(c) ((c)->state |= MMC_STATE_NEED_BKOPS)
+
+#define mmc_card_clr_doing_bkops(c) ((c)->state &= ~MMC_STATE_DOING_BKOPS)
+#define mmc_card_clr_need_bkops(c) ((c)->state &= ~MMC_STATE_NEED_BKOPS)
 
 static inline int mmc_card_lenient_fn0(const struct mmc_card *c)
 {
@@ -403,4 +417,4 @@ extern void mmc_unregister_driver(struct mmc_driver *);
 extern void mmc_fixup_device(struct mmc_card *card,
                              const struct mmc_fixup *table);
 
-#endif
+#endif /* LINUX_MMC_CARD_H */
diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
index b6718e549a5..c3e55fa63fb 100644
--- a/include/linux/mmc/core.h
+++ b/include/linux/mmc/core.h
@@ -117,6 +117,7 @@ struct mmc_data {
 
         unsigned int            sg_len;         /* size of scatter list */
         struct scatterlist      *sg;            /* I/O scatter list */
+        s32                     host_cookie;    /* host private data */
 };
 
 struct mmc_request {
@@ -125,12 +126,18 @@ struct mmc_request {
         struct mmc_data         *data;
         struct mmc_command      *stop;
 
-        void                    *done_data;     /* completion data */
+        struct completion       completion;
         void                    (*done)(struct mmc_request *);/* completion function */
 };
 
 struct mmc_host;
 struct mmc_card;
+struct mmc_async_req;
+
+extern struct mmc_async_req *mmc_start_req(struct mmc_host *,
+                                           struct mmc_async_req *, int *);
+extern int mmc_interrupt_hpi(struct mmc_card *);
+extern int mmc_bkops_start(struct mmc_card *card, bool is_synchronous);
 
 extern void mmc_wait_for_req(struct mmc_host *, struct mmc_request *);
 extern int mmc_wait_for_cmd(struct mmc_host *, struct mmc_command *, int);
@@ -155,6 +162,7 @@ extern int mmc_can_trim(struct mmc_card *card);
 extern int mmc_can_secure_erase_trim(struct mmc_card *card);
 extern int mmc_erase_group_aligned(struct mmc_card *card, unsigned int from,
                                    unsigned int nr);
+extern unsigned int mmc_calc_max_discard(struct mmc_card *card);
 
 extern int mmc_set_blocklen(struct mmc_card *card, unsigned int blocklen);
 
@@ -179,4 +187,4 @@ static inline void mmc_claim_host(struct mmc_host *host)
 
 extern u32 mmc_vddrange_to_ocrmask(int vdd_min, int vdd_max);
 
-#endif
+#endif /* LINUX_MMC_CORE_H */
diff --git a/include/linux/mmc/dw_mmc.h b/include/linux/mmc/dw_mmc.h
index bdd7ceeb99e..6b46819705d 100644
--- a/include/linux/mmc/dw_mmc.h
+++ b/include/linux/mmc/dw_mmc.h
@@ -11,8 +11,8 @@
  * (at your option) any later version.
  */
 
-#ifndef _LINUX_MMC_DW_MMC_H_
-#define _LINUX_MMC_DW_MMC_H_
+#ifndef LINUX_MMC_DW_MMC_H
+#define LINUX_MMC_DW_MMC_H
 
 #define MAX_MCI_SLOTS   2
 
@@ -48,6 +48,7 @@ struct mmc_data;
  * @data: The data currently being transferred, or NULL if no data
  *      transfer is in progress.
  * @use_dma: Whether DMA channel is initialized or not.
+ * @using_dma: Whether DMA is in use for the current transfer.
  * @sg_dma: Bus address of DMA buffer.
  * @sg_cpu: Virtual address of DMA buffer.
  * @dma_ops: Pointer to platform-specific DMA callbacks.
@@ -74,7 +75,11 @@ struct mmc_data;
  * @pdev: Platform device associated with the MMC controller.
  * @pdata: Platform data associated with the MMC controller.
  * @slot: Slots sharing this MMC controller.
+ * @fifo_depth: depth of FIFO.
  * @data_shift: log2 of FIFO item size.
+ * @part_buf_start: Start index in part_buf.
+ * @part_buf_count: Bytes of partial data in part_buf.
+ * @part_buf: Simple buffer for partial fifo reads/writes.
  * @push_data: Pointer to FIFO push function.
  * @pull_data: Pointer to FIFO pull function.
  * @quirks: Set of quirks that apply to specific versions of the IP.
@@ -117,6 +122,7 @@ struct dw_mci {
 
         /* DMA interface members*/
         int                     use_dma;
+        int                     using_dma;
 
         dma_addr_t              sg_dma;
         void                    *sg_cpu;
@@ -131,7 +137,7 @@ struct dw_mci {
         u32                     stop_cmdr;
         u32                     dir_status;
         struct tasklet_struct   tasklet;
-        struct tasklet_struct   card_tasklet;
+        struct work_struct      card_work;
         unsigned long           pending_events;
         unsigned long           completed_events;
         enum dw_mci_state       state;
@@ -146,7 +152,15 @@ struct dw_mci {
         struct dw_mci_slot      *slot[MAX_MCI_SLOTS];
 
         /* FIFO push and pull */
+        int                     fifo_depth;
         int                     data_shift;
+        u8                      part_buf_start;
+        u8                      part_buf_count;
+        union {
+                u16             part_buf16;
+                u32             part_buf32;
+                u64             part_buf;
+        };
         void (*push_data)(struct dw_mci *host, void *buf, int cnt);
         void (*pull_data)(struct dw_mci *host, void *buf, int cnt);
 
@@ -196,6 +210,12 @@ struct dw_mci_board {
         unsigned int bus_hz; /* Bus speed */
 
         unsigned int caps;      /* Capabilities */
+        /*
+         * Override fifo depth. If 0, autodetect it from the FIFOTH register,
+         * but note that this may not be reliable after a bootloader has used
+         * it.
+         */
+        unsigned int fifo_depth;
 
         /* delay in mS before detecting cards after interrupt */
         u32 detect_delay_ms;
@@ -219,4 +239,4 @@ struct dw_mci_board {
         struct block_settings *blk_settings;
 };
 
-#endif /* _LINUX_MMC_DW_MMC_H_ */
+#endif /* LINUX_MMC_DW_MMC_H */
diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h
index 1ee4424462e..8c0bf3f2a36 100644
--- a/include/linux/mmc/host.h
+++ b/include/linux/mmc/host.h
@@ -12,6 +12,7 @@
 
 #include <linux/leds.h>
 #include <linux/sched.h>
+#include <linux/wakelock.h>
 
 #include <linux/mmc/core.h>
 #include <linux/mmc/pm.h>
@@ -56,8 +57,6 @@ struct mmc_ios {
 #define MMC_TIMING_UHS_SDR104   4
 #define MMC_TIMING_UHS_DDR50    5
 
-        unsigned char   ddr;                    /* dual data rate used */
-
 #define MMC_SDR_MODE            0
 #define MMC_1_2V_DDR_MODE       1
 #define MMC_1_8V_DDR_MODE       2
@@ -106,6 +105,15 @@ struct mmc_host_ops {
          */
         int (*enable)(struct mmc_host *host);
         int (*disable)(struct mmc_host *host, int lazy);
+        /*
+         * It is optional for the host to implement pre_req and post_req in
+         * order to support double buffering of requests (prepare one
+         * request while another request is active).
+         */
+        void    (*post_req)(struct mmc_host *host, struct mmc_request *req,
+                            int err);
+        void    (*pre_req)(struct mmc_host *host, struct mmc_request *req,
+                           bool is_first_req);
         void    (*request)(struct mmc_host *host, struct mmc_request *req);
         /*
          * Avoid calling these three functions too often or in a "fast path",
@@ -139,11 +147,22 @@ struct mmc_host_ops {
         int     (*start_signal_voltage_switch)(struct mmc_host *host, struct mmc_ios *ios);
         int     (*execute_tuning)(struct mmc_host *host);
         void    (*enable_preset_value)(struct mmc_host *host, bool enable);
+        int     (*select_drive_strength)(unsigned int max_dtr, int host_drv, int card_drv);
 };
 
 struct mmc_card;
 struct device;
 
+struct mmc_async_req {
+        /* active mmc request */
+        struct mmc_request      *mrq;
+        /*
+         * Check error status of completed mmc request.
+         * Returns 0 if success otherwise non zero.
+         */
+        int (*err_check) (struct mmc_card *, struct mmc_async_req *);
+};
+
 struct mmc_host {
         struct device           *parent;
         struct device           class_dev;
@@ -211,6 +230,7 @@ struct mmc_host {
 #define MMC_CAP_MAX_CURRENT_600 (1 << 28)       /* Host max current limit is 600mA */
 #define MMC_CAP_MAX_CURRENT_800 (1 << 29)       /* Host max current limit is 800mA */
 #define MMC_CAP_CMD23           (1 << 30)       /* CMD23 supported. */
+#define MMC_CAP_BKOPS           (1 << 31)       /* Host supports BKOPS */
 
         mmc_pm_flag_t           pm_caps;        /* supported pm features */
 
@@ -231,6 +251,7 @@ struct mmc_host {
         unsigned int            max_req_size;   /* maximum number of bytes in one req */
         unsigned int            max_blk_size;   /* maximum size of one mmc block */
         unsigned int            max_blk_count;  /* maximum number of blocks in one req */
+        unsigned int            max_discard_to; /* max. discard timeout in ms */
 
         /* private data */
         spinlock_t              lock;           /* lock for claim and bus ops */
@@ -261,10 +282,15 @@ struct mmc_host {
         int                     claim_cnt;      /* "claim" nesting count */
 
         struct delayed_work     detect;
+        struct wake_lock        detect_wake_lock;
 
         const struct mmc_bus_ops *bus_ops;      /* current bus driver */
         unsigned int            bus_refs;       /* reference counter */
 
+        unsigned int            bus_resume_flags;
+#define MMC_BUSRESUME_MANUAL_RESUME     (1 << 0)
+#define MMC_BUSRESUME_NEEDS_RESUME      (1 << 1)
+
         unsigned int            sdio_irqs;
         struct task_struct      *sdio_irq_thread;
         atomic_t                sdio_irq_thread_abort;
@@ -281,6 +307,17 @@ struct mmc_host {
 
         struct dentry           *debugfs_root;
 
+        struct mmc_async_req    *areq;          /* active async req */
+
+#ifdef CONFIG_MMC_EMBEDDED_SDIO
+        struct {
+                struct sdio_cis                 *cis;
+                struct sdio_cccr                *cccr;
+                struct sdio_embedded_func       *funcs;
+                int                             num_funcs;
+        } embedded_sdio_data;
+#endif
+
         unsigned long           private[0] ____cacheline_aligned;
 };
 
@@ -289,6 +326,14 @@ extern int mmc_add_host(struct mmc_host *);
 extern void mmc_remove_host(struct mmc_host *);
 extern void mmc_free_host(struct mmc_host *);
 
+#ifdef CONFIG_MMC_EMBEDDED_SDIO
+extern void mmc_set_embedded_sdio_data(struct mmc_host *host,
+                                       struct sdio_cis *cis,
+                                       struct sdio_cccr *cccr,
+                                       struct sdio_embedded_func *funcs,
+                                       int num_funcs);
+#endif
+
 static inline void *mmc_priv(struct mmc_host *host)
 {
         return (void *)host->private;
@@ -299,6 +344,18 @@ static inline void *mmc_priv(struct mmc_host *host)
 #define mmc_dev(x)      ((x)->parent)
 #define mmc_classdev(x) (&(x)->class_dev)
 #define mmc_hostname(x) (dev_name(&(x)->class_dev))
+#define mmc_bus_needs_resume(host) ((host)->bus_resume_flags & MMC_BUSRESUME_NEEDS_RESUME)
+#define mmc_bus_manual_resume(host) ((host)->bus_resume_flags & MMC_BUSRESUME_MANUAL_RESUME)
+
+static inline void mmc_set_bus_resume_policy(struct mmc_host *host, int manual)
+{
+        if (manual)
+                host->bus_resume_flags |= MMC_BUSRESUME_MANUAL_RESUME;
+        else
+                host->bus_resume_flags &= ~MMC_BUSRESUME_MANUAL_RESUME;
+}
+
+extern int mmc_resume_bus(struct mmc_host *host);
 
 extern int mmc_suspend_host(struct mmc_host *);
 extern int mmc_resume_host(struct mmc_host *);
@@ -373,5 +430,4 @@ static inline int mmc_host_cmd23(struct mmc_host *host)
 {
         return host->caps & MMC_CAP_CMD23;
 }
-#endif
-
+#endif /* LINUX_MMC_HOST_H */
diff --git a/include/linux/mmc/ioctl.h b/include/linux/mmc/ioctl.h
index 5baf2983a12..8fa5bc5f805 100644
--- a/include/linux/mmc/ioctl.h
+++ b/include/linux/mmc/ioctl.h
@@ -51,4 +51,4 @@ struct mmc_ioc_cmd {
  * block device operations.
  */
 #define MMC_IOC_MAX_BYTES  (512L * 256)
-#endif  /* LINUX_MMC_IOCTL_H */
+#endif /* LINUX_MMC_IOCTL_H */
diff --git a/include/linux/mmc/mmc.h b/include/linux/mmc/mmc.h
index ac26a685cca..2bb1dfd4cf1 100644
--- a/include/linux/mmc/mmc.h
+++ b/include/linux/mmc/mmc.h
@@ -21,8 +21,8 @@
  *          15 May 2002
  */
 
-#ifndef MMC_MMC_H
-#define MMC_MMC_H
+#ifndef LINUX_MMC_MMC_H
+#define LINUX_MMC_MMC_H
 
 /* Standard MMC commands (4.1)           type  argument     response */
    /* class 1 */
@@ -138,8 +138,19 @@ static inline bool mmc_op_multi(u32 opcode)
 #define R1_CURRENT_STATE(x)     ((x & 0x00001E00) >> 9) /* sx, b (4 bits) */
 #define R1_READY_FOR_DATA       (1 << 8)        /* sx, a */
 #define R1_SWITCH_ERROR         (1 << 7)        /* sx, c */
+#define R1_URGENT_BKOPS (1 << 6)        /* sr, a */
 #define R1_APP_CMD              (1 << 5)        /* sr, c */
 
+#define R1_STATE_IDLE   0
+#define R1_STATE_READY  1
+#define R1_STATE_IDENT  2
+#define R1_STATE_STBY   3
+#define R1_STATE_TRAN   4
+#define R1_STATE_DATA   5
+#define R1_STATE_RCV    6
+#define R1_STATE_PRG    7
+#define R1_STATE_DIS    8
+
 /*
  * MMC/SD in SPI mode reports R1 status always, and R2 for SEND_STATUS
  * R1 is the low order byte; R2 is the next highest byte, when present.
@@ -262,6 +273,9 @@ struct _mmc_csd {
 
 #define EXT_CSD_PARTITION_ATTRIBUTE     156     /* R/W */
 #define EXT_CSD_PARTITION_SUPPORT       160     /* RO */
+#define EXT_CSD_HPI_MGMT                161     /* R/W */
+#define EXT_CSD_BKOPS_EN                163     /* R/W */
+#define EXT_CSD_BKOPS_START             164     /* R/W */
 #define EXT_CSD_WR_REL_PARAM            166     /* RO */
 #define EXT_CSD_ERASE_GROUP_DEF         175     /* R/W */
 #define EXT_CSD_PART_CONFIG             179     /* R/W */
@@ -271,6 +285,7 @@ struct _mmc_csd {
 #define EXT_CSD_REV                     192     /* RO */
 #define EXT_CSD_STRUCTURE               194     /* RO */
 #define EXT_CSD_CARD_TYPE               196     /* RO */
+#define EXT_CSD_OUT_OF_INTERRUPT_TIME   198     /* RO */
 #define EXT_CSD_PART_SWITCH_TIME        199     /* RO */
 #define EXT_CSD_SEC_CNT                 212     /* RO, 4 bytes */
 #define EXT_CSD_S_A_TIMEOUT             217     /* RO */
@@ -283,6 +298,9 @@ struct _mmc_csd {
 #define EXT_CSD_SEC_ERASE_MULT          230     /* RO */
 #define EXT_CSD_SEC_FEATURE_SUPPORT     231     /* RO */
 #define EXT_CSD_TRIM_MULT               232     /* RO */
+#define EXT_CSD_BKOPS_STATUS            246     /* RO */
+#define EXT_CSD_BKOPS_SUPPORT           502     /* RO */
+#define EXT_CSD_HPI_FEATURES            503     /* RO */
 
 /*
  * EXT_CSD field definitions
@@ -327,5 +345,4 @@ struct _mmc_csd {
 #define MMC_SWITCH_MODE_CLEAR_BITS      0x02    /* Clear bits which are 1 in value */
 #define MMC_SWITCH_MODE_WRITE_BYTE      0x03    /* Set target to value */
 
-#endif  /* MMC_MMC_PROTOCOL_H */
-
+#endif /* LINUX_MMC_MMC_H */
diff --git a/include/linux/mmc/pm.h b/include/linux/mmc/pm.h
index d37aac49cf9..6e2d6a135c7 100644
--- a/include/linux/mmc/pm.h
+++ b/include/linux/mmc/pm.h
@@ -26,5 +26,6 @@ typedef unsigned int mmc_pm_flag_t;
 
 #define MMC_PM_KEEP_POWER       (1 << 0)        /* preserve card power during suspend */
 #define MMC_PM_WAKE_SDIO_IRQ    (1 << 1)        /* wake up host system on SDIO IRQ assertion */
+#define MMC_PM_IGNORE_PM_NOTIFY (1 << 2)        /* ignore mmc pm notify */
 
-#endif
+#endif /* LINUX_MMC_PM_H */
diff --git a/include/linux/mmc/sd.h b/include/linux/mmc/sd.h
index 7d35d52c3df..1ebcf9ba125 100644
--- a/include/linux/mmc/sd.h
+++ b/include/linux/mmc/sd.h
@@ -9,8 +9,8 @@
  * your option) any later version.
  */
 
-#ifndef MMC_SD_H
-#define MMC_SD_H
+#ifndef LINUX_MMC_SD_H
+#define LINUX_MMC_SD_H
 
 /* SD commands                           type  argument     response */
   /* class 0 */
@@ -91,5 +91,4 @@
 #define SD_SWITCH_ACCESS_DEF    0
 #define SD_SWITCH_ACCESS_HS     1
 
-#endif
-
+#endif /* LINUX_MMC_SD_H */
diff --git a/include/linux/mmc/sdhci-pltfm.h b/include/linux/mmc/sdhci-pltfm.h
deleted file mode 100644
index 548d59d404c..00000000000
--- a/include/linux/mmc/sdhci-pltfm.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Platform data declarations for the sdhci-pltfm driver.
- *
- * Copyright (c) 2010 MontaVista Software, LLC.
- *
- * Author: Anton Vorontsov <avorontsov@ru.mvista.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or (at
- * your option) any later version.
- */
-
-#ifndef _SDHCI_PLTFM_H
-#define _SDHCI_PLTFM_H
-
-struct sdhci_ops;
-struct sdhci_host;
-
-/**
- * struct sdhci_pltfm_data - SDHCI platform-specific information & hooks
- * @ops: optional pointer to the platform-provided SDHCI ops
- * @quirks: optional SDHCI quirks
- * @init: optional hook that is called during device probe, before the
- *        driver tries to access any SDHCI registers
- * @exit: optional hook that is called during device removal
- */
-struct sdhci_pltfm_data {
-        struct sdhci_ops *ops;
-        unsigned int quirks;
-        int (*init)(struct sdhci_host *host, struct sdhci_pltfm_data *pdata);
-        void (*exit)(struct sdhci_host *host);
-};
-
-#endif /* _SDHCI_PLTFM_H */
diff --git a/include/linux/mmc/sdhci-spear.h b/include/linux/mmc/sdhci-spear.h
index 9188c973f3e..5cdc96da9dd 100644
--- a/include/linux/mmc/sdhci-spear.h
+++ b/include/linux/mmc/sdhci-spear.h
@@ -11,8 +11,8 @@
  * warranty of any kind, whether express or implied.
  */
 
-#ifndef MMC_SDHCI_SPEAR_H
-#define MMC_SDHCI_SPEAR_H
+#ifndef LINUX_MMC_SDHCI_SPEAR_H
+#define LINUX_MMC_SDHCI_SPEAR_H
 
 #include <linux/platform_device.h>
 /*
@@ -39,4 +39,4 @@ sdhci_set_plat_data(struct platform_device *pdev, struct sdhci_plat_data *data)
         pdev->dev.platform_data = data;
 }
 
-#endif /* MMC_SDHCI_SPEAR_H */
+#endif /* LINUX_MMC_SDHCI_SPEAR_H */
diff --git a/include/linux/mmc/sdhci.h b/include/linux/mmc/sdhci.h
index 6a68c4eb4e4..5ee48390dec 100644
--- a/include/linux/mmc/sdhci.h
+++ b/include/linux/mmc/sdhci.h
@@ -8,8 +8,8 @@
  * the Free Software Foundation; either version 2 of the License, or (at
  * your option) any later version.
  */
-#ifndef __SDHCI_H
-#define __SDHCI_H
+#ifndef LINUX_MMC_SDHCI_H
+#define LINUX_MMC_SDHCI_H
 
 #include <linux/scatterlist.h>
 #include <linux/compiler.h>
@@ -21,72 +21,78 @@ struct sdhci_host {
         /* Data set by hardware interface driver */
         const char *hw_name;    /* Hardware bus name */
 
-        unsigned int quirks;    /* Deviations from spec. */
+        u64 quirks;     /* Deviations from spec. */
 
 /* Controller doesn't honor resets unless we touch the clock register */
-#define SDHCI_QUIRK_CLOCK_BEFORE_RESET                  (1<<0)
+#define SDHCI_QUIRK_CLOCK_BEFORE_RESET                  (1ULL<<0)
 /* Controller has bad caps bits, but really supports DMA */
-#define SDHCI_QUIRK_FORCE_DMA                           (1<<1)
+#define SDHCI_QUIRK_FORCE_DMA                           (1ULL<<1)
 /* Controller doesn't like to be reset when there is no card inserted. */
-#define SDHCI_QUIRK_NO_CARD_NO_RESET                    (1<<2)
+#define SDHCI_QUIRK_NO_CARD_NO_RESET                    (1ULL<<2)
 /* Controller doesn't like clearing the power reg before a change */
-#define SDHCI_QUIRK_SINGLE_POWER_WRITE                  (1<<3)
+#define SDHCI_QUIRK_SINGLE_POWER_WRITE                  (1ULL<<3)
 /* Controller has flaky internal state so reset it on each ios change */
-#define SDHCI_QUIRK_RESET_CMD_DATA_ON_IOS               (1<<4)
+#define SDHCI_QUIRK_RESET_CMD_DATA_ON_IOS               (1ULL<<4)
 /* Controller has an unusable DMA engine */
-#define SDHCI_QUIRK_BROKEN_DMA                          (1<<5)
+#define SDHCI_QUIRK_BROKEN_DMA                          (1ULL<<5)
 /* Controller has an unusable ADMA engine */
-#define SDHCI_QUIRK_BROKEN_ADMA                         (1<<6)
+#define SDHCI_QUIRK_BROKEN_ADMA                         (1ULL<<6)
 /* Controller can only DMA from 32-bit aligned addresses */
-#define SDHCI_QUIRK_32BIT_DMA_ADDR                      (1<<7)
+#define SDHCI_QUIRK_32BIT_DMA_ADDR                      (1ULL<<7)
 /* Controller can only DMA chunk sizes that are a multiple of 32 bits */
-#define SDHCI_QUIRK_32BIT_DMA_SIZE                      (1<<8)
+#define SDHCI_QUIRK_32BIT_DMA_SIZE                      (1ULL<<8)
 /* Controller can only ADMA chunks that are a multiple of 32 bits */
-#define SDHCI_QUIRK_32BIT_ADMA_SIZE                     (1<<9)
+#define SDHCI_QUIRK_32BIT_ADMA_SIZE                     (1ULL<<9)
 /* Controller needs to be reset after each request to stay stable */
-#define SDHCI_QUIRK_RESET_AFTER_REQUEST                 (1<<10)
+#define SDHCI_QUIRK_RESET_AFTER_REQUEST                 (1ULL<<10)
 /* Controller needs voltage and power writes to happen separately */
-#define SDHCI_QUIRK_NO_SIMULT_VDD_AND_POWER             (1<<11)
+#define SDHCI_QUIRK_NO_SIMULT_VDD_AND_POWER             (1ULL<<11)
 /* Controller provides an incorrect timeout value for transfers */
-#define SDHCI_QUIRK_BROKEN_TIMEOUT_VAL                  (1<<12)
+#define SDHCI_QUIRK_BROKEN_TIMEOUT_VAL                  (1ULL<<12)
 /* Controller has an issue with buffer bits for small transfers */
-#define SDHCI_QUIRK_BROKEN_SMALL_PIO                    (1<<13)
+#define SDHCI_QUIRK_BROKEN_SMALL_PIO                    (1ULL<<13)
 /* Controller does not provide transfer-complete interrupt when not busy */
-#define SDHCI_QUIRK_NO_BUSY_IRQ                         (1<<14)
+#define SDHCI_QUIRK_NO_BUSY_IRQ                         (1ULL<<14)
 /* Controller has unreliable card detection */
-#define SDHCI_QUIRK_BROKEN_CARD_DETECTION               (1<<15)
+#define SDHCI_QUIRK_BROKEN_CARD_DETECTION               (1ULL<<15)
 /* Controller reports inverted write-protect state */
-#define SDHCI_QUIRK_INVERTED_WRITE_PROTECT              (1<<16)
+#define SDHCI_QUIRK_INVERTED_WRITE_PROTECT              (1ULL<<16)
 /* Controller has nonstandard clock management */
-#define SDHCI_QUIRK_NONSTANDARD_CLOCK                   (1<<17)
+#define SDHCI_QUIRK_NONSTANDARD_CLOCK                   (1ULL<<17)
 /* Controller does not like fast PIO transfers */
-#define SDHCI_QUIRK_PIO_NEEDS_DELAY                     (1<<18)
+#define SDHCI_QUIRK_PIO_NEEDS_DELAY                     (1ULL<<18)
 /* Controller losing signal/interrupt enable states after reset */
-#define SDHCI_QUIRK_RESTORE_IRQS_AFTER_RESET            (1<<19)
+#define SDHCI_QUIRK_RESTORE_IRQS_AFTER_RESET            (1ULL<<19)
 /* Controller has to be forced to use block size of 2048 bytes */
-#define SDHCI_QUIRK_FORCE_BLK_SZ_2048                   (1<<20)
+#define SDHCI_QUIRK_FORCE_BLK_SZ_2048                   (1ULL<<20)
 /* Controller cannot do multi-block transfers */
-#define SDHCI_QUIRK_NO_MULTIBLOCK                       (1<<21)
+#define SDHCI_QUIRK_NO_MULTIBLOCK                       (1ULL<<21)
 /* Controller can only handle 1-bit data transfers */
-#define SDHCI_QUIRK_FORCE_1_BIT_DATA                    (1<<22)
+#define SDHCI_QUIRK_FORCE_1_BIT_DATA                    (1ULL<<22)
 /* Controller needs 10ms delay between applying power and clock */
-#define SDHCI_QUIRK_DELAY_AFTER_POWER                   (1<<23)
+#define SDHCI_QUIRK_DELAY_AFTER_POWER                   (1ULL<<23)
 /* Controller uses SDCLK instead of TMCLK for data timeouts */
-#define SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK             (1<<24)
+#define SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK             (1ULL<<24)
 /* Controller reports wrong base clock capability */
-#define SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN               (1<<25)
+#define SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN               (1ULL<<25)
 /* Controller cannot support End Attribute in NOP ADMA descriptor */
-#define SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC               (1<<26)
+#define SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC               (1ULL<<26)
 /* Controller is missing device caps. Use caps provided by host */
-#define SDHCI_QUIRK_MISSING_CAPS                        (1<<27)
+#define SDHCI_QUIRK_MISSING_CAPS                        (1ULL<<27)
 /* Controller uses Auto CMD12 command to stop the transfer */
-#define SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12              (1<<28)
+#define SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12              (1ULL<<28)
 /* Controller doesn't have HISPD bit field in HI-SPEED SD card */
-#define SDHCI_QUIRK_NO_HISPD_BIT                        (1<<29)
+#define SDHCI_QUIRK_NO_HISPD_BIT                        (1ULL<<29)
 /* Controller treats ADMA descriptors with length 0000h incorrectly */
-#define SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC            (1<<30)
+#define SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC            (1ULL<<30)
 /* The read-only detection via SDHCI_PRESENT_STATE register is unstable */
-#define SDHCI_QUIRK_UNSTABLE_RO_DETECT                  (1<<31)
+#define SDHCI_QUIRK_UNSTABLE_RO_DETECT                  (1ULL<<31)
+/* Controller cannot report the line status in present state register */
+#define SDHCI_QUIRK_NON_STD_VOLTAGE_SWITCHING           (1ULL<<32)
+/* Controller doesn't follow the standard frequency tuning procedure */
+#define SDHCI_QUIRK_NON_STANDARD_TUNING                 (1ULL<<33)
+/* Controller doesn't calculate max_discard_to */
+#define SDHCI_QUIRK_NO_CALC_MAX_DISCARD_TO              (1ULL<<34)
 
         int irq;                /* Device IRQ */
         void __iomem *ioaddr;   /* Mapped address */
@@ -145,6 +151,7 @@ struct sdhci_host {
         struct tasklet_struct finish_tasklet;
 
         struct timer_list timer;        /* Timer for timeouts */
+        unsigned int card_int_set;      /* card int status */
 
         unsigned int caps;      /* Alternative capabilities */
 
@@ -162,4 +169,4 @@ struct sdhci_host {
 
         unsigned long private[0] ____cacheline_aligned;
 };
-#endif /* __SDHCI_H */
+#endif /* LINUX_MMC_SDHCI_H */
diff --git a/include/linux/mmc/sdio.h b/include/linux/mmc/sdio.h
index 245cdacee54..666ff6b0aea 100644
--- a/include/linux/mmc/sdio.h
+++ b/include/linux/mmc/sdio.h
@@ -9,8 +9,8 @@
  * your option) any later version.
  */
 
-#ifndef MMC_SDIO_H
-#define MMC_SDIO_H
+#ifndef LINUX_MMC_SDIO_H
+#define LINUX_MMC_SDIO_H
 
 /* SDIO commands                         type  argument     response */
 #define SD_IO_SEND_OP_COND          5 /* bcr  [23:0] OCR         R4  */
@@ -38,7 +38,8 @@
  *      [8:0] Byte/block count
  */
 
-#define R4_MEMORY_PRESENT (1 << 27)
+#define R4_18V_PRESENT BIT(24)
+#define R4_MEMORY_PRESENT BIT(27)
 
 /*
   SDIO status in R5
@@ -72,17 +73,20 @@
 #define  SDIO_CCCR_REV_1_00     0       /* CCCR/FBR Version 1.00 */
 #define  SDIO_CCCR_REV_1_10     1       /* CCCR/FBR Version 1.10 */
 #define  SDIO_CCCR_REV_1_20     2       /* CCCR/FBR Version 1.20 */
+#define  SDIO_CCCR_REV_3_00     3       /* CCCR/FBR Version 3.00 */
 
 #define  SDIO_SDIO_REV_1_00     0       /* SDIO Spec Version 1.00 */
 #define  SDIO_SDIO_REV_1_10     1       /* SDIO Spec Version 1.10 */
 #define  SDIO_SDIO_REV_1_20     2       /* SDIO Spec Version 1.20 */
 #define  SDIO_SDIO_REV_2_00     3       /* SDIO Spec Version 2.00 */
+#define  SDIO_SDIO_REV_3_00     4       /* SDIO Spec Version 3.00 */
 
 #define SDIO_CCCR_SD            0x01
 
 #define  SDIO_SD_REV_1_01       0       /* SD Physical Spec Version 1.01 */
 #define  SDIO_SD_REV_1_10       1       /* SD Physical Spec Version 1.10 */
 #define  SDIO_SD_REV_2_00       2       /* SD Physical Spec Version 2.00 */
+#define  SDIO_SD_REV_3_00       3       /* SD Physical Spev Version 3.00 */
 
 #define SDIO_CCCR_IOEx          0x02
 #define SDIO_CCCR_IORx          0x03
@@ -132,8 +136,31 @@
 #define SDIO_CCCR_SPEED         0x13
 
 #define  SDIO_SPEED_SHS         0x01    /* Supports High-Speed mode */
-#define  SDIO_SPEED_EHS         0x02    /* Enable High-Speed mode */
-
+#define  SDIO_SPEED_BSS_SHIFT   1
+#define  SDIO_SPEED_BSS_MASK    (7 << SDIO_SPEED_BSS_SHIFT)
+#define  SDIO_SPEED_SDR12       (0 << SDIO_SPEED_BSS_SHIFT)
+#define  SDIO_SPEED_SDR25       (1 << SDIO_SPEED_BSS_SHIFT)
+#define  SDIO_SPEED_SDR50       (2 << SDIO_SPEED_BSS_SHIFT)
+#define  SDIO_SPEED_SDR104      (3 << SDIO_SPEED_BSS_SHIFT)
+#define  SDIO_SPEED_DDR50       (4 << SDIO_SPEED_BSS_SHIFT)
+#define  SDIO_SPEED_EHS         SDIO_SPEED_SDR25        /* Enable High-Speed */
+
+#define SDIO_CCCR_UHS           0x14
+#define  SDIO_UHS_SDR50         0x01
+#define  SDIO_UHS_SDR104        0x02
+#define  SDIO_UHS_DDR50         0x04
+
+#define SDIO_CCCR_DRIVE_STRENGTH 0x15
+#define  SDIO_SDTx_MASK         0x07
+#define  SDIO_DRIVE_SDTA        (1 << 0)
+#define  SDIO_DRIVE_SDTC        (1 << 1)
+#define  SDIO_DRIVE_SDTD        (1 << 2)
+#define  SDIO_DRIVE_DTSx_MASK   0x03
+#define  SDIO_DRIVE_DTSx_SHIFT  4
+#define  SDIO_DTSx_SET_TYPE_B   (0 << SDIO_DRIVE_DTSx_SHIFT)
+#define  SDIO_DTSx_SET_TYPE_A   (1 << SDIO_DRIVE_DTSx_SHIFT)
+#define  SDIO_DTSx_SET_TYPE_C   (2 << SDIO_DRIVE_DTSx_SHIFT)
+#define  SDIO_DTSx_SET_TYPE_D   (3 << SDIO_DRIVE_DTSx_SHIFT)
 /*
  * Function Basic Registers (FBR)
  */
@@ -161,5 +188,4 @@
 
 #define SDIO_FBR_BLKSIZE        0x10    /* block size (2 bytes) */
 
-#endif
-
+#endif /* LINUX_MMC_SDIO_H */
diff --git a/include/linux/mmc/sdio_func.h b/include/linux/mmc/sdio_func.h
index 31baaf82f45..dc680c4b50d 100644
--- a/include/linux/mmc/sdio_func.h
+++ b/include/linux/mmc/sdio_func.h
@@ -9,8 +9,8 @@
  * your option) any later version.
  */
 
-#ifndef MMC_SDIO_FUNC_H
-#define MMC_SDIO_FUNC_H
+#ifndef LINUX_MMC_SDIO_FUNC_H
+#define LINUX_MMC_SDIO_FUNC_H
 
 #include <linux/device.h>
 #include <linux/mod_devicetable.h>
@@ -23,6 +23,14 @@ struct sdio_func;
 typedef void (sdio_irq_handler_t)(struct sdio_func *);
 
 /*
+ * Structure used to hold embedded SDIO device data from platform layer
+ */
+struct sdio_embedded_func {
+        uint8_t f_class;
+        uint32_t f_maxblksize;
+};
+
+/*
  * SDIO function CIS tuple (unknown to the core)
  */
 struct sdio_func_tuple {
@@ -130,6 +138,8 @@ extern int sdio_release_irq(struct sdio_func *func);
 extern unsigned int sdio_align_size(struct sdio_func *func, unsigned int sz);
 
 extern u8 sdio_readb(struct sdio_func *func, unsigned int addr, int *err_ret);
+extern u8 sdio_readb_ext(struct sdio_func *func, unsigned int addr, int *err_ret,
+        unsigned in);
 extern u16 sdio_readw(struct sdio_func *func, unsigned int addr, int *err_ret);
 extern u32 sdio_readl(struct sdio_func *func, unsigned int addr, int *err_ret);
 
@@ -161,5 +171,4 @@ extern void sdio_f0_writeb(struct sdio_func *func, unsigned char b,
 extern mmc_pm_flag_t sdio_get_host_pm_caps(struct sdio_func *func);
 extern int sdio_set_host_pm_flags(struct sdio_func *func, mmc_pm_flag_t flags);
 
-#endif
-
+#endif /* LINUX_MMC_SDIO_FUNC_H */
diff --git a/include/linux/mmc/sdio_ids.h b/include/linux/mmc/sdio_ids.h
index a36ab3bc7b0..9f03feedc8e 100644
--- a/include/linux/mmc/sdio_ids.h
+++ b/include/linux/mmc/sdio_ids.h
@@ -2,8 +2,8 @@
  * SDIO Classes, Interface Types, Manufacturer IDs, etc.
  */
 
-#ifndef MMC_SDIO_IDS_H
-#define MMC_SDIO_IDS_H
+#ifndef LINUX_MMC_SDIO_IDS_H
+#define LINUX_MMC_SDIO_IDS_H
 
 /*
  * Standard SDIO Function Interfaces
@@ -44,4 +44,4 @@
 #define SDIO_DEVICE_ID_SIANO_NOVA_A0            0x1100
 #define SDIO_DEVICE_ID_SIANO_STELLAR            0x5347
 
-#endif
+#endif /* LINUX_MMC_SDIO_IDS_H */
diff --git a/include/linux/mmc/sh_mmcif.h b/include/linux/mmc/sh_mmcif.h
index 9eb9b4b96f5..0222cd8ebe7 100644
--- a/include/linux/mmc/sh_mmcif.h
+++ b/include/linux/mmc/sh_mmcif.h
@@ -11,8 +11,8 @@
  *
  */
 
-#ifndef __SH_MMCIF_H__
-#define __SH_MMCIF_H__
+#ifndef LINUX_MMC_SH_MMCIF_H
+#define LINUX_MMC_SH_MMCIF_H
 
 #include <linux/io.h>
 #include <linux/platform_device.h>
@@ -220,4 +220,4 @@ static inline void sh_mmcif_boot_init(void __iomem *base)
         sh_mmcif_boot_cmd(base, 0x03400040, 0x00010000);
 }
 
-#endif /* __SH_MMCIF_H__ */
+#endif /* LINUX_MMC_SH_MMCIF_H */
diff --git a/include/linux/mmc/sh_mobile_sdhi.h b/include/linux/mmc/sh_mobile_sdhi.h
index faf32b6ec18..bd50b365167 100644
--- a/include/linux/mmc/sh_mobile_sdhi.h
+++ b/include/linux/mmc/sh_mobile_sdhi.h
@@ -1,5 +1,5 @@
-#ifndef __SH_MOBILE_SDHI_H__
-#define __SH_MOBILE_SDHI_H__
+#ifndef LINUX_MMC_SH_MOBILE_SDHI_H
+#define LINUX_MMC_SH_MOBILE_SDHI_H
 
 #include <linux/types.h>
 
@@ -17,4 +17,4 @@ struct sh_mobile_sdhi_info {
         int (*get_cd)(struct platform_device *pdev);
 };
 
-#endif /* __SH_MOBILE_SDHI_H__ */
+#endif /* LINUX_MMC_SH_MOBILE_SDHI_H */
diff --git a/include/linux/mmc/tmio.h b/include/linux/mmc/tmio.h
index 19490b942db..a1c1f321e51 100644
--- a/include/linux/mmc/tmio.h
+++ b/include/linux/mmc/tmio.h
@@ -12,8 +12,8 @@
  *
  * TC6393XB TC6391XB TC6387XB T7L66XB ASIC3
  */
-#ifndef _LINUX_MMC_TMIO_H_
-#define _LINUX_MMC_TMIO_H_
+#ifndef LINUX_MMC_TMIO_H
+#define LINUX_MMC_TMIO_H
 
 #define CTL_SD_CMD 0x00
 #define CTL_ARG_REG 0x04
@@ -21,6 +21,7 @@
 #define CTL_XFER_BLK_COUNT 0xa
 #define CTL_RESPONSE 0x0c
 #define CTL_STATUS 0x1c
+#define CTL_STATUS2 0x1e
 #define CTL_IRQ_MASK 0x20
 #define CTL_SD_CARD_CLK_CTL 0x24
 #define CTL_SD_XFER_LEN 0x26
@@ -30,6 +31,7 @@
 #define CTL_TRANSACTION_CTL 0x34
 #define CTL_SDIO_STATUS 0x36
 #define CTL_SDIO_IRQ_MASK 0x38
+#define CTL_DMA_ENABLE 0xd8
 #define CTL_RESET_SD 0xe0
 #define CTL_SDIO_REGS 0x100
 #define CTL_CLK_AND_WAIT_CTL 0x138
@@ -60,4 +62,4 @@
 
 #define TMIO_BBS                512             /* Boot block size */
 
-#endif /* _LINUX_MMC_TMIO_H_ */
+#endif /* LINUX_MMC_TMIO_H */
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index 9f7c3ebcbba..be1ac8d7789 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -16,7 +16,7 @@
 #include <linux/nodemask.h>
 #include <linux/pageblock-flags.h>
 #include <generated/bounds.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <asm/page.h>
 
 /* Free memory management - zoned buddy allocator.  */
@@ -158,6 +158,12 @@ static inline int is_unevictable_lru(enum lru_list l)
         return (l == LRU_UNEVICTABLE);
 }
 
+/* Mask used at gathering information at once (see memcontrol.c) */
+#define LRU_ALL_FILE (BIT(LRU_INACTIVE_FILE) | BIT(LRU_ACTIVE_FILE))
+#define LRU_ALL_ANON (BIT(LRU_INACTIVE_ANON) | BIT(LRU_ACTIVE_ANON))
+#define LRU_ALL_EVICTABLE (LRU_ALL_FILE | LRU_ALL_ANON)
+#define LRU_ALL      ((1 << NR_LRU_LISTS) - 1)
+
 enum zone_watermarks {
         WMARK_MIN,
         WMARK_LOW,
diff --git a/include/linux/mnt_namespace.h b/include/linux/mnt_namespace.h
index 0b89efc6f21..29304855652 100644
--- a/include/linux/mnt_namespace.h
+++ b/include/linux/mnt_namespace.h
@@ -18,7 +18,6 @@ struct proc_mounts {
         struct seq_file m; /* must be the first element */
         struct mnt_namespace *ns;
         struct path root;
-        int event;
 };
 
 struct fs_struct;
diff --git a/include/linux/module.h b/include/linux/module.h
index d9ca2d5dc6d..bbd77fa05b1 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -16,6 +16,7 @@
 #include <linux/kobject.h>
 #include <linux/moduleparam.h>
 #include <linux/tracepoint.h>
+#include <linux/export.h>
 
 #include <linux/percpu.h>
 #include <asm/module.h>
@@ -25,21 +26,8 @@
 /* Not Yet Implemented */
 #define MODULE_SUPPORTED_DEVICE(name)
 
-/* Some toolchains use a `_' prefix for all user symbols. */
-#ifdef CONFIG_SYMBOL_PREFIX
-#define MODULE_SYMBOL_PREFIX CONFIG_SYMBOL_PREFIX
-#else
-#define MODULE_SYMBOL_PREFIX ""
-#endif
-
 #define MODULE_NAME_LEN MAX_PARAM_PREFIX_LEN
 
-struct kernel_symbol
-{
-        unsigned long value;
-        const char *name;
-};
-
 struct modversion_info
 {
         unsigned long crc;
@@ -48,10 +36,18 @@ struct modversion_info
 
 struct module;
 
+struct module_kobject {
+        struct kobject kobj;
+        struct module *mod;
+        struct kobject *drivers_dir;
+        struct module_param_attrs *mp;
+};
+
 struct module_attribute {
-        struct attribute attr;
-        ssize_t (*show)(struct module_attribute *, struct module *, char *);
-        ssize_t (*store)(struct module_attribute *, struct module *,
+        struct attribute attr;
+        ssize_t (*show)(struct module_attribute *, struct module_kobject *,
+                        char *);
+        ssize_t (*store)(struct module_attribute *, struct module_kobject *,
                          const char *, size_t count);
         void (*setup)(struct module *, const char *);
         int (*test)(struct module *);
@@ -65,15 +61,9 @@ struct module_version_attribute {
 } __attribute__ ((__aligned__(sizeof(void *))));
 
 extern ssize_t __modver_version_show(struct module_attribute *,
-                                     struct module *, char *);
+                                     struct module_kobject *, char *);
 
-struct module_kobject
-{
-        struct kobject kobj;
-        struct module *mod;
-        struct kobject *drivers_dir;
-        struct module_param_attrs *mp;
-};
+extern struct module_attribute module_uevent;
 
 /* These are either module local, or the kernel's dummy ones. */
 extern int init_module(void);
@@ -96,11 +86,8 @@ void trim_init_extable(struct module *m);
 extern const struct gtype##_id __mod_##gtype##_table            \
   __attribute__ ((unused, alias(__stringify(name))))
 
-extern struct module __this_module;
-#define THIS_MODULE (&__this_module)
 #else  /* !MODULE */
 #define MODULE_GENERIC_TABLE(gtype,name)
-#define THIS_MODULE ((struct module *)0)
 #endif
 
 /* Generic info of form tag = "info" */
@@ -216,52 +203,6 @@ struct module_use {
         struct module *source, *target;
 };
 
-#ifndef __GENKSYMS__
-#ifdef CONFIG_MODVERSIONS
-/* Mark the CRC weak since genksyms apparently decides not to
- * generate a checksums for some symbols */
-#define __CRC_SYMBOL(sym, sec)                                  \
-        extern void *__crc_##sym __attribute__((weak));         \
-        static const unsigned long __kcrctab_##sym              \
-        __used                                                  \
-        __attribute__((section("___kcrctab" sec "+" #sym), unused))     \
-        = (unsigned long) &__crc_##sym;
-#else
-#define __CRC_SYMBOL(sym, sec)
-#endif
-
-/* For every exported symbol, place a struct in the __ksymtab section */
-#define __EXPORT_SYMBOL(sym, sec)                               \
-        extern typeof(sym) sym;                                 \
-        __CRC_SYMBOL(sym, sec)                                  \
-        static const char __kstrtab_##sym[]                     \
-        __attribute__((section("__ksymtab_strings"), aligned(1))) \
-        = MODULE_SYMBOL_PREFIX #sym;                            \
-        static const struct kernel_symbol __ksymtab_##sym       \
-        __used                                                  \
-        __attribute__((section("___ksymtab" sec "+" #sym), unused))     \
-        = { (unsigned long)&sym, __kstrtab_##sym }
-
-#define EXPORT_SYMBOL(sym)                                      \
-        __EXPORT_SYMBOL(sym, "")
-
-#define EXPORT_SYMBOL_GPL(sym)                                  \
-        __EXPORT_SYMBOL(sym, "_gpl")
-
-#define EXPORT_SYMBOL_GPL_FUTURE(sym)                           \
-        __EXPORT_SYMBOL(sym, "_gpl_future")
-
-
-#ifdef CONFIG_UNUSED_SYMBOLS
-#define EXPORT_UNUSED_SYMBOL(sym) __EXPORT_SYMBOL(sym, "_unused")
-#define EXPORT_UNUSED_SYMBOL_GPL(sym) __EXPORT_SYMBOL(sym, "_unused_gpl")
-#else
-#define EXPORT_UNUSED_SYMBOL(sym)
-#define EXPORT_UNUSED_SYMBOL_GPL(sym)
-#endif
-
-#endif
-
 enum module_state
 {
         MODULE_STATE_LIVE,
@@ -582,11 +523,6 @@ extern void module_update_tracepoints(void);
 extern int module_get_iter_tracepoints(struct tracepoint_iter *iter);
 
 #else /* !CONFIG_MODULES... */
-#define EXPORT_SYMBOL(sym)
-#define EXPORT_SYMBOL_GPL(sym)
-#define EXPORT_SYMBOL_GPL_FUTURE(sym)
-#define EXPORT_UNUSED_SYMBOL(sym)
-#define EXPORT_UNUSED_SYMBOL_GPL(sym)
 
 /* Given an address, look for it in the exception tables. */
 static inline const struct exception_table_entry *
diff --git a/include/linux/moduleloader.h b/include/linux/moduleloader.h
index c1f40c2f7ff..b2be02ebf45 100644
--- a/include/linux/moduleloader.h
+++ b/include/linux/moduleloader.h
@@ -5,7 +5,12 @@
 #include <linux/module.h>
 #include <linux/elf.h>
 
-/* These must be implemented by the specific architecture */
+/* These may be implemented by architectures that need to hook into the
+ * module loader code.  Architectures that don't need to do anything special
+ * can just rely on the 'weak' default hooks defined in kernel/module.c.
+ * Note, however, that at least one of apply_relocate or apply_relocate_add
+ * must be implemented by each architecture.
+ */
 
 /* Adjust arch-specific sections.  Return 0 on success.  */
 int module_frob_arch_sections(Elf_Ehdr *hdr,
diff --git a/include/linux/mount.h b/include/linux/mount.h
index 604f122a232..33fe53d7811 100644
--- a/include/linux/mount.h
+++ b/include/linux/mount.h
@@ -14,7 +14,7 @@
 #include <linux/nodemask.h>
 #include <linux/spinlock.h>
 #include <linux/seqlock.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 struct super_block;
 struct vfsmount;
diff --git a/include/linux/mpu.h b/include/linux/mpu.h
new file mode 100644
index 00000000000..1977b38b8c1
--- /dev/null
+++ b/include/linux/mpu.h
@@ -0,0 +1,367 @@
+/*
+        $License:
+        Copyright (C) 2011 InvenSense Corporation, All Rights Reserved.
+
+        This program is free software; you can redistribute it and/or modify
+        it under the terms of the GNU General Public License as published by
+        the Free Software Foundation; either version 2 of the License, or
+        (at your option) any later version.
+
+        This program is distributed in the hope that it will be useful,
+        but WITHOUT ANY WARRANTY; without even the implied warranty of
+        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+        GNU General Public License for more details.
+
+        You should have received a copy of the GNU General Public License
+        along with this program.  If not, see <http://www.gnu.org/licenses/>.
+        $
+ */
+
+#ifndef __MPU_H_
+#define __MPU_H_
+
+#include <linux/types.h>
+#include <linux/ioctl.h>
+
+/* Number of axes on each sensor */
+#define GYRO_NUM_AXES               (3)
+#define ACCEL_NUM_AXES              (3)
+#define COMPASS_NUM_AXES            (3)
+
+struct mpu_read_write {
+        /* Memory address or register address depending on ioctl */
+        __u16 address;
+        __u16 length;
+        __u8 *data;
+};
+
+enum mpuirq_data_type {
+        MPUIRQ_DATA_TYPE_MPU_IRQ,
+        MPUIRQ_DATA_TYPE_SLAVE_IRQ,
+        MPUIRQ_DATA_TYPE_PM_EVENT,
+        MPUIRQ_DATA_TYPE_NUM_TYPES,
+};
+
+/* User space PM event notification */
+#define MPU_PM_EVENT_SUSPEND_PREPARE (3)
+#define MPU_PM_EVENT_POST_SUSPEND    (4)
+
+struct mpuirq_data {
+        __u32 interruptcount;
+        __u64 irqtime;
+        __u32 data_type;
+        __s32 data;
+};
+
+enum ext_slave_config_key {
+        MPU_SLAVE_CONFIG_ODR_SUSPEND,
+        MPU_SLAVE_CONFIG_ODR_RESUME,
+        MPU_SLAVE_CONFIG_FSR_SUSPEND,
+        MPU_SLAVE_CONFIG_FSR_RESUME,
+        MPU_SLAVE_CONFIG_MOT_THS,
+        MPU_SLAVE_CONFIG_NMOT_THS,
+        MPU_SLAVE_CONFIG_MOT_DUR,
+        MPU_SLAVE_CONFIG_NMOT_DUR,
+        MPU_SLAVE_CONFIG_IRQ_SUSPEND,
+        MPU_SLAVE_CONFIG_IRQ_RESUME,
+        MPU_SLAVE_WRITE_REGISTERS,
+        MPU_SLAVE_READ_REGISTERS,
+        MPU_SLAVE_CONFIG_INTERNAL_REFERENCE,
+        /* AMI 306 specific config keys */
+        MPU_SLAVE_PARAM,
+        MPU_SLAVE_WINDOW,
+        MPU_SLAVE_READWINPARAMS,
+        MPU_SLAVE_SEARCHOFFSET,
+        /* AKM specific config keys */
+        MPU_SLAVE_READ_SCALE,
+        /* MPU3050 and MPU6050 Keys */
+        MPU_SLAVE_INT_CONFIG,
+        MPU_SLAVE_EXT_SYNC,
+        MPU_SLAVE_FULL_SCALE,
+        MPU_SLAVE_LPF,
+        MPU_SLAVE_CLK_SRC,
+        MPU_SLAVE_DIVIDER,
+        MPU_SLAVE_DMP_ENABLE,
+        MPU_SLAVE_FIFO_ENABLE,
+        MPU_SLAVE_DMP_CFG1,
+        MPU_SLAVE_DMP_CFG2,
+        MPU_SLAVE_TC,
+        MPU_SLAVE_GYRO,
+        MPU_SLAVE_ADDR,
+        MPU_SLAVE_PRODUCT_REVISION,
+        MPU_SLAVE_SILICON_REVISION,
+        MPU_SLAVE_PRODUCT_ID,
+        MPU_SLAVE_GYRO_SENS_TRIM,
+        MPU_SLAVE_ACCEL_SENS_TRIM,
+        MPU_SLAVE_RAM,
+        /* -------------------------- */
+        MPU_SLAVE_CONFIG_NUM_CONFIG_KEYS
+};
+
+/* For the MPU_SLAVE_CONFIG_IRQ_SUSPEND and MPU_SLAVE_CONFIG_IRQ_RESUME */
+enum ext_slave_config_irq_type {
+        MPU_SLAVE_IRQ_TYPE_NONE,
+        MPU_SLAVE_IRQ_TYPE_MOTION,
+        MPU_SLAVE_IRQ_TYPE_DATA_READY,
+};
+
+/* Structure for the following IOCTS's
+ * MPU_CONFIG_GYRO
+ * MPU_CONFIG_ACCEL
+ * MPU_CONFIG_COMPASS
+ * MPU_CONFIG_PRESSURE
+ * MPU_GET_CONFIG_GYRO
+ * MPU_GET_CONFIG_ACCEL
+ * MPU_GET_CONFIG_COMPASS
+ * MPU_GET_CONFIG_PRESSURE
+ *
+ * @key one of enum ext_slave_config_key
+ * @len length of data pointed to by data
+ * @apply zero if communication with the chip is not necessary, false otherwise
+ *        This flag can be used to select cached data or to refresh cashed data
+ *        cache data to be pushed later or push immediately.  If true and the
+ *        slave is on the secondary bus the MPU will first enger bypass mode
+ *        before calling the slaves .config or .get_config funcion
+ * @data pointer to the data to confgure or get
+ */
+struct ext_slave_config {
+        __u8 key;
+        __u16 len;
+        __u8 apply;
+        void *data;
+};
+
+enum ext_slave_type {
+        EXT_SLAVE_TYPE_GYROSCOPE,
+        EXT_SLAVE_TYPE_ACCEL,
+        EXT_SLAVE_TYPE_COMPASS,
+        EXT_SLAVE_TYPE_PRESSURE,
+        /*EXT_SLAVE_TYPE_TEMPERATURE */
+
+        EXT_SLAVE_NUM_TYPES
+};
+
+enum ext_slave_id {
+        ID_INVALID = 0,
+
+        ACCEL_ID_LIS331,
+        ACCEL_ID_LSM303DLX,
+        ACCEL_ID_LIS3DH,
+        ACCEL_ID_KXSD9,
+        ACCEL_ID_KXTF9,
+        ACCEL_ID_BMA150,
+        ACCEL_ID_BMA222,
+        ACCEL_ID_BMA250,
+        ACCEL_ID_ADXL34X,
+        ACCEL_ID_MMA8450,
+        ACCEL_ID_MMA845X,
+        ACCEL_ID_MPU6050,
+
+        COMPASS_ID_AK8975,
+        COMPASS_ID_AK8963,
+        COMPASS_ID_AK8972,
+        COMPASS_ID_AMI30X,
+        COMPASS_ID_AMI306,
+        COMPASS_ID_YAS529,
+        COMPASS_ID_YAS530,
+        COMPASS_ID_HMC5883,
+        COMPASS_ID_LSM303DLH,
+        COMPASS_ID_LSM303DLM,
+        COMPASS_ID_MMC314X,
+        COMPASS_ID_HSCDTD002B,
+        COMPASS_ID_HSCDTD004A,
+
+        PRESSURE_ID_BMA085,
+};
+
+enum ext_slave_endian {
+        EXT_SLAVE_BIG_ENDIAN,
+        EXT_SLAVE_LITTLE_ENDIAN,
+        EXT_SLAVE_FS8_BIG_ENDIAN,
+        EXT_SLAVE_FS16_BIG_ENDIAN,
+};
+
+enum ext_slave_bus {
+        EXT_SLAVE_BUS_INVALID = -1,
+        EXT_SLAVE_BUS_PRIMARY = 0,
+        EXT_SLAVE_BUS_SECONDARY = 1
+};
+
+
+/**
+ *  struct ext_slave_platform_data - Platform data for mpu3050 and mpu6050
+ *  slave devices
+ *
+ *  @type: the type of slave device based on the enum ext_slave_type
+ *         definitions.
+ *  @irq: the irq number attached to the slave if any.
+ *  @adapt_num: the I2C adapter number.
+ *  @bus: the bus the slave is attached to: enum ext_slave_bus
+ *  @address: the I2C slave address of the slave device.
+ *  @orientation: the mounting matrix of the device relative to MPU.
+ *  @irq_data: private data for the slave irq handler
+ *  @private_data: additional data, user customizable.  Not touched by the MPU
+ *                 driver.
+ *
+ * The orientation matricies are 3x3 rotation matricies
+ * that are applied to the data to rotate from the mounting orientation to the
+ * platform orientation.  The values must be one of 0, 1, or -1 and each row and
+ * column should have exactly 1 non-zero value.
+ */
+struct ext_slave_platform_data {
+        __u8 type;
+        __u32 irq;
+        __u32 adapt_num;
+        __u32 bus;
+        __u8 address;
+        __s8 orientation[9];
+        void *irq_data;
+        void *private_data;
+};
+
+struct fix_pnt_range {
+        __s32 mantissa;
+        __s32 fraction;
+};
+
+static inline long range_fixedpoint_to_long_mg(struct fix_pnt_range rng)
+{
+        return (long)(rng.mantissa * 1000 + rng.fraction / 10);
+}
+
+struct ext_slave_read_trigger {
+        __u8 reg;
+        __u8 value;
+};
+
+/**
+ *  struct ext_slave_descr - Description of the slave device for programming.
+ *
+ *  @suspend:   function pointer to put the device in suspended state
+ *  @resume:    function pointer to put the device in running state
+ *  @read:      function that reads the device data
+ *  @init:      function used to preallocate memory used by the driver
+ *  @exit:      function used to free memory allocated for the driver
+ *  @config:    function used to configure the device
+ *  @get_config:function used to get the device's configuration
+ *
+ *  @name:      text name of the device
+ *  @type:      device type. enum ext_slave_type
+ *  @id:        enum ext_slave_id
+ *  @read_reg:  starting register address to retrieve data.
+ *  @read_len:  length in bytes of the sensor data.  Typically  6.
+ *  @endian:    byte order of the data. enum ext_slave_endian
+ *  @range:     full scale range of the slave ouput: struct fix_pnt_range
+ *  @trigger:   If reading data first requires writing a register this is the
+ *              data to write.
+ *
+ *  Defines the functions and information about the slave the mpu3050 and
+ *  mpu6050 needs to use the slave device.
+ */
+struct ext_slave_descr {
+        int (*init) (void *mlsl_handle,
+                     struct ext_slave_descr *slave,
+                     struct ext_slave_platform_data *pdata);
+        int (*exit) (void *mlsl_handle,
+                     struct ext_slave_descr *slave,
+                     struct ext_slave_platform_data *pdata);
+        int (*suspend) (void *mlsl_handle,
+                        struct ext_slave_descr *slave,
+                        struct ext_slave_platform_data *pdata);
+        int (*resume) (void *mlsl_handle,
+                       struct ext_slave_descr *slave,
+                       struct ext_slave_platform_data *pdata);
+        int (*read) (void *mlsl_handle,
+                     struct ext_slave_descr *slave,
+                     struct ext_slave_platform_data *pdata,
+                     __u8 *data);
+        int (*config) (void *mlsl_handle,
+                       struct ext_slave_descr *slave,
+                       struct ext_slave_platform_data *pdata,
+                       struct ext_slave_config *config);
+        int (*get_config) (void *mlsl_handle,
+                           struct ext_slave_descr *slave,
+                           struct ext_slave_platform_data *pdata,
+                           struct ext_slave_config *config);
+
+        char *name;
+        __u8 type;
+        __u8 id;
+        __u8 read_reg;
+        __u8 read_len;
+        __u8 endian;
+        struct fix_pnt_range range;
+        struct ext_slave_read_trigger *trigger;
+};
+
+/**
+ * struct mpu_platform_data - Platform data for the mpu driver
+ * @int_config:         Bits [7:3] of the int config register.
+ * @level_shifter:      0: VLogic, 1: VDD
+ * @orientation:        Orientation matrix of the gyroscope
+ *
+ * Contains platform specific information on how to configure the MPU3050 to
+ * work on this platform.  The orientation matricies are 3x3 rotation matricies
+ * that are applied to the data to rotate from the mounting orientation to the
+ * platform orientation.  The values must be one of 0, 1, or -1 and each row and
+ * column should have exactly 1 non-zero value.
+ */
+struct mpu_platform_data {
+        __u8 int_config;
+        __u8 level_shifter;
+        __s8 orientation[GYRO_NUM_AXES * GYRO_NUM_AXES];
+};
+
+#define MPU_IOCTL (0x81) /* Magic number for MPU Iocts */
+/* IOCTL commands for /dev/mpu */
+
+/*--------------------------------------------------------------------------
+ * Deprecated, debugging only
+ */
+#define MPU_SET_MPU_PLATFORM_DATA       \
+        _IOWR(MPU_IOCTL, 0x01, struct mpu_platform_data)
+#define MPU_SET_EXT_SLAVE_PLATFORM_DATA \
+        _IOWR(MPU_IOCTL, 0x01, struct ext_slave_platform_data)
+/*--------------------------------------------------------------------------*/
+#define MPU_GET_EXT_SLAVE_PLATFORM_DATA \
+        _IOWR(MPU_IOCTL, 0x02, struct ext_slave_platform_data)
+#define MPU_GET_MPU_PLATFORM_DATA       \
+        _IOWR(MPU_IOCTL, 0x02, struct mpu_platform_data)
+#define MPU_GET_EXT_SLAVE_DESCR \
+        _IOWR(MPU_IOCTL, 0x02, struct ext_slave_descr)
+
+#define MPU_READ                _IOWR(MPU_IOCTL, 0x10, struct mpu_read_write)
+#define MPU_WRITE               _IOW(MPU_IOCTL,  0x10, struct mpu_read_write)
+#define MPU_READ_MEM            _IOWR(MPU_IOCTL, 0x11, struct mpu_read_write)
+#define MPU_WRITE_MEM           _IOW(MPU_IOCTL,  0x11, struct mpu_read_write)
+#define MPU_READ_FIFO           _IOWR(MPU_IOCTL, 0x12, struct mpu_read_write)
+#define MPU_WRITE_FIFO          _IOW(MPU_IOCTL,  0x12, struct mpu_read_write)
+
+#define MPU_READ_COMPASS        _IOR(MPU_IOCTL, 0x12, __u8)
+#define MPU_READ_ACCEL          _IOR(MPU_IOCTL, 0x13, __u8)
+#define MPU_READ_PRESSURE       _IOR(MPU_IOCTL, 0x14, __u8)
+
+#define MPU_CONFIG_GYRO         _IOW(MPU_IOCTL, 0x20, struct ext_slave_config)
+#define MPU_CONFIG_ACCEL        _IOW(MPU_IOCTL, 0x21, struct ext_slave_config)
+#define MPU_CONFIG_COMPASS      _IOW(MPU_IOCTL, 0x22, struct ext_slave_config)
+#define MPU_CONFIG_PRESSURE     _IOW(MPU_IOCTL, 0x23, struct ext_slave_config)
+
+#define MPU_GET_CONFIG_GYRO     _IOWR(MPU_IOCTL, 0x20, struct ext_slave_config)
+#define MPU_GET_CONFIG_ACCEL    _IOWR(MPU_IOCTL, 0x21, struct ext_slave_config)
+#define MPU_GET_CONFIG_COMPASS  _IOWR(MPU_IOCTL, 0x22, struct ext_slave_config)
+#define MPU_GET_CONFIG_PRESSURE _IOWR(MPU_IOCTL, 0x23, struct ext_slave_config)
+
+#define MPU_SUSPEND             _IOW(MPU_IOCTL, 0x30, __u32)
+#define MPU_RESUME              _IOW(MPU_IOCTL, 0x31, __u32)
+/* Userspace PM Event response */
+#define MPU_PM_EVENT_HANDLED    _IO(MPU_IOCTL, 0x32)
+
+#define MPU_GET_REQUESTED_SENSORS       _IOR(MPU_IOCTL, 0x40, __u8)
+#define MPU_SET_REQUESTED_SENSORS       _IOW(MPU_IOCTL, 0x40, __u8)
+#define MPU_GET_IGNORE_SYSTEM_SUSPEND   _IOR(MPU_IOCTL, 0x41, __u8)
+#define MPU_SET_IGNORE_SYSTEM_SUSPEND   _IOW(MPU_IOCTL, 0x41, __u8)
+#define MPU_GET_MLDL_STATUS             _IOR(MPU_IOCTL, 0x42, __u8)
+#define MPU_GET_I2C_SLAVES_ENABLED      _IOR(MPU_IOCTL, 0x43, __u8)
+
+
+#endif                          /* __MPU_H_ */
diff --git a/include/linux/mpu3050.h b/include/linux/mpu3050.h
new file mode 100644
index 00000000000..a8dcd5a9473
--- /dev/null
+++ b/include/linux/mpu3050.h
@@ -0,0 +1,255 @@
+/*
+ $License:
+    Copyright (C) 2010 InvenSense Corporation, All Rights Reserved.
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+  $
+ */
+
+#ifndef __MPU3050_H_
+#define __MPU3050_H_
+
+#ifdef __KERNEL__
+#include <linux/types.h>
+#endif
+
+#ifdef M_HW
+#error MPU6000 build including MPU3050 header
+#endif
+
+#define MPU_NAME "mpu3050"
+#define DEFAULT_MPU_SLAVEADDR       0x68
+
+/*==== MPU REGISTER SET ====*/
+enum mpu_register {
+        MPUREG_WHO_AM_I = 0,    /* 00 0x00 */
+        MPUREG_PRODUCT_ID,      /* 01 0x01 */
+        MPUREG_02_RSVD,         /* 02 0x02 */
+        MPUREG_03_RSVD,         /* 03 0x03 */
+        MPUREG_04_RSVD,         /* 04 0x04 */
+        MPUREG_XG_OFFS_TC,      /* 05 0x05 */
+        MPUREG_06_RSVD,         /* 06 0x06 */
+        MPUREG_07_RSVD,         /* 07 0x07 */
+        MPUREG_YG_OFFS_TC,      /* 08 0x08 */
+        MPUREG_09_RSVD,         /* 09 0x09 */
+        MPUREG_0A_RSVD,         /* 10 0x0a */
+        MPUREG_ZG_OFFS_TC,      /* 11 0x0b */
+        MPUREG_X_OFFS_USRH,     /* 12 0x0c */
+        MPUREG_X_OFFS_USRL,     /* 13 0x0d */
+        MPUREG_Y_OFFS_USRH,     /* 14 0x0e */
+        MPUREG_Y_OFFS_USRL,     /* 15 0x0f */
+        MPUREG_Z_OFFS_USRH,     /* 16 0x10 */
+        MPUREG_Z_OFFS_USRL,     /* 17 0x11 */
+        MPUREG_FIFO_EN1,        /* 18 0x12 */
+        MPUREG_FIFO_EN2,        /* 19 0x13 */
+        MPUREG_AUX_SLV_ADDR,    /* 20 0x14 */
+        MPUREG_SMPLRT_DIV,      /* 21 0x15 */
+        MPUREG_DLPF_FS_SYNC,    /* 22 0x16 */
+        MPUREG_INT_CFG,         /* 23 0x17 */
+        MPUREG_ACCEL_BURST_ADDR,/* 24 0x18 */
+        MPUREG_19_RSVD,         /* 25 0x19 */
+        MPUREG_INT_STATUS,      /* 26 0x1a */
+        MPUREG_TEMP_OUT_H,      /* 27 0x1b */
+        MPUREG_TEMP_OUT_L,      /* 28 0x1c */
+        MPUREG_GYRO_XOUT_H,     /* 29 0x1d */
+        MPUREG_GYRO_XOUT_L,     /* 30 0x1e */
+        MPUREG_GYRO_YOUT_H,     /* 31 0x1f */
+        MPUREG_GYRO_YOUT_L,     /* 32 0x20 */
+        MPUREG_GYRO_ZOUT_H,     /* 33 0x21 */
+        MPUREG_GYRO_ZOUT_L,     /* 34 0x22 */
+        MPUREG_23_RSVD,         /* 35 0x23 */
+        MPUREG_24_RSVD,         /* 36 0x24 */
+        MPUREG_25_RSVD,         /* 37 0x25 */
+        MPUREG_26_RSVD,         /* 38 0x26 */
+        MPUREG_27_RSVD,         /* 39 0x27 */
+        MPUREG_28_RSVD,         /* 40 0x28 */
+        MPUREG_29_RSVD,         /* 41 0x29 */
+        MPUREG_2A_RSVD,         /* 42 0x2a */
+        MPUREG_2B_RSVD,         /* 43 0x2b */
+        MPUREG_2C_RSVD,         /* 44 0x2c */
+        MPUREG_2D_RSVD,         /* 45 0x2d */
+        MPUREG_2E_RSVD,         /* 46 0x2e */
+        MPUREG_2F_RSVD,         /* 47 0x2f */
+        MPUREG_30_RSVD,         /* 48 0x30 */
+        MPUREG_31_RSVD,         /* 49 0x31 */
+        MPUREG_32_RSVD,         /* 50 0x32 */
+        MPUREG_33_RSVD,         /* 51 0x33 */
+        MPUREG_34_RSVD,         /* 52 0x34 */
+        MPUREG_DMP_CFG_1,       /* 53 0x35 */
+        MPUREG_DMP_CFG_2,       /* 54 0x36 */
+        MPUREG_BANK_SEL,        /* 55 0x37 */
+        MPUREG_MEM_START_ADDR,  /* 56 0x38 */
+        MPUREG_MEM_R_W,         /* 57 0x39 */
+        MPUREG_FIFO_COUNTH,     /* 58 0x3a */
+        MPUREG_FIFO_COUNTL,     /* 59 0x3b */
+        MPUREG_FIFO_R_W,        /* 60 0x3c */
+        MPUREG_USER_CTRL,       /* 61 0x3d */
+        MPUREG_PWR_MGM,         /* 62 0x3e */
+        MPUREG_3F_RSVD,         /* 63 0x3f */
+        NUM_OF_MPU_REGISTERS    /* 64 0x40 */
+};
+
+/*==== BITS FOR MPU ====*/
+
+/*---- MPU 'FIFO_EN1' register (12) ----*/
+#define BIT_TEMP_OUT                0x80
+#define BIT_GYRO_XOUT               0x40
+#define BIT_GYRO_YOUT               0x20
+#define BIT_GYRO_ZOUT               0x10
+#define BIT_ACCEL_XOUT              0x08
+#define BIT_ACCEL_YOUT              0x04
+#define BIT_ACCEL_ZOUT              0x02
+#define BIT_AUX_1OUT                0x01
+/*---- MPU 'FIFO_EN2' register (13) ----*/
+#define BIT_AUX_2OUT                0x02
+#define BIT_AUX_3OUT                0x01
+/*---- MPU 'DLPF_FS_SYNC' register (16) ----*/
+#define BITS_EXT_SYNC_NONE          0x00
+#define BITS_EXT_SYNC_TEMP          0x20
+#define BITS_EXT_SYNC_GYROX         0x40
+#define BITS_EXT_SYNC_GYROY         0x60
+#define BITS_EXT_SYNC_GYROZ         0x80
+#define BITS_EXT_SYNC_ACCELX        0xA0
+#define BITS_EXT_SYNC_ACCELY        0xC0
+#define BITS_EXT_SYNC_ACCELZ        0xE0
+#define BITS_EXT_SYNC_MASK          0xE0
+#define BITS_FS_250DPS              0x00
+#define BITS_FS_500DPS              0x08
+#define BITS_FS_1000DPS             0x10
+#define BITS_FS_2000DPS             0x18
+#define BITS_FS_MASK                0x18
+#define BITS_DLPF_CFG_256HZ_NOLPF2  0x00
+#define BITS_DLPF_CFG_188HZ         0x01
+#define BITS_DLPF_CFG_98HZ          0x02
+#define BITS_DLPF_CFG_42HZ          0x03
+#define BITS_DLPF_CFG_20HZ          0x04
+#define BITS_DLPF_CFG_10HZ          0x05
+#define BITS_DLPF_CFG_5HZ           0x06
+#define BITS_DLPF_CFG_2100HZ_NOLPF  0x07
+#define BITS_DLPF_CFG_MASK          0x07
+/*---- MPU 'INT_CFG' register (17) ----*/
+#define BIT_ACTL                    0x80
+#define BIT_ACTL_LOW                0x80
+#define BIT_ACTL_HIGH               0x00
+#define BIT_OPEN                    0x40
+#define BIT_OPEN_DRAIN              0x40
+#define BIT_PUSH_PULL               0x00
+#define BIT_LATCH_INT_EN            0x20
+#define BIT_LATCH_INT_EN            0x20
+#define BIT_INT_PULSE_WIDTH_50US    0x00
+#define BIT_INT_ANYRD_2CLEAR        0x10
+#define BIT_INT_STAT_READ_2CLEAR    0x00
+#define BIT_MPU_RDY_EN              0x04
+#define BIT_DMP_INT_EN              0x02
+#define BIT_RAW_RDY_EN              0x01
+/*---- MPU 'INT_STATUS' register (1A) ----*/
+#define BIT_INT_STATUS_FIFO_OVERLOW 0x80
+#define BIT_MPU_RDY                 0x04
+#define BIT_DMP_INT                 0x02
+#define BIT_RAW_RDY                 0x01
+/*---- MPU 'BANK_SEL' register (37) ----*/
+#define BIT_PRFTCH_EN               0x20
+#define BIT_CFG_USER_BANK           0x10
+#define BITS_MEM_SEL                0x0f
+/*---- MPU 'USER_CTRL' register (3D) ----*/
+#define BIT_DMP_EN                  0x80
+#define BIT_FIFO_EN                 0x40
+#define BIT_AUX_IF_EN               0x20
+#define BIT_AUX_RD_LENG             0x10
+#define BIT_AUX_IF_RST              0x08
+#define BIT_DMP_RST                 0x04
+#define BIT_FIFO_RST                0x02
+#define BIT_GYRO_RST                0x01
+/*---- MPU 'PWR_MGM' register (3E) ----*/
+#define BIT_H_RESET                 0x80
+#define BIT_SLEEP                   0x40
+#define BIT_STBY_XG                 0x20
+#define BIT_STBY_YG                 0x10
+#define BIT_STBY_ZG                 0x08
+#define BITS_CLKSEL                 0x07
+
+/*---- MPU Silicon Revision ----*/
+#define MPU_SILICON_REV_A4           1  /* MPU A4 Device */
+#define MPU_SILICON_REV_B1           2  /* MPU B1 Device */
+#define MPU_SILICON_REV_B4           3  /* MPU B4 Device */
+#define MPU_SILICON_REV_B6           4  /* MPU B6 Device */
+
+/*---- MPU Memory ----*/
+#define MPU_MEM_BANK_SIZE           (256)
+#define FIFO_HW_SIZE                (512)
+
+enum MPU_MEMORY_BANKS {
+        MPU_MEM_RAM_BANK_0 = 0,
+        MPU_MEM_RAM_BANK_1,
+        MPU_MEM_RAM_BANK_2,
+        MPU_MEM_RAM_BANK_3,
+        MPU_MEM_NUM_RAM_BANKS,
+        MPU_MEM_OTP_BANK_0 = MPU_MEM_NUM_RAM_BANKS,
+        /* This one is always last */
+        MPU_MEM_NUM_BANKS
+};
+
+#define MPU_NUM_AXES (3)
+
+/*---- structure containing control variables used by MLDL ----*/
+/*---- MPU clock source settings ----*/
+/*---- MPU filter selections ----*/
+enum mpu_filter {
+        MPU_FILTER_256HZ_NOLPF2 = 0,
+        MPU_FILTER_188HZ,
+        MPU_FILTER_98HZ,
+        MPU_FILTER_42HZ,
+        MPU_FILTER_20HZ,
+        MPU_FILTER_10HZ,
+        MPU_FILTER_5HZ,
+        MPU_FILTER_2100HZ_NOLPF,
+        NUM_MPU_FILTER
+};
+
+enum mpu_fullscale {
+        MPU_FS_250DPS = 0,
+        MPU_FS_500DPS,
+        MPU_FS_1000DPS,
+        MPU_FS_2000DPS,
+        NUM_MPU_FS
+};
+
+enum mpu_clock_sel {
+        MPU_CLK_SEL_INTERNAL = 0,
+        MPU_CLK_SEL_PLLGYROX,
+        MPU_CLK_SEL_PLLGYROY,
+        MPU_CLK_SEL_PLLGYROZ,
+        MPU_CLK_SEL_PLLEXT32K,
+        MPU_CLK_SEL_PLLEXT19M,
+        MPU_CLK_SEL_RESERVED,
+        MPU_CLK_SEL_STOP,
+        NUM_CLK_SEL
+};
+
+enum mpu_ext_sync {
+        MPU_EXT_SYNC_NONE = 0,
+        MPU_EXT_SYNC_TEMP,
+        MPU_EXT_SYNC_GYROX,
+        MPU_EXT_SYNC_GYROY,
+        MPU_EXT_SYNC_GYROZ,
+        MPU_EXT_SYNC_ACCELX,
+        MPU_EXT_SYNC_ACCELY,
+        MPU_EXT_SYNC_ACCELZ,
+        NUM_MPU_EXT_SYNC
+};
+
+#define DLPF_FS_SYNC_VALUE(ext_sync, full_scale, lpf) \
+    ((ext_sync << 5) | (full_scale << 3) | lpf)
+
+#endif                          /* __MPU3050_H_ */
diff --git a/include/linux/mpu6000.h b/include/linux/mpu6000.h
new file mode 100644
index 00000000000..5a63c8f07b7
--- /dev/null
+++ b/include/linux/mpu6000.h
@@ -0,0 +1,406 @@
+/*
+ $License:
+    Copyright (C) 2010 InvenSense Corporation, All Rights Reserved.
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+  $
+ */
+
+/**
+ * @defgroup
+ * @brief
+ *
+ * @{
+ *      @file     mpu6000.h
+ *      @brief
+ */
+
+#ifndef __MPU6000_H_
+#define __MPU6000_H_
+
+#define MPU_NAME "mpu6000"
+#define DEFAULT_MPU_SLAVEADDR       0x68
+
+/*==== M_HW REGISTER SET ====*/
+enum {
+        MPUREG_XG_OFFS_TC = 0,                  /* 0x00 */
+        MPUREG_YG_OFFS_TC,                      /* 0x00 */
+        MPUREG_ZG_OFFS_TC,                      /* 0x00 */
+        MPUREG_X_FINE_GAIN,                     /* 0x00 */
+        MPUREG_Y_FINE_GAIN,                     /* 0x00 */
+        MPUREG_Z_FINE_GAIN,                     /* 0x00 */
+        MPUREG_XA_OFFS_H,                       /* 0x00 */
+        MPUREG_XA_OFFS_L_TC,                    /* 0x00 */
+        MPUREG_YA_OFFS_H,                       /* 0x00 */
+        MPUREG_YA_OFFS_L_TC,                    /* 0x00 */
+        MPUREG_ZA_OFFS_H,                       /* 0x00 */
+        MPUREG_ZA_OFFS_L_TC,    /* 0xB */
+        MPUREG_0C_RSVD,                 /* 0x00 */
+        MPUREG_0D_RSVD,                 /* 0x00 */
+        MPUREG_0E_RSVD,                 /* 0x00 */
+        MPUREG_0F_RSVD,                 /* 0x00 */
+        MPUREG_10_RSVD,                 /* 0x00 */
+        MPUREG_11_RSVD,                 /* 0x00 */
+        MPUREG_12_RSVD,                 /* 0x00 */
+        MPUREG_XG_OFFS_USRH,                    /* 0x00 */
+        MPUREG_XG_OFFS_USRL,                    /* 0x00 */
+        MPUREG_YG_OFFS_USRH,                    /* 0x00 */
+        MPUREG_YG_OFFS_USRL,                    /* 0x00 */
+        MPUREG_ZG_OFFS_USRH,                    /* 0x00 */
+        MPUREG_ZG_OFFS_USRL,                    /* 0x00 */
+        MPUREG_SMPLRT_DIV,      /* 0x19 */
+        MPUREG_CONFIG,          /* 0x1A ==> DLPF_FS_SYNC */
+        MPUREG_GYRO_CONFIG,                     /* 0x00 */
+        MPUREG_ACCEL_CONFIG,                    /* 0x00 */
+        MPUREG_ACCEL_FF_THR,                    /* 0x00 */
+        MPUREG_ACCEL_FF_DUR,                    /* 0x00 */
+        MPUREG_ACCEL_MOT_THR,                   /* 0x00 */
+        MPUREG_ACCEL_MOT_DUR,                   /* 0x00 */
+        MPUREG_ACCEL_ZRMOT_THR,                 /* 0x00 */
+        MPUREG_ACCEL_ZRMOT_DUR,                 /* 0x00 */
+        MPUREG_FIFO_EN,         /* 0x23 */
+        MPUREG_I2C_MST_CTRL,                    /* 0x00 */
+        MPUREG_I2C_SLV0_ADDR,   /* 0x25 */
+        MPUREG_I2C_SLV0_REG,                    /* 0x00 */
+        MPUREG_I2C_SLV0_CTRL,                   /* 0x00 */
+        MPUREG_I2C_SLV1_ADDR,   /* 0x28 */
+        MPUREG_I2C_SLV1_REG_PASSWORD,                   /* 0x00 */
+        MPUREG_I2C_SLV1_CTRL,                   /* 0x00 */
+        MPUREG_I2C_SLV2_ADDR,   /* 0x2B */
+        MPUREG_I2C_SLV2_REG,                    /* 0x00 */
+        MPUREG_I2C_SLV2_CTRL,                   /* 0x00 */
+        MPUREG_I2C_SLV3_ADDR,   /* 0x2E */
+        MPUREG_I2C_SLV3_REG,                    /* 0x00 */
+        MPUREG_I2C_SLV3_CTRL,                   /* 0x00 */
+        MPUREG_I2C_SLV4_ADDR,   /* 0x31 */
+        MPUREG_I2C_SLV4_REG,                    /* 0x00 */
+        MPUREG_I2C_SLV4_DO,                     /* 0x00 */
+        MPUREG_I2C_SLV4_CTRL,                   /* 0x00 */
+        MPUREG_I2C_SLV4_DI,                     /* 0x00 */
+        MPUREG_I2C_MST_STATUS,  /* 0x36 */
+        MPUREG_INT_PIN_CFG,     /* 0x37 ==> -* INT_CFG */
+        MPUREG_INT_ENABLE,      /* 0x38 ==> / */
+        MPUREG_DMP_INT_STATUS,  /* 0x39 */
+        MPUREG_INT_STATUS,      /* 0x3A */
+        MPUREG_ACCEL_XOUT_H,    /* 0x3B */
+        MPUREG_ACCEL_XOUT_L,                    /* 0x00 */
+        MPUREG_ACCEL_YOUT_H,                    /* 0x00 */
+        MPUREG_ACCEL_YOUT_L,                    /* 0x00 */
+        MPUREG_ACCEL_ZOUT_H,                    /* 0x00 */
+        MPUREG_ACCEL_ZOUT_L,                    /* 0x00 */
+        MPUREG_TEMP_OUT_H,      /* 0x41 */
+        MPUREG_TEMP_OUT_L,                      /* 0x00 */
+        MPUREG_GYRO_XOUT_H,     /* 0x43 */
+        MPUREG_GYRO_XOUT_L,                     /* 0x00 */
+        MPUREG_GYRO_YOUT_H,                     /* 0x00 */
+        MPUREG_GYRO_YOUT_L,                     /* 0x00 */
+        MPUREG_GYRO_ZOUT_H,                     /* 0x00 */
+        MPUREG_GYRO_ZOUT_L,                     /* 0x00 */
+        MPUREG_EXT_SLV_SENS_DATA_00,    /* 0x49 */
+        MPUREG_EXT_SLV_SENS_DATA_01,                    /* 0x00 */
+        MPUREG_EXT_SLV_SENS_DATA_02,                    /* 0x00 */
+        MPUREG_EXT_SLV_SENS_DATA_03,                    /* 0x00 */
+        MPUREG_EXT_SLV_SENS_DATA_04,                    /* 0x00 */
+        MPUREG_EXT_SLV_SENS_DATA_05,                    /* 0x00 */
+        MPUREG_EXT_SLV_SENS_DATA_06,    /* 0x4F */
+        MPUREG_EXT_SLV_SENS_DATA_07,                    /* 0x00 */
+        MPUREG_EXT_SLV_SENS_DATA_08,                    /* 0x00 */
+        MPUREG_EXT_SLV_SENS_DATA_09,                    /* 0x00 */
+        MPUREG_EXT_SLV_SENS_DATA_10,                    /* 0x00 */
+        MPUREG_EXT_SLV_SENS_DATA_11,                    /* 0x00 */
+        MPUREG_EXT_SLV_SENS_DATA_12,    /* 0x55 */
+        MPUREG_EXT_SLV_SENS_DATA_13,                    /* 0x00 */
+        MPUREG_EXT_SLV_SENS_DATA_14,                    /* 0x00 */
+        MPUREG_EXT_SLV_SENS_DATA_15,                    /* 0x00 */
+        MPUREG_EXT_SLV_SENS_DATA_16,                    /* 0x00 */
+        MPUREG_EXT_SLV_SENS_DATA_17,                    /* 0x00 */
+        MPUREG_EXT_SLV_SENS_DATA_18,    /* 0x5B */
+        MPUREG_EXT_SLV_SENS_DATA_19,                    /* 0x00 */
+        MPUREG_EXT_SLV_SENS_DATA_20,                    /* 0x00 */
+        MPUREG_EXT_SLV_SENS_DATA_21,                    /* 0x00 */
+        MPUREG_EXT_SLV_SENS_DATA_22,                    /* 0x00 */
+        MPUREG_EXT_SLV_SENS_DATA_23,                    /* 0x00 */
+        ACCEL_INTEL_STATUS,     /* 0x61 */
+        MPUREG_62_RSVD,                 /* 0x00 */
+        MPUREG_63_RSVD,                 /* 0x00 */
+        MPUREG_64_RSVD,                 /* 0x00 */
+        MPUREG_65_RSVD,                 /* 0x00 */
+        MPUREG_66_RSVD,                 /* 0x00 */
+        MPUREG_67_RSVD,                 /* 0x00 */
+        SIGNAL_PATH_RESET,      /* 0x68 */
+        ACCEL_INTEL_CTRL,       /* 0x69 */
+        MPUREG_USER_CTRL,       /* 0x6A */
+        MPUREG_PWR_MGMT_1,      /* 0x6B */
+        MPUREG_PWR_MGMT_2,                      /* 0x00 */
+        MPUREG_BANK_SEL,        /* 0x6D */
+        MPUREG_MEM_START_ADDR,  /* 0x6E */
+        MPUREG_MEM_R_W,         /* 0x6F */
+        MPUREG_PRGM_STRT_ADDRH,                 /* 0x00 */
+        MPUREG_PRGM_STRT_ADDRL,                 /* 0x00 */
+        MPUREG_FIFO_COUNTH,     /* 0x72 */
+        MPUREG_FIFO_COUNTL,                     /* 0x00 */
+        MPUREG_FIFO_R_W,        /* 0x74 */
+        MPUREG_WHOAMI,          /* 0x75,117 */
+
+        NUM_OF_MPU_REGISTERS    /* = 0x76,118 */
+};
+
+/*==== M_HW MEMORY ====*/
+enum MPU_MEMORY_BANKS {
+        MEM_RAM_BANK_0 = 0,
+        MEM_RAM_BANK_1,
+        MEM_RAM_BANK_2,
+        MEM_RAM_BANK_3,
+        MEM_RAM_BANK_4,
+        MEM_RAM_BANK_5,
+        MEM_RAM_BANK_6,
+        MEM_RAM_BANK_7,
+        MEM_RAM_BANK_8,
+        MEM_RAM_BANK_9,
+        MEM_RAM_BANK_10,
+        MEM_RAM_BANK_11,
+        MPU_MEM_NUM_RAM_BANKS,
+        MPU_MEM_OTP_BANK_0 = 16
+};
+
+
+/*==== M_HW parameters ====*/
+
+#define NUM_REGS            (NUM_OF_MPU_REGISTERS)
+#define START_SENS_REGS     (0x3B)
+#define NUM_SENS_REGS       (0x60-START_SENS_REGS+1)
+
+/*---- MPU Memory ----*/
+#define NUM_BANKS           (MPU_MEM_NUM_RAM_BANKS)
+#define BANK_SIZE           (256)
+#define MEM_SIZE            (NUM_BANKS*BANK_SIZE)
+#define MPU_MEM_BANK_SIZE   (BANK_SIZE) /*alternative name */
+
+#define FIFO_HW_SIZE        (1024)
+
+#define NUM_EXT_SLAVES      (4)
+
+
+/*==== BITS FOR M_HW ====*/
+
+/*---- M_HW 'FIFO_EN' register (23) ----*/
+#define BIT_TEMP_OUT                            0x80
+#define BIT_GYRO_XOUT                           0x40
+#define BIT_GYRO_YOUT                           0x20
+#define BIT_GYRO_ZOUT                           0x10
+#define BIT_ACCEL                               0x08
+#define BIT_SLV_2                               0x04
+#define BIT_SLV_1                               0x02
+#define BIT_SLV_0                               0x01
+/*---- M_HW 'CONFIG' register (1A) ----*/
+/*NONE                                          0xC0 */
+#define BITS_EXT_SYNC_SET                       0x38
+#define BITS_DLPF_CFG                           0x07
+/*---- M_HW 'GYRO_CONFIG' register (1B) ----*/
+/* voluntarily modified label from BITS_FS_SEL to
+ * BITS_GYRO_FS_SEL to avoid confusion with MPU
+ */
+#define BITS_GYRO_FS_SEL                        0x18
+/*NONE                                          0x07 */
+/*---- M_HW 'ACCEL_CONFIG' register (1C) ----*/
+#define BITS_ACCEL_FS_SEL                       0x18
+#define BITS_ACCEL_HPF                          0x07
+/*---- M_HW 'I2C_MST_CTRL' register (24) ----*/
+#define BIT_MULT_MST_DIS                        0x80
+#define BIT_WAIT_FOR_ES                         0x40
+#define BIT_I2C_MST_VDDIO                       0x20
+/*NONE                                          0x10 */
+#define BITS_I2C_MST_CLK                        0x0F
+/*---- M_HW 'I2C_SLV?_CTRL' register (27,2A,2D,30) ----*/
+#define BIT_SLV_ENABLE                          0x80
+#define BIT_SLV_BYTE_SW                         0x40
+/*NONE                                          0x20 */
+#define BIT_SLV_GRP                             0x10
+#define BITS_SLV_LENG                           0x0F
+/*---- M_HW 'I2C_SLV4_ADDR' register (31) ----*/
+#define BIT_I2C_SLV4_RNW                        0x80
+/*---- M_HW 'I2C_SLV4_CTRL' register (34) ----*/
+#define BIT_I2C_SLV4_EN                         0x80
+#define BIT_SLV4_DONE_INT_EN                    0x40
+/*NONE                                          0x3F */
+/*---- M_HW 'I2C_MST_STATUS' register (36) ----*/
+#define BIT_PASSTHROUGH                         0x80
+#define BIT_I2C_SLV4_DONE                       0x40
+#define BIT_I2C_LOST_ARB                        0x20
+#define BIT_I2C_SLV4_NACK                       0x10
+#define BIT_I2C_SLV3_NACK                       0x08
+#define BIT_I2C_SLV2_NACK                       0x04
+#define BIT_I2C_SLV1_NACK                       0x02
+#define BIT_I2C_SLV0_NACK                       0x01
+/*---- M_HW 'INT_PIN_CFG' register (37) ----*/
+#define BIT_ACTL                                0x80
+#define BIT_ACTL_LOW                            0x80
+#define BIT_ACTL_HIGH                           0x00
+#define BIT_OPEN                                0x40
+#define BIT_LATCH_INT_EN                        0x20
+#define BIT_INT_ANYRD_2CLEAR                    0x10
+#define BIT_ACTL_FSYNC                          0x08
+#define BIT_FSYNC_INT_EN                        0x04
+#define BIT_BYPASS_EN                           0x02
+#define BIT_CLKOUT_EN                           0x01
+/*---- M_HW 'INT_ENABLE' register (38) ----*/
+#define BIT_FF_EN                               0x80
+#define BIT_MOT_EN                              0x40
+#define BIT_ZMOT_EN                             0x20
+#define BIT_FIFO_OVERFLOW_EN                    0x10
+#define BIT_I2C_MST_INT_EN                      0x08
+#define BIT_PLL_RDY_EN                          0x04
+#define BIT_DMP_INT_EN                          0x02
+#define BIT_RAW_RDY_EN                          0x01
+/*---- M_HW 'DMP_INT_STATUS' register (39) ----*/
+/*NONE                                          0x80 */
+/*NONE                                          0x40 */
+#define BIT_DMP_INT_5                           0x20
+#define BIT_DMP_INT_4                           0x10
+#define BIT_DMP_INT_3                           0x08
+#define BIT_DMP_INT_2                           0x04
+#define BIT_DMP_INT_1                           0x02
+#define BIT_DMP_INT_0                           0x01
+/*---- M_HW 'INT_STATUS' register (3A) ----*/
+#define BIT_FF_INT                              0x80
+#define BIT_MOT_INT                             0x40
+#define BIT_ZMOT_INT                            0x20
+#define BIT_FIFO_OVERFLOW_INT                   0x10
+#define BIT_I2C_MST_INT                         0x08
+#define BIT_PLL_RDY_INT                         0x04
+#define BIT_DMP_INT                             0x02
+#define BIT_RAW_DATA_RDY_INT                    0x01
+/*---- M_HW 'BANK_SEL' register (6D) ----*/
+#define BIT_PRFTCH_EN                           0x40
+#define BIT_CFG_USER_BANK                       0x20
+#define BITS_MEM_SEL                            0x1f
+/*---- M_HW 'USER_CTRL' register (6A) ----*/
+#define BIT_DMP_EN                              0x80
+#define BIT_FIFO_EN                             0x40
+#define BIT_I2C_MST_EN                          0x20
+#define BIT_I2C_IF_DIS                          0x10
+#define BIT_DMP_RST                             0x08
+#define BIT_FIFO_RST                            0x04
+#define BIT_I2C_MST_RST                         0x02
+#define BIT_SIG_COND_RST                        0x01
+/*---- M_HW 'PWR_MGMT_1' register (6B) ----*/
+#define BIT_H_RESET                             0x80
+#define BITS_PWRSEL                             0x70
+#define BIT_WKUP_INT                            0x08
+#define BITS_CLKSEL                             0x07
+/*---- M_HW 'PWR_MGMT_2' register (6C) ----*/
+#define BITS_LPA_WAKE_CTRL                      0xC0
+#define BIT_STBY_XA                             0x20
+#define BIT_STBY_YA                             0x10
+#define BIT_STBY_ZA                             0x08
+#define BIT_STBY_XG                             0x04
+#define BIT_STBY_YG                             0x02
+#define BIT_STBY_ZG                             0x01
+
+/* although it has 6, this refers to the gyros */
+#define MPU_NUM_AXES     (3)
+
+#define ACCEL_MOT_THR_LSB (32) /* mg */
+#define ACCEL_MOT_DUR_LSB (1)
+#define ACCEL_ZRMOT_THR_LSB_CONVERSION(mg) ((mg *1000)/255)
+#define ACCEL_ZRMOT_DUR_LSB (64)
+
+/*----------------------------------------------------------------------------*/
+/*---- Alternative names to take care of conflicts with current mpu3050.h ----*/
+/*----------------------------------------------------------------------------*/
+
+/*-- registers --*/
+#define MPUREG_DLPF_FS_SYNC        MPUREG_CONFIG                /* 0x1A */
+
+#define MPUREG_PRODUCT_ID          MPUREG_WHOAMI                /* 0x75  HACK!*/
+#define MPUREG_PWR_MGM             MPUREG_PWR_MGMT_1            /* 0x6B */
+#define MPUREG_FIFO_EN1            MPUREG_FIFO_EN               /* 0x23 */
+#define MPUREG_DMP_CFG_1           MPUREG_PRGM_STRT_ADDRH       /* 0x70 */
+#define MPUREG_DMP_CFG_2           MPUREG_PRGM_STRT_ADDRL       /* 0x71 */
+#define MPUREG_INT_CFG             MPUREG_INT_ENABLE            /* 0x38 */
+#define MPUREG_X_OFFS_USRH         MPUREG_XG_OFFS_USRH          /* 0x13 */
+#define MPUREG_WHO_AM_I            MPUREG_WHOAMI                /* 0x75 */
+#define MPUREG_23_RSVD             MPUREG_EXT_SLV_SENS_DATA_00  /* 0x49 */
+#define MPUREG_AUX_SLV_ADDR        MPUREG_I2C_SLV0_ADDR         /* 0x25 */
+#define MPUREG_ACCEL_BURST_ADDR    MPUREG_I2C_SLV0_REG          /* 0x26 */
+
+/*-- bits --*/
+/* 'USER_CTRL' register */
+#define BIT_AUX_IF_EN               BIT_I2C_MST_EN
+#define BIT_AUX_RD_LENG             BIT_I2C_MST_EN
+#define BIT_IME_IF_RST              BIT_I2C_MST_RST
+#define BIT_GYRO_RST                BIT_SIG_COND_RST
+/* 'INT_ENABLE' register */
+#define BIT_RAW_RDY                 BIT_RAW_DATA_RDY_INT
+#define BIT_MPU_RDY_EN              BIT_PLL_RDY_EN
+/* 'INT_STATUS' register */
+#define BIT_INT_STATUS_FIFO_OVERLOW BIT_FIFO_OVERFLOW_INT
+
+
+
+/*---- M_HW Silicon Revisions ----*/
+#define MPU_SILICON_REV_A1           1  /* M_HW A1 Device */
+#define MPU_SILICON_REV_B1           2  /* M_HW B1 Device */
+
+/*---- structure containing control variables used by MLDL ----*/
+/*---- MPU clock source settings ----*/
+/*---- MPU filter selections ----*/
+enum mpu_filter {
+        MPU_FILTER_256HZ_NOLPF2 = 0,
+        MPU_FILTER_188HZ,
+        MPU_FILTER_98HZ,
+        MPU_FILTER_42HZ,
+        MPU_FILTER_20HZ,
+        MPU_FILTER_10HZ,
+        MPU_FILTER_5HZ,
+        MPU_FILTER_2100HZ_NOLPF,
+        NUM_MPU_FILTER
+};
+
+enum mpu_fullscale {
+        MPU_FS_250DPS = 0,
+        MPU_FS_500DPS,
+        MPU_FS_1000DPS,
+        MPU_FS_2000DPS,
+        NUM_MPU_FS
+};
+
+enum mpu_clock_sel {
+        MPU_CLK_SEL_INTERNAL = 0,
+        MPU_CLK_SEL_PLLGYROX,
+        MPU_CLK_SEL_PLLGYROY,
+        MPU_CLK_SEL_PLLGYROZ,
+        MPU_CLK_SEL_PLLEXT32K,
+        MPU_CLK_SEL_PLLEXT19M,
+        MPU_CLK_SEL_RESERVED,
+        MPU_CLK_SEL_STOP,
+        NUM_CLK_SEL
+};
+
+enum mpu_ext_sync {
+        MPU_EXT_SYNC_NONE = 0,
+        MPU_EXT_SYNC_TEMP,
+        MPU_EXT_SYNC_GYROX,
+        MPU_EXT_SYNC_GYROY,
+        MPU_EXT_SYNC_GYROZ,
+        MPU_EXT_SYNC_ACCELX,
+        MPU_EXT_SYNC_ACCELY,
+        MPU_EXT_SYNC_ACCELZ,
+        NUM_MPU_EXT_SYNC
+};
+
+#define DLPF_FS_SYNC_VALUE(ext_sync, full_scale, lpf) \
+    ((ext_sync << 5) | (full_scale << 3) | lpf)
+
+#endif                          /* __IMU6000_H_ */
diff --git a/include/linux/msdos_fs.h b/include/linux/msdos_fs.h
index 34066e65fde..f38d4f0a5ae 100644
--- a/include/linux/msdos_fs.h
+++ b/include/linux/msdos_fs.h
@@ -101,6 +101,7 @@ struct __fat_dirent {
 /* <linux/videotext.h> has used 0x72 ('r') in collision, so skip a few */
 #define FAT_IOCTL_GET_ATTRIBUTES        _IOR('r', 0x10, __u32)
 #define FAT_IOCTL_SET_ATTRIBUTES        _IOW('r', 0x11, __u32)
+#define VFAT_IOCTL_GET_VOLUME_ID        _IOR('r', 0x12, __u32)
 
 struct fat_boot_sector {
         __u8    ignored[3];     /* Boot strap short or near jump */
@@ -138,6 +139,17 @@ struct fat_boot_fsinfo {
         __le32   reserved2[4];
 };
 
+struct fat_boot_bsx {
+        __u8     drive;             /* drive number */
+        __u8     reserved1;
+        __u8     signature;         /* extended boot signature */
+        __u8     vol_id[4];     /* volume ID */
+        __u8     vol_label[11]; /* volume label */
+        __u8     type[8];       /* file system type */
+};
+#define FAT16_BSX_OFFSET        36 /* offset of fat_boot_bsx in FAT12 and FAT16 */
+#define FAT32_BSX_OFFSET        64 /* offset of fat_boot_bsx in FAT32 */
+
 struct msdos_dir_entry {
         __u8    name[MSDOS_NAME];/* name and extension */
         __u8    attr;           /* attribute bits */
diff --git a/include/linux/mtd/ubi.h b/include/linux/mtd/ubi.h
index 15da0e99f48..db4836bed51 100644
--- a/include/linux/mtd/ubi.h
+++ b/include/linux/mtd/ubi.h
@@ -155,12 +155,14 @@ struct ubi_device_info {
 };
 
 /*
- * enum - volume notification types.
- * @UBI_VOLUME_ADDED: volume has been added
- * @UBI_VOLUME_REMOVED: start volume volume
- * @UBI_VOLUME_RESIZED: volume size has been re-sized
- * @UBI_VOLUME_RENAMED: volume name has been re-named
- * @UBI_VOLUME_UPDATED: volume name has been updated
+ * Volume notification types.
+ * @UBI_VOLUME_ADDED: a volume has been added (an UBI device was attached or a
+ *                    volume was created)
+ * @UBI_VOLUME_REMOVED: a volume has been removed (an UBI device was detached
+ *                      or a volume was removed)
+ * @UBI_VOLUME_RESIZED: a volume has been re-sized
+ * @UBI_VOLUME_RENAMED: a volume has been re-named
+ * @UBI_VOLUME_UPDATED: data has been written to a volume
  *
  * These constants define which type of event has happened when a volume
  * notification function is invoked.
diff --git a/include/linux/mutex.h b/include/linux/mutex.h
index a940fe435ac..9121595a8eb 100644
--- a/include/linux/mutex.h
+++ b/include/linux/mutex.h
@@ -15,7 +15,7 @@
 #include <linux/linkage.h>
 #include <linux/lockdep.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 /*
  * Simple, straightforward mutexes with strict semantics:
@@ -92,7 +92,7 @@ do {							\
                                                         \
         __mutex_init((mutex), #mutex, &__key);          \
 } while (0)
-# define mutex_destroy(mutex)                           do { } while (0)
+static inline void mutex_destroy(struct mutex *lock) {}
 #endif
 
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
diff --git a/include/linux/namei.h b/include/linux/namei.h
index eba45ea1029..ffc02135c48 100644
--- a/include/linux/namei.h
+++ b/include/linux/namei.h
@@ -48,12 +48,12 @@ enum {LAST_NORM, LAST_ROOT, LAST_DOT, LAST_DOTDOT, LAST_BIND};
  */
 #define LOOKUP_FOLLOW           0x0001
 #define LOOKUP_DIRECTORY        0x0002
-#define LOOKUP_CONTINUE         0x0004
+#define LOOKUP_AUTOMOUNT        0x0004
 
 #define LOOKUP_PARENT           0x0010
 #define LOOKUP_REVAL            0x0020
 #define LOOKUP_RCU              0x0040
-#define LOOKUP_NO_AUTOMOUNT     0x0080
+
 /*
  * Intent data
  */
@@ -67,6 +67,7 @@ enum {LAST_NORM, LAST_ROOT, LAST_DOT, LAST_DOTDOT, LAST_BIND};
 #define LOOKUP_EMPTY            0x4000
 
 extern int user_path_at(int, const char __user *, unsigned, struct path *);
+extern int user_path_at_empty(int, const char __user *, unsigned, struct path *, int *empty);
 
 #define user_path(name, path) user_path_at(AT_FDCWD, name, LOOKUP_FOLLOW, path)
 #define user_lpath(name, path) user_path_at(AT_FDCWD, name, 0, path)
@@ -75,9 +76,11 @@ extern int user_path_at(int, const char __user *, unsigned, struct path *);
 
 extern int kern_path(const char *, unsigned, struct path *);
 
+extern struct dentry *kern_path_create(int, const char *, struct path *, int);
+extern struct dentry *user_path_create(int, const char __user *, struct path *, int);
 extern int kern_path_parent(const char *, struct nameidata *);
 extern int vfs_path_lookup(struct dentry *, struct vfsmount *,
-                           const char *, unsigned int, struct nameidata *);
+                           const char *, unsigned int, struct path *);
 
 extern struct file *lookup_instantiate_filp(struct nameidata *nd, struct dentry *dentry,
                 int (*open)(struct inode *, struct file *));
diff --git a/include/linux/nct1008.h b/include/linux/nct1008.h
new file mode 100644
index 00000000000..0a517f1d6d8
--- /dev/null
+++ b/include/linux/nct1008.h
@@ -0,0 +1,100 @@
+/*
+ * include/linux/nct1008.h
+ *
+ * NCT1008, temperature monitoring device from ON Semiconductors
+ *
+ * Copyright (c) 2010, NVIDIA Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#ifndef _LINUX_NCT1008_H
+#define _LINUX_NCT1008_H
+
+#include <linux/types.h>
+
+#include <mach/edp.h>
+
+#define MAX_ZONES       16
+
+struct nct1008_data;
+
+struct nct1008_platform_data {
+        bool supported_hwrev;
+        bool ext_range;
+        u8 conv_rate;
+        u8 offset;
+        u8 hysteresis;
+        s8 shutdown_ext_limit;
+        s8 shutdown_local_limit;
+        s8 throttling_ext_limit;
+        s8 thermal_zones[MAX_ZONES];
+        u8 thermal_zones_sz;
+        void (*alarm_fn)(bool raised);
+        void (*probe_callback)(struct nct1008_data *);
+};
+
+struct nct1008_data {
+        struct workqueue_struct *workqueue;
+        struct work_struct work;
+        struct i2c_client *client;
+        struct nct1008_platform_data plat_data;
+        struct mutex mutex;
+        struct dentry *dent;
+        u8 config;
+        s8 *limits;
+        u8 limits_sz;
+        void (*alarm_fn)(bool raised);
+        struct regulator *nct_reg;
+        long current_lo_limit;
+        long current_hi_limit;
+        int conv_period_ms;
+
+        void (*alert_func)(void *);
+        void *alert_data;
+};
+
+#ifdef CONFIG_SENSORS_NCT1008
+int nct1008_thermal_get_temp(struct nct1008_data *data, long *temp);
+int nct1008_thermal_get_temp_low(struct nct1008_data *data, long *temp);
+int nct1008_thermal_set_limits(struct nct1008_data *data,
+                                long lo_limit_milli,
+                                long hi_limit_milli);
+int nct1008_thermal_set_alert(struct nct1008_data *data,
+                                void (*alert_func)(void *),
+                                void *alert_data);
+int nct1008_thermal_set_shutdown_temp(struct nct1008_data *data,
+                                        long shutdown_temp);
+#else
+static inline int nct1008_thermal_get_temp(struct nct1008_data *data,
+                                                long *temp)
+{ return -EINVAL; }
+static inline int nct1008_thermal_get_temp_low(struct nct1008_data *data,
+                                                long *temp)
+{ return -EINVAL; }
+static inline int nct1008_thermal_set_limits(struct nct1008_data *data,
+                                long lo_limit_milli,
+                                long hi_limit_milli)
+{ return -EINVAL; }
+static inline int nct1008_thermal_set_alert(struct nct1008_data *data,
+                                void (*alert_func)(void *),
+                                void *alert_data)
+{ return -EINVAL; }
+static inline int nct1008_thermal_set_shutdown_temp(struct nct1008_data *data,
+                                        long shutdown_temp)
+{ return -EINVAL; }
+#endif
+
+#endif /* _LINUX_NCT1008_H */
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index 9e19477991a..ddee79bb8f1 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -34,8 +34,7 @@
 #include <linux/pm_qos_params.h>
 #include <linux/timer.h>
 #include <linux/delay.h>
-#include <linux/mm.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <asm/cache.h>
 #include <asm/byteorder.h>
 
@@ -61,11 +60,6 @@ struct wireless_dev;
 #define SET_ETHTOOL_OPS(netdev,ops) \
         ( (netdev)->ethtool_ops = (ops) )
 
-#define HAVE_ALLOC_NETDEV               /* feature macro: alloc_xxxdev
-                                           functions are available. */
-#define HAVE_FREE_NETDEV                /* free_netdev() */
-#define HAVE_NETDEV_PRIV                /* netdev_priv() */
-
 /* hardware address assignment types */
 #define NET_ADDR_PERM           0       /* address is permanent (default) */
 #define NET_ADDR_RANDOM         1       /* address is generated randomly */
@@ -258,21 +252,8 @@ struct netdev_hw_addr_list {
         netdev_hw_addr_list_for_each(ha, &(dev)->mc)
 
 struct hh_cache {
-        struct hh_cache *hh_next;       /* Next entry                        */
-        atomic_t        hh_refcnt;      /* number of users                   */
-/*
- * We want hh_output, hh_len, hh_lock and hh_data be a in a separate
- * cache line on SMP.
- * They are mostly read, but hh_refcnt may be changed quite frequently,
- * incurring cache line ping pongs.
- */
-        __be16          hh_type ____cacheline_aligned_in_smp;
-                                        /* protocol identifier, f.e ETH_P_IP
-                                         *  NOTE:  For VLANs, this will be the
-                                         *  encapuslated type. --BLG
-                                         */
-        u16             hh_len;         /* length of header */
-        int             (*hh_output)(struct sk_buff *skb);
+        u16             hh_len;
+        u16             __pad;
         seqlock_t       hh_lock;
 
         /* cached hardware header; allow for machine alignment needs.        */
@@ -284,12 +265,6 @@ struct hh_cache {
         unsigned long   hh_data[HH_DATA_ALIGN(LL_MAX_HEADER) / sizeof(long)];
 };
 
-static inline void hh_cache_put(struct hh_cache *hh)
-{
-        if (atomic_dec_and_test(&hh->hh_refcnt))
-                kfree(hh);
-}
-
 /* Reserve HH_DATA_MOD byte aligned hard_header_len, but at least that much.
  * Alternative is:
  *   dev->hard_header_len ? (dev->hard_header_len +
@@ -314,8 +289,7 @@ struct header_ops {
                            const void *saddr, unsigned len);
         int     (*parse)(const struct sk_buff *skb, unsigned char *haddr);
         int     (*rebuild)(struct sk_buff *skb);
-#define HAVE_HEADER_CACHE
-        int     (*cache)(const struct neighbour *neigh, struct hh_cache *hh);
+        int     (*cache)(const struct neighbour *neigh, struct hh_cache *hh, __be16 type);
         void    (*cache_update)(struct hh_cache *hh,
                                 const struct net_device *dev,
                                 const unsigned char *haddr);
@@ -556,7 +530,7 @@ struct netdev_queue {
         struct Qdisc            *qdisc;
         unsigned long           state;
         struct Qdisc            *qdisc_sleeping;
-#ifdef CONFIG_RPS
+#if defined(CONFIG_RPS) || defined(CONFIG_XPS)
         struct kobject          kobj;
 #endif
 #if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
@@ -794,12 +768,6 @@ struct netdev_tc_txq {
  *      3. Update dev->stats asynchronously and atomically, and define
  *         neither operation.
  *
- * void (*ndo_vlan_rx_register)(struct net_device *dev, struct vlan_group *grp);
- *      If device support VLAN receive acceleration
- *      (ie. dev->features & NETIF_F_HW_VLAN_RX), then this function is called
- *      when vlan groups for the device changes.  Note: grp is NULL
- *      if no vlan's groups are being used.
- *
  * void (*ndo_vlan_rx_add_vid)(struct net_device *dev, unsigned short vid);
  *      If device support VLAN filtering (dev->features & NETIF_F_HW_VLAN_FILTER)
  *      this function is called when a VLAN id is registered.
@@ -888,7 +856,6 @@ struct netdev_tc_txq {
  *      Must return >0 or -errno if it changed dev->features itself.
  *
  */
-#define HAVE_NET_DEVICE_OPS
 struct net_device_ops {
         int                     (*ndo_init)(struct net_device *dev);
         void                    (*ndo_uninit)(struct net_device *dev);
@@ -919,8 +886,6 @@ struct net_device_ops {
                                                      struct rtnl_link_stats64 *storage);
         struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
 
-        void                    (*ndo_vlan_rx_register)(struct net_device *dev,
-                                                        struct vlan_group *grp);
         void                    (*ndo_vlan_rx_add_vid)(struct net_device *dev,
                                                        unsigned short vid);
         void                    (*ndo_vlan_rx_kill_vid)(struct net_device *dev,
@@ -1167,7 +1132,7 @@ struct net_device {
         spinlock_t              addr_list_lock;
         struct netdev_hw_addr_list      uc;     /* Unicast mac addresses */
         struct netdev_hw_addr_list      mc;     /* Multicast mac addresses */
-        int                     uc_promisc;
+        bool                    uc_promisc;
         unsigned int            promiscuity;
         unsigned int            allmulti;
 
@@ -1214,7 +1179,7 @@ struct net_device {
 
         unsigned char           broadcast[MAX_ADDR_LEN];        /* hw bcast add */
 
-#ifdef CONFIG_RPS
+#if defined(CONFIG_RPS) || defined(CONFIG_XPS)
         struct kset             *queues_kset;
 
         struct netdev_rx_queue  *_rx;
@@ -1342,9 +1307,6 @@ struct net_device {
         /* max exchange id for FCoE LRO by ddp */
         unsigned int            fcoe_ddp_xid;
 #endif
-        /* n-tuple filter list attached to this device */
-        struct ethtool_rx_ntuple_list ethtool_ntuple_list;
-
         /* phy device may attach itself for hardware timestamping */
         struct phy_device *phydev;
 
@@ -1557,9 +1519,41 @@ struct packet_type {
         struct list_head        list;
 };
 
-#include <linux/interrupt.h>
 #include <linux/notifier.h>
 
+/* netdevice notifier chain. Please remember to update the rtnetlink
+ * notification exclusion list in rtnetlink_event() when adding new
+ * types.
+ */
+#define NETDEV_UP       0x0001  /* For now you can't veto a device up/down */
+#define NETDEV_DOWN     0x0002
+#define NETDEV_REBOOT   0x0003  /* Tell a protocol stack a network interface
+                                   detected a hardware crash and restarted
+                                   - we can use this eg to kick tcp sessions
+                                   once done */
+#define NETDEV_CHANGE   0x0004  /* Notify device state change */
+#define NETDEV_REGISTER 0x0005
+#define NETDEV_UNREGISTER       0x0006
+#define NETDEV_CHANGEMTU        0x0007
+#define NETDEV_CHANGEADDR       0x0008
+#define NETDEV_GOING_DOWN       0x0009
+#define NETDEV_CHANGENAME       0x000A
+#define NETDEV_FEAT_CHANGE      0x000B
+#define NETDEV_BONDING_FAILOVER 0x000C
+#define NETDEV_PRE_UP           0x000D
+#define NETDEV_PRE_TYPE_CHANGE  0x000E
+#define NETDEV_POST_TYPE_CHANGE 0x000F
+#define NETDEV_POST_INIT        0x0010
+#define NETDEV_UNREGISTER_BATCH 0x0011
+#define NETDEV_RELEASE          0x0012
+#define NETDEV_NOTIFY_PEERS     0x0013
+#define NETDEV_JOIN             0x0014
+
+extern int register_netdevice_notifier(struct notifier_block *nb);
+extern int unregister_netdevice_notifier(struct notifier_block *nb);
+extern int call_netdevice_notifiers(unsigned long val, struct net_device *dev);
+
+
 extern rwlock_t                         dev_base_lock;          /* Device list lock */
 
 
@@ -1642,12 +1636,9 @@ static inline void unregister_netdevice(struct net_device *dev)
 extern int              netdev_refcnt_read(const struct net_device *dev);
 extern void             free_netdev(struct net_device *dev);
 extern void             synchronize_net(void);
-extern int              register_netdevice_notifier(struct notifier_block *nb);
-extern int              unregister_netdevice_notifier(struct notifier_block *nb);
 extern int              init_dummy_netdev(struct net_device *dev);
 extern void             netdev_resync_ops(struct net_device *dev);
 
-extern int call_netdevice_notifiers(unsigned long val, struct net_device *dev);
 extern struct net_device        *dev_get_by_index(struct net *net, int ifindex);
 extern struct net_device        *__dev_get_by_index(struct net *net, int ifindex);
 extern struct net_device        *dev_get_by_index_rcu(struct net *net, int ifindex);
@@ -1688,9 +1679,12 @@ static inline int skb_gro_header_hard(struct sk_buff *skb, unsigned int hlen)
 static inline void *skb_gro_header_slow(struct sk_buff *skb, unsigned int hlen,
                                         unsigned int offset)
 {
+        if (!pskb_may_pull(skb, hlen))
+                return NULL;
+
         NAPI_GRO_CB(skb)->frag0 = NULL;
         NAPI_GRO_CB(skb)->frag0_len = 0;
-        return pskb_may_pull(skb, hlen) ? skb->data + offset : NULL;
+        return skb->data + offset;
 }
 
 static inline void *skb_gro_mac_header(struct sk_buff *skb)
@@ -1780,8 +1774,6 @@ static inline void input_queue_tail_incr_save(struct softnet_data *sd,
 
 DECLARE_PER_CPU_ALIGNED(struct softnet_data, softnet_data);
 
-#define HAVE_NETIF_QUEUE
-
 extern void __netif_schedule(struct Qdisc *q);
 
 static inline void netif_schedule_queue(struct netdev_queue *txq)
@@ -2057,10 +2049,8 @@ extern void dev_kfree_skb_irq(struct sk_buff *skb);
  */
 extern void dev_kfree_skb_any(struct sk_buff *skb);
 
-#define HAVE_NETIF_RX 1
 extern int              netif_rx(struct sk_buff *skb);
 extern int              netif_rx_ni(struct sk_buff *skb);
-#define HAVE_NETIF_RECEIVE_SKB 1
 extern int              netif_receive_skb(struct sk_buff *skb);
 extern gro_result_t     dev_gro_receive(struct napi_struct *napi,
                                         struct sk_buff *skb);
@@ -2240,7 +2230,6 @@ extern void netif_device_attach(struct net_device *dev);
 /*
  * Network interface message level settings
  */
-#define HAVE_NETIF_MSG 1
 
 enum {
         NETIF_MSG_DRV           = 0x0001,
@@ -2558,7 +2547,6 @@ static inline u32 netdev_get_wanted_features(struct net_device *dev)
         return (dev->features & ~dev->hw_features) | dev->wanted_features;
 }
 u32 netdev_increment_features(u32 all, u32 one, u32 mask);
-u32 netdev_fix_features(struct net_device *dev, u32 features);
 int __netdev_update_features(struct net_device *dev);
 void netdev_update_features(struct net_device *dev);
 void netdev_change_features(struct net_device *dev);
diff --git a/include/linux/netfilter/ipset/ip_set.h b/include/linux/netfilter/ipset/ip_set.h
index 5a262e3ae71..3540c6e262f 100644
--- a/include/linux/netfilter/ipset/ip_set.h
+++ b/include/linux/netfilter/ipset/ip_set.h
@@ -104,6 +104,8 @@ enum {
         IPSET_ATTR_NAMEREF,
         IPSET_ATTR_IP2,
         IPSET_ATTR_CIDR2,
+        IPSET_ATTR_IP2_TO,
+        IPSET_ATTR_IFACE,
         __IPSET_ATTR_ADT_MAX,
 };
 #define IPSET_ATTR_ADT_MAX      (__IPSET_ATTR_ADT_MAX - 1)
@@ -142,12 +144,18 @@ enum ipset_errno {
 enum ipset_cmd_flags {
         IPSET_FLAG_BIT_EXIST    = 0,
         IPSET_FLAG_EXIST        = (1 << IPSET_FLAG_BIT_EXIST),
+        IPSET_FLAG_BIT_LIST_SETNAME = 1,
+        IPSET_FLAG_LIST_SETNAME = (1 << IPSET_FLAG_BIT_LIST_SETNAME),
+        IPSET_FLAG_BIT_LIST_HEADER = 2,
+        IPSET_FLAG_LIST_HEADER  = (1 << IPSET_FLAG_BIT_LIST_HEADER),
 };
 
 /* Flags at CADT attribute level */
 enum ipset_cadt_flags {
         IPSET_FLAG_BIT_BEFORE   = 0,
         IPSET_FLAG_BEFORE       = (1 << IPSET_FLAG_BIT_BEFORE),
+        IPSET_FLAG_BIT_PHYSDEV  = 1,
+        IPSET_FLAG_PHYSDEV      = (1 << IPSET_FLAG_BIT_PHYSDEV),
 };
 
 /* Commands with settype-specific attributes */
@@ -165,6 +173,7 @@ enum ipset_adt {
 #include <linux/ipv6.h>
 #include <linux/netlink.h>
 #include <linux/netfilter.h>
+#include <linux/netfilter/x_tables.h>
 #include <linux/vmalloc.h>
 #include <net/netlink.h>
 
@@ -206,6 +215,8 @@ enum ip_set_feature {
         IPSET_TYPE_IP2 = (1 << IPSET_TYPE_IP2_FLAG),
         IPSET_TYPE_NAME_FLAG = 4,
         IPSET_TYPE_NAME = (1 << IPSET_TYPE_NAME_FLAG),
+        IPSET_TYPE_IFACE_FLAG = 5,
+        IPSET_TYPE_IFACE = (1 << IPSET_TYPE_IFACE_FLAG),
         /* Strictly speaking not a feature, but a flag for dumping:
          * this settype must be dumped last */
         IPSET_DUMP_LAST_FLAG = 7,
@@ -214,7 +225,17 @@ enum ip_set_feature {
 
 struct ip_set;
 
-typedef int (*ipset_adtfn)(struct ip_set *set, void *value, u32 timeout);
+typedef int (*ipset_adtfn)(struct ip_set *set, void *value,
+                           u32 timeout, u32 flags);
+
+/* Kernel API function options */
+struct ip_set_adt_opt {
+        u8 family;              /* Actual protocol family */
+        u8 dim;                 /* Dimension of match/target */
+        u8 flags;               /* Direction and negation flags */
+        u32 cmdflags;           /* Command-like flags */
+        u32 timeout;            /* Timeout value */
+};
 
 /* Set type, variant-specific part */
 struct ip_set_type_variant {
@@ -223,14 +244,15 @@ struct ip_set_type_variant {
          *                      zero for no match/success to add/delete
          *                      positive for matching element */
         int (*kadt)(struct ip_set *set, const struct sk_buff * skb,
-                    enum ipset_adt adt, u8 pf, u8 dim, u8 flags);
+                    const struct xt_action_param *par,
+                    enum ipset_adt adt, const struct ip_set_adt_opt *opt);
 
         /* Userspace: test/add/del entries
          *              returns negative error code,
          *                      zero for no match/success to add/delete
          *                      positive for matching element */
         int (*uadt)(struct ip_set *set, struct nlattr *tb[],
-                    enum ipset_adt adt, u32 *lineno, u32 flags);
+                    enum ipset_adt adt, u32 *lineno, u32 flags, bool retried);
 
         /* Low level add/del/test functions */
         ipset_adtfn adt[IPSET_ADT_MAX];
@@ -268,8 +290,8 @@ struct ip_set_type {
         u8 dimension;
         /* Supported family: may be AF_UNSPEC for both AF_INET/AF_INET6 */
         u8 family;
-        /* Type revision */
-        u8 revision;
+        /* Type revisions */
+        u8 revision_min, revision_max;
 
         /* Create set */
         int (*create)(struct ip_set *set, struct nlattr *tb[], u32 flags);
@@ -300,6 +322,8 @@ struct ip_set {
         const struct ip_set_type_variant *variant;
         /* The actual INET family of the set */
         u8 family;
+        /* The type revision */
+        u8 revision;
         /* The type specific data */
         void *data;
 };
@@ -307,21 +331,25 @@ struct ip_set {
 /* register and unregister set references */
 extern ip_set_id_t ip_set_get_byname(const char *name, struct ip_set **set);
 extern void ip_set_put_byindex(ip_set_id_t index);
-extern const char * ip_set_name_byindex(ip_set_id_t index);
+extern const char *ip_set_name_byindex(ip_set_id_t index);
 extern ip_set_id_t ip_set_nfnl_get(const char *name);
 extern ip_set_id_t ip_set_nfnl_get_byindex(ip_set_id_t index);
 extern void ip_set_nfnl_put(ip_set_id_t index);
 
 /* API for iptables set match, and SET target */
+
 extern int ip_set_add(ip_set_id_t id, const struct sk_buff *skb,
-                      u8 family, u8 dim, u8 flags);
+                      const struct xt_action_param *par,
+                      const struct ip_set_adt_opt *opt);
 extern int ip_set_del(ip_set_id_t id, const struct sk_buff *skb,
-                      u8 family, u8 dim, u8 flags);
+                      const struct xt_action_param *par,
+                      const struct ip_set_adt_opt *opt);
 extern int ip_set_test(ip_set_id_t id, const struct sk_buff *skb,
-                       u8 family, u8 dim, u8 flags);
+                       const struct xt_action_param *par,
+                       const struct ip_set_adt_opt *opt);
 
 /* Utility functions */
-extern void * ip_set_alloc(size_t size);
+extern void *ip_set_alloc(size_t size);
 extern void ip_set_free(void *members);
 extern int ip_set_get_ipaddr4(struct nlattr *nla,  __be32 *ipaddr);
 extern int ip_set_get_ipaddr6(struct nlattr *nla, union nf_inet_addr *ipaddr);
@@ -331,7 +359,7 @@ ip_set_get_hostipaddr4(struct nlattr *nla, u32 *ipaddr)
 {
         __be32 ip;
         int ret = ip_set_get_ipaddr4(nla, &ip);
-        
+
         if (ret)
                 return ret;
         *ipaddr = ntohl(ip);
diff --git a/include/linux/netfilter/ipset/ip_set_ahash.h b/include/linux/netfilter/ipset/ip_set_ahash.h
index ac3c822eb39..b89fb79cb44 100644
--- a/include/linux/netfilter/ipset/ip_set_ahash.h
+++ b/include/linux/netfilter/ipset/ip_set_ahash.h
@@ -5,6 +5,11 @@
 #include <linux/jhash.h>
 #include <linux/netfilter/ipset/ip_set_timeout.h>
 
+#define CONCAT(a, b, c)         a##b##c
+#define TOKEN(a, b, c)          CONCAT(a, b, c)
+
+#define type_pf_next            TOKEN(TYPE, PF, _elem)
+
 /* Hashing which uses arrays to resolve clashing. The hash table is resized
  * (doubled) when searching becomes too long.
  * Internally jhash is used with the assumption that the size of the
@@ -23,7 +28,32 @@
 /* Number of elements to store in an initial array block */
 #define AHASH_INIT_SIZE                 4
 /* Max number of elements to store in an array block */
-#define AHASH_MAX_SIZE                  (3*4)
+#define AHASH_MAX_SIZE                  (3*AHASH_INIT_SIZE)
+
+/* Max number of elements can be tuned */
+#ifdef IP_SET_HASH_WITH_MULTI
+#define AHASH_MAX(h)                    ((h)->ahash_max)
+
+static inline u8
+tune_ahash_max(u8 curr, u32 multi)
+{
+        u32 n;
+
+        if (multi < curr)
+                return curr;
+
+        n = curr + AHASH_INIT_SIZE;
+        /* Currently, at listing one hash bucket must fit into a message.
+         * Therefore we have a hard limit here.
+         */
+        return n > curr && n <= 64 ? n : curr;
+}
+#define TUNE_AHASH_MAX(h, multi)        \
+        ((h)->ahash_max = tune_ahash_max((h)->ahash_max, multi))
+#else
+#define AHASH_MAX(h)                    AHASH_MAX_SIZE
+#define TUNE_AHASH_MAX(h, multi)
+#endif
 
 /* A hash bucket */
 struct hbucket {
@@ -38,7 +68,7 @@ struct htable {
         struct hbucket bucket[0]; /* hashtable buckets */
 };
 
-#define hbucket(h, i)           &((h)->bucket[i])
+#define hbucket(h, i)           (&((h)->bucket[i]))
 
 /* Book-keeping of the prefixes added to the set */
 struct ip_set_hash_nets {
@@ -54,9 +84,16 @@ struct ip_set_hash {
         u32 initval;            /* random jhash init value */
         u32 timeout;            /* timeout value, if enabled */
         struct timer_list gc;   /* garbage collection when timeout enabled */
+        struct type_pf_next next; /* temporary storage for uadd */
+#ifdef IP_SET_HASH_WITH_MULTI
+        u8 ahash_max;           /* max elements in an array block */
+#endif
 #ifdef IP_SET_HASH_WITH_NETMASK
         u8 netmask;             /* netmask value for subnets to store */
 #endif
+#ifdef IP_SET_HASH_WITH_RBTREE
+        struct rb_root rbtree;
+#endif
 #ifdef IP_SET_HASH_WITH_NETS
         struct ip_set_hash_nets nets[0]; /* book-keeping of prefixes */
 #endif
@@ -194,17 +231,24 @@ ip_set_hash_destroy(struct ip_set *set)
                 del_timer_sync(&h->gc);
 
         ahash_destroy(h->table);
+#ifdef IP_SET_HASH_WITH_RBTREE
+        rbtree_destroy(&h->rbtree);
+#endif
         kfree(h);
 
         set->data = NULL;
 }
 
-#define HKEY(data, initval, htable_bits)                                 \
-(jhash2((u32 *)(data), sizeof(struct type_pf_elem)/sizeof(u32), initval) \
-        & jhash_mask(htable_bits))
-
 #endif /* _IP_SET_AHASH_H */
 
+#ifndef HKEY_DATALEN
+#define HKEY_DATALEN    sizeof(struct type_pf_elem)
+#endif
+
+#define HKEY(data, initval, htable_bits)                        \
+(jhash2((u32 *)(data), HKEY_DATALEN/sizeof(u32), initval)       \
+        & jhash_mask(htable_bits))
+
 #define CONCAT(a, b, c)         a##b##c
 #define TOKEN(a, b, c)          CONCAT(a, b, c)
 
@@ -217,6 +261,7 @@ ip_set_hash_destroy(struct ip_set *set)
 #define type_pf_data_netmask    TOKEN(TYPE, PF, _data_netmask)
 #define type_pf_data_list       TOKEN(TYPE, PF, _data_list)
 #define type_pf_data_tlist      TOKEN(TYPE, PF, _data_tlist)
+#define type_pf_data_next       TOKEN(TYPE, PF, _data_next)
 
 #define type_pf_elem            TOKEN(TYPE, PF, _elem)
 #define type_pf_telem           TOKEN(TYPE, PF, _telem)
@@ -262,12 +307,13 @@ ip_set_hash_destroy(struct ip_set *set)
 /* Add an element to the hash table when resizing the set:
  * we spare the maintenance of the internal counters. */
 static int
-type_pf_elem_add(struct hbucket *n, const struct type_pf_elem *value)
+type_pf_elem_add(struct hbucket *n, const struct type_pf_elem *value,
+                 u8 ahash_max)
 {
         if (n->pos >= n->size) {
                 void *tmp;
 
-                if (n->size >= AHASH_MAX_SIZE)
+                if (n->size >= ahash_max)
                         /* Trigger rehashing */
                         return -EAGAIN;
 
@@ -322,7 +368,7 @@ retry:
                 for (j = 0; j < n->pos; j++) {
                         data = ahash_data(n, j);
                         m = hbucket(t, HKEY(data, h->initval, htable_bits));
-                        ret = type_pf_elem_add(m, data);
+                        ret = type_pf_elem_add(m, data, AHASH_MAX(h));
                         if (ret < 0) {
                                 read_unlock_bh(&set->lock);
                                 ahash_destroy(t);
@@ -346,17 +392,20 @@ retry:
         return 0;
 }
 
+static inline void
+type_pf_data_next(struct ip_set_hash *h, const struct type_pf_elem *d);
+
 /* Add an element to a hash and update the internal counters when succeeded,
  * otherwise report the proper error code. */
 static int
-type_pf_add(struct ip_set *set, void *value, u32 timeout)
+type_pf_add(struct ip_set *set, void *value, u32 timeout, u32 flags)
 {
         struct ip_set_hash *h = set->data;
         struct htable *t;
         const struct type_pf_elem *d = value;
         struct hbucket *n;
         int i, ret = 0;
-        u32 key;
+        u32 key, multi = 0;
 
         if (h->elements >= h->maxelem)
                 return -IPSET_ERR_HASH_FULL;
@@ -366,14 +415,17 @@ type_pf_add(struct ip_set *set, void *value, u32 timeout)
         key = HKEY(value, h->initval, t->htable_bits);
         n = hbucket(t, key);
         for (i = 0; i < n->pos; i++)
-                if (type_pf_data_equal(ahash_data(n, i), d)) {
+                if (type_pf_data_equal(ahash_data(n, i), d, &multi)) {
                         ret = -IPSET_ERR_EXIST;
                         goto out;
                 }
-
-        ret = type_pf_elem_add(n, value);
-        if (ret != 0)
+        TUNE_AHASH_MAX(h, multi);
+        ret = type_pf_elem_add(n, value, AHASH_MAX(h));
+        if (ret != 0) {
+                if (ret == -EAGAIN)
+                        type_pf_data_next(h, d);
                 goto out;
+        }
 
 #ifdef IP_SET_HASH_WITH_NETS
         add_cidr(h, d->cidr, HOST_MASK);
@@ -388,7 +440,7 @@ out:
  * and free up space if possible.
  */
 static int
-type_pf_del(struct ip_set *set, void *value, u32 timeout)
+type_pf_del(struct ip_set *set, void *value, u32 timeout, u32 flags)
 {
         struct ip_set_hash *h = set->data;
         struct htable *t = h->table;
@@ -396,13 +448,13 @@ type_pf_del(struct ip_set *set, void *value, u32 timeout)
         struct hbucket *n;
         int i;
         struct type_pf_elem *data;
-        u32 key;
+        u32 key, multi = 0;
 
         key = HKEY(value, h->initval, t->htable_bits);
         n = hbucket(t, key);
         for (i = 0; i < n->pos; i++) {
                 data = ahash_data(n, i);
-                if (!type_pf_data_equal(data, d))
+                if (!type_pf_data_equal(data, d, &multi))
                         continue;
                 if (i != n->pos - 1)
                         /* Not last one */
@@ -443,17 +495,17 @@ type_pf_test_cidrs(struct ip_set *set, struct type_pf_elem *d, u32 timeout)
         struct hbucket *n;
         const struct type_pf_elem *data;
         int i, j = 0;
-        u32 key;
+        u32 key, multi = 0;
         u8 host_mask = SET_HOST_MASK(set->family);
 
         pr_debug("test by nets\n");
-        for (; j < host_mask && h->nets[j].cidr; j++) {
+        for (; j < host_mask && h->nets[j].cidr && !multi; j++) {
                 type_pf_data_netmask(d, h->nets[j].cidr);
                 key = HKEY(d, h->initval, t->htable_bits);
                 n = hbucket(t, key);
                 for (i = 0; i < n->pos; i++) {
                         data = ahash_data(n, i);
-                        if (type_pf_data_equal(data, d))
+                        if (type_pf_data_equal(data, d, &multi))
                                 return 1;
                 }
         }
@@ -463,7 +515,7 @@ type_pf_test_cidrs(struct ip_set *set, struct type_pf_elem *d, u32 timeout)
 
 /* Test whether the element is added to the set */
 static int
-type_pf_test(struct ip_set *set, void *value, u32 timeout)
+type_pf_test(struct ip_set *set, void *value, u32 timeout, u32 flags)
 {
         struct ip_set_hash *h = set->data;
         struct htable *t = h->table;
@@ -471,7 +523,7 @@ type_pf_test(struct ip_set *set, void *value, u32 timeout)
         struct hbucket *n;
         const struct type_pf_elem *data;
         int i;
-        u32 key;
+        u32 key, multi = 0;
 
 #ifdef IP_SET_HASH_WITH_NETS
         /* If we test an IP address and not a network address,
@@ -484,7 +536,7 @@ type_pf_test(struct ip_set *set, void *value, u32 timeout)
         n = hbucket(t, key);
         for (i = 0; i < n->pos; i++) {
                 data = ahash_data(n, i);
-                if (type_pf_data_equal(data, d))
+                if (type_pf_data_equal(data, d, &multi))
                         return 1;
         }
         return 0;
@@ -586,10 +638,11 @@ nla_put_failure:
 
 static int
 type_pf_kadt(struct ip_set *set, const struct sk_buff * skb,
-             enum ipset_adt adt, u8 pf, u8 dim, u8 flags);
+             const struct xt_action_param *par,
+             enum ipset_adt adt, const struct ip_set_adt_opt *opt);
 static int
 type_pf_uadt(struct ip_set *set, struct nlattr *tb[],
-             enum ipset_adt adt, u32 *lineno, u32 flags);
+             enum ipset_adt adt, u32 *lineno, u32 flags, bool retried);
 
 static const struct ip_set_type_variant type_pf_variant = {
         .kadt   = type_pf_kadt,
@@ -640,14 +693,14 @@ type_pf_data_timeout_set(struct type_pf_elem *data, u32 timeout)
 
 static int
 type_pf_elem_tadd(struct hbucket *n, const struct type_pf_elem *value,
-                  u32 timeout)
+                  u8 ahash_max, u32 timeout)
 {
         struct type_pf_elem *data;
 
         if (n->pos >= n->size) {
                 void *tmp;
 
-                if (n->size >= AHASH_MAX_SIZE)
+                if (n->size >= ahash_max)
                         /* Trigger rehashing */
                         return -EAGAIN;
 
@@ -752,7 +805,7 @@ retry:
                 for (j = 0; j < n->pos; j++) {
                         data = ahash_tdata(n, j);
                         m = hbucket(t, HKEY(data, h->initval, htable_bits));
-                        ret = type_pf_elem_tadd(m, data,
+                        ret = type_pf_elem_tadd(m, data, AHASH_MAX(h),
                                                 type_pf_data_timeout(data));
                         if (ret < 0) {
                                 read_unlock_bh(&set->lock);
@@ -776,15 +829,16 @@ retry:
 }
 
 static int
-type_pf_tadd(struct ip_set *set, void *value, u32 timeout)
+type_pf_tadd(struct ip_set *set, void *value, u32 timeout, u32 flags)
 {
         struct ip_set_hash *h = set->data;
         struct htable *t = h->table;
         const struct type_pf_elem *d = value;
         struct hbucket *n;
         struct type_pf_elem *data;
-        int ret = 0, i, j = AHASH_MAX_SIZE + 1;
-        u32 key;
+        int ret = 0, i, j = AHASH_MAX(h) + 1;
+        bool flag_exist = flags & IPSET_FLAG_EXIST;
+        u32 key, multi = 0;
 
         if (h->elements >= h->maxelem)
                 /* FIXME: when set is full, we slow down here */
@@ -798,18 +852,18 @@ type_pf_tadd(struct ip_set *set, void *value, u32 timeout)
         n = hbucket(t, key);
         for (i = 0; i < n->pos; i++) {
                 data = ahash_tdata(n, i);
-                if (type_pf_data_equal(data, d)) {
-                        if (type_pf_data_expired(data))
+                if (type_pf_data_equal(data, d, &multi)) {
+                        if (type_pf_data_expired(data) || flag_exist)
                                 j = i;
                         else {
                                 ret = -IPSET_ERR_EXIST;
                                 goto out;
                         }
-                } else if (j == AHASH_MAX_SIZE + 1 &&
+                } else if (j == AHASH_MAX(h) + 1 &&
                            type_pf_data_expired(data))
                         j = i;
         }
-        if (j != AHASH_MAX_SIZE + 1) {
+        if (j != AHASH_MAX(h) + 1) {
                 data = ahash_tdata(n, j);
 #ifdef IP_SET_HASH_WITH_NETS
                 del_cidr(h, data->cidr, HOST_MASK);
@@ -819,9 +873,13 @@ type_pf_tadd(struct ip_set *set, void *value, u32 timeout)
                 type_pf_data_timeout_set(data, timeout);
                 goto out;
         }
-        ret = type_pf_elem_tadd(n, d, timeout);
-        if (ret != 0)
+        TUNE_AHASH_MAX(h, multi);
+        ret = type_pf_elem_tadd(n, d, AHASH_MAX(h), timeout);
+        if (ret != 0) {
+                if (ret == -EAGAIN)
+                        type_pf_data_next(h, d);
                 goto out;
+        }
 
 #ifdef IP_SET_HASH_WITH_NETS
         add_cidr(h, d->cidr, HOST_MASK);
@@ -833,7 +891,7 @@ out:
 }
 
 static int
-type_pf_tdel(struct ip_set *set, void *value, u32 timeout)
+type_pf_tdel(struct ip_set *set, void *value, u32 timeout, u32 flags)
 {
         struct ip_set_hash *h = set->data;
         struct htable *t = h->table;
@@ -841,13 +899,13 @@ type_pf_tdel(struct ip_set *set, void *value, u32 timeout)
         struct hbucket *n;
         int i;
         struct type_pf_elem *data;
-        u32 key;
+        u32 key, multi = 0;
 
         key = HKEY(value, h->initval, t->htable_bits);
         n = hbucket(t, key);
         for (i = 0; i < n->pos; i++) {
                 data = ahash_tdata(n, i);
-                if (!type_pf_data_equal(data, d))
+                if (!type_pf_data_equal(data, d, &multi))
                         continue;
                 if (type_pf_data_expired(data))
                         return -IPSET_ERR_EXIST;
@@ -887,16 +945,16 @@ type_pf_ttest_cidrs(struct ip_set *set, struct type_pf_elem *d, u32 timeout)
         struct type_pf_elem *data;
         struct hbucket *n;
         int i, j = 0;
-        u32 key;
+        u32 key, multi = 0;
         u8 host_mask = SET_HOST_MASK(set->family);
 
-        for (; j < host_mask && h->nets[j].cidr; j++) {
+        for (; j < host_mask && h->nets[j].cidr && !multi; j++) {
                 type_pf_data_netmask(d, h->nets[j].cidr);
                 key = HKEY(d, h->initval, t->htable_bits);
                 n = hbucket(t, key);
                 for (i = 0; i < n->pos; i++) {
                         data = ahash_tdata(n, i);
-                        if (type_pf_data_equal(data, d))
+                        if (type_pf_data_equal(data, d, &multi))
                                 return !type_pf_data_expired(data);
                 }
         }
@@ -905,14 +963,14 @@ type_pf_ttest_cidrs(struct ip_set *set, struct type_pf_elem *d, u32 timeout)
 #endif
 
 static int
-type_pf_ttest(struct ip_set *set, void *value, u32 timeout)
+type_pf_ttest(struct ip_set *set, void *value, u32 timeout, u32 flags)
 {
         struct ip_set_hash *h = set->data;
         struct htable *t = h->table;
         struct type_pf_elem *data, *d = value;
         struct hbucket *n;
         int i;
-        u32 key;
+        u32 key, multi = 0;
 
 #ifdef IP_SET_HASH_WITH_NETS
         if (d->cidr == SET_HOST_MASK(set->family))
@@ -922,7 +980,7 @@ type_pf_ttest(struct ip_set *set, void *value, u32 timeout)
         n = hbucket(t, key);
         for (i = 0; i < n->pos; i++) {
                 data = ahash_tdata(n, i);
-                if (type_pf_data_equal(data, d))
+                if (type_pf_data_equal(data, d, &multi))
                         return !type_pf_data_expired(data);
         }
         return 0;
@@ -1030,6 +1088,8 @@ type_pf_gc_init(struct ip_set *set)
                  IPSET_GC_PERIOD(h->timeout));
 }
 
+#undef HKEY_DATALEN
+#undef HKEY
 #undef type_pf_data_equal
 #undef type_pf_data_isnull
 #undef type_pf_data_copy
diff --git a/include/linux/netfilter/ipset/ip_set_hash.h b/include/linux/netfilter/ipset/ip_set_hash.h
index b86f15c0452..e2a9fae767f 100644
--- a/include/linux/netfilter/ipset/ip_set_hash.h
+++ b/include/linux/netfilter/ipset/ip_set_hash.h
@@ -11,6 +11,10 @@ enum {
         IPSET_ERR_INVALID_PROTO,
         /* Protocol missing but must be specified */
         IPSET_ERR_MISSING_PROTO,
+        /* Range not supported */
+        IPSET_ERR_HASH_RANGE_UNSUPPORTED,
+        /* Invalid range */
+        IPSET_ERR_HASH_RANGE,
 };
 
 #ifdef __KERNEL__
diff --git a/include/linux/netfilter/ipset/ip_set_timeout.h b/include/linux/netfilter/ipset/ip_set_timeout.h
index bcdd40ad39e..47923205a4a 100644
--- a/include/linux/netfilter/ipset/ip_set_timeout.h
+++ b/include/linux/netfilter/ipset/ip_set_timeout.h
@@ -22,6 +22,9 @@
 
 #define with_timeout(timeout)   ((timeout) != IPSET_NO_TIMEOUT)
 
+#define opt_timeout(opt, map)   \
+        (with_timeout((opt)->timeout) ? (opt)->timeout : (map)->timeout)
+
 static inline unsigned int
 ip_set_timeout_uget(struct nlattr *tb)
 {
@@ -75,7 +78,7 @@ ip_set_timeout_set(u32 timeout)
 static inline u32
 ip_set_timeout_get(unsigned long timeout)
 {
-        return timeout == IPSET_ELEM_PERMANENT ? 0 : 
+        return timeout == IPSET_ELEM_PERMANENT ? 0 :
                 jiffies_to_msecs(timeout - jiffies)/1000;
 }
 
diff --git a/include/linux/netfilter/ipset/pfxlen.h b/include/linux/netfilter/ipset/pfxlen.h
index 0e1fb50da56..199fd11fedc 100644
--- a/include/linux/netfilter/ipset/pfxlen.h
+++ b/include/linux/netfilter/ipset/pfxlen.h
@@ -2,7 +2,8 @@
 #define _PFXLEN_H
 
 #include <asm/byteorder.h>
-#include <linux/netfilter.h> 
+#include <linux/netfilter.h>
+#include <net/tcp.h>
 
 /* Prefixlen maps, by Jan Engelhardt  */
 extern const union nf_inet_addr ip_set_netmask_map[];
@@ -32,4 +33,12 @@ ip_set_hostmask6(u8 pfxlen)
         return &ip_set_hostmask_map[pfxlen].ip6[0];
 }
 
+extern u32 ip_set_range_to_cidr(u32 from, u32 to, u8 *cidr);
+
+#define ip_set_mask_from_to(from, to, cidr)     \
+do {                                            \
+        from &= ip_set_hostmask(cidr);          \
+        to = from | ~ip_set_hostmask(cidr);     \
+} while (0)
+
 #endif /*_PFXLEN_H */
diff --git a/include/linux/netfilter/nfnetlink.h b/include/linux/netfilter/nfnetlink.h
index 2b11fc1a86b..74d33861473 100644
--- a/include/linux/netfilter/nfnetlink.h
+++ b/include/linux/netfilter/nfnetlink.h
@@ -60,6 +60,9 @@ struct nfnl_callback {
         int (*call)(struct sock *nl, struct sk_buff *skb, 
                     const struct nlmsghdr *nlh,
                     const struct nlattr * const cda[]);
+        int (*call_rcu)(struct sock *nl, struct sk_buff *skb, 
+                    const struct nlmsghdr *nlh,
+                    const struct nlattr * const cda[]);
         const struct nla_policy *policy;        /* netlink attribute policy */
         const u_int16_t attr_count;             /* number of nlattr's */
 };
diff --git a/include/linux/netfilter/nfnetlink_queue.h b/include/linux/netfilter/nfnetlink_queue.h
index af94e0014eb..24b32e6c009 100644
--- a/include/linux/netfilter/nfnetlink_queue.h
+++ b/include/linux/netfilter/nfnetlink_queue.h
@@ -8,6 +8,7 @@ enum nfqnl_msg_types {
         NFQNL_MSG_PACKET,               /* packet from kernel to userspace */
         NFQNL_MSG_VERDICT,              /* verdict from userspace to kernel */
         NFQNL_MSG_CONFIG,               /* connect to a particular queue */
+        NFQNL_MSG_VERDICT_BATCH,        /* batchv from userspace to kernel */
 
         NFQNL_MSG_MAX
 };
diff --git a/include/linux/netfilter/xt_qtaguid.h b/include/linux/netfilter/xt_qtaguid.h
new file mode 100644
index 00000000000..ca60fbdec2f
--- /dev/null
+++ b/include/linux/netfilter/xt_qtaguid.h
@@ -0,0 +1,13 @@
+#ifndef _XT_QTAGUID_MATCH_H
+#define _XT_QTAGUID_MATCH_H
+
+/* For now we just replace the xt_owner.
+ * FIXME: make iptables aware of qtaguid. */
+#include <linux/netfilter/xt_owner.h>
+
+#define XT_QTAGUID_UID    XT_OWNER_UID
+#define XT_QTAGUID_GID    XT_OWNER_GID
+#define XT_QTAGUID_SOCKET XT_OWNER_SOCKET
+#define xt_qtaguid_match_info xt_owner_match_info
+
+#endif /* _XT_QTAGUID_MATCH_H */
diff --git a/include/linux/netfilter/xt_quota2.h b/include/linux/netfilter/xt_quota2.h
new file mode 100644
index 00000000000..eadc6903314
--- /dev/null
+++ b/include/linux/netfilter/xt_quota2.h
@@ -0,0 +1,25 @@
+#ifndef _XT_QUOTA_H
+#define _XT_QUOTA_H
+
+enum xt_quota_flags {
+        XT_QUOTA_INVERT    = 1 << 0,
+        XT_QUOTA_GROW      = 1 << 1,
+        XT_QUOTA_PACKET    = 1 << 2,
+        XT_QUOTA_NO_CHANGE = 1 << 3,
+        XT_QUOTA_MASK      = 0x0F,
+};
+
+struct xt_quota_counter;
+
+struct xt_quota_mtinfo2 {
+        char name[15];
+        u_int8_t flags;
+
+        /* Comparison-invariant */
+        aligned_u64 quota;
+
+        /* Used internally by the kernel */
+        struct xt_quota_counter *master __attribute__((aligned(8)));
+};
+
+#endif /* _XT_QUOTA_H */
diff --git a/include/linux/netfilter/xt_set.h b/include/linux/netfilter/xt_set.h
index 081f1ded284..c0405ac9287 100644
--- a/include/linux/netfilter/xt_set.h
+++ b/include/linux/netfilter/xt_set.h
@@ -35,7 +35,7 @@ struct xt_set_info_target_v0 {
         struct xt_set_info_v0 del_set;
 };
 
-/* Revision 1: current interface to netfilter/iptables */
+/* Revision 1  match and target */
 
 struct xt_set_info {
         ip_set_id_t index;
@@ -44,13 +44,22 @@ struct xt_set_info {
 };
 
 /* match and target infos */
-struct xt_set_info_match {
+struct xt_set_info_match_v1 {
         struct xt_set_info match_set;
 };
 
-struct xt_set_info_target {
+struct xt_set_info_target_v1 {
         struct xt_set_info add_set;
         struct xt_set_info del_set;
 };
 
+/* Revision 2 target */
+
+struct xt_set_info_target_v2 {
+        struct xt_set_info add_set;
+        struct xt_set_info del_set;
+        u32 flags;
+        u32 timeout;
+};
+
 #endif /*_XT_SET_H*/
diff --git a/include/linux/netfilter/xt_socket.h b/include/linux/netfilter/xt_socket.h
index 26d7217bd4f..63594564831 100644
--- a/include/linux/netfilter/xt_socket.h
+++ b/include/linux/netfilter/xt_socket.h
@@ -11,4 +11,10 @@ struct xt_socket_mtinfo1 {
         __u8 flags;
 };
 
+void xt_socket_put_sk(struct sock *sk);
+struct sock *xt_socket_get4_sk(const struct sk_buff *skb,
+                               struct xt_action_param *par);
+struct sock *xt_socket_get6_sk(const struct sk_buff *skb,
+                               struct xt_action_param *par);
+
 #endif /* _XT_SOCKET_H */
diff --git a/include/linux/netlink.h b/include/linux/netlink.h
index a9dd89552f9..180540a84d3 100644
--- a/include/linux/netlink.h
+++ b/include/linux/netlink.h
@@ -29,7 +29,7 @@
 #define MAX_LINKS 32            
 
 struct sockaddr_nl {
-        sa_family_t     nl_family;      /* AF_NETLINK   */
+        __kernel_sa_family_t    nl_family;      /* AF_NETLINK   */
         unsigned short  nl_pad;         /* zero         */
         __u32           nl_pid;         /* port ID      */
         __u32           nl_groups;      /* multicast groups mask */
@@ -49,6 +49,7 @@ struct nlmsghdr {
 #define NLM_F_MULTI             2       /* Multipart message, terminated by NLMSG_DONE */
 #define NLM_F_ACK               4       /* Reply with ack, with zero or error code */
 #define NLM_F_ECHO              8       /* Echo this request            */
+#define NLM_F_DUMP_INTR         16      /* Dump was inconsistent due to sequence change */
 
 /* Modifiers to GET request */
 #define NLM_F_ROOT      0x100   /* specify tree root    */
@@ -221,7 +222,9 @@ struct netlink_callback {
         int                     (*dump)(struct sk_buff * skb,
                                         struct netlink_callback *cb);
         int                     (*done)(struct netlink_callback *cb);
-        int                     family;
+        u16                     family;
+        u16                     min_dump_alloc;
+        unsigned int            prev_seq, seq;
         long                    args[6];
 };
 
@@ -259,7 +262,8 @@ __nlmsg_put(struct sk_buff *skb, u32 pid, u32 seq, int type, int len, int flags)
 extern int netlink_dump_start(struct sock *ssk, struct sk_buff *skb,
                               const struct nlmsghdr *nlh,
                               int (*dump)(struct sk_buff *skb, struct netlink_callback*),
-                              int (*done)(struct netlink_callback*));
+                              int (*done)(struct netlink_callback*),
+                              u16 min_dump_alloc);
 
 
 #define NL_NONROOT_RECV 0x1
diff --git a/include/linux/netpoll.h b/include/linux/netpoll.h
index 79358bb712c..5dfa091c334 100644
--- a/include/linux/netpoll.h
+++ b/include/linux/netpoll.h
@@ -40,8 +40,6 @@ struct netpoll_info {
         struct netpoll *netpoll;
 };
 
-void netpoll_poll_dev(struct net_device *dev);
-void netpoll_poll(struct netpoll *np);
 void netpoll_send_udp(struct netpoll *np, const char *msg, int len);
 void netpoll_print_options(struct netpoll *np);
 int netpoll_parse_options(struct netpoll *np, char *opt);
diff --git a/include/linux/nfc.h b/include/linux/nfc.h
new file mode 100644
index 00000000000..330a4c5db58
--- /dev/null
+++ b/include/linux/nfc.h
@@ -0,0 +1,126 @@
+/*
+ * Copyright (C) 2011 Instituto Nokia de Tecnologia
+ *
+ * Authors:
+ *    Lauro Ramos Venancio <lauro.venancio@openbossa.org>
+ *    Aloisio Almeida Jr <aloisio.almeida@openbossa.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the
+ * Free Software Foundation, Inc.,
+ * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __LINUX_NFC_H
+#define __LINUX_NFC_H
+
+#include <linux/types.h>
+#include <linux/socket.h>
+
+#define NFC_GENL_NAME "nfc"
+#define NFC_GENL_VERSION 1
+
+#define NFC_GENL_MCAST_EVENT_NAME "events"
+
+/**
+ * enum nfc_commands - supported nfc commands
+ *
+ * @NFC_CMD_UNSPEC: unspecified command
+ *
+ * @NFC_CMD_GET_DEVICE: request information about a device (requires
+ *      %NFC_ATTR_DEVICE_INDEX) or dump request to get a list of all nfc devices
+ * @NFC_CMD_START_POLL: start polling for targets using the given protocols
+ *      (requires %NFC_ATTR_DEVICE_INDEX and %NFC_ATTR_PROTOCOLS)
+ * @NFC_CMD_STOP_POLL: stop polling for targets (requires
+ *      %NFC_ATTR_DEVICE_INDEX)
+ * @NFC_CMD_GET_TARGET: dump all targets found by the previous poll (requires
+ *      %NFC_ATTR_DEVICE_INDEX)
+ * @NFC_EVENT_TARGETS_FOUND: event emitted when a new target is found
+ *      (it sends %NFC_ATTR_DEVICE_INDEX)
+ * @NFC_EVENT_DEVICE_ADDED: event emitted when a new device is registred
+ *      (it sends %NFC_ATTR_DEVICE_NAME, %NFC_ATTR_DEVICE_INDEX and
+ *      %NFC_ATTR_PROTOCOLS)
+ * @NFC_EVENT_DEVICE_REMOVED: event emitted when a device is removed
+ *      (it sends %NFC_ATTR_DEVICE_INDEX)
+ */
+enum nfc_commands {
+        NFC_CMD_UNSPEC,
+        NFC_CMD_GET_DEVICE,
+        NFC_CMD_START_POLL,
+        NFC_CMD_STOP_POLL,
+        NFC_CMD_GET_TARGET,
+        NFC_EVENT_TARGETS_FOUND,
+        NFC_EVENT_DEVICE_ADDED,
+        NFC_EVENT_DEVICE_REMOVED,
+/* private: internal use only */
+        __NFC_CMD_AFTER_LAST
+};
+#define NFC_CMD_MAX (__NFC_CMD_AFTER_LAST - 1)
+
+/**
+ * enum nfc_attrs - supported nfc attributes
+ *
+ * @NFC_ATTR_UNSPEC: unspecified attribute
+ *
+ * @NFC_ATTR_DEVICE_INDEX: index of nfc device
+ * @NFC_ATTR_DEVICE_NAME: device name, max 8 chars
+ * @NFC_ATTR_PROTOCOLS: nfc protocols - bitwise or-ed combination from
+ *      NFC_PROTO_*_MASK constants
+ * @NFC_ATTR_TARGET_INDEX: index of the nfc target
+ * @NFC_ATTR_TARGET_SENS_RES: NFC-A targets extra information such as NFCID
+ * @NFC_ATTR_TARGET_SEL_RES: NFC-A targets extra information (useful if the
+ *      target is not NFC-Forum compliant)
+ */
+enum nfc_attrs {
+        NFC_ATTR_UNSPEC,
+        NFC_ATTR_DEVICE_INDEX,
+        NFC_ATTR_DEVICE_NAME,
+        NFC_ATTR_PROTOCOLS,
+        NFC_ATTR_TARGET_INDEX,
+        NFC_ATTR_TARGET_SENS_RES,
+        NFC_ATTR_TARGET_SEL_RES,
+/* private: internal use only */
+        __NFC_ATTR_AFTER_LAST
+};
+#define NFC_ATTR_MAX (__NFC_ATTR_AFTER_LAST - 1)
+
+#define NFC_DEVICE_NAME_MAXSIZE 8
+
+/* NFC protocols */
+#define NFC_PROTO_JEWEL         1
+#define NFC_PROTO_MIFARE        2
+#define NFC_PROTO_FELICA        3
+#define NFC_PROTO_ISO14443      4
+#define NFC_PROTO_NFC_DEP       5
+
+#define NFC_PROTO_MAX           6
+
+/* NFC protocols masks used in bitsets */
+#define NFC_PROTO_JEWEL_MASK    (1 << NFC_PROTO_JEWEL)
+#define NFC_PROTO_MIFARE_MASK   (1 << NFC_PROTO_MIFARE)
+#define NFC_PROTO_FELICA_MASK   (1 << NFC_PROTO_FELICA)
+#define NFC_PROTO_ISO14443_MASK (1 << NFC_PROTO_ISO14443)
+#define NFC_PROTO_NFC_DEP_MASK  (1 << NFC_PROTO_NFC_DEP)
+
+struct sockaddr_nfc {
+        sa_family_t sa_family;
+        __u32 dev_idx;
+        __u32 target_idx;
+        __u32 nfc_protocol;
+};
+
+/* NFC socket protocols */
+#define NFC_SOCKPROTO_RAW       0
+#define NFC_SOCKPROTO_MAX       1
+
+#endif /*__LINUX_NFC_H */
diff --git a/include/linux/nfc/pn544.h b/include/linux/nfc/pn544.h
index 7ab8521f234..9285000dbb4 100644
--- a/include/linux/nfc/pn544.h
+++ b/include/linux/nfc/pn544.h
@@ -1,97 +1,33 @@
 /*
- * Driver include for the PN544 NFC chip.
+ * Copyright (C) 2010 Trusted Logic S.A.
  *
- * Copyright (C) Nokia Corporation
- *
- * Author: Jari Vanhala <ext-jari.vanhala@nokia.com>
- * Contact: Matti Aaltoenn <matti.j.aaltonen@nokia.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 free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * 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
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
-#ifndef _PN544_H_
-#define _PN544_H_
-
-#include <linux/i2c.h>
-
-#define PN544_DRIVER_NAME       "pn544"
-#define PN544_MAXWINDOW_SIZE    7
-#define PN544_WINDOW_SIZE       4
-#define PN544_RETRIES           10
-#define PN544_MAX_I2C_TRANSFER  0x0400
-#define PN544_MSG_MAX_SIZE      0x21 /* at normal HCI mode */
-
-/* ioctl */
-#define PN544_CHAR_BASE         'P'
-#define PN544_IOR(num, dtype)   _IOR(PN544_CHAR_BASE, num, dtype)
-#define PN544_IOW(num, dtype)   _IOW(PN544_CHAR_BASE, num, dtype)
-#define PN544_GET_FW_MODE       PN544_IOW(1, unsigned int)
-#define PN544_SET_FW_MODE       PN544_IOW(2, unsigned int)
-#define PN544_GET_DEBUG         PN544_IOW(3, unsigned int)
-#define PN544_SET_DEBUG         PN544_IOW(4, unsigned int)
-
-/* Timing restrictions (ms) */
-#define PN544_RESETVEN_TIME     30 /* 7 */
-#define PN544_PVDDVEN_TIME      0
-#define PN544_VBATVEN_TIME      0
-#define PN544_GPIO4VEN_TIME     0
-#define PN544_WAKEUP_ACK        5
-#define PN544_WAKEUP_GUARD      (PN544_WAKEUP_ACK + 1)
-#define PN544_INACTIVITY_TIME   1000
-#define PN544_INTERFRAME_DELAY  200 /* us */
-#define PN544_BAUDRATE_CHANGE   150 /* us */
-
-/* Debug bits */
-#define PN544_DEBUG_BUF         0x01
-#define PN544_DEBUG_READ        0x02
-#define PN544_DEBUG_WRITE       0x04
-#define PN544_DEBUG_IRQ         0x08
-#define PN544_DEBUG_CALLS       0x10
-#define PN544_DEBUG_MODE        0x20
-
-/* Normal (HCI) mode */
-#define PN544_LLC_HCI_OVERHEAD  3 /* header + crc (to length) */
-#define PN544_LLC_MIN_SIZE      (1 + PN544_LLC_HCI_OVERHEAD) /* length + */
-#define PN544_LLC_MAX_DATA      (PN544_MSG_MAX_SIZE - 2)
-#define PN544_LLC_MAX_HCI_SIZE  (PN544_LLC_MAX_DATA - 2)
+#define PN544_MAGIC     0xE9
 
-struct pn544_llc_packet {
-        unsigned char length; /* of rest of packet */
-        unsigned char header;
-        unsigned char data[PN544_LLC_MAX_DATA]; /* includes crc-ccitt */
-};
-
-/* Firmware upgrade mode */
-#define PN544_FW_HEADER_SIZE    3
-/* max fw transfer is 1024bytes, but I2C limits it to 0xC0 */
-#define PN544_MAX_FW_DATA       (PN544_MAX_I2C_TRANSFER - PN544_FW_HEADER_SIZE)
-
-struct pn544_fw_packet {
-        unsigned char command; /* status in answer */
-        unsigned char length[2]; /* big-endian order (msf) */
-        unsigned char data[PN544_MAX_FW_DATA];
-};
+/*
+ * PN544 power control via ioctl
+ * PN544_SET_PWR(0): power off
+ * PN544_SET_PWR(1): power on
+ * PN544_SET_PWR(2): reset and power on with firmware download enabled
+ */
+#define PN544_SET_PWR   _IOW(PN544_MAGIC, 0x01, unsigned int)
 
-#ifdef __KERNEL__
-/* board config */
-struct pn544_nfc_platform_data {
-        int (*request_resources) (struct i2c_client *client);
-        void (*free_resources) (void);
-        void (*enable) (int fw);
-        int (*test) (void);
-        void (*disable) (void);
+struct pn544_i2c_platform_data {
+        unsigned int irq_gpio;
+        unsigned int ven_gpio;
+        unsigned int firm_gpio;
 };
-#endif /* __KERNEL__ */
-
-#endif /* _PN544_H_ */
diff --git a/include/linux/nfs.h b/include/linux/nfs.h
index f387919bbc5..8c6ee44914c 100644
--- a/include/linux/nfs.h
+++ b/include/linux/nfs.h
@@ -29,6 +29,8 @@
 #define NFS_MNT_VERSION         1
 #define NFS_MNT3_VERSION        3
 
+#define NFS_PIPE_DIRNAME "/nfs"
+
 /*
  * NFS stats. The good thing with these values is that NFSv3 errors are
  * a superset of NFSv2 errors (with the exception of NFSERR_WFLUSH which
diff --git a/include/linux/nfs4.h b/include/linux/nfs4.h
index 504b289ba68..76f99e8714f 100644
--- a/include/linux/nfs4.h
+++ b/include/linux/nfs4.h
@@ -563,6 +563,10 @@ enum {
         NFSPROC4_CLNT_GETDEVICEINFO,
         NFSPROC4_CLNT_LAYOUTCOMMIT,
         NFSPROC4_CLNT_LAYOUTRETURN,
+        NFSPROC4_CLNT_SECINFO_NO_NAME,
+        NFSPROC4_CLNT_TEST_STATEID,
+        NFSPROC4_CLNT_FREE_STATEID,
+        NFSPROC4_CLNT_GETDEVICELIST,
 };
 
 /* nfs41 types */
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index 1b93b9c60e5..fc0fd15c28d 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -85,7 +85,7 @@ struct nfs_lock_context {
 struct nfs4_state;
 struct nfs_open_context {
         struct nfs_lock_context lock_context;
-        struct path path;
+        struct dentry *dentry;
         struct rpc_cred *cred;
         struct nfs4_state *state;
         fmode_t mode;
@@ -99,9 +99,10 @@ struct nfs_open_context {
 
 struct nfs_open_dir_context {
         struct rpc_cred *cred;
+        unsigned long attr_gencount;
         __u64 dir_cookie;
         __u64 dup_cookie;
-        int duped;
+        signed char duped;
 };
 
 /*
@@ -360,7 +361,7 @@ extern int nfs_refresh_inode(struct inode *, struct nfs_fattr *);
 extern int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr);
 extern int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr);
 extern int nfs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
-extern int nfs_permission(struct inode *, int, unsigned int);
+extern int nfs_permission(struct inode *, int);
 extern int nfs_open(struct inode *, struct file *);
 extern int nfs_release(struct inode *, struct file *);
 extern int nfs_attribute_timeout(struct inode *inode);
@@ -372,7 +373,7 @@ extern void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr);
 extern struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx);
 extern void put_nfs_open_context(struct nfs_open_context *ctx);
 extern struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, fmode_t mode);
-extern struct nfs_open_context *alloc_nfs_open_context(struct path *path, struct rpc_cred *cred, fmode_t f_mode);
+extern struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, struct rpc_cred *cred, fmode_t f_mode);
 extern void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx);
 extern struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx);
 extern void nfs_put_lock_context(struct nfs_lock_context *l_ctx);
@@ -409,6 +410,9 @@ extern const struct inode_operations nfs_file_inode_operations;
 extern const struct inode_operations nfs3_file_inode_operations;
 #endif /* CONFIG_NFS_V3 */
 extern const struct file_operations nfs_file_operations;
+#ifdef CONFIG_NFS_V4
+extern const struct file_operations nfs4_file_operations;
+#endif /* CONFIG_NFS_V4 */
 extern const struct address_space_operations nfs_file_aops;
 extern const struct address_space_operations nfs_dir_aops;
 
@@ -568,12 +572,12 @@ extern struct posix_acl *nfs3_proc_getacl(struct inode *inode, int type);
 extern int nfs3_proc_setacl(struct inode *inode, int type,
                             struct posix_acl *acl);
 extern int nfs3_proc_set_default_acl(struct inode *dir, struct inode *inode,
-                mode_t mode);
+                umode_t mode);
 extern void nfs3_forget_cached_acls(struct inode *inode);
 #else
 static inline int nfs3_proc_set_default_acl(struct inode *dir,
                                             struct inode *inode,
-                                            mode_t mode)
+                                            umode_t mode)
 {
         return 0;
 }
diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h
index 87694ca8691..b5479df8378 100644
--- a/include/linux/nfs_fs_sb.h
+++ b/include/linux/nfs_fs_sb.h
@@ -7,7 +7,7 @@
 #include <linux/nfs_xdr.h>
 #include <linux/sunrpc/xprt.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 struct nfs4_session;
 struct nfs_iostats;
@@ -16,6 +16,7 @@ struct nfs4_sequence_args;
 struct nfs4_sequence_res;
 struct nfs_server;
 struct nfs4_minor_version_ops;
+struct server_scope;
 
 /*
  * The nfs_client identifies our client state to the server.
@@ -77,12 +78,13 @@ struct nfs_client {
         /* The flags used for obtaining the clientid during EXCHANGE_ID */
         u32                     cl_exchange_flags;
         struct nfs4_session     *cl_session;    /* sharred session */
-        struct list_head        cl_layouts;
 #endif /* CONFIG_NFS_V4 */
 
 #ifdef CONFIG_NFS_FSCACHE
         struct fscache_cookie   *fscache;       /* client index cache cookie */
 #endif
+
+        struct server_scope     *server_scope;  /* from exchange_id */
 };
 
 /*
@@ -129,8 +131,9 @@ struct nfs_server {
         struct fscache_cookie   *fscache;       /* superblock cookie */
 #endif
 
+        u32                     pnfs_blksize;   /* layout_blksize attr */
 #ifdef CONFIG_NFS_V4
-        u32                     attr_bitmask[2];/* V4 bitmask representing the set
+        u32                     attr_bitmask[3];/* V4 bitmask representing the set
                                                    of attributes supported on this
                                                    filesystem */
         u32                     cache_consistency_bitmask[2];
@@ -143,12 +146,14 @@ struct nfs_server {
                                                    filesystem */
         struct pnfs_layoutdriver_type  *pnfs_curr_ld; /* Active layout driver */
         struct rpc_wait_queue   roc_rpcwaitq;
+        void                    *pnfs_ld_data;  /* per mount point data */
 
         /* the following fields are protected by nfs_client->cl_lock */
         struct rb_root          state_owners;
         struct rb_root          openowner_id;
         struct rb_root          lockowner_id;
 #endif
+        struct list_head        layouts;
         struct list_head        delegations;
         void (*destroy)(struct nfs_server *);
 
diff --git a/include/linux/nfs_page.h b/include/linux/nfs_page.h
index 25311b3bedf..e2791a27a90 100644
--- a/include/linux/nfs_page.h
+++ b/include/linux/nfs_page.h
@@ -55,20 +55,28 @@ struct nfs_page {
         struct nfs_writeverf    wb_verf;        /* Commit cookie */
 };
 
+struct nfs_pageio_descriptor;
+struct nfs_pageio_ops {
+        void    (*pg_init)(struct nfs_pageio_descriptor *, struct nfs_page *);
+        bool    (*pg_test)(struct nfs_pageio_descriptor *, struct nfs_page *, struct nfs_page *);
+        int     (*pg_doio)(struct nfs_pageio_descriptor *);
+};
+
 struct nfs_pageio_descriptor {
         struct list_head        pg_list;
         unsigned long           pg_bytes_written;
         size_t                  pg_count;
         size_t                  pg_bsize;
         unsigned int            pg_base;
-        char                    pg_moreio;
+        unsigned char           pg_moreio : 1,
+                                pg_recoalesce : 1;
 
         struct inode            *pg_inode;
-        int                     (*pg_doio)(struct nfs_pageio_descriptor *);
+        const struct nfs_pageio_ops *pg_ops;
         int                     pg_ioflags;
         int                     pg_error;
+        const struct rpc_call_ops *pg_rpc_callops;
         struct pnfs_layout_segment *pg_lseg;
-        bool                    (*pg_test)(struct nfs_pageio_descriptor *, struct nfs_page *, struct nfs_page *);
 };
 
 #define NFS_WBACK_BUSY(req)     (test_bit(PG_BUSY,&(req)->wb_flags))
@@ -85,7 +93,7 @@ extern	int nfs_scan_list(struct nfs_inode *nfsi, struct list_head *dst,
                           pgoff_t idx_start, unsigned int npages, int tag);
 extern  void nfs_pageio_init(struct nfs_pageio_descriptor *desc,
                              struct inode *inode,
-                             int (*doio)(struct nfs_pageio_descriptor *desc),
+                             const struct nfs_pageio_ops *pg_ops,
                              size_t bsize,
                              int how);
 extern  int nfs_pageio_add_request(struct nfs_pageio_descriptor *,
@@ -100,7 +108,6 @@ extern	void nfs_unlock_request(struct nfs_page *req);
 extern  int nfs_set_page_tag_locked(struct nfs_page *req);
 extern  void nfs_clear_page_tag_locked(struct nfs_page *req);
 
-
 /*
  * Lock the page of an asynchronous request without getting a new reference
  */
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index 00848d86ffb..5c0e10d7da7 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -122,6 +122,7 @@ struct nfs_fsinfo {
         struct timespec         time_delta; /* server time granularity */
         __u32                   lease_time; /* in seconds */
         __u32                   layouttype; /* supported pnfs layout driver */
+        __u32                   blksize; /* preferred pnfs io block size */
 };
 
 struct nfs_fsstat {
@@ -235,6 +236,17 @@ struct nfs4_layoutget {
         gfp_t gfp_flags;
 };
 
+struct nfs4_getdevicelist_args {
+        const struct nfs_fh *fh;
+        u32 layoutclass;
+        struct nfs4_sequence_args seq_args;
+};
+
+struct nfs4_getdevicelist_res {
+        struct pnfs_devicelist *devlist;
+        struct nfs4_sequence_res seq_res;
+};
+
 struct nfs4_getdeviceinfo_args {
         struct pnfs_device *pdev;
         struct nfs4_sequence_args seq_args;
@@ -257,21 +269,23 @@ struct nfs4_layoutcommit_res {
         struct nfs_fattr *fattr;
         const struct nfs_server *server;
         struct nfs4_sequence_res seq_res;
+        int status;
 };
 
 struct nfs4_layoutcommit_data {
         struct rpc_task task;
         struct nfs_fattr fattr;
-        struct pnfs_layout_segment *lseg;
+        struct list_head lseg_list;
         struct rpc_cred *cred;
         struct nfs4_layoutcommit_args args;
         struct nfs4_layoutcommit_res res;
 };
 
 struct nfs4_layoutreturn_args {
-        __u32   layout_type;
+        struct pnfs_layout_hdr *layout;
         struct inode *inode;
         nfs4_stateid stateid;
+        __u32   layout_type;
         struct nfs4_sequence_args seq_args;
 };
 
@@ -588,11 +602,16 @@ struct nfs_getaclargs {
         size_t                          acl_len;
         unsigned int                    acl_pgbase;
         struct page **                  acl_pages;
+        struct page *                   acl_scratch;
         struct nfs4_sequence_args       seq_args;
 };
 
+/* getxattr ACL interface flags */
+#define NFS4_ACL_LEN_REQUEST    0x0001  /* zero length getxattr buffer */
 struct nfs_getaclres {
         size_t                          acl_len;
+        size_t                          acl_data_offset;
+        int                             acl_flags;
         struct nfs4_sequence_res        seq_res;
 };
 
@@ -759,6 +778,11 @@ struct nfs3_getaclres {
         struct posix_acl *      acl_default;
 };
 
+struct nfs4_string {
+        unsigned int len;
+        char *data;
+};
+
 #ifdef CONFIG_NFS_V4
 
 typedef u64 clientid4;
@@ -942,18 +966,13 @@ struct nfs4_server_caps_arg {
 };
 
 struct nfs4_server_caps_res {
-        u32                             attr_bitmask[2];
+        u32                             attr_bitmask[3];
         u32                             acl_bitmask;
         u32                             has_links;
         u32                             has_symlinks;
         struct nfs4_sequence_res        seq_res;
 };
 
-struct nfs4_string {
-        unsigned int len;
-        char *data;
-};
-
 #define NFS4_PATHNAME_MAXCOMPONENTS 512
 struct nfs4_pathname {
         unsigned int ncomponents;
@@ -1060,6 +1079,7 @@ struct server_scope {
 struct nfs41_exchange_id_res {
         struct nfs_client               *client;
         u32                             flags;
+        struct server_scope             *server_scope;
 };
 
 struct nfs41_create_session_args {
@@ -1083,6 +1103,34 @@ struct nfs41_reclaim_complete_args {
 struct nfs41_reclaim_complete_res {
         struct nfs4_sequence_res        seq_res;
 };
+
+#define SECINFO_STYLE_CURRENT_FH 0
+#define SECINFO_STYLE_PARENT 1
+struct nfs41_secinfo_no_name_args {
+        int                             style;
+        struct nfs4_sequence_args       seq_args;
+};
+
+struct nfs41_test_stateid_args {
+        nfs4_stateid                    *stateid;
+        struct nfs4_sequence_args       seq_args;
+};
+
+struct nfs41_test_stateid_res {
+        unsigned int                    status;
+        struct nfs4_sequence_res        seq_res;
+};
+
+struct nfs41_free_stateid_args {
+        nfs4_stateid                    *stateid;
+        struct nfs4_sequence_args       seq_args;
+};
+
+struct nfs41_free_stateid_res {
+        unsigned int                    status;
+        struct nfs4_sequence_res        seq_res;
+};
+
 #endif /* CONFIG_NFS_V4_1 */
 
 struct nfs_page;
@@ -1096,6 +1144,7 @@ struct nfs_read_data {
         struct rpc_cred         *cred;
         struct nfs_fattr        fattr;  /* fattr storage */
         struct list_head        pages;  /* Coalesced read requests */
+        struct list_head        list;   /* lists of struct nfs_read_data */
         struct nfs_page         *req;   /* multi ops per nfs_page */
         struct page             **pagevec;
         unsigned int            npages; /* Max length of pagevec */
@@ -1119,6 +1168,7 @@ struct nfs_write_data {
         struct nfs_fattr        fattr;
         struct nfs_writeverf    verf;
         struct list_head        pages;          /* Coalesced requests we wish to flush */
+        struct list_head        list;           /* lists of struct nfs_write_data */
         struct nfs_page         *req;           /* multi ops per nfs_page */
         struct page             **pagevec;
         unsigned int            npages;         /* Max length of pagevec */
@@ -1149,6 +1199,7 @@ struct nfs_rpc_ops {
         const struct dentry_operations *dentry_ops;
         const struct inode_operations *dir_inode_ops;
         const struct inode_operations *file_inode_ops;
+        const struct file_operations *file_ops;
 
         int     (*getroot) (struct nfs_server *, struct nfs_fh *,
                             struct nfs_fsinfo *);
diff --git a/include/linux/nfsd/export.h b/include/linux/nfsd/export.h
index 84058ec6939..8a31a20efe7 100644
--- a/include/linux/nfsd/export.h
+++ b/include/linux/nfsd/export.h
@@ -133,8 +133,6 @@ __be32 check_nfsd_access(struct svc_export *exp, struct svc_rqst *rqstp);
 int                     nfsd_export_init(void);
 void                    nfsd_export_shutdown(void);
 void                    nfsd_export_flush(void);
-void                    exp_readlock(void);
-void                    exp_readunlock(void);
 struct svc_export *     rqst_exp_get_by_name(struct svc_rqst *,
                                              struct path *);
 struct svc_export *     rqst_exp_parent(struct svc_rqst *,
diff --git a/include/linux/nl80211.h b/include/linux/nl80211.h
index c7ccaae15af..8ad70dcac3f 100644
--- a/include/linux/nl80211.h
+++ b/include/linux/nl80211.h
@@ -6,7 +6,7 @@
  * Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net>
  * Copyright 2008 Michael Wu <flamingice@sourmilk.net>
  * Copyright 2008 Luis Carlos Cobo <luisca@cozybit.com>
- * Copyright 2008 Michael Buesch <mb@bu3sch.de>
+ * Copyright 2008 Michael Buesch <m@bues.ch>
  * Copyright 2008, 2009 Luis R. Rodriguez <lrodriguez@atheros.com>
  * Copyright 2008 Jouni Malinen <jouni.malinen@atheros.com>
  * Copyright 2008 Colin McCabe <colin@cozybit.com>
@@ -247,7 +247,8 @@
  *      passed, all channels allowed for the current regulatory domain
  *      are used.  Extra IEs can also be passed from the userspace by
  *      using the %NL80211_ATTR_IE attribute.
- * @NL80211_CMD_STOP_SCHED_SCAN: stop a scheduled scan
+ * @NL80211_CMD_STOP_SCHED_SCAN: stop a scheduled scan.  Returns -ENOENT
+ *      if scheduled scan is not running.
  * @NL80211_CMD_SCHED_SCAN_RESULTS: indicates that there are scheduled scan
  *      results available.
  * @NL80211_CMD_SCHED_SCAN_STOPPED: indicates that the scheduled scan has
@@ -483,6 +484,14 @@
  *      more background information, see
  *      http://wireless.kernel.org/en/users/Documentation/WoWLAN.
  *
+ * @NL80211_CMD_SET_REKEY_OFFLOAD: This command is used give the driver
+ *      the necessary information for supporting GTK rekey offload. This
+ *      feature is typically used during WoWLAN. The configuration data
+ *      is contained in %NL80211_ATTR_REKEY_DATA (which is nested and
+ *      contains the data in sub-attributes). After rekeying happened,
+ *      this command may also be sent by the driver as an MLME event to
+ *      inform userspace of the new replay counter.
+ *
  * @NL80211_CMD_MAX: highest used command number
  * @__NL80211_CMD_AFTER_LAST: internal use
  */
@@ -605,6 +614,8 @@ enum nl80211_commands {
         NL80211_CMD_SCHED_SCAN_RESULTS,
         NL80211_CMD_SCHED_SCAN_STOPPED,
 
+        NL80211_CMD_SET_REKEY_OFFLOAD,
+
         /* add new commands above here */
 
         /* used to define NL80211_CMD_MAX below */
@@ -745,8 +756,12 @@ enum nl80211_commands {
  *
  * @NL80211_ATTR_MAX_NUM_SCAN_SSIDS: number of SSIDs you can scan with
  *      a single scan request, a wiphy attribute.
+ * @NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS: number of SSIDs you can
+ *      scan with a single scheduled scan request, a wiphy attribute.
  * @NL80211_ATTR_MAX_SCAN_IE_LEN: maximum length of information elements
  *      that can be added to a scan request
+ * @NL80211_ATTR_MAX_SCHED_SCAN_IE_LEN: maximum length of information
+ *      elements that can be added to a scheduled scan request
  *
  * @NL80211_ATTR_SCAN_FREQUENCIES: nested attribute with frequencies (in MHz)
  * @NL80211_ATTR_SCAN_SSIDS: nested attribute with SSIDs, leave out for passive
@@ -978,8 +993,8 @@ enum nl80211_commands {
  *      driving the peer link management state machine.
  *      @NL80211_MESH_SETUP_USERSPACE_AMPE must be enabled.
  *
- * @NL80211_ATTR_WOWLAN_SUPPORTED: indicates, as part of the wiphy capabilities,
- *      the supported WoWLAN triggers
+ * @NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED: indicates, as part of the wiphy
+ *      capabilities, the supported WoWLAN triggers
  * @NL80211_ATTR_WOWLAN_TRIGGERS: used by %NL80211_CMD_SET_WOWLAN to
  *      indicate which WoW triggers should be enabled. This is also
  *      used by %NL80211_CMD_GET_WOWLAN to get the currently enabled WoWLAN
@@ -996,6 +1011,14 @@ enum nl80211_commands {
  *      are managed in software: interfaces of these types aren't subject to
  *      any restrictions in their number or combinations.
  *
+ * @%NL80211_ATTR_REKEY_DATA: nested attribute containing the information
+ *      necessary for GTK rekeying in the device, see &enum nl80211_rekey_data.
+ *
+ * @NL80211_ATTR_SCAN_SUPP_RATES: rates per to be advertised as supported in scan,
+ *      nested array attribute containing an entry for each band, with the entry
+ *      being a list of supported rates as defined by IEEE 802.11 7.3.2.2 but
+ *      without the length restriction (at most %NL80211_MAX_SUPP_RATES).
+ *
  * @NL80211_ATTR_MAX: highest attribute number currently defined
  * @__NL80211_ATTR_AFTER_LAST: internal use
  */
@@ -1194,6 +1217,13 @@ enum nl80211_attrs {
         NL80211_ATTR_INTERFACE_COMBINATIONS,
         NL80211_ATTR_SOFTWARE_IFTYPES,
 
+        NL80211_ATTR_REKEY_DATA,
+
+        NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS,
+        NL80211_ATTR_MAX_SCHED_SCAN_IE_LEN,
+
+        NL80211_ATTR_SCAN_SUPP_RATES,
+
         /* add attributes here, update the policy in nl80211.c */
 
         __NL80211_ATTR_AFTER_LAST,
@@ -2239,6 +2269,16 @@ struct nl80211_wowlan_pattern_support {
  *
  *      In %NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED, it is a binary attribute
  *      carrying a &struct nl80211_wowlan_pattern_support.
+ * @NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED: Not a real trigger, and cannot be
+ *      used when setting, used only to indicate that GTK rekeying is supported
+ *      by the device (flag)
+ * @NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE: wake up on GTK rekey failure (if
+ *      done by the device) (flag)
+ * @NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST: wake up on EAP Identity Request
+ *      packet (flag)
+ * @NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE: wake up on 4-way handshake (flag)
+ * @NL80211_WOWLAN_TRIG_RFKILL_RELEASE: wake up when rfkill is released
+ *      (on devices that have rfkill in the device) (flag)
  * @NUM_NL80211_WOWLAN_TRIG: number of wake on wireless triggers
  * @MAX_NL80211_WOWLAN_TRIG: highest wowlan trigger attribute number
  */
@@ -2248,6 +2288,11 @@ enum nl80211_wowlan_triggers {
         NL80211_WOWLAN_TRIG_DISCONNECT,
         NL80211_WOWLAN_TRIG_MAGIC_PKT,
         NL80211_WOWLAN_TRIG_PKT_PATTERN,
+        NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED,
+        NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE,
+        NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST,
+        NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE,
+        NL80211_WOWLAN_TRIG_RFKILL_RELEASE,
 
         /* keep last */
         NUM_NL80211_WOWLAN_TRIG,
@@ -2361,4 +2406,28 @@ enum nl80211_plink_state {
         MAX_NL80211_PLINK_STATES = NUM_NL80211_PLINK_STATES - 1
 };
 
+#define NL80211_KCK_LEN                 16
+#define NL80211_KEK_LEN                 16
+#define NL80211_REPLAY_CTR_LEN          8
+
+/**
+ * enum nl80211_rekey_data - attributes for GTK rekey offload
+ * @__NL80211_REKEY_DATA_INVALID: invalid number for nested attributes
+ * @NL80211_REKEY_DATA_KEK: key encryption key (binary)
+ * @NL80211_REKEY_DATA_KCK: key confirmation key (binary)
+ * @NL80211_REKEY_DATA_REPLAY_CTR: replay counter (binary)
+ * @NUM_NL80211_REKEY_DATA: number of rekey attributes (internal)
+ * @MAX_NL80211_REKEY_DATA: highest rekey attribute (internal)
+ */
+enum nl80211_rekey_data {
+        __NL80211_REKEY_DATA_INVALID,
+        NL80211_REKEY_DATA_KEK,
+        NL80211_REKEY_DATA_KCK,
+        NL80211_REKEY_DATA_REPLAY_CTR,
+
+        /* keep last */
+        NUM_NL80211_REKEY_DATA,
+        MAX_NL80211_REKEY_DATA = NUM_NL80211_REKEY_DATA - 1
+};
+
 #endif /* __LINUX_NL80211_H */
diff --git a/include/linux/nodemask.h b/include/linux/nodemask.h
index dba35e41337..7afc36334d5 100644
--- a/include/linux/nodemask.h
+++ b/include/linux/nodemask.h
@@ -66,6 +66,8 @@
  * int num_online_nodes()               Number of online Nodes
  * int num_possible_nodes()             Number of all possible Nodes
  *
+ * int node_random(mask)                Random node with set bit in mask
+ *
  * int node_online(node)                Is some node online?
  * int node_possible(node)              Is some node possible?
  *
@@ -430,6 +432,7 @@ static inline void node_set_offline(int nid)
         node_clear_state(nid, N_ONLINE);
         nr_online_nodes = num_node_state(N_ONLINE);
 }
+
 #else
 
 static inline int node_state(int node, enum node_states state)
@@ -460,6 +463,16 @@ static inline int num_node_state(enum node_states state)
 
 #define node_set_online(node)      node_set_state((node), N_ONLINE)
 #define node_set_offline(node)     node_clear_state((node), N_ONLINE)
+
+#endif
+
+#if defined(CONFIG_NUMA) && (MAX_NUMNODES > 1)
+extern int node_random(const nodemask_t *maskp);
+#else
+static inline int node_random(const nodemask_t *mask)
+{
+        return 0;
+}
 #endif
 
 #define node_online_map         node_states[N_ONLINE]
diff --git a/include/linux/notifier.h b/include/linux/notifier.h
index c0688b0168b..d65746efc95 100644
--- a/include/linux/notifier.h
+++ b/include/linux/notifier.h
@@ -185,80 +185,17 @@ static inline int notifier_to_errno(int ret)
  *      VC switch chains (for loadable kernel svgalib VC switch helpers) etc...
  */
  
-/* netdevice notifier chain. Please remember to update the rtnetlink
- * notification exclusion list in rtnetlink_event() when adding new
- * types.
- */
-#define NETDEV_UP       0x0001  /* For now you can't veto a device up/down */
-#define NETDEV_DOWN     0x0002
-#define NETDEV_REBOOT   0x0003  /* Tell a protocol stack a network interface
-                                   detected a hardware crash and restarted
-                                   - we can use this eg to kick tcp sessions
-                                   once done */
-#define NETDEV_CHANGE   0x0004  /* Notify device state change */
-#define NETDEV_REGISTER 0x0005
-#define NETDEV_UNREGISTER       0x0006
-#define NETDEV_CHANGEMTU        0x0007
-#define NETDEV_CHANGEADDR       0x0008
-#define NETDEV_GOING_DOWN       0x0009
-#define NETDEV_CHANGENAME       0x000A
-#define NETDEV_FEAT_CHANGE      0x000B
-#define NETDEV_BONDING_FAILOVER 0x000C
-#define NETDEV_PRE_UP           0x000D
-#define NETDEV_PRE_TYPE_CHANGE  0x000E
-#define NETDEV_POST_TYPE_CHANGE 0x000F
-#define NETDEV_POST_INIT        0x0010
-#define NETDEV_UNREGISTER_BATCH 0x0011
-#define NETDEV_RELEASE          0x0012
-#define NETDEV_NOTIFY_PEERS     0x0013
-#define NETDEV_JOIN             0x0014
-
-#define SYS_DOWN        0x0001  /* Notify of system down */
-#define SYS_RESTART     SYS_DOWN
-#define SYS_HALT        0x0002  /* Notify of system halt */
-#define SYS_POWER_OFF   0x0003  /* Notify of system power off */
+/* CPU notfiers are defined in include/linux/cpu.h. */
 
-#define NETLINK_URELEASE        0x0001  /* Unicast netlink socket released */
+/* netdevice notifiers are defined in include/linux/netdevice.h */
 
-#define CPU_ONLINE              0x0002 /* CPU (unsigned)v is up */
-#define CPU_UP_PREPARE          0x0003 /* CPU (unsigned)v coming up */
-#define CPU_UP_CANCELED         0x0004 /* CPU (unsigned)v NOT coming up */
-#define CPU_DOWN_PREPARE        0x0005 /* CPU (unsigned)v going down */
-#define CPU_DOWN_FAILED         0x0006 /* CPU (unsigned)v NOT going down */
-#define CPU_DEAD                0x0007 /* CPU (unsigned)v dead */
-#define CPU_DYING               0x0008 /* CPU (unsigned)v not running any task,
-                                        * not handling interrupts, soon dead.
-                                        * Called on the dying cpu, interrupts
-                                        * are already disabled. Must not
-                                        * sleep, must not fail */
-#define CPU_POST_DEAD           0x0009 /* CPU (unsigned)v dead, cpu_hotplug
-                                        * lock is dropped */
-#define CPU_STARTING            0x000A /* CPU (unsigned)v soon running.
-                                        * Called on the new cpu, just before
-                                        * enabling interrupts. Must not sleep,
-                                        * must not fail */
+/* reboot notifiers are defined in include/linux/reboot.h. */
 
-/* Used for CPU hotplug events occurring while tasks are frozen due to a suspend
- * operation in progress
- */
-#define CPU_TASKS_FROZEN        0x0010
+/* Hibernation and suspend events are defined in include/linux/suspend.h. */
 
-#define CPU_ONLINE_FROZEN       (CPU_ONLINE | CPU_TASKS_FROZEN)
-#define CPU_UP_PREPARE_FROZEN   (CPU_UP_PREPARE | CPU_TASKS_FROZEN)
-#define CPU_UP_CANCELED_FROZEN  (CPU_UP_CANCELED | CPU_TASKS_FROZEN)
-#define CPU_DOWN_PREPARE_FROZEN (CPU_DOWN_PREPARE | CPU_TASKS_FROZEN)
-#define CPU_DOWN_FAILED_FROZEN  (CPU_DOWN_FAILED | CPU_TASKS_FROZEN)
-#define CPU_DEAD_FROZEN         (CPU_DEAD | CPU_TASKS_FROZEN)
-#define CPU_DYING_FROZEN        (CPU_DYING | CPU_TASKS_FROZEN)
-#define CPU_STARTING_FROZEN     (CPU_STARTING | CPU_TASKS_FROZEN)
+/* Virtual Terminal events are defined in include/linux/vt.h. */
 
-/* Hibernation and suspend events */
-#define PM_HIBERNATION_PREPARE  0x0001 /* Going to hibernate */
-#define PM_POST_HIBERNATION     0x0002 /* Hibernation finished */
-#define PM_SUSPEND_PREPARE      0x0003 /* Going to suspend the system */
-#define PM_POST_SUSPEND         0x0004 /* Suspend finished */
-#define PM_RESTORE_PREPARE      0x0005 /* Going to restore a saved image */
-#define PM_POST_RESTORE         0x0006 /* Restore failed */
+#define NETLINK_URELEASE        0x0001  /* Unicast netlink socket released */
 
 /* Console keyboard events.
  * Note: KBD_KEYCODE is always sent before KBD_UNBOUND_KEYCODE, KBD_UNICODE and
@@ -271,12 +208,5 @@ static inline int notifier_to_errno(int ret)
 
 extern struct blocking_notifier_head reboot_notifier_list;
 
-/* Virtual Terminal events. */
-#define VT_ALLOCATE             0x0001 /* Console got allocated */
-#define VT_DEALLOCATE           0x0002 /* Console will be deallocated */
-#define VT_WRITE                0x0003 /* A char got output */
-#define VT_UPDATE               0x0004 /* A bigger update occurred */
-#define VT_PREWRITE             0x0005 /* A char is about to be written to the console */
-
 #endif /* __KERNEL__ */
 #endif /* _LINUX_NOTIFIER_H */
diff --git a/include/linux/nsproxy.h b/include/linux/nsproxy.h
index 50d20aba57d..cc37a55ad00 100644
--- a/include/linux/nsproxy.h
+++ b/include/linux/nsproxy.h
@@ -68,6 +68,7 @@ void switch_task_namespaces(struct task_struct *tsk, struct nsproxy *new);
 void free_nsproxy(struct nsproxy *ns);
 int unshare_nsproxy_namespaces(unsigned long, struct nsproxy **,
         struct fs_struct *);
+int __init nsproxy_cache_init(void);
 
 static inline void put_nsproxy(struct nsproxy *ns)
 {
diff --git a/include/linux/nvhost.h b/include/linux/nvhost.h
new file mode 100644
index 00000000000..da5e1e6862c
--- /dev/null
+++ b/include/linux/nvhost.h
@@ -0,0 +1,145 @@
+/*
+ * include/linux/nvhost.h
+ *
+ * Tegra graphics host driver
+ *
+ * Copyright (c) 2009-2012, NVIDIA Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#ifndef __LINUX_NVHOST_H
+#define __LINUX_NVHOST_H
+
+#include <linux/device.h>
+#include <linux/types.h>
+
+struct nvhost_master;
+
+#define NVHOST_MODULE_MAX_CLOCKS 3
+#define NVHOST_MODULE_MAX_POWERGATE_IDS 2
+#define NVHOST_MODULE_NO_POWERGATE_IDS .powergate_ids = {-1, -1}
+#define NVHOST_DEFAULT_CLOCKGATE_DELAY .clockgate_delay = 25
+
+struct nvhost_clock {
+        char *name;
+        long default_rate;
+};
+
+enum nvhost_device_powerstate_t {
+        NVHOST_POWER_STATE_DEINIT,
+        NVHOST_POWER_STATE_RUNNING,
+        NVHOST_POWER_STATE_CLOCKGATED,
+        NVHOST_POWER_STATE_POWERGATED
+};
+
+struct nvhost_device {
+        const char      *name;          /* Device name */
+        struct device   dev;            /* Linux device struct */
+        int             id;             /* Separates clients of same hw */
+        int             index;          /* Hardware channel number */
+        u32             num_resources;  /* Number of resources following */
+        struct resource *resource;      /* Resources (IOMEM in particular) */
+        struct resource *reg_mem;
+        void __iomem    *aperture;      /* Iomem mapped to kernel */
+
+        u32             syncpts;        /* Bitfield of sync points used */
+        u32             waitbases;      /* Bit field of wait bases */
+        u32             modulemutexes;  /* Bit field of module mutexes */
+        u32             moduleid;       /* Module id for user space API */
+
+        u32             class;          /* Device class */
+        bool            exclusive;      /* True if only one user at a time */
+        bool            keepalive;      /* Do not power gate when opened */
+        bool            waitbasesync;   /* Force sync of wait bases */
+
+        int             powergate_ids[NVHOST_MODULE_MAX_POWERGATE_IDS];
+        bool            can_powergate;  /* True if module can be power gated */
+        int             clockgate_delay;/* Delay before clock gated */
+        int             powergate_delay;/* Delay before power gated */
+        struct nvhost_clock clocks[NVHOST_MODULE_MAX_CLOCKS];/* Clock names */
+
+        struct delayed_work powerstate_down;/* Power state management */
+        int             num_clks;       /* Number of clocks opened for dev */
+        struct clk      *clk[NVHOST_MODULE_MAX_CLOCKS];
+        struct mutex    lock;           /* Power management lock */
+        int             powerstate;     /* Current power state */
+        int             refcount;       /* Number of tasks active */
+        wait_queue_head_t idle_wq;      /* Work queue for idle */
+        struct list_head client_list;   /* List of clients and rate requests */
+
+        struct nvhost_channel *channel; /* Channel assigned for the module */
+
+        /* Allocates a context handler for the device */
+        struct nvhost_hwctx_handler *(*alloc_hwctx_handler)(u32 syncpt,
+                        u32 waitbase, struct nvhost_channel *ch);
+        /* Preparing for power off. Used for context save. */
+        int (*prepare_poweroff)(struct nvhost_device *dev);
+        /* Finalize power on. Can be used for context restore. */
+        void (*finalize_poweron)(struct nvhost_device *dev);
+        /* Device is busy. */
+        void (*busy)(struct nvhost_device *);
+        /* Device is idle. */
+        void (*idle)(struct nvhost_device *);
+        /* Device is going to be suspended */
+        void (*suspend)(struct nvhost_device *);
+        /* Device is initialized */
+        void (*init)(struct nvhost_device *dev);
+        /* Device is de-initialized. */
+        void (*deinit)(struct nvhost_device *dev);
+};
+
+/* Register device to nvhost bus */
+extern int nvhost_device_register(struct nvhost_device *);
+
+/* Deregister device from nvhost bus */
+extern void nvhost_device_unregister(struct nvhost_device *);
+
+extern struct bus_type nvhost_bus_type;
+
+struct nvhost_driver {
+        int (*probe)(struct nvhost_device *);
+        int (*remove)(struct nvhost_device *);
+        void (*shutdown)(struct nvhost_device *);
+        int (*suspend)(struct nvhost_device *, pm_message_t state);
+        int (*resume)(struct nvhost_device *);
+        struct device_driver driver;
+};
+
+extern int nvhost_driver_register(struct nvhost_driver *);
+extern void nvhost_driver_unregister(struct nvhost_driver *);
+extern struct resource *nvhost_get_resource(struct nvhost_device *,
+                unsigned int, unsigned int);
+extern int nvhost_get_irq(struct nvhost_device *, unsigned int);
+extern struct resource *nvhost_get_resource_byname(struct nvhost_device *,
+                unsigned int, const char *);
+extern int nvhost_get_irq_byname(struct nvhost_device *, const char *);
+
+#define to_nvhost_device(x) container_of((x), struct nvhost_device, dev)
+#define to_nvhost_driver(drv)   (container_of((drv), struct nvhost_driver, \
+                                 driver))
+
+#define nvhost_get_drvdata(_dev)        dev_get_drvdata(&(_dev)->dev)
+#define nvhost_set_drvdata(_dev, data)  dev_set_drvdata(&(_dev)->dev, (data))
+static inline struct nvhost_master *nvhost_get_host(struct nvhost_device *_dev)
+{
+        return (_dev->dev.parent) ? \
+                ((struct nvhost_master *) dev_get_drvdata(_dev->dev.parent)) : \
+                ((struct nvhost_master *) dev_get_drvdata(&(_dev->dev)));
+}
+
+int nvhost_bus_add_host(struct nvhost_master *host);
+
+#endif
diff --git a/include/linux/nvhost_ioctl.h b/include/linux/nvhost_ioctl.h
new file mode 100644
index 00000000000..3f6eabf522f
--- /dev/null
+++ b/include/linux/nvhost_ioctl.h
@@ -0,0 +1,213 @@
+/*
+ * include/linux/nvhost_ioctl.h
+ *
+ * Tegra graphics host driver
+ *
+ * Copyright (c) 2009-2012, NVIDIA Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#ifndef __LINUX_NVHOST_IOCTL_H
+#define __LINUX_NVHOST_IOCTL_H
+
+#include <linux/ioctl.h>
+#include <linux/types.h>
+
+#if !defined(__KERNEL__)
+#define __user
+#endif
+
+#define NVHOST_INVALID_SYNCPOINT 0xFFFFFFFF
+#define NVHOST_NO_TIMEOUT (-1)
+#define NVHOST_NO_CONTEXT 0x0
+#define NVHOST_IOCTL_MAGIC 'H'
+#define NVHOST_PRIORITY_LOW 50
+#define NVHOST_PRIORITY_MEDIUM 100
+#define NVHOST_PRIORITY_HIGH 150
+
+/* version 0 header (used with write() submit interface) */
+struct nvhost_submit_hdr {
+        __u32 syncpt_id;
+        __u32 syncpt_incrs;
+        __u32 num_cmdbufs;
+        __u32 num_relocs;
+};
+
+#define NVHOST_SUBMIT_VERSION_V0                0x0
+#define NVHOST_SUBMIT_VERSION_V1                0x1
+#define NVHOST_SUBMIT_VERSION_V2                0x2
+#define NVHOST_SUBMIT_VERSION_MAX_SUPPORTED     NVHOST_SUBMIT_VERSION_V2
+
+/* version 1 header (used with ioctl() submit interface) */
+struct nvhost_submit_hdr_ext {
+        __u32 syncpt_id;        /* version 0 fields */
+        __u32 syncpt_incrs;
+        __u32 num_cmdbufs;
+        __u32 num_relocs;
+        __u32 submit_version;   /* version 1 fields */
+        __u32 num_waitchks;
+        __u32 waitchk_mask;
+        __u32 pad[5];           /* future expansion */
+};
+
+struct nvhost_cmdbuf {
+        __u32 mem;
+        __u32 offset;
+        __u32 words;
+};
+
+struct nvhost_reloc {
+        __u32 cmdbuf_mem;
+        __u32 cmdbuf_offset;
+        __u32 target;
+        __u32 target_offset;
+};
+
+struct nvhost_reloc_shift {
+        __u32 shift;
+};
+
+struct nvhost_waitchk {
+        __u32 mem;
+        __u32 offset;
+        __u32 syncpt_id;
+        __u32 thresh;
+};
+
+struct nvhost_get_param_args {
+        __u32 value;
+};
+
+struct nvhost_set_nvmap_fd_args {
+        __u32 fd;
+};
+
+struct nvhost_read_3d_reg_args {
+        __u32 offset;
+        __u32 value;
+};
+
+struct nvhost_clk_rate_args {
+        __u64 rate;
+};
+
+struct nvhost_set_timeout_args {
+        __u32 timeout;
+};
+
+struct nvhost_set_priority_args {
+        __u32 priority;
+};
+
+#define NVHOST_IOCTL_CHANNEL_FLUSH              \
+        _IOR(NVHOST_IOCTL_MAGIC, 1, struct nvhost_get_param_args)
+#define NVHOST_IOCTL_CHANNEL_GET_SYNCPOINTS     \
+        _IOR(NVHOST_IOCTL_MAGIC, 2, struct nvhost_get_param_args)
+#define NVHOST_IOCTL_CHANNEL_GET_WAITBASES      \
+        _IOR(NVHOST_IOCTL_MAGIC, 3, struct nvhost_get_param_args)
+#define NVHOST_IOCTL_CHANNEL_GET_MODMUTEXES     \
+        _IOR(NVHOST_IOCTL_MAGIC, 4, struct nvhost_get_param_args)
+#define NVHOST_IOCTL_CHANNEL_SET_NVMAP_FD       \
+        _IOW(NVHOST_IOCTL_MAGIC, 5, struct nvhost_set_nvmap_fd_args)
+#define NVHOST_IOCTL_CHANNEL_NULL_KICKOFF       \
+        _IOR(NVHOST_IOCTL_MAGIC, 6, struct nvhost_get_param_args)
+#define NVHOST_IOCTL_CHANNEL_SUBMIT_EXT         \
+        _IOW(NVHOST_IOCTL_MAGIC, 7, struct nvhost_submit_hdr_ext)
+#define NVHOST_IOCTL_CHANNEL_READ_3D_REG \
+        _IOWR(NVHOST_IOCTL_MAGIC, 8, struct nvhost_read_3d_reg_args)
+#define NVHOST_IOCTL_CHANNEL_GET_CLK_RATE               \
+        _IOR(NVHOST_IOCTL_MAGIC, 9, struct nvhost_clk_rate_args)
+#define NVHOST_IOCTL_CHANNEL_SET_CLK_RATE               \
+        _IOW(NVHOST_IOCTL_MAGIC, 10, struct nvhost_clk_rate_args)
+#define NVHOST_IOCTL_CHANNEL_SET_TIMEOUT        \
+        _IOW(NVHOST_IOCTL_MAGIC, 11, struct nvhost_set_timeout_args)
+#define NVHOST_IOCTL_CHANNEL_GET_TIMEDOUT       \
+        _IOR(NVHOST_IOCTL_MAGIC, 12, struct nvhost_get_param_args)
+#define NVHOST_IOCTL_CHANNEL_SET_PRIORITY       \
+        _IOW(NVHOST_IOCTL_MAGIC, 13, struct nvhost_set_priority_args)
+#define NVHOST_IOCTL_CHANNEL_LAST               \
+        _IOC_NR(NVHOST_IOCTL_CHANNEL_SET_PRIORITY)
+#define NVHOST_IOCTL_CHANNEL_MAX_ARG_SIZE sizeof(struct nvhost_submit_hdr_ext)
+
+struct nvhost_ctrl_syncpt_read_args {
+        __u32 id;
+        __u32 value;
+};
+
+struct nvhost_ctrl_syncpt_incr_args {
+        __u32 id;
+};
+
+struct nvhost_ctrl_syncpt_wait_args {
+        __u32 id;
+        __u32 thresh;
+        __s32 timeout;
+};
+
+struct nvhost_ctrl_syncpt_waitex_args {
+        __u32 id;
+        __u32 thresh;
+        __s32 timeout;
+        __u32 value;
+};
+
+struct nvhost_ctrl_module_mutex_args {
+        __u32 id;
+        __u32 lock;
+};
+
+enum nvhost_module_id {
+        NVHOST_MODULE_NONE = -1,
+        NVHOST_MODULE_DISPLAY_A = 0,
+        NVHOST_MODULE_DISPLAY_B,
+        NVHOST_MODULE_VI,
+        NVHOST_MODULE_ISP,
+        NVHOST_MODULE_MPE,
+};
+
+struct nvhost_ctrl_module_regrdwr_args {
+        __u32 id;
+        __u32 num_offsets;
+        __u32 block_size;
+        __u32 *offsets;
+        __u32 *values;
+        __u32 write;
+};
+
+#define NVHOST_IOCTL_CTRL_SYNCPT_READ           \
+        _IOWR(NVHOST_IOCTL_MAGIC, 1, struct nvhost_ctrl_syncpt_read_args)
+#define NVHOST_IOCTL_CTRL_SYNCPT_INCR           \
+        _IOW(NVHOST_IOCTL_MAGIC, 2, struct nvhost_ctrl_syncpt_incr_args)
+#define NVHOST_IOCTL_CTRL_SYNCPT_WAIT           \
+        _IOW(NVHOST_IOCTL_MAGIC, 3, struct nvhost_ctrl_syncpt_wait_args)
+
+#define NVHOST_IOCTL_CTRL_MODULE_MUTEX          \
+        _IOWR(NVHOST_IOCTL_MAGIC, 4, struct nvhost_ctrl_module_mutex_args)
+#define NVHOST_IOCTL_CTRL_MODULE_REGRDWR        \
+        _IOWR(NVHOST_IOCTL_MAGIC, 5, struct nvhost_ctrl_module_regrdwr_args)
+
+#define NVHOST_IOCTL_CTRL_SYNCPT_WAITEX         \
+        _IOWR(NVHOST_IOCTL_MAGIC, 6, struct nvhost_ctrl_syncpt_waitex_args)
+
+#define NVHOST_IOCTL_CTRL_GET_VERSION   \
+        _IOR(NVHOST_IOCTL_MAGIC, 7, struct nvhost_get_param_args)
+
+#define NVHOST_IOCTL_CTRL_LAST                  \
+        _IOC_NR(NVHOST_IOCTL_CTRL_GET_VERSION)
+#define NVHOST_IOCTL_CTRL_MAX_ARG_SIZE  \
+        sizeof(struct nvhost_ctrl_module_regrdwr_args)
+
+#endif
diff --git a/include/linux/of.h b/include/linux/of.h
index bfc0ed1b0ce..9180dc5cb00 100644
--- a/include/linux/of.h
+++ b/include/linux/of.h
@@ -195,6 +195,14 @@ extern struct device_node *of_find_node_with_property(
 extern struct property *of_find_property(const struct device_node *np,
                                          const char *name,
                                          int *lenp);
+extern int of_property_read_u32_array(const struct device_node *np,
+                                      const char *propname,
+                                      u32 *out_values,
+                                      size_t sz);
+
+extern int of_property_read_string(struct device_node *np,
+                                   const char *propname,
+                                   const char **out_string);
 extern int of_device_is_compatible(const struct device_node *device,
                                    const char *);
 extern int of_device_is_available(const struct device_node *device);
@@ -227,12 +235,41 @@ extern void of_attach_node(struct device_node *);
 extern void of_detach_node(struct device_node *);
 #endif
 
-#else
+#else /* CONFIG_OF */
 
 static inline bool of_have_populated_dt(void)
 {
         return false;
 }
 
+static inline int of_property_read_u32_array(const struct device_node *np,
+                                             const char *propname,
+                                             u32 *out_values, size_t sz)
+{
+        return -ENOSYS;
+}
+
+static inline int of_property_read_string(struct device_node *np,
+                                          const char *propname,
+                                          const char **out_string)
+{
+        return -ENOSYS;
+}
+
+static inline const void *of_get_property(const struct device_node *node,
+                                const char *name,
+                                int *lenp)
+{
+        return NULL;
+}
+
 #endif /* CONFIG_OF */
+
+static inline int of_property_read_u32(const struct device_node *np,
+                                       const char *propname,
+                                       u32 *out_value)
+{
+        return of_property_read_u32_array(np, propname, out_value, 1);
+}
+
 #endif /* _LINUX_OF_H */
diff --git a/include/linux/of_address.h b/include/linux/of_address.h
index 2feda6ee614..3118623c2c1 100644
--- a/include/linux/of_address.h
+++ b/include/linux/of_address.h
@@ -1,11 +1,16 @@
 #ifndef __OF_ADDRESS_H
 #define __OF_ADDRESS_H
 #include <linux/ioport.h>
+#include <linux/errno.h>
 #include <linux/of.h>
 
 extern u64 of_translate_address(struct device_node *np, const __be32 *addr);
 extern int of_address_to_resource(struct device_node *dev, int index,
                                   struct resource *r);
+extern struct device_node *of_find_matching_node_by_address(
+                                        struct device_node *from,
+                                        const struct of_device_id *matches,
+                                        u64 base_address);
 extern void __iomem *of_iomap(struct device_node *device, int index);
 
 /* Extract an address from a device, returns the region size and
diff --git a/include/linux/of_gpio.h b/include/linux/of_gpio.h
index 6598c04dab0..52280a2b5e6 100644
--- a/include/linux/of_gpio.h
+++ b/include/linux/of_gpio.h
@@ -46,8 +46,9 @@ static inline struct of_mm_gpio_chip *to_of_mm_gpio_chip(struct gpio_chip *gc)
         return container_of(gc, struct of_mm_gpio_chip, gc);
 }
 
-extern int of_get_gpio_flags(struct device_node *np, int index,
-                             enum of_gpio_flags *flags);
+extern int of_get_named_gpio_flags(struct device_node *np,
+                const char *list_name, int index, enum of_gpio_flags *flags);
+
 extern unsigned int of_gpio_count(struct device_node *np);
 
 extern int of_mm_gpiochip_add(struct device_node *np,
@@ -56,12 +57,14 @@ extern int of_mm_gpiochip_add(struct device_node *np,
 extern void of_gpiochip_add(struct gpio_chip *gc);
 extern void of_gpiochip_remove(struct gpio_chip *gc);
 extern struct gpio_chip *of_node_to_gpiochip(struct device_node *np);
+extern int of_gpio_simple_xlate(struct gpio_chip *gc, struct device_node *np,
+                                const void *gpio_spec, u32 *flags);
 
 #else /* CONFIG_OF_GPIO */
 
 /* Drivers may not strictly depend on the GPIO support, so let them link. */
-static inline int of_get_gpio_flags(struct device_node *np, int index,
-                                    enum of_gpio_flags *flags)
+static inline int of_get_named_gpio_flags(struct device_node *np,
+                const char *list_name, int index, enum of_gpio_flags *flags)
 {
         return -ENOSYS;
 }
@@ -71,13 +74,51 @@ static inline unsigned int of_gpio_count(struct device_node *np)
         return 0;
 }
 
+static inline int of_gpio_simple_xlate(struct gpio_chip *gc,
+                                       struct device_node *np,
+                                       const void *gpio_spec, u32 *flags)
+{
+        return -ENOSYS;
+}
+
 static inline void of_gpiochip_add(struct gpio_chip *gc) { }
 static inline void of_gpiochip_remove(struct gpio_chip *gc) { }
 
 #endif /* CONFIG_OF_GPIO */
 
 /**
- * of_get_gpio - Get a GPIO number to use with GPIO API
+ * of_get_gpio_flags() - Get a GPIO number and flags to use with GPIO API
+ * @np:         device node to get GPIO from
+ * @index:      index of the GPIO
+ * @flags:      a flags pointer to fill in
+ *
+ * Returns GPIO number to use with Linux generic GPIO API, or one of the errno
+ * value on the error condition. If @flags is not NULL the function also fills
+ * in flags for the GPIO.
+ */
+static inline int of_get_gpio_flags(struct device_node *np, int index,
+                      enum of_gpio_flags *flags)
+{
+        return of_get_named_gpio_flags(np, "gpios", index, flags);
+}
+
+/**
+ * of_get_named_gpio() - Get a GPIO number to use with GPIO API
+ * @np:         device node to get GPIO from
+ * @propname:   Name of property containing gpio specifier(s)
+ * @index:      index of the GPIO
+ *
+ * Returns GPIO number to use with Linux generic GPIO API, or one of the errno
+ * value on the error condition.
+ */
+static inline int of_get_named_gpio(struct device_node *np,
+                                   const char *propname, int index)
+{
+        return of_get_named_gpio_flags(np, propname, index, NULL);
+}
+
+/**
+ * of_get_gpio() - Get a GPIO number to use with GPIO API
  * @np:         device node to get GPIO from
  * @index:      index of the GPIO
  *
diff --git a/include/linux/of_irq.h b/include/linux/of_irq.h
index e6955f5d1f0..cd2e61ce4e8 100644
--- a/include/linux/of_irq.h
+++ b/include/linux/of_irq.h
@@ -63,6 +63,9 @@ extern int of_irq_map_one(struct device_node *device, int index,
 extern unsigned int irq_create_of_mapping(struct device_node *controller,
                                           const u32 *intspec,
                                           unsigned int intsize);
+#ifdef CONFIG_IRQ_DOMAIN
+extern void irq_dispose_mapping(unsigned int irq);
+#endif
 extern int of_irq_to_resource(struct device_node *dev, int index,
                               struct resource *r);
 extern int of_irq_count(struct device_node *dev);
@@ -70,6 +73,7 @@ extern int of_irq_to_resource_table(struct device_node *dev,
                 struct resource *res, int nr_irqs);
 extern struct device_node *of_irq_find_parent(struct device_node *child);
 
+
 #endif /* CONFIG_OF_IRQ */
 #endif /* CONFIG_OF */
 #endif /* __OF_IRQ_H */
diff --git a/include/linux/of_net.h b/include/linux/of_net.h
index e913081fb52..f4746418871 100644
--- a/include/linux/of_net.h
+++ b/include/linux/of_net.h
@@ -9,6 +9,7 @@
 
 #ifdef CONFIG_OF_NET
 #include <linux/of.h>
+extern const int of_get_phy_mode(struct device_node *np);
 extern const void *of_get_mac_address(struct device_node *np);
 #endif
 
diff --git a/include/linux/of_pci.h b/include/linux/of_pci.h
index 85a27b650d7..f93e21700d3 100644
--- a/include/linux/of_pci.h
+++ b/include/linux/of_pci.h
@@ -6,4 +6,9 @@
 struct pci_dev;
 struct of_irq;
 int of_irq_map_pci(struct pci_dev *pdev, struct of_irq *out_irq);
+
+struct device_node;
+struct device_node *of_pci_find_child_device(struct device_node *parent,
+                                             unsigned int devfn);
+
 #endif
diff --git a/include/linux/of_platform.h b/include/linux/of_platform.h
index fb51ae38cea..5a6f458a4bb 100644
--- a/include/linux/of_platform.h
+++ b/include/linux/of_platform.h
@@ -20,6 +20,40 @@
 #include <linux/platform_device.h>
 
 /**
+ * struct of_dev_auxdata - lookup table entry for device names & platform_data
+ * @compatible: compatible value of node to match against node
+ * @phys_addr: Start address of registers to match against node
+ * @name: Name to assign for matching nodes
+ * @platform_data: platform_data to assign for matching nodes
+ *
+ * This lookup table allows the caller of of_platform_populate() to override
+ * the names of devices when creating devices from the device tree.  The table
+ * should be terminated with an empty entry.  It also allows the platform_data
+ * pointer to be set.
+ *
+ * The reason for this functionality is that some Linux infrastructure uses
+ * the device name to look up a specific device, but the Linux-specific names
+ * are not encoded into the device tree, so the kernel needs to provide specific
+ * values.
+ *
+ * Note: Using an auxdata lookup table should be considered a last resort when
+ * converting a platform to use the DT.  Normally the automatically generated
+ * device name will not matter, and drivers should obtain data from the device
+ * node instead of from an anonymouns platform_data pointer.
+ */
+struct of_dev_auxdata {
+        char *compatible;
+        resource_size_t phys_addr;
+        char *name;
+        void *platform_data;
+};
+
+/* Macro to simplify populating a lookup table */
+#define OF_DEV_AUXDATA(_compat,_phys,_name,_pdata) \
+        { .compatible = _compat, .phys_addr = _phys, .name = _name, \
+          .platform_data = _pdata }
+
+/**
  * of_platform_driver - Legacy of-aware driver for platform devices.
  *
  * An of_platform_driver driver is attached to a basic platform_device on
@@ -40,6 +74,8 @@ struct of_platform_driver
 #define to_of_platform_driver(drv) \
         container_of(drv,struct of_platform_driver, driver)
 
+extern const struct of_device_id of_default_bus_match_table[];
+
 /* Platform drivers register/unregister */
 extern struct platform_device *of_device_alloc(struct device_node *np,
                                          const char *bus_id,
@@ -55,6 +91,10 @@ extern struct platform_device *of_platform_device_create(struct device_node *np,
 extern int of_platform_bus_probe(struct device_node *root,
                                  const struct of_device_id *matches,
                                  struct device *parent);
+extern int of_platform_populate(struct device_node *root,
+                                const struct of_device_id *matches,
+                                const struct of_dev_auxdata *lookup,
+                                struct device *parent);
 #endif /* !CONFIG_SPARC */
 
 #endif /* CONFIG_OF_DEVICE */
diff --git a/include/linux/oom.h b/include/linux/oom.h
index 4952fb874ad..13b7b02e599 100644
--- a/include/linux/oom.h
+++ b/include/linux/oom.h
@@ -64,10 +64,6 @@ static inline void oom_killer_enable(void)
         oom_killer_disabled = false;
 }
 
-/* The badness from the OOM killer */
-extern unsigned long badness(struct task_struct *p, struct mem_cgroup *mem,
-                      const nodemask_t *nodemask, unsigned long uptime);
-
 extern struct task_struct *find_lock_task_mm(struct task_struct *p);
 
 /* sysctls */
diff --git a/include/linux/opp.h b/include/linux/opp.h
index 5449945d589..7020e9736fc 100644
--- a/include/linux/opp.h
+++ b/include/linux/opp.h
@@ -94,12 +94,20 @@ static inline int opp_disable(struct device *dev, unsigned long freq)
 #if defined(CONFIG_CPU_FREQ) && defined(CONFIG_PM_OPP)
 int opp_init_cpufreq_table(struct device *dev,
                             struct cpufreq_frequency_table **table);
+void opp_free_cpufreq_table(struct device *dev,
+                                struct cpufreq_frequency_table **table);
 #else
 static inline int opp_init_cpufreq_table(struct device *dev,
                             struct cpufreq_frequency_table **table)
 {
         return -EINVAL;
 }
+
+static inline
+void opp_free_cpufreq_table(struct device *dev,
+                                struct cpufreq_frequency_table **table)
+{
+}
 #endif          /* CONFIG_CPU_FREQ */
 
 #endif          /* __LINUX_OPP_H__ */
diff --git a/include/linux/oprofile.h b/include/linux/oprofile.h
index 7f5cfd3b37d..49c8727eeb5 100644
--- a/include/linux/oprofile.h
+++ b/include/linux/oprofile.h
@@ -18,7 +18,7 @@
 #include <linux/init.h>
 #include <linux/errno.h>
 #include <linux/printk.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
  
 /* Each escaped entry is prefixed by ESCAPE_CODE
  * then one of the following codes, then the
diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h
index 6081493db68..e90a673be67 100644
--- a/include/linux/page-flags.h
+++ b/include/linux/page-flags.h
@@ -124,9 +124,6 @@ enum pageflags {
 
         /* SLOB */
         PG_slob_free = PG_private,
-
-        /* SLUB */
-        PG_slub_frozen = PG_active,
 };
 
 #ifndef __GENERATING_BOUNDS_H
@@ -135,7 +132,7 @@ enum pageflags {
  * Macros to create function definitions for page flags
  */
 #define TESTPAGEFLAG(uname, lname)                                      \
-static inline int Page##uname(struct page *page)                        \
+static inline int Page##uname(const struct page *page)                  \
                         { return test_bit(PG_##lname, &page->flags); }
 
 #define SETPAGEFLAG(uname, lname)                                       \
@@ -173,7 +170,7 @@ static inline int __TestClearPage##uname(struct page *page)		\
         __SETPAGEFLAG(uname, lname)  __CLEARPAGEFLAG(uname, lname)
 
 #define PAGEFLAG_FALSE(uname)                                           \
-static inline int Page##uname(struct page *page)                        \
+static inline int Page##uname(const struct page *page)                  \
                         { return 0; }
 
 #define TESTSCFLAG(uname, lname)                                        \
@@ -212,8 +209,6 @@ PAGEFLAG(SwapBacked, swapbacked) __CLEARPAGEFLAG(SwapBacked, swapbacked)
 
 __PAGEFLAG(SlobFree, slob_free)
 
-__PAGEFLAG(SlubFrozen, slub_frozen)
-
 /*
  * Private page markings that may be used by the filesystem that owns the page
  * for its own purposes.
diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
index 716875e5352..cfaaa6949b8 100644
--- a/include/linux/pagemap.h
+++ b/include/linux/pagemap.h
@@ -134,7 +134,7 @@ static inline int page_cache_get_speculative(struct page *page)
         VM_BUG_ON(in_interrupt());
 
 #if !defined(CONFIG_SMP) && defined(CONFIG_TREE_RCU)
-# ifdef CONFIG_PREEMPT
+# ifdef CONFIG_PREEMPT_COUNT
         VM_BUG_ON(!in_atomic());
 # endif
         /*
@@ -172,7 +172,7 @@ static inline int page_cache_add_speculative(struct page *page, int count)
         VM_BUG_ON(in_interrupt());
 
 #if !defined(CONFIG_SMP) && defined(CONFIG_TREE_RCU)
-# ifdef CONFIG_PREEMPT
+# ifdef CONFIG_PREEMPT_COUNT
         VM_BUG_ON(!in_atomic());
 # endif
         VM_BUG_ON(page_count(page) == 0);
@@ -255,26 +255,24 @@ static inline struct page *grab_cache_page(struct address_space *mapping,
 extern struct page * grab_cache_page_nowait(struct address_space *mapping,
                                 pgoff_t index);
 extern struct page * read_cache_page_async(struct address_space *mapping,
-                                pgoff_t index, filler_t *filler,
-                                void *data);
+                                pgoff_t index, filler_t *filler, void *data);
 extern struct page * read_cache_page(struct address_space *mapping,
-                                pgoff_t index, filler_t *filler,
-                                void *data);
+                                pgoff_t index, filler_t *filler, void *data);
 extern struct page * read_cache_page_gfp(struct address_space *mapping,
                                 pgoff_t index, gfp_t gfp_mask);
 extern int read_cache_pages(struct address_space *mapping,
                 struct list_head *pages, filler_t *filler, void *data);
 
 static inline struct page *read_mapping_page_async(
-                                                struct address_space *mapping,
-                                                     pgoff_t index, void *data)
+                                struct address_space *mapping,
+                                pgoff_t index, void *data)
 {
         filler_t *filler = (filler_t *)mapping->a_ops->readpage;
         return read_cache_page_async(mapping, index, filler, data);
 }
 
 static inline struct page *read_mapping_page(struct address_space *mapping,
-                                             pgoff_t index, void *data)
+                                pgoff_t index, void *data)
 {
         filler_t *filler = (filler_t *)mapping->a_ops->readpage;
         return read_cache_page(mapping, index, filler, data);
diff --git a/include/linux/pci.h b/include/linux/pci.h
index c446b5ca2d3..9fc01226055 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -49,7 +49,7 @@
 #include <linux/compiler.h>
 #include <linux/errno.h>
 #include <linux/kobject.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <linux/device.h>
 #include <linux/io.h>
 #include <linux/irqreturn.h>
@@ -251,7 +251,8 @@ struct pci_dev {
         u8              revision;       /* PCI revision, low byte of class word */
         u8              hdr_type;       /* PCI header type (`multi' flag masked out) */
         u8              pcie_cap;       /* PCI-E capability offset */
-        u8              pcie_type;      /* PCI-E device/port type */
+        u8              pcie_type:4;    /* PCI-E device/port type */
+        u8              pcie_mpss:3;    /* PCI-E Max Payload Size Supported */
         u8              rom_base_reg;   /* which config register controls the ROM */
         u8              pin;            /* which interrupt pin this device uses */
 
@@ -617,6 +618,17 @@ struct pci_driver {
 /* these external functions are only available when PCI support is enabled */
 #ifdef CONFIG_PCI
 
+extern void pcie_bus_configure_settings(struct pci_bus *bus, u8 smpss);
+
+enum pcie_bus_config_types {
+        PCIE_BUS_TUNE_OFF,
+        PCIE_BUS_SAFE,
+        PCIE_BUS_PERFORMANCE,
+        PCIE_BUS_PEER2PEER,
+};
+
+extern enum pcie_bus_config_types pcie_bus_config;
+
 extern struct bus_type pci_bus_type;
 
 /* Do NOT directly access these two variables, unless you are arch specific pci
@@ -796,10 +808,13 @@ int pcix_get_mmrbc(struct pci_dev *dev);
 int pcix_set_mmrbc(struct pci_dev *dev, int mmrbc);
 int pcie_get_readrq(struct pci_dev *dev);
 int pcie_set_readrq(struct pci_dev *dev, int rq);
+int pcie_get_mps(struct pci_dev *dev);
+int pcie_set_mps(struct pci_dev *dev, int mps);
 int __pci_reset_function(struct pci_dev *dev);
 int pci_reset_function(struct pci_dev *dev);
 void pci_update_resource(struct pci_dev *dev, int resno);
 int __must_check pci_assign_resource(struct pci_dev *dev, int i);
+int __must_check pci_reassign_resource(struct pci_dev *dev, int i, resource_size_t add_size, resource_size_t align);
 int pci_select_bars(struct pci_dev *dev, unsigned long flags);
 
 /* ROM control related routines */
@@ -843,8 +858,8 @@ void pci_enable_ido(struct pci_dev *dev, unsigned long type);
 void pci_disable_ido(struct pci_dev *dev, unsigned long type);
 
 enum pci_obff_signal_type {
-        PCI_EXP_OBFF_SIGNAL_L0,
-        PCI_EXP_OBFF_SIGNAL_ALWAYS,
+        PCI_EXP_OBFF_SIGNAL_L0 = 0,
+        PCI_EXP_OBFF_SIGNAL_ALWAYS = 1,
 };
 int pci_enable_obff(struct pci_dev *dev, enum pci_obff_signal_type);
 void pci_disable_obff(struct pci_dev *dev);
@@ -879,7 +894,7 @@ void pdev_enable_device(struct pci_dev *);
 void pdev_sort_resources(struct pci_dev *, struct resource_list *);
 int pci_enable_resources(struct pci_dev *, int mask);
 void pci_fixup_irqs(u8 (*)(struct pci_dev *, u8 *),
-                    int (*)(struct pci_dev *, u8, u8));
+                    int (*)(const struct pci_dev *, u8, u8));
 #define HAVE_PCI_REQ_REGIONS    2
 int __must_check pci_request_regions(struct pci_dev *, const char *);
 int __must_check pci_request_regions_exclusive(struct pci_dev *, const char *);
@@ -1589,5 +1604,44 @@ int pci_vpd_find_tag(const u8 *buf, unsigned int off, unsigned int len, u8 rdt);
 int pci_vpd_find_info_keyword(const u8 *buf, unsigned int off,
                               unsigned int len, const char *kw);
 
+/* PCI <-> OF binding helpers */
+#ifdef CONFIG_OF
+struct device_node;
+extern void pci_set_of_node(struct pci_dev *dev);
+extern void pci_release_of_node(struct pci_dev *dev);
+extern void pci_set_bus_of_node(struct pci_bus *bus);
+extern void pci_release_bus_of_node(struct pci_bus *bus);
+
+/* Arch may override this (weak) */
+extern struct device_node * __weak pcibios_get_phb_of_node(struct pci_bus *bus);
+
+static inline struct device_node *pci_device_to_OF_node(struct pci_dev *pdev)
+{
+        return pdev ? pdev->dev.of_node : NULL;
+}
+
+static inline struct device_node *pci_bus_to_OF_node(struct pci_bus *bus)
+{
+        return bus ? bus->dev.of_node : NULL;
+}
+
+#else /* CONFIG_OF */
+static inline void pci_set_of_node(struct pci_dev *dev) { }
+static inline void pci_release_of_node(struct pci_dev *dev) { }
+static inline void pci_set_bus_of_node(struct pci_bus *bus) { }
+static inline void pci_release_bus_of_node(struct pci_bus *bus) { }
+#endif  /* CONFIG_OF */
+
+/**
+ * pci_find_upstream_pcie_bridge - find upstream PCIe-to-PCI bridge of a device
+ * @pdev: the PCI device
+ *
+ * if the device is PCIE, return NULL
+ * if the device isn't connected to a PCIe bridge (that is its parent is a
+ * legacy PCI bridge and the bridge is directly connected to bus 0), return its
+ * parent
+ */
+struct pci_dev *pci_find_upstream_pcie_bridge(struct pci_dev *pdev);
+
 #endif /* __KERNEL__ */
 #endif /* LINUX_PCI_H */
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index f8910e15556..ae96bbe5451 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -1308,6 +1308,7 @@
 #define PCI_SUBDEVICE_ID_CREATIVE_SB08801       0x0041
 #define PCI_SUBDEVICE_ID_CREATIVE_SB08802       0x0042
 #define PCI_SUBDEVICE_ID_CREATIVE_SB08803       0x0043
+#define PCI_SUBDEVICE_ID_CREATIVE_SB1270        0x0062
 #define PCI_SUBDEVICE_ID_CREATIVE_HENDRIX       0x6000
 
 #define PCI_VENDOR_ID_ECTIVA            0x1102 /* duplicate: CREATIVE */
@@ -2103,6 +2104,9 @@
 #define PCI_DEVICE_ID_TIGON3_5761E      0x1680
 #define PCI_DEVICE_ID_TIGON3_5761       0x1681
 #define PCI_DEVICE_ID_TIGON3_5764       0x1684
+#define PCI_DEVICE_ID_NX2_57800         0x168a
+#define PCI_DEVICE_ID_NX2_57840         0x168d
+#define PCI_DEVICE_ID_NX2_57810         0x168e
 #define PCI_DEVICE_ID_TIGON3_5787M      0x1693
 #define PCI_DEVICE_ID_TIGON3_5782       0x1696
 #define PCI_DEVICE_ID_TIGON3_5784       0x1698
@@ -2110,11 +2114,17 @@
 #define PCI_DEVICE_ID_TIGON3_5787       0x169b
 #define PCI_DEVICE_ID_TIGON3_5788       0x169c
 #define PCI_DEVICE_ID_TIGON3_5789       0x169d
+#define PCI_DEVICE_ID_NX2_57800_MF      0x16a5
 #define PCI_DEVICE_ID_TIGON3_5702X      0x16a6
 #define PCI_DEVICE_ID_TIGON3_5703X      0x16a7
 #define PCI_DEVICE_ID_TIGON3_5704S      0x16a8
+#define PCI_DEVICE_ID_NX2_57800_VF      0x16a9
 #define PCI_DEVICE_ID_NX2_5706S         0x16aa
+#define PCI_DEVICE_ID_NX2_57840_MF      0x16ab
 #define PCI_DEVICE_ID_NX2_5708S         0x16ac
+#define PCI_DEVICE_ID_NX2_57840_VF      0x16ad
+#define PCI_DEVICE_ID_NX2_57810_MF      0x16ae
+#define PCI_DEVICE_ID_NX2_57810_VF      0x16af
 #define PCI_DEVICE_ID_TIGON3_5702A3     0x16c6
 #define PCI_DEVICE_ID_TIGON3_5703A3     0x16c7
 #define PCI_DEVICE_ID_TIGON3_5781       0x16dd
@@ -2699,6 +2709,16 @@
 #define PCI_DEVICE_ID_INTEL_ICH10_5     0x3a60
 #define PCI_DEVICE_ID_INTEL_5_3400_SERIES_LPC_MIN       0x3b00
 #define PCI_DEVICE_ID_INTEL_5_3400_SERIES_LPC_MAX       0x3b1f
+#define PCI_DEVICE_ID_INTEL_IOAT_SNB0   0x3c20
+#define PCI_DEVICE_ID_INTEL_IOAT_SNB1   0x3c21
+#define PCI_DEVICE_ID_INTEL_IOAT_SNB2   0x3c22
+#define PCI_DEVICE_ID_INTEL_IOAT_SNB3   0x3c23
+#define PCI_DEVICE_ID_INTEL_IOAT_SNB4   0x3c24
+#define PCI_DEVICE_ID_INTEL_IOAT_SNB5   0x3c25
+#define PCI_DEVICE_ID_INTEL_IOAT_SNB6   0x3c26
+#define PCI_DEVICE_ID_INTEL_IOAT_SNB7   0x3c27
+#define PCI_DEVICE_ID_INTEL_IOAT_SNB8   0x3c2e
+#define PCI_DEVICE_ID_INTEL_IOAT_SNB9   0x3c2f
 #define PCI_DEVICE_ID_INTEL_IOAT_SNB    0x402f
 #define PCI_DEVICE_ID_INTEL_5100_16     0x65f0
 #define PCI_DEVICE_ID_INTEL_5100_21     0x65f5
@@ -2822,7 +2842,11 @@
 #define PCI_DEVICE_ID_NETMOS_9845       0x9845
 #define PCI_DEVICE_ID_NETMOS_9855       0x9855
 #define PCI_DEVICE_ID_NETMOS_9865       0x9865
+#define PCI_DEVICE_ID_NETMOS_9900       0x9900
 #define PCI_DEVICE_ID_NETMOS_9901       0x9901
+#define PCI_DEVICE_ID_NETMOS_9904       0x9904
+#define PCI_DEVICE_ID_NETMOS_9912       0x9912
+#define PCI_DEVICE_ID_NETMOS_9922       0x9922
 
 #define PCI_VENDOR_ID_3COM_2            0xa727
 
diff --git a/include/linux/pci_regs.h b/include/linux/pci_regs.h
index e8840964aca..dad7d9a4abc 100644
--- a/include/linux/pci_regs.h
+++ b/include/linux/pci_regs.h
@@ -392,7 +392,7 @@
 #define  PCI_EXP_TYPE_DOWNSTREAM 0x6    /* Downstream Port */
 #define  PCI_EXP_TYPE_PCI_BRIDGE 0x7    /* PCI/PCI-X Bridge */
 #define  PCI_EXP_TYPE_RC_END    0x9     /* Root Complex Integrated Endpoint */
-#define  PCI_EXP_TYPE_RC_EC     0x10    /* Root Complex Event Collector */
+#define  PCI_EXP_TYPE_RC_EC     0xa     /* Root Complex Event Collector */
 #define PCI_EXP_FLAGS_SLOT      0x0100  /* Slot implemented */
 #define PCI_EXP_FLAGS_IRQ       0x3e00  /* Interrupt message number */
 #define PCI_EXP_DEVCAP          4       /* Device capabilities */
diff --git a/include/linux/pda_power.h b/include/linux/pda_power.h
index c9e4d814ff7..2bb62bf296a 100644
--- a/include/linux/pda_power.h
+++ b/include/linux/pda_power.h
@@ -35,6 +35,8 @@ struct pda_power_pdata {
         unsigned int polling_interval; /* msecs, default is 2000 */
 
         unsigned long ac_max_uA; /* current to draw when on AC */
+
+        bool use_otg_notifier;
 };
 
 #endif /* __PDA_POWER_H__ */
diff --git a/include/linux/perf_event.h b/include/linux/perf_event.h
index e0786e35f24..c816075c01c 100644
--- a/include/linux/perf_event.h
+++ b/include/linux/perf_event.h
@@ -61,7 +61,7 @@ enum perf_hw_id {
 /*
  * Generalized hardware cache events:
  *
- *       { L1-D, L1-I, LLC, ITLB, DTLB, BPU } x
+ *       { L1-D, L1-I, LLC, ITLB, DTLB, BPU, NODE } x
  *       { read, write, prefetch } x
  *       { accesses, misses }
  */
@@ -72,6 +72,7 @@ enum perf_hw_cache_id {
         PERF_COUNT_HW_CACHE_DTLB                = 3,
         PERF_COUNT_HW_CACHE_ITLB                = 4,
         PERF_COUNT_HW_CACHE_BPU                 = 5,
+        PERF_COUNT_HW_CACHE_NODE                = 6,
 
         PERF_COUNT_HW_CACHE_MAX,                /* non-ABI */
 };
@@ -508,7 +509,7 @@ struct perf_guest_info_callbacks {
 #include <linux/cpu.h>
 #include <linux/irq_work.h>
 #include <linux/jump_label.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <asm/local.h>
 
 #define PERF_MAX_STACK_DEPTH            255
@@ -536,6 +537,16 @@ struct perf_branch_stack {
 
 struct task_struct;
 
+/*
+ * extra PMU register associated with an event
+ */
+struct hw_perf_event_extra {
+        u64             config; /* register value */
+        unsigned int    reg;    /* register address or index */
+        int             alloc;  /* extra register already allocated */
+        int             idx;    /* index in shared_regs->regs[] */
+};
+
 /**
  * struct hw_perf_event - performance event hardware details:
  */
@@ -549,9 +560,7 @@ struct hw_perf_event {
                         unsigned long   event_base;
                         int             idx;
                         int             last_cpu;
-                        unsigned int    extra_reg;
-                        u64             extra_config;
-                        int             extra_alloc;
+                        struct hw_perf_event_extra extra_reg;
                 };
                 struct { /* software */
                         struct hrtimer  hrtimer;
@@ -680,36 +689,9 @@ enum perf_event_active_state {
 };
 
 struct file;
-
-#define PERF_BUFFER_WRITABLE            0x01
-
-struct perf_buffer {
-        atomic_t                        refcount;
-        struct rcu_head                 rcu_head;
-#ifdef CONFIG_PERF_USE_VMALLOC
-        struct work_struct              work;
-        int                             page_order;     /* allocation order  */
-#endif
-        int                             nr_pages;       /* nr of data pages  */
-        int                             writable;       /* are we writable   */
-
-        atomic_t                        poll;           /* POLL_ for wakeups */
-
-        local_t                         head;           /* write position    */
-        local_t                         nest;           /* nested writers    */
-        local_t                         events;         /* event limit       */
-        local_t                         wakeup;         /* wakeup stamp      */
-        local_t                         lost;           /* nr records lost   */
-
-        long                            watermark;      /* wakeup watermark  */
-
-        struct perf_event_mmap_page     *user_page;
-        void                            *data_pages[0];
-};
-
 struct perf_sample_data;
 
-typedef void (*perf_overflow_handler_t)(struct perf_event *, int,
+typedef void (*perf_overflow_handler_t)(struct perf_event *,
                                         struct perf_sample_data *,
                                         struct pt_regs *regs);
 
@@ -745,6 +727,8 @@ struct perf_cgroup {
 };
 #endif
 
+struct ring_buffer;
+
 /**
  * struct perf_event - performance event kernel representation:
  */
@@ -834,7 +818,7 @@ struct perf_event {
         atomic_t                        mmap_count;
         int                             mmap_locked;
         struct user_struct              *mmap_user;
-        struct perf_buffer              *buffer;
+        struct ring_buffer              *rb;
 
         /* poll related */
         wait_queue_head_t               waitq;
@@ -855,6 +839,7 @@ struct perf_event {
         u64                             id;
 
         perf_overflow_handler_t         overflow_handler;
+        void                            *overflow_handler_context;
 
 #ifdef CONFIG_EVENT_TRACING
         struct ftrace_event_call        *tp_event;
@@ -919,8 +904,8 @@ struct perf_event_context {
         u64                             parent_gen;
         u64                             generation;
         int                             pin_count;
-        struct rcu_head                 rcu_head;
         int                             nr_cgroups; /* cgroup events present */
+        struct rcu_head                 rcu_head;
 };
 
 /*
@@ -945,13 +930,11 @@ struct perf_cpu_context {
 
 struct perf_output_handle {
         struct perf_event               *event;
-        struct perf_buffer              *buffer;
+        struct ring_buffer              *rb;
         unsigned long                   wakeup;
         unsigned long                   size;
         void                            *addr;
         int                             page;
-        int                             nmi;
-        int                             sample;
 };
 
 #ifdef CONFIG_PERF_EVENTS
@@ -961,8 +944,10 @@ extern void perf_pmu_unregister(struct pmu *pmu);
 
 extern int perf_num_counters(void);
 extern const char *perf_pmu_name(void);
-extern void __perf_event_task_sched_in(struct task_struct *task);
-extern void __perf_event_task_sched_out(struct task_struct *task, struct task_struct *next);
+extern void __perf_event_task_sched_in(struct task_struct *prev,
+                                       struct task_struct *task);
+extern void __perf_event_task_sched_out(struct task_struct *prev,
+                                        struct task_struct *next);
 extern int perf_event_init_task(struct task_struct *child);
 extern void perf_event_exit_task(struct task_struct *child);
 extern void perf_event_free_task(struct task_struct *task);
@@ -972,13 +957,15 @@ extern void perf_pmu_disable(struct pmu *pmu);
 extern void perf_pmu_enable(struct pmu *pmu);
 extern int perf_event_task_disable(void);
 extern int perf_event_task_enable(void);
+extern int perf_event_refresh(struct perf_event *event, int refresh);
 extern void perf_event_update_userpage(struct perf_event *event);
 extern int perf_event_release_kernel(struct perf_event *event);
 extern struct perf_event *
 perf_event_create_kernel_counter(struct perf_event_attr *attr,
                                 int cpu,
                                 struct task_struct *task,
-                                perf_overflow_handler_t callback);
+                                perf_overflow_handler_t callback,
+                                void *context);
 extern u64 perf_event_read_value(struct perf_event *event,
                                  u64 *enabled, u64 *running);
 
@@ -1018,7 +1005,7 @@ extern void perf_prepare_sample(struct perf_event_header *header,
                                 struct perf_event *event,
                                 struct pt_regs *regs);
 
-extern int perf_event_overflow(struct perf_event *event, int nmi,
+extern int perf_event_overflow(struct perf_event *event,
                                  struct perf_sample_data *data,
                                  struct pt_regs *regs);
 
@@ -1037,7 +1024,7 @@ static inline int is_software_event(struct perf_event *event)
 
 extern struct jump_label_key perf_swevent_enabled[PERF_COUNT_SW_MAX];
 
-extern void __perf_sw_event(u32, u64, int, struct pt_regs *, u64);
+extern void __perf_sw_event(u32, u64, struct pt_regs *, u64);
 
 #ifndef perf_arch_fetch_caller_regs
 static inline void perf_arch_fetch_caller_regs(struct pt_regs *regs, unsigned long ip) { }
@@ -1059,7 +1046,7 @@ static inline void perf_fetch_caller_regs(struct pt_regs *regs)
 }
 
 static __always_inline void
-perf_sw_event(u32 event_id, u64 nr, int nmi, struct pt_regs *regs, u64 addr)
+perf_sw_event(u32 event_id, u64 nr, struct pt_regs *regs, u64 addr)
 {
         struct pt_regs hot_regs;
 
@@ -1068,23 +1055,26 @@ perf_sw_event(u32 event_id, u64 nr, int nmi, struct pt_regs *regs, u64 addr)
                         perf_fetch_caller_regs(&hot_regs);
                         regs = &hot_regs;
                 }
-                __perf_sw_event(event_id, nr, nmi, regs, addr);
+                __perf_sw_event(event_id, nr, regs, addr);
         }
 }
 
 extern struct jump_label_key perf_sched_events;
 
-static inline void perf_event_task_sched_in(struct task_struct *task)
+static inline void perf_event_task_sched_in(struct task_struct *prev,
+                                            struct task_struct *task)
 {
         if (static_branch(&perf_sched_events))
-                __perf_event_task_sched_in(task);
+                __perf_event_task_sched_in(prev, task);
 }
 
-static inline void perf_event_task_sched_out(struct task_struct *task, struct task_struct *next)
+static inline void perf_event_task_sched_out(struct task_struct *prev,
+                                             struct task_struct *next)
 {
-        perf_sw_event(PERF_COUNT_SW_CONTEXT_SWITCHES, 1, 1, NULL, 0);
+        perf_sw_event(PERF_COUNT_SW_CONTEXT_SWITCHES, 1, NULL, 0);
 
-        __perf_event_task_sched_out(task, next);
+        if (static_branch(&perf_sched_events))
+                __perf_event_task_sched_out(prev, next);
 }
 
 extern void perf_event_mmap(struct vm_area_struct *vma);
@@ -1143,8 +1133,7 @@ extern void perf_bp_event(struct perf_event *event, void *data);
 #endif
 
 extern int perf_output_begin(struct perf_output_handle *handle,
-                             struct perf_event *event, unsigned int size,
-                             int nmi, int sample);
+                             struct perf_event *event, unsigned int size);
 extern void perf_output_end(struct perf_output_handle *handle);
 extern void perf_output_copy(struct perf_output_handle *handle,
                              const void *buf, unsigned int len);
@@ -1155,10 +1144,11 @@ extern void perf_event_disable(struct perf_event *event);
 extern void perf_event_task_tick(void);
 #else
 static inline void
-perf_event_task_sched_in(struct task_struct *task)                      { }
+perf_event_task_sched_in(struct task_struct *prev,
+                         struct task_struct *task)                      { }
 static inline void
-perf_event_task_sched_out(struct task_struct *task,
-                            struct task_struct *next)                   { }
+perf_event_task_sched_out(struct task_struct *prev,
+                          struct task_struct *next)                     { }
 static inline int perf_event_init_task(struct task_struct *child)       { return 0; }
 static inline void perf_event_exit_task(struct task_struct *child)      { }
 static inline void perf_event_free_task(struct task_struct *task)       { }
@@ -1166,10 +1156,13 @@ static inline void perf_event_delayed_put(struct task_struct *task)	{ }
 static inline void perf_event_print_debug(void)                         { }
 static inline int perf_event_task_disable(void)                         { return -EINVAL; }
 static inline int perf_event_task_enable(void)                          { return -EINVAL; }
+static inline int perf_event_refresh(struct perf_event *event, int refresh)
+{
+        return -EINVAL;
+}
 
 static inline void
-perf_sw_event(u32 event_id, u64 nr, int nmi,
-                     struct pt_regs *regs, u64 addr)                    { }
+perf_sw_event(u32 event_id, u64 nr, struct pt_regs *regs, u64 addr)     { }
 static inline void
 perf_bp_event(struct perf_event *event, void *data)                     { }
 
diff --git a/include/linux/personality.h b/include/linux/personality.h
index eec3bae164d..8fc7dd1a57f 100644
--- a/include/linux/personality.h
+++ b/include/linux/personality.h
@@ -22,6 +22,7 @@ extern int		__set_personality(unsigned int);
  * These occupy the top three bytes.
  */
 enum {
+        UNAME26 =               0x0020000,
         ADDR_NO_RANDOMIZE =     0x0040000,      /* disable randomization of VA space */
         FDPIC_FUNCPTRS =        0x0080000,      /* userspace function ptrs point to descriptors
                                                  * (signal handling)
diff --git a/include/linux/phy.h b/include/linux/phy.h
index 7da5fa84595..79f337c4738 100644
--- a/include/linux/phy.h
+++ b/include/linux/phy.h
@@ -26,7 +26,7 @@
 #include <linux/workqueue.h>
 #include <linux/mod_devicetable.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 #define PHY_BASIC_FEATURES      (SUPPORTED_10baseT_Half | \
                                  SUPPORTED_10baseT_Full | \
@@ -53,6 +53,7 @@
 
 /* Interface Mode definitions */
 typedef enum {
+        PHY_INTERFACE_MODE_NA,
         PHY_INTERFACE_MODE_MII,
         PHY_INTERFACE_MODE_GMII,
         PHY_INTERFACE_MODE_SGMII,
@@ -62,7 +63,8 @@ typedef enum {
         PHY_INTERFACE_MODE_RGMII_ID,
         PHY_INTERFACE_MODE_RGMII_RXID,
         PHY_INTERFACE_MODE_RGMII_TXID,
-        PHY_INTERFACE_MODE_RTBI
+        PHY_INTERFACE_MODE_RTBI,
+        PHY_INTERFACE_MODE_SMII,
 } phy_interface_t;
 
 
@@ -418,7 +420,7 @@ struct phy_driver {
 
         /*
          * Requests a Tx timestamp for 'skb'. The phy driver promises
-         * to deliver it to the socket's error queue as soon as a
+         * to deliver it using skb_complete_tx_timestamp() as soon as a
          * timestamp becomes available. One of the PTP_CLASS_ values
          * is passed in 'type'.
          */
diff --git a/include/linux/platform_data/fsa9480.h b/include/linux/platform_data/fsa9480.h
new file mode 100644
index 00000000000..72dddcb4bed
--- /dev/null
+++ b/include/linux/platform_data/fsa9480.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2010 Samsung Electronics
+ * Minkyu Kang <mk7.kang@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef _FSA9480_H_
+#define _FSA9480_H_
+
+#define FSA9480_ATTACHED        1
+#define FSA9480_DETACHED        0
+
+struct fsa9480_platform_data {
+        void (*cfg_gpio) (void);
+        void (*usb_cb) (u8 attached);
+        void (*uart_cb) (u8 attached);
+        void (*charger_cb) (u8 attached);
+        void (*jig_cb) (u8 attached);
+        void (*reset_cb) (void);
+        void (*usb_power) (u8 on);
+        int wakeup;
+};
+
+#endif /* _FSA9480_H_ */
diff --git a/include/linux/platform_data/ina230.h b/include/linux/platform_data/ina230.h
new file mode 100644
index 00000000000..fb1ac28ff62
--- /dev/null
+++ b/include/linux/platform_data/ina230.h
@@ -0,0 +1,32 @@
+/*
+ * include/linux/platform_data/ina230.h
+ *
+ * Copyright (c) 2011, NVIDIA Corporation.
+ *
+ * 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; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#ifndef _INA230_H
+#define _INA230_H
+
+#include <linux/types.h>
+
+struct ina230_platform_data {
+        const char *rail_name;
+        s32 current_threshold;
+        s32 resistor;
+        s32 min_cores_online;
+};
+
+#endif /* _INA230_H */
diff --git a/include/linux/platform_data/ntc_thermistor.h b/include/linux/platform_data/ntc_thermistor.h
new file mode 100644
index 00000000000..abd28621527
--- /dev/null
+++ b/include/linux/platform_data/ntc_thermistor.h
@@ -0,0 +1,53 @@
+/*
+ * ntc_thermistor.h - NTC Thermistors
+ *
+ *  Copyright (C) 2010 Samsung Electronics
+ *  MyungJoo Ham <myungjoo.ham@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#ifndef _LINUX_NTC_H
+#define _LINUX_NTC_H
+
+enum ntc_thermistor_type {
+        TYPE_NCPXXWB473,
+        TYPE_NCPXXWL333,
+};
+
+struct ntc_thermistor_platform_data {
+        /*
+         * One (not both) of read_uV and read_ohm should be provided and only
+         * one of the two should be provided.
+         * Both functions should return negative value for an error case.
+         *
+         * pullup_uV, pullup_ohm, pulldown_ohm, and connect are required to use
+         * read_uV()
+         *
+         * How to setup pullup_ohm, pulldown_ohm, and connect is
+         * described at Documentation/hwmon/ntc
+         *
+         * pullup/down_ohm: 0 for infinite / not-connected
+         */
+        int (*read_uV)(void);
+        unsigned int pullup_uV;
+
+        unsigned int pullup_ohm;
+        unsigned int pulldown_ohm;
+        enum { NTC_CONNECTED_POSITIVE, NTC_CONNECTED_GROUND } connect;
+
+        int (*read_ohm)(void);
+};
+
+#endif /* _LINUX_NTC_H */
diff --git a/include/linux/platform_data/pxa_sdhci.h b/include/linux/platform_data/pxa_sdhci.h
new file mode 100644
index 00000000000..51ad0995aba
--- /dev/null
+++ b/include/linux/platform_data/pxa_sdhci.h
@@ -0,0 +1,60 @@
+/*
+ * include/linux/platform_data/pxa_sdhci.h
+ *
+ * Copyright 2010 Marvell
+ *      Zhangfei Gao <zhangfei.gao@marvell.com>
+ *
+ * PXA Platform - SDHCI platform data definitions
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef _PXA_SDHCI_H_
+#define _PXA_SDHCI_H_
+
+/* pxa specific flag */
+/* Require clock free running */
+#define PXA_FLAG_ENABLE_CLOCK_GATING (1<<0)
+/* card always wired to host, like on-chip emmc */
+#define PXA_FLAG_CARD_PERMANENT (1<<1)
+/* Board design supports 8-bit data on SD/SDIO BUS */
+#define PXA_FLAG_SD_8_BIT_CAPABLE_SLOT (1<<2)
+
+/*
+ * struct pxa_sdhci_platdata() - Platform device data for PXA SDHCI
+ * @flags: flags for platform requirement
+ * @clk_delay_cycles:
+ *      mmp2: each step is roughly 100ps, 5bits width
+ *      pxa910: each step is 1ns, 4bits width
+ * @clk_delay_sel: select clk_delay, used on pxa910
+ *      0: choose feedback clk
+ *      1: choose feedback clk + delay value
+ *      2: choose internal clk
+ * @clk_delay_enable: enable clk_delay or not, used on pxa910
+ * @ext_cd_gpio: gpio pin used for external CD line
+ * @ext_cd_gpio_invert: invert values for external CD gpio line
+ * @max_speed: the maximum speed supported
+ * @host_caps: Standard MMC host capabilities bit field.
+ * @quirks: quirks of platfrom
+ * @pm_caps: pm_caps of platfrom
+ */
+struct sdhci_pxa_platdata {
+        unsigned int    flags;
+        unsigned int    clk_delay_cycles;
+        unsigned int    clk_delay_sel;
+        bool            clk_delay_enable;
+        unsigned int    ext_cd_gpio;
+        bool            ext_cd_gpio_invert;
+        unsigned int    max_speed;
+        unsigned int    host_caps;
+        unsigned int    quirks;
+        unsigned int    pm_caps;
+};
+
+struct sdhci_pxa {
+        u8      clk_enable;
+        u8      power_mode;
+};
+#endif /* _PXA_SDHCI_H_ */
diff --git a/include/linux/platform_data/ram_console.h b/include/linux/platform_data/ram_console.h
new file mode 100644
index 00000000000..9f1125c1106
--- /dev/null
+++ b/include/linux/platform_data/ram_console.h
@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2010 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _INCLUDE_LINUX_PLATFORM_DATA_RAM_CONSOLE_H_
+#define _INCLUDE_LINUX_PLATFORM_DATA_RAM_CONSOLE_H_
+
+struct ram_console_platform_data {
+        const char *bootinfo;
+};
+
+#endif /* _INCLUDE_LINUX_PLATFORM_DATA_RAM_CONSOLE_H_ */
diff --git a/include/linux/platform_data/tegra_bpc_mgmt.h b/include/linux/platform_data/tegra_bpc_mgmt.h
new file mode 100644
index 00000000000..bdd4862d63a
--- /dev/null
+++ b/include/linux/platform_data/tegra_bpc_mgmt.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2010-2011 NVIDIA Corporation
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef __TEGRA_BPC_MGMT_H
+#define __TEGRA_BPC_MGMT_H
+#include <linux/cpumask.h>
+
+struct tegra_bpc_mgmt_platform_data {
+        int gpio_trigger;
+        struct cpumask affinity_mask;
+        int bpc_mgmt_timeout;
+};
+
+#endif /*__TEGRA_BPC_MGMT_H*/
diff --git a/include/linux/platform_data/tegra_nor.h b/include/linux/platform_data/tegra_nor.h
new file mode 100644
index 00000000000..cd8faff2f1c
--- /dev/null
+++ b/include/linux/platform_data/tegra_nor.h
@@ -0,0 +1,37 @@
+/*
+ * include/linux/platform_data/tegra_nor.h
+ *
+ * Copyright (C) 2010 - 2011 NVIDIA Corporation.
+ *
+ * Author:
+ *      Raghavendra V K <rvk@nvidia.com>
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef __MACH_TEGRA_NOR_PDATA_H
+#define __MACH_TEGRA_NOR_PDATA_H
+
+#include <asm/mach/flash.h>
+
+struct tegra_nor_chip_parms {
+        struct {
+                uint32_t timing0;
+                uint32_t timing1;
+        } timing_default, timing_read;
+};
+
+struct tegra_nor_platform_data {
+        struct tegra_nor_chip_parms chip_parms;
+        struct flash_platform_data flash;
+};
+
+#endif /* __MACH_TEGRA_NOR_PDATA_H */
diff --git a/include/linux/platform_data/tegra_usb.h b/include/linux/platform_data/tegra_usb.h
index 6bca5b569ac..e6377c379b4 100644
--- a/include/linux/platform_data/tegra_usb.h
+++ b/include/linux/platform_data/tegra_usb.h
@@ -1,5 +1,6 @@
 /*
  * Copyright (C) 2010 Google, Inc.
+ * Copyright (C) 2010-2011 NVIDIA Corporation
  *
  * This software is licensed under the terms of the GNU General Public
  * License version 2, as published by the Free Software Foundation, and
@@ -21,11 +22,27 @@ enum tegra_usb_operating_modes {
         TEGRA_USB_OTG,
 };
 
+enum tegra_usb_phy_type {
+        TEGRA_USB_PHY_TYPE_UTMIP = 0,
+        TEGRA_USB_PHY_TYPE_LINK_ULPI = 1,
+        TEGRA_USB_PHY_TYPE_NULL_ULPI = 2,
+        TEGRA_USB_PHY_TYPE_HSIC = 3,
+        TEGRA_USB_PHY_TYPE_ICUSB = 4,
+};
+
 struct tegra_ehci_platform_data {
         enum tegra_usb_operating_modes operating_mode;
         /* power down the phy on bus suspend */
         int power_down_on_bus_suspend;
+        int hotplug;
+        int default_enable;
         void *phy_config;
+        enum tegra_usb_phy_type phy_type;
+};
+
+struct tegra_otg_platform_data {
+        struct platform_device *ehci_device;
+        struct tegra_ehci_platform_data *ehci_pdata;
 };
 
 #endif /* _TEGRA_USB_H_ */
diff --git a/include/linux/platform_device.h b/include/linux/platform_device.h
index ede1a80e335..27bb05aae70 100644
--- a/include/linux/platform_device.h
+++ b/include/linux/platform_device.h
@@ -42,6 +42,7 @@ extern void platform_device_unregister(struct platform_device *);
 extern struct bus_type platform_bus_type;
 extern struct device platform_bus;
 
+extern void arch_setup_pdev_archdata(struct platform_device *);
 extern struct resource *platform_get_resource(struct platform_device *, unsigned int, unsigned int);
 extern int platform_get_irq(struct platform_device *, unsigned int);
 extern struct resource *platform_get_resource_byname(struct platform_device *, unsigned int, const char *);
diff --git a/include/linux/plist.h b/include/linux/plist.h
index c9b9f322c8d..aa0fb390bd2 100644
--- a/include/linux/plist.h
+++ b/include/linux/plist.h
@@ -77,14 +77,9 @@
 
 #include <linux/kernel.h>
 #include <linux/list.h>
-#include <linux/spinlock_types.h>
 
 struct plist_head {
         struct list_head node_list;
-#ifdef CONFIG_DEBUG_PI_LIST
-        raw_spinlock_t *rawlock;
-        spinlock_t *spinlock;
-#endif
 };
 
 struct plist_node {
@@ -93,37 +88,13 @@ struct plist_node {
         struct list_head        node_list;
 };
 
-#ifdef CONFIG_DEBUG_PI_LIST
-# define PLIST_HEAD_LOCK_INIT(_lock)            .spinlock = _lock
-# define PLIST_HEAD_LOCK_INIT_RAW(_lock)        .rawlock = _lock
-#else
-# define PLIST_HEAD_LOCK_INIT(_lock)
-# define PLIST_HEAD_LOCK_INIT_RAW(_lock)
-#endif
-
-#define _PLIST_HEAD_INIT(head)                          \
-        .node_list = LIST_HEAD_INIT((head).node_list)
-
 /**
  * PLIST_HEAD_INIT - static struct plist_head initializer
  * @head:       struct plist_head variable name
- * @_lock:      lock to initialize for this list
- */
-#define PLIST_HEAD_INIT(head, _lock)                    \
-{                                                       \
-        _PLIST_HEAD_INIT(head),                         \
-        PLIST_HEAD_LOCK_INIT(&(_lock))                  \
-}
-
-/**
- * PLIST_HEAD_INIT_RAW - static struct plist_head initializer
- * @head:       struct plist_head variable name
- * @_lock:      lock to initialize for this list
  */
-#define PLIST_HEAD_INIT_RAW(head, _lock)                \
+#define PLIST_HEAD_INIT(head)                           \
 {                                                       \
-        _PLIST_HEAD_INIT(head),                         \
-        PLIST_HEAD_LOCK_INIT_RAW(&(_lock))              \
+        .node_list = LIST_HEAD_INIT((head).node_list)   \
 }
 
 /**
@@ -141,31 +112,11 @@ struct plist_node {
 /**
  * plist_head_init - dynamic struct plist_head initializer
  * @head:       &struct plist_head pointer
- * @lock:       spinlock protecting the list (debugging)
  */
 static inline void
-plist_head_init(struct plist_head *head, spinlock_t *lock)
+plist_head_init(struct plist_head *head)
 {
         INIT_LIST_HEAD(&head->node_list);
-#ifdef CONFIG_DEBUG_PI_LIST
-        head->spinlock = lock;
-        head->rawlock = NULL;
-#endif
-}
-
-/**
- * plist_head_init_raw - dynamic struct plist_head initializer
- * @head:       &struct plist_head pointer
- * @lock:       raw_spinlock protecting the list (debugging)
- */
-static inline void
-plist_head_init_raw(struct plist_head *head, raw_spinlock_t *lock)
-{
-        INIT_LIST_HEAD(&head->node_list);
-#ifdef CONFIG_DEBUG_PI_LIST
-        head->rawlock = lock;
-        head->spinlock = NULL;
-#endif
 }
 
 /**
diff --git a/include/linux/pm.h b/include/linux/pm.h
index 411e4f4be52..f7c84c9abd3 100644
--- a/include/linux/pm.h
+++ b/include/linux/pm.h
@@ -461,8 +461,8 @@ struct dev_pm_info {
         unsigned long           active_jiffies;
         unsigned long           suspended_jiffies;
         unsigned long           accounting_timestamp;
-        void                    *subsys_data;  /* Owned by the subsystem. */
 #endif
+        void                    *subsys_data;  /* Owned by the subsystem. */
 };
 
 extern void update_pm_runtime_accounting(struct device *dev);
@@ -472,7 +472,7 @@ extern void update_pm_runtime_accounting(struct device *dev);
  * hibernation, system resume and during runtime PM transitions along with
  * subsystem-level and driver-level callbacks.
  */
-struct dev_power_domain {
+struct dev_pm_domain {
         struct dev_pm_ops       ops;
 };
 
@@ -553,11 +553,17 @@ extern void __suspend_report_result(const char *function, void *fn, int ret);
 extern int device_pm_wait_for_dev(struct device *sub, struct device *dev);
 
 extern int pm_generic_prepare(struct device *dev);
+extern int pm_generic_suspend_noirq(struct device *dev);
 extern int pm_generic_suspend(struct device *dev);
+extern int pm_generic_resume_noirq(struct device *dev);
 extern int pm_generic_resume(struct device *dev);
+extern int pm_generic_freeze_noirq(struct device *dev);
 extern int pm_generic_freeze(struct device *dev);
+extern int pm_generic_thaw_noirq(struct device *dev);
 extern int pm_generic_thaw(struct device *dev);
+extern int pm_generic_restore_noirq(struct device *dev);
 extern int pm_generic_restore(struct device *dev);
+extern int pm_generic_poweroff_noirq(struct device *dev);
 extern int pm_generic_poweroff(struct device *dev);
 extern void pm_generic_complete(struct device *dev);
 
diff --git a/include/linux/pm_domain.h b/include/linux/pm_domain.h
new file mode 100644
index 00000000000..f9ec1736a11
--- /dev/null
+++ b/include/linux/pm_domain.h
@@ -0,0 +1,112 @@
+/*
+ * pm_domain.h - Definitions and headers related to device power domains.
+ *
+ * Copyright (C) 2011 Rafael J. Wysocki <rjw@sisk.pl>, Renesas Electronics Corp.
+ *
+ * This file is released under the GPLv2.
+ */
+
+#ifndef _LINUX_PM_DOMAIN_H
+#define _LINUX_PM_DOMAIN_H
+
+#include <linux/device.h>
+
+enum gpd_status {
+        GPD_STATE_ACTIVE = 0,   /* PM domain is active */
+        GPD_STATE_BUSY,         /* Something is happening to the PM domain */
+        GPD_STATE_REPEAT,       /* Power off in progress, to be repeated */
+        GPD_STATE_POWER_OFF,    /* PM domain is off */
+};
+
+struct dev_power_governor {
+        bool (*power_down_ok)(struct dev_pm_domain *domain);
+};
+
+struct generic_pm_domain {
+        struct dev_pm_domain domain;    /* PM domain operations */
+        struct list_head gpd_list_node; /* Node in the global PM domains list */
+        struct list_head sd_node;       /* Node in the parent's subdomain list */
+        struct generic_pm_domain *parent;       /* Parent PM domain */
+        struct list_head sd_list;       /* List of dubdomains */
+        struct list_head dev_list;      /* List of devices */
+        struct mutex lock;
+        struct dev_power_governor *gov;
+        struct work_struct power_off_work;
+        unsigned int in_progress;       /* Number of devices being suspended now */
+        unsigned int sd_count;  /* Number of subdomains with power "on" */
+        enum gpd_status status; /* Current state of the domain */
+        wait_queue_head_t status_wait_queue;
+        struct task_struct *poweroff_task;      /* Powering off task */
+        unsigned int resume_count;      /* Number of devices being resumed */
+        unsigned int device_count;      /* Number of devices */
+        unsigned int suspended_count;   /* System suspend device counter */
+        unsigned int prepared_count;    /* Suspend counter of prepared devices */
+        bool suspend_power_off; /* Power status before system suspend */
+        int (*power_off)(struct generic_pm_domain *domain);
+        int (*power_on)(struct generic_pm_domain *domain);
+        int (*start_device)(struct device *dev);
+        int (*stop_device)(struct device *dev);
+        bool (*active_wakeup)(struct device *dev);
+};
+
+static inline struct generic_pm_domain *pd_to_genpd(struct dev_pm_domain *pd)
+{
+        return container_of(pd, struct generic_pm_domain, domain);
+}
+
+struct dev_list_entry {
+        struct list_head node;
+        struct device *dev;
+        bool need_restore;
+};
+
+#ifdef CONFIG_PM_GENERIC_DOMAINS
+extern int pm_genpd_add_device(struct generic_pm_domain *genpd,
+                               struct device *dev);
+extern int pm_genpd_remove_device(struct generic_pm_domain *genpd,
+                                  struct device *dev);
+extern int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
+                                  struct generic_pm_domain *new_subdomain);
+extern int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
+                                     struct generic_pm_domain *target);
+extern void pm_genpd_init(struct generic_pm_domain *genpd,
+                          struct dev_power_governor *gov, bool is_off);
+extern int pm_genpd_poweron(struct generic_pm_domain *genpd);
+#else
+static inline int pm_genpd_add_device(struct generic_pm_domain *genpd,
+                                      struct device *dev)
+{
+        return -ENOSYS;
+}
+static inline int pm_genpd_remove_device(struct generic_pm_domain *genpd,
+                                         struct device *dev)
+{
+        return -ENOSYS;
+}
+static inline int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
+                                         struct generic_pm_domain *new_sd)
+{
+        return -ENOSYS;
+}
+static inline int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
+                                            struct generic_pm_domain *target)
+{
+        return -ENOSYS;
+}
+static inline void pm_genpd_init(struct generic_pm_domain *genpd,
+                                 struct dev_power_governor *gov, bool is_off) {}
+static inline int pm_genpd_poweron(struct generic_pm_domain *genpd)
+{
+        return -ENOSYS;
+}
+#endif
+
+#ifdef CONFIG_PM_GENERIC_DOMAINS_RUNTIME
+extern void genpd_queue_power_off_work(struct generic_pm_domain *genpd);
+extern void pm_genpd_poweroff_unused(void);
+#else
+static inline void genpd_queue_power_off_work(struct generic_pm_domain *gpd) {}
+static inline void pm_genpd_poweroff_unused(void) {}
+#endif
+
+#endif /* _LINUX_PM_DOMAIN_H */
diff --git a/include/linux/pm_qos_params.h b/include/linux/pm_qos_params.h
index a7d87f911ca..5a536cbb25b 100644
--- a/include/linux/pm_qos_params.h
+++ b/include/linux/pm_qos_params.h
@@ -8,17 +8,30 @@
 #include <linux/notifier.h>
 #include <linux/miscdevice.h>
 
-#define PM_QOS_RESERVED 0
-#define PM_QOS_CPU_DMA_LATENCY 1
-#define PM_QOS_NETWORK_LATENCY 2
-#define PM_QOS_NETWORK_THROUGHPUT 3
+enum {
+        PM_QOS_RESERVED = 0,
+        PM_QOS_CPU_DMA_LATENCY,
+        PM_QOS_NETWORK_LATENCY,
+        PM_QOS_NETWORK_THROUGHPUT,
+        PM_QOS_MIN_ONLINE_CPUS,
+        PM_QOS_MAX_ONLINE_CPUS,
+        PM_QOS_CPU_FREQ_MIN,
+        PM_QOS_CPU_FREQ_MAX,
+
+        /* insert new class ID */
+
+        PM_QOS_NUM_CLASSES,
+};
 
-#define PM_QOS_NUM_CLASSES 4
 #define PM_QOS_DEFAULT_VALUE -1
 
 #define PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE        (2000 * USEC_PER_SEC)
 #define PM_QOS_NETWORK_LAT_DEFAULT_VALUE        (2000 * USEC_PER_SEC)
 #define PM_QOS_NETWORK_THROUGHPUT_DEFAULT_VALUE 0
+#define PM_QOS_MIN_ONLINE_CPUS_DEFAULT_VALUE    1
+#define PM_QOS_MAX_ONLINE_CPUS_DEFAULT_VALUE    LONG_MAX
+#define PM_QOS_CPU_FREQ_MIN_DEFAULT_VALUE       0
+#define PM_QOS_CPU_FREQ_MAX_DEFAULT_VALUE       LONG_MAX
 
 struct pm_qos_request_list {
         struct plist_node list;
diff --git a/include/linux/pm_runtime.h b/include/linux/pm_runtime.h
index 878cf84baeb..daac05d751b 100644
--- a/include/linux/pm_runtime.h
+++ b/include/linux/pm_runtime.h
@@ -82,6 +82,11 @@ static inline bool pm_runtime_suspended(struct device *dev)
                 && !dev->power.disable_depth;
 }
 
+static inline bool pm_runtime_status_suspended(struct device *dev)
+{
+        return dev->power.runtime_status == RPM_SUSPENDED;
+}
+
 static inline bool pm_runtime_enabled(struct device *dev)
 {
         return !dev->power.disable_depth;
@@ -130,6 +135,7 @@ static inline void pm_runtime_put_noidle(struct device *dev) {}
 static inline bool device_run_wake(struct device *dev) { return false; }
 static inline void device_set_run_wake(struct device *dev, bool enable) {}
 static inline bool pm_runtime_suspended(struct device *dev) { return false; }
+static inline bool pm_runtime_status_suspended(struct device *dev) { return false; }
 static inline bool pm_runtime_enabled(struct device *dev) { return false; }
 
 static inline int pm_generic_runtime_idle(struct device *dev) { return 0; }
@@ -247,41 +253,41 @@ static inline void pm_runtime_dont_use_autosuspend(struct device *dev)
 
 struct pm_clk_notifier_block {
         struct notifier_block nb;
-        struct dev_power_domain *pwr_domain;
+        struct dev_pm_domain *pm_domain;
         char *con_ids[];
 };
 
-#ifdef CONFIG_PM_RUNTIME_CLK
-extern int pm_runtime_clk_init(struct device *dev);
-extern void pm_runtime_clk_destroy(struct device *dev);
-extern int pm_runtime_clk_add(struct device *dev, const char *con_id);
-extern void pm_runtime_clk_remove(struct device *dev, const char *con_id);
-extern int pm_runtime_clk_suspend(struct device *dev);
-extern int pm_runtime_clk_resume(struct device *dev);
+#ifdef CONFIG_PM_CLK
+extern int pm_clk_init(struct device *dev);
+extern void pm_clk_destroy(struct device *dev);
+extern int pm_clk_add(struct device *dev, const char *con_id);
+extern void pm_clk_remove(struct device *dev, const char *con_id);
+extern int pm_clk_suspend(struct device *dev);
+extern int pm_clk_resume(struct device *dev);
 #else
-static inline int pm_runtime_clk_init(struct device *dev)
+static inline int pm_clk_init(struct device *dev)
 {
         return -EINVAL;
 }
-static inline void pm_runtime_clk_destroy(struct device *dev)
+static inline void pm_clk_destroy(struct device *dev)
 {
 }
-static inline int pm_runtime_clk_add(struct device *dev, const char *con_id)
+static inline int pm_clk_add(struct device *dev, const char *con_id)
 {
         return -EINVAL;
 }
-static inline void pm_runtime_clk_remove(struct device *dev, const char *con_id)
+static inline void pm_clk_remove(struct device *dev, const char *con_id)
 {
 }
-#define pm_runtime_clock_suspend        NULL
-#define pm_runtime_clock_resume         NULL
+#define pm_clk_suspend  NULL
+#define pm_clk_resume   NULL
 #endif
 
 #ifdef CONFIG_HAVE_CLK
-extern void pm_runtime_clk_add_notifier(struct bus_type *bus,
+extern void pm_clk_add_notifier(struct bus_type *bus,
                                         struct pm_clk_notifier_block *clknb);
 #else
-static inline void pm_runtime_clk_add_notifier(struct bus_type *bus,
+static inline void pm_clk_add_notifier(struct bus_type *bus,
                                         struct pm_clk_notifier_block *clknb)
 {
 }
diff --git a/include/linux/pnfs_osd_xdr.h b/include/linux/pnfs_osd_xdr.h
index 76efbdd0162..435dd5fa745 100644
--- a/include/linux/pnfs_osd_xdr.h
+++ b/include/linux/pnfs_osd_xdr.h
@@ -41,9 +41,6 @@
 
 #include <linux/nfs_fs.h>
 #include <linux/nfs_page.h>
-#include <scsi/osd_protocol.h>
-
-#define PNFS_OSD_OSDNAME_MAXSIZE 256
 
 /*
  * draft-ietf-nfsv4-minorversion-22
@@ -99,12 +96,6 @@ struct pnfs_osd_objid {
 #define _DEVID_HI(oid_device_id) \
         (unsigned long long)be64_to_cpup(((__be64 *)(oid_device_id)->data) + 1)
 
-static inline int
-pnfs_osd_objid_xdr_sz(void)
-{
-        return (NFS4_DEVICEID4_SIZE / 4) + 2 + 2;
-}
-
 enum pnfs_osd_version {
         PNFS_OSD_MISSING              = 0,
         PNFS_OSD_VERSION_1            = 1,
@@ -189,8 +180,6 @@ struct pnfs_osd_targetid {
         struct nfs4_string              oti_scsi_device_id;
 };
 
-enum { PNFS_OSD_TARGETID_MAX = 1 + PNFS_OSD_OSDNAME_MAXSIZE / 4 };
-
 /*   struct netaddr4 {
  *       // see struct rpcb in RFC1833
  *       string r_netid<>;    // network id
@@ -207,12 +196,6 @@ struct pnfs_osd_targetaddr {
         struct pnfs_osd_net_addr        ota_netaddr;
 };
 
-enum {
-        NETWORK_ID_MAX = 16 / 4,
-        UNIVERSAL_ADDRESS_MAX = 64 / 4,
-        PNFS_OSD_TARGETADDR_MAX = 3 +  NETWORK_ID_MAX + UNIVERSAL_ADDRESS_MAX,
-};
-
 struct pnfs_osd_deviceaddr {
         struct pnfs_osd_targetid        oda_targetid;
         struct pnfs_osd_targetaddr      oda_targetaddr;
@@ -222,15 +205,6 @@ struct pnfs_osd_deviceaddr {
         struct nfs4_string              oda_osdname;
 };
 
-enum {
-        ODA_OSDNAME_MAX = PNFS_OSD_OSDNAME_MAXSIZE / 4,
-        PNFS_OSD_DEVICEADDR_MAX =
-                PNFS_OSD_TARGETID_MAX + PNFS_OSD_TARGETADDR_MAX +
-                2 /*oda_lun*/ +
-                1 + OSD_SYSTEMID_LEN +
-                1 + ODA_OSDNAME_MAX,
-};
-
 /* LAYOUTCOMMIT: layoutupdate */
 
 /*   union pnfs_osd_deltaspaceused4 switch (bool dsu_valid) {
@@ -279,7 +253,7 @@ struct pnfs_osd_ioerr {
         u32                     oer_errno;
 };
 
-/* OSD XDR API */
+/* OSD XDR Client API */
 /* Layout helpers */
 /* Layout decoding is done in two parts:
  * 1. First Call pnfs_osd_xdr_decode_layout_map to read in only the header part
@@ -337,8 +311,7 @@ extern int
 pnfs_osd_xdr_encode_layoutupdate(struct xdr_stream *xdr,
                                  struct pnfs_osd_layoutupdate *lou);
 
-/* osd_ioerror encoding/decoding (layout_return) */
-/* Client */
+/* osd_ioerror encoding (layout_return) */
 extern __be32 *pnfs_osd_xdr_ioerr_reserve_space(struct xdr_stream *xdr);
 extern void pnfs_osd_xdr_encode_ioerr(__be32 *p, struct pnfs_osd_ioerr *ioerr);
 
diff --git a/include/linux/pnp.h b/include/linux/pnp.h
index 1bc1338b817..195aafc6cd0 100644
--- a/include/linux/pnp.h
+++ b/include/linux/pnp.h
@@ -50,7 +50,7 @@ static inline resource_size_t pnp_resource_len(struct resource *res)
 {
         if (res->start == 0 && res->end == 0)
                 return 0;
-        return res->end - res->start + 1;
+        return resource_size(res);
 }
 
 
diff --git a/include/linux/poison.h b/include/linux/poison.h
index 2110a81c5e2..79159de0e34 100644
--- a/include/linux/poison.h
+++ b/include/linux/poison.h
@@ -40,6 +40,12 @@
 #define RED_INACTIVE    0x09F911029D74E35BULL   /* when obj is inactive */
 #define RED_ACTIVE      0xD84156C5635688C0ULL   /* when obj is active */
 
+#ifdef CONFIG_PHYS_ADDR_T_64BIT
+#define MEMBLOCK_INACTIVE       0x3a84fb0144c9e71bULL
+#else
+#define MEMBLOCK_INACTIVE       0x44c9e71bUL
+#endif
+
 #define SLUB_RED_INACTIVE       0xbb
 #define SLUB_RED_ACTIVE         0xcc
 
diff --git a/include/linux/posix_acl.h b/include/linux/posix_acl.h
index 54211c1cd92..b7681102a4b 100644
--- a/include/linux/posix_acl.h
+++ b/include/linux/posix_acl.h
@@ -9,6 +9,7 @@
 #define __LINUX_POSIX_ACL_H
 
 #include <linux/slab.h>
+#include <linux/rcupdate.h>
 
 #define ACL_UNDEFINED_ID        (-1)
 
@@ -38,7 +39,10 @@ struct posix_acl_entry {
 };
 
 struct posix_acl {
-        atomic_t                a_refcount;
+        union {
+                atomic_t                a_refcount;
+                struct rcu_head         a_rcu;
+        };
         unsigned int            a_count;
         struct posix_acl_entry  a_entries[0];
 };
@@ -65,7 +69,7 @@ static inline void
 posix_acl_release(struct posix_acl *acl)
 {
         if (acl && atomic_dec_and_test(&acl->a_refcount))
-                kfree(acl);
+                kfree_rcu(acl, a_rcu);
 }
 
 
@@ -73,32 +77,33 @@ posix_acl_release(struct posix_acl *acl)
 
 extern void posix_acl_init(struct posix_acl *, int);
 extern struct posix_acl *posix_acl_alloc(int, gfp_t);
-extern struct posix_acl *posix_acl_clone(const struct posix_acl *, gfp_t);
 extern int posix_acl_valid(const struct posix_acl *);
 extern int posix_acl_permission(struct inode *, const struct posix_acl *, int);
-extern struct posix_acl *posix_acl_from_mode(mode_t, gfp_t);
-extern int posix_acl_equiv_mode(const struct posix_acl *, mode_t *);
-extern int posix_acl_create_masq(struct posix_acl *, mode_t *);
-extern int posix_acl_chmod_masq(struct posix_acl *, mode_t);
+extern struct posix_acl *posix_acl_from_mode(umode_t, gfp_t);
+extern int posix_acl_equiv_mode(const struct posix_acl *, umode_t *);
+extern int posix_acl_create(struct posix_acl **, gfp_t, umode_t *);
+extern int posix_acl_chmod(struct posix_acl **, gfp_t, umode_t);
 
 extern struct posix_acl *get_posix_acl(struct inode *, int);
 extern int set_posix_acl(struct inode *, int, struct posix_acl *);
 
 #ifdef CONFIG_FS_POSIX_ACL
-static inline struct posix_acl *get_cached_acl(struct inode *inode, int type)
+static inline struct posix_acl **acl_by_type(struct inode *inode, int type)
 {
-        struct posix_acl **p, *acl;
         switch (type) {
         case ACL_TYPE_ACCESS:
-                p = &inode->i_acl;
-                break;
+                return &inode->i_acl;
         case ACL_TYPE_DEFAULT:
-                p = &inode->i_default_acl;
-                break;
+                return &inode->i_default_acl;
         default:
-                return ERR_PTR(-EINVAL);
+                BUG();
         }
-        acl = ACCESS_ONCE(*p);
+}
+
+static inline struct posix_acl *get_cached_acl(struct inode *inode, int type)
+{
+        struct posix_acl **p = acl_by_type(inode, type);
+        struct posix_acl *acl = ACCESS_ONCE(*p);
         if (acl) {
                 spin_lock(&inode->i_lock);
                 acl = *p;
@@ -109,41 +114,20 @@ static inline struct posix_acl *get_cached_acl(struct inode *inode, int type)
         return acl;
 }
 
-static inline int negative_cached_acl(struct inode *inode, int type)
+static inline struct posix_acl *get_cached_acl_rcu(struct inode *inode, int type)
 {
-        struct posix_acl **p, *acl;
-        switch (type) {
-        case ACL_TYPE_ACCESS:
-                p = &inode->i_acl;
-                break;
-        case ACL_TYPE_DEFAULT:
-                p = &inode->i_default_acl;
-                break;
-        default:
-                BUG();
-        }
-        acl = ACCESS_ONCE(*p);
-        if (acl)
-                return 0;
-        return 1;
+        return rcu_dereference(*acl_by_type(inode, type));
 }
 
 static inline void set_cached_acl(struct inode *inode,
                                   int type,
                                   struct posix_acl *acl)
 {
-        struct posix_acl *old = NULL;
+        struct posix_acl **p = acl_by_type(inode, type);
+        struct posix_acl *old;
         spin_lock(&inode->i_lock);
-        switch (type) {
-        case ACL_TYPE_ACCESS:
-                old = inode->i_acl;
-                inode->i_acl = posix_acl_dup(acl);
-                break;
-        case ACL_TYPE_DEFAULT:
-                old = inode->i_default_acl;
-                inode->i_default_acl = posix_acl_dup(acl);
-                break;
-        }
+        old = *p;
+        rcu_assign_pointer(*p, posix_acl_dup(acl));
         spin_unlock(&inode->i_lock);
         if (old != ACL_NOT_CACHED)
                 posix_acl_release(old);
@@ -151,18 +135,11 @@ static inline void set_cached_acl(struct inode *inode,
 
 static inline void forget_cached_acl(struct inode *inode, int type)
 {
-        struct posix_acl *old = NULL;
+        struct posix_acl **p = acl_by_type(inode, type);
+        struct posix_acl *old;
         spin_lock(&inode->i_lock);
-        switch (type) {
-        case ACL_TYPE_ACCESS:
-                old = inode->i_acl;
-                inode->i_acl = ACL_NOT_CACHED;
-                break;
-        case ACL_TYPE_DEFAULT:
-                old = inode->i_default_acl;
-                inode->i_default_acl = ACL_NOT_CACHED;
-                break;
-        }
+        old = *p;
+        *p = ACL_NOT_CACHED;
         spin_unlock(&inode->i_lock);
         if (old != ACL_NOT_CACHED)
                 posix_acl_release(old);
diff --git a/include/linux/power/bq20z75.h b/include/linux/power/bq20z75.h
index b0843b68af9..1398eb004e8 100644
--- a/include/linux/power/bq20z75.h
+++ b/include/linux/power/bq20z75.h
@@ -29,11 +29,14 @@
  * @battery_detect:             GPIO which is used to detect battery presence
  * @battery_detect_present:     gpio state when battery is present (0 / 1)
  * @i2c_retry_count:            # of times to retry on i2c IO failure
+ * @poll_retry_count:           # of times to retry looking for new status after
+ *                              external change notification
  */
 struct bq20z75_platform_data {
         int battery_detect;
         int battery_detect_present;
         int i2c_retry_count;
+        int poll_retry_count;
 };
 
 #endif
diff --git a/include/linux/power/max17042_battery.h b/include/linux/power/max17042_battery.h
index 7995deb8bfc..fe99211fb2b 100644
--- a/include/linux/power/max17042_battery.h
+++ b/include/linux/power/max17042_battery.h
@@ -23,8 +23,99 @@
 #ifndef __MAX17042_BATTERY_H_
 #define __MAX17042_BATTERY_H_
 
+#define MAX17042_STATUS_BattAbsent      (1 << 3)
+#define MAX17042_BATTERY_FULL   (100)
+#define MAX17042_DEFAULT_SNS_RESISTOR   (10000)
+
+enum max17042_register {
+        MAX17042_STATUS         = 0x00,
+        MAX17042_VALRT_Th       = 0x01,
+        MAX17042_TALRT_Th       = 0x02,
+        MAX17042_SALRT_Th       = 0x03,
+        MAX17042_AtRate         = 0x04,
+        MAX17042_RepCap         = 0x05,
+        MAX17042_RepSOC         = 0x06,
+        MAX17042_Age            = 0x07,
+        MAX17042_TEMP           = 0x08,
+        MAX17042_VCELL          = 0x09,
+        MAX17042_Current        = 0x0A,
+        MAX17042_AvgCurrent     = 0x0B,
+        MAX17042_Qresidual      = 0x0C,
+        MAX17042_SOC            = 0x0D,
+        MAX17042_AvSOC          = 0x0E,
+        MAX17042_RemCap         = 0x0F,
+        MAX17402_FullCAP        = 0x10,
+        MAX17042_TTE            = 0x11,
+        MAX17042_V_empty        = 0x12,
+
+        MAX17042_RSLOW          = 0x14,
+
+        MAX17042_AvgTA          = 0x16,
+        MAX17042_Cycles         = 0x17,
+        MAX17042_DesignCap      = 0x18,
+        MAX17042_AvgVCELL       = 0x19,
+        MAX17042_MinMaxTemp     = 0x1A,
+        MAX17042_MinMaxVolt     = 0x1B,
+        MAX17042_MinMaxCurr     = 0x1C,
+        MAX17042_CONFIG         = 0x1D,
+        MAX17042_ICHGTerm       = 0x1E,
+        MAX17042_AvCap          = 0x1F,
+        MAX17042_ManName        = 0x20,
+        MAX17042_DevName        = 0x21,
+        MAX17042_DevChem        = 0x22,
+
+        MAX17042_TempNom        = 0x24,
+        MAX17042_TempCold       = 0x25,
+        MAX17042_TempHot        = 0x26,
+        MAX17042_AIN            = 0x27,
+        MAX17042_LearnCFG       = 0x28,
+        MAX17042_SHFTCFG        = 0x29,
+        MAX17042_RelaxCFG       = 0x2A,
+        MAX17042_MiscCFG        = 0x2B,
+        MAX17042_TGAIN          = 0x2C,
+        MAx17042_TOFF           = 0x2D,
+        MAX17042_CGAIN          = 0x2E,
+        MAX17042_COFF           = 0x2F,
+
+        MAX17042_Q_empty        = 0x33,
+        MAX17042_T_empty        = 0x34,
+
+        MAX17042_RCOMP0         = 0x38,
+        MAX17042_TempCo         = 0x39,
+        MAX17042_Rx             = 0x3A,
+        MAX17042_T_empty0       = 0x3B,
+        MAX17042_TaskPeriod     = 0x3C,
+        MAX17042_FSTAT          = 0x3D,
+
+        MAX17042_SHDNTIMER      = 0x3F,
+
+        MAX17042_VFRemCap       = 0x4A,
+
+        MAX17042_QH             = 0x4D,
+        MAX17042_QL             = 0x4E,
+};
+
+/*
+ * used for setting a register to a desired value
+ * addr : address for a register
+ * data : setting value for the register
+ */
+struct max17042_reg_data {
+        u8 addr;
+        u16 data;
+};
+
 struct max17042_platform_data {
+        struct max17042_reg_data *init_data;
+        int num_init_data; /* Number of enties in init_data array */
         bool enable_current_sense;
+
+        /*
+         * R_sns in micro-ohms.
+         * default 10000 (if r_sns = 0) as it is the recommended value by
+         * the datasheet although it can be changed by board designers.
+         */
+        unsigned int r_sns;
 };
 
 #endif /* __MAX17042_BATTERY_H_ */
diff --git a/include/linux/power/max8907c-charger.h b/include/linux/power/max8907c-charger.h
new file mode 100644
index 00000000000..2cebad768b0
--- /dev/null
+++ b/include/linux/power/max8907c-charger.h
@@ -0,0 +1,64 @@
+/* linux/power/max8907c-charger.h
+ *
+ * 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_MAX8907C_CHARGER_H
+#define __LINUX_MAX8907C_CHARGER_H
+
+/* interrupt */
+#define MAX8907C_VCHG_OVP               (1 << 0)
+#define MAX8907C_VCHG_F                 (1 << 1)
+#define MAX8907C_VCHG_R                 (1 << 2)
+#define MAX8907C_THM_OK_R               (1 << 8)
+#define MAX8907C_THM_OK_F               (1 << 9)
+#define MAX8907C_MBATTLOW_F             (1 << 10)
+#define MAX8907C_MBATTLOW_R             (1 << 11)
+#define MAX8907C_CHG_RST                (1 << 12)
+#define MAX8907C_CHG_DONE               (1 << 13)
+#define MAX8907C_CHG_TOPOFF             (1 << 14)
+#define MAX8907C_CHK_TMR_FAULT          (1 << 15)
+
+enum max8907c_charger_topoff_threshold {
+        MAX8907C_TOPOFF_5PERCENT        = 0x00,
+        MAX8907C_TOPOFF_10PERCENT       = 0x01,
+        MAX8907C_TOPOFF_15PERCENT       = 0x02,
+        MAX8907C_TOPOFF_20PERCENT       = 0x03,
+};
+
+enum max8907c_charger_restart_hysteresis {
+        MAX8907C_RESTART_100MV  = 0x00,
+        MAX8907C_RESTART_150MV  = 0x01,
+        MAX8907C_RESTART_200MV  = 0x02,
+        MAX8907C_RESTART_FLOAT  = 0x03,
+};
+
+enum max8907c_fast_charging_current {
+        MAX8907C_FASTCHARGE_90MA        = 0x00,
+        MAX8907C_FASTCHARGE_300MA       = 0x01,
+        MAX8907C_FASTCHARGE_460MA       = 0x02,
+        MAX8907C_FASTCHARGE_600MA       = 0x03,
+        MAX8907C_FASTCHARGE_700MA       = 0x04,
+        MAX8907C_FASTCHARGE_800MA       = 0x05,
+        MAX8907C_FASTCHARGE_900MA       = 0x06,
+        MAX8907C_FASTCHARGE_1000MA      = 0x07,
+};
+
+enum max8907c_fast_charger_time {
+        MAX8907C_FCHARGE_TM_8H          = 0x00,
+        MAX8907C_FCHARGE_TM_12H         = 0x01,
+        MAX8907C_FCHARGE_TM_16H         = 0x02,
+        MAX8907C_FCHARGE_TM_OFF         = 0x03,
+};
+
+struct max8907c_charger_pdata {
+        int irq;
+        enum max8907c_charger_topoff_threshold topoff_threshold;
+        enum max8907c_charger_restart_hysteresis restart_hysteresis;
+        enum max8907c_charger_restart_hysteresis fast_charging_current;
+        enum max8907c_fast_charger_time fast_charger_time;
+};
+
+#endif
diff --git a/include/linux/power_supply.h b/include/linux/power_supply.h
index 204c18dfdc9..2287c321413 100644
--- a/include/linux/power_supply.h
+++ b/include/linux/power_supply.h
@@ -14,6 +14,7 @@
 #define __LINUX_POWER_SUPPLY_H__
 
 #include <linux/device.h>
+#include <linux/wakelock.h>
 #include <linux/workqueue.h>
 #include <linux/leds.h>
 
@@ -163,6 +164,9 @@ struct power_supply {
         /* private */
         struct device *dev;
         struct work_struct changed_work;
+        spinlock_t changed_lock;
+        bool changed;
+        struct wake_lock work_wake_lock;
 
 #ifdef CONFIG_LEDS_TRIGGERS
         struct led_trigger *charging_full_trig;
diff --git a/include/linux/preempt.h b/include/linux/preempt.h
index 2e681d9555b..58969b2a8a8 100644
--- a/include/linux/preempt.h
+++ b/include/linux/preempt.h
@@ -27,6 +27,21 @@
 
 asmlinkage void preempt_schedule(void);
 
+#define preempt_check_resched() \
+do { \
+        if (unlikely(test_thread_flag(TIF_NEED_RESCHED))) \
+                preempt_schedule(); \
+} while (0)
+
+#else /* !CONFIG_PREEMPT */
+
+#define preempt_check_resched()         do { } while (0)
+
+#endif /* CONFIG_PREEMPT */
+
+
+#ifdef CONFIG_PREEMPT_COUNT
+
 #define preempt_disable() \
 do { \
         inc_preempt_count(); \
@@ -39,12 +54,6 @@ do { \
         dec_preempt_count(); \
 } while (0)
 
-#define preempt_check_resched() \
-do { \
-        if (unlikely(test_thread_flag(TIF_NEED_RESCHED))) \
-                preempt_schedule(); \
-} while (0)
-
 #define preempt_enable() \
 do { \
         preempt_enable_no_resched(); \
@@ -80,18 +89,17 @@ do { \
         preempt_check_resched(); \
 } while (0)
 
-#else
+#else /* !CONFIG_PREEMPT_COUNT */
 
 #define preempt_disable()               do { } while (0)
 #define preempt_enable_no_resched()     do { } while (0)
 #define preempt_enable()                do { } while (0)
-#define preempt_check_resched()         do { } while (0)
 
 #define preempt_disable_notrace()               do { } while (0)
 #define preempt_enable_no_resched_notrace()     do { } while (0)
 #define preempt_enable_notrace()                do { } while (0)
 
-#endif
+#endif /* CONFIG_PREEMPT_COUNT */
 
 #ifdef CONFIG_PREEMPT_NOTIFIERS
 
diff --git a/include/linux/proc_fs.h b/include/linux/proc_fs.h
index e7576cf9e32..643b96c7a94 100644
--- a/include/linux/proc_fs.h
+++ b/include/linux/proc_fs.h
@@ -5,7 +5,7 @@
 #include <linux/fs.h>
 #include <linux/spinlock.h>
 #include <linux/magic.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 struct net;
 struct completion;
@@ -50,8 +50,6 @@ typedef	int (write_proc_t)(struct file *file, const char __user *buffer,
 
 struct proc_dir_entry {
         unsigned int low_ino;
-        unsigned int namelen;
-        const char *name;
         mode_t mode;
         nlink_t nlink;
         uid_t uid;
@@ -73,9 +71,11 @@ struct proc_dir_entry {
         write_proc_t *write_proc;
         atomic_t count;         /* use count */
         int pde_users;  /* number of callers into module in progress */
-        spinlock_t pde_unload_lock; /* proc_fops checks and pde_users bumps */
         struct completion *pde_unload_completion;
         struct list_head pde_openers;   /* who did ->open, but not ->release */
+        spinlock_t pde_unload_lock; /* proc_fops checks and pde_users bumps */
+        u8 namelen;
+        char name[];
 };
 
 enum kcore_type {
diff --git a/include/linux/pstore.h b/include/linux/pstore.h
index 2455ef2683f..cc03bbf5c4b 100644
--- a/include/linux/pstore.h
+++ b/include/linux/pstore.h
@@ -38,9 +38,12 @@ struct pstore_info {
         int             (*open)(struct pstore_info *psi);
         int             (*close)(struct pstore_info *psi);
         ssize_t         (*read)(u64 *id, enum pstore_type_id *type,
-                        struct timespec *time);
-        u64             (*write)(enum pstore_type_id type, size_t size);
-        int             (*erase)(u64 id);
+                        struct timespec *time, struct pstore_info *psi);
+        u64             (*write)(enum pstore_type_id type, unsigned int part,
+                        size_t size, struct pstore_info *psi);
+        int             (*erase)(enum pstore_type_id type, u64 id,
+                        struct pstore_info *psi);
+        void            *data;
 };
 
 #ifdef CONFIG_PSTORE
diff --git a/include/linux/pti.h b/include/linux/pti.h
index 81af667bb2d..b3ea01a3197 100644
--- a/include/linux/pti.h
+++ b/include/linux/pti.h
@@ -36,7 +36,8 @@ struct pti_masterchannel {
 
 /* the following functions are defined in misc/pti.c */
 void pti_writedata(struct pti_masterchannel *mc, u8 *buf, int count);
-struct pti_masterchannel *pti_request_masterchannel(u8 type);
+struct pti_masterchannel *pti_request_masterchannel(u8 type,
+                                                    const char *thread_name);
 void pti_release_masterchannel(struct pti_masterchannel *mc);
 
 #endif /*PTI_H_*/
diff --git a/include/linux/ptp_classify.h b/include/linux/ptp_classify.h
index e07e2742a86..1dc420ba213 100644
--- a/include/linux/ptp_classify.h
+++ b/include/linux/ptp_classify.h
@@ -51,6 +51,7 @@
 #define PTP_CLASS_V2_VLAN (PTP_CLASS_V2 | PTP_CLASS_VLAN)
 
 #define PTP_EV_PORT 319
+#define PTP_GEN_BIT 0x08 /* indicates general message, if set in message type */
 
 #define OFF_ETYPE       12
 #define OFF_IHL         14
@@ -116,14 +117,20 @@ static inline int ptp_filter_init(struct sock_filter *f, int len)
         {OP_OR,         0,   0, PTP_CLASS_IPV6          }, /*              */ \
         {OP_RETA,       0,   0, 0                       }, /*              */ \
 /*L3x*/ {OP_RETK,       0,   0, PTP_CLASS_NONE          }, /*              */ \
-/*L40*/ {OP_JEQ,        0,   6, ETH_P_8021Q             }, /* f goto L50   */ \
+/*L40*/ {OP_JEQ,        0,   9, ETH_P_8021Q             }, /* f goto L50   */ \
         {OP_LDH,        0,   0, OFF_ETYPE + 4           }, /*              */ \
-        {OP_JEQ,        0,   9, ETH_P_1588              }, /* f goto L60   */ \
+        {OP_JEQ,        0,  15, ETH_P_1588              }, /* f goto L60   */ \
+        {OP_LDB,        0,   0, ETH_HLEN + VLAN_HLEN    }, /*              */ \
+        {OP_AND,        0,   0, PTP_GEN_BIT             }, /*              */ \
+        {OP_JEQ,        0,  12, 0                       }, /* f goto L6x   */ \
         {OP_LDH,        0,   0, ETH_HLEN + VLAN_HLEN    }, /*              */ \
         {OP_AND,        0,   0, PTP_CLASS_VMASK         }, /*              */ \
         {OP_OR,         0,   0, PTP_CLASS_VLAN          }, /*              */ \
         {OP_RETA,       0,   0, 0                       }, /*              */ \
-/*L50*/ {OP_JEQ,        0,   4, ETH_P_1588              }, /* f goto L61   */ \
+/*L50*/ {OP_JEQ,        0,   7, ETH_P_1588              }, /* f goto L61   */ \
+        {OP_LDB,        0,   0, ETH_HLEN                }, /*              */ \
+        {OP_AND,        0,   0, PTP_GEN_BIT             }, /*              */ \
+        {OP_JEQ,        0,   4, 0                       }, /* f goto L6x   */ \
         {OP_LDH,        0,   0, ETH_HLEN                }, /*              */ \
         {OP_AND,        0,   0, PTP_CLASS_VMASK         }, /*              */ \
         {OP_OR,         0,   0, PTP_CLASS_L2            }, /*              */ \
diff --git a/include/linux/ptrace.h b/include/linux/ptrace.h
index 9178d5cc0b0..800f113bea6 100644
--- a/include/linux/ptrace.h
+++ b/include/linux/ptrace.h
@@ -47,6 +47,13 @@
 #define PTRACE_GETREGSET        0x4204
 #define PTRACE_SETREGSET        0x4205
 
+#define PTRACE_SEIZE            0x4206
+#define PTRACE_INTERRUPT        0x4207
+#define PTRACE_LISTEN           0x4208
+
+/* flags in @data for PTRACE_SEIZE */
+#define PTRACE_SEIZE_DEVEL      0x80000000 /* temp flag for development */
+
 /* options set using PTRACE_SETOPTIONS */
 #define PTRACE_O_TRACESYSGOOD   0x00000001
 #define PTRACE_O_TRACEFORK      0x00000002
@@ -65,6 +72,7 @@
 #define PTRACE_EVENT_EXEC       4
 #define PTRACE_EVENT_VFORK_DONE 5
 #define PTRACE_EVENT_EXIT       6
+#define PTRACE_EVENT_STOP       7
 
 #include <asm/ptrace.h>
 
@@ -77,16 +85,22 @@
  * flags.  When the a task is stopped the ptracer owns task->ptrace.
  */
 
+#define PT_SEIZED       0x00010000      /* SEIZE used, enable new behavior */
 #define PT_PTRACED      0x00000001
 #define PT_DTRACE       0x00000002      /* delayed trace (used on m68k, i386) */
 #define PT_TRACESYSGOOD 0x00000004
 #define PT_PTRACE_CAP   0x00000008      /* ptracer can follow suid-exec */
-#define PT_TRACE_FORK   0x00000010
-#define PT_TRACE_VFORK  0x00000020
-#define PT_TRACE_CLONE  0x00000040
-#define PT_TRACE_EXEC   0x00000080
-#define PT_TRACE_VFORK_DONE     0x00000100
-#define PT_TRACE_EXIT   0x00000200
+
+/* PT_TRACE_* event enable flags */
+#define PT_EVENT_FLAG_SHIFT     4
+#define PT_EVENT_FLAG(event)    (1 << (PT_EVENT_FLAG_SHIFT + (event) - 1))
+
+#define PT_TRACE_FORK           PT_EVENT_FLAG(PTRACE_EVENT_FORK)
+#define PT_TRACE_VFORK          PT_EVENT_FLAG(PTRACE_EVENT_VFORK)
+#define PT_TRACE_CLONE          PT_EVENT_FLAG(PTRACE_EVENT_CLONE)
+#define PT_TRACE_EXEC           PT_EVENT_FLAG(PTRACE_EVENT_EXEC)
+#define PT_TRACE_VFORK_DONE     PT_EVENT_FLAG(PTRACE_EVENT_VFORK_DONE)
+#define PT_TRACE_EXIT           PT_EVENT_FLAG(PTRACE_EVENT_EXIT)
 
 #define PT_TRACE_MASK   0x000003f4
 
@@ -105,7 +119,7 @@ extern long arch_ptrace(struct task_struct *child, long request,
 extern int ptrace_readdata(struct task_struct *tsk, unsigned long src, char __user *dst, int len);
 extern int ptrace_writedata(struct task_struct *tsk, char __user *src, unsigned long dst, int len);
 extern void ptrace_disable(struct task_struct *);
-extern int ptrace_check_attach(struct task_struct *task, int kill);
+extern int ptrace_check_attach(struct task_struct *task, bool ignore_state);
 extern int ptrace_request(struct task_struct *child, long request,
                           unsigned long addr, unsigned long data);
 extern void ptrace_notify(int exit_code);
@@ -122,7 +136,7 @@ extern bool ptrace_may_access(struct task_struct *task, unsigned int mode);
 
 static inline int ptrace_reparented(struct task_struct *child)
 {
-        return child->real_parent != child->parent;
+        return !same_thread_group(child->real_parent, child->parent);
 }
 
 static inline void ptrace_unlink(struct task_struct *child)
@@ -137,36 +151,56 @@ int generic_ptrace_pokedata(struct task_struct *tsk, unsigned long addr,
                             unsigned long data);
 
 /**
- * task_ptrace - return %PT_* flags that apply to a task
- * @task:       pointer to &task_struct in question
+ * ptrace_parent - return the task that is tracing the given task
+ * @task: task to consider
  *
- * Returns the %PT_* flags that apply to @task.
+ * Returns %NULL if no one is tracing @task, or the &struct task_struct
+ * pointer to its tracer.
+ *
+ * Must called under rcu_read_lock().  The pointer returned might be kept
+ * live only by RCU.  During exec, this may be called with task_lock() held
+ * on @task, still held from when check_unsafe_exec() was called.
  */
-static inline int task_ptrace(struct task_struct *task)
+static inline struct task_struct *ptrace_parent(struct task_struct *task)
 {
-        return task->ptrace;
+        if (unlikely(task->ptrace))
+                return rcu_dereference(task->parent);
+        return NULL;
+}
+
+/**
+ * ptrace_event_enabled - test whether a ptrace event is enabled
+ * @task: ptracee of interest
+ * @event: %PTRACE_EVENT_* to test
+ *
+ * Test whether @event is enabled for ptracee @task.
+ *
+ * Returns %true if @event is enabled, %false otherwise.
+ */
+static inline bool ptrace_event_enabled(struct task_struct *task, int event)
+{
+        return task->ptrace & PT_EVENT_FLAG(event);
 }
 
 /**
  * ptrace_event - possibly stop for a ptrace event notification
- * @mask:       %PT_* bit to check in @current->ptrace
- * @event:      %PTRACE_EVENT_* value to report if @mask is set
+ * @event:      %PTRACE_EVENT_* value to report
  * @message:    value for %PTRACE_GETEVENTMSG to return
  *
- * This checks the @mask bit to see if ptrace wants stops for this event.
- * If so we stop, reporting @event and @message to the ptrace parent.
- *
- * Returns nonzero if we did a ptrace notification, zero if not.
+ * Check whether @event is enabled and, if so, report @event and @message
+ * to the ptrace parent.
  *
  * Called without locks.
  */
-static inline int ptrace_event(int mask, int event, unsigned long message)
+static inline void ptrace_event(int event, unsigned long message)
 {
-        if (mask && likely(!(current->ptrace & mask)))
-                return 0;
-        current->ptrace_message = message;
-        ptrace_notify((event << 8) | SIGTRAP);
-        return 1;
+        if (unlikely(ptrace_event_enabled(current, event))) {
+                current->ptrace_message = message;
+                ptrace_notify((event << 8) | SIGTRAP);
+        } else if (event == PTRACE_EVENT_EXEC && unlikely(current->ptrace)) {
+                /* legacy EXEC report via SIGTRAP */
+                send_sig(SIGTRAP, current, 0);
+        }
 }
 
 /**
@@ -183,16 +217,24 @@ static inline void ptrace_init_task(struct task_struct *child, bool ptrace)
 {
         INIT_LIST_HEAD(&child->ptrace_entry);
         INIT_LIST_HEAD(&child->ptraced);
-        child->parent = child->real_parent;
+#ifdef CONFIG_HAVE_HW_BREAKPOINT
+        atomic_set(&child->ptrace_bp_refcnt, 1);
+#endif
+        child->jobctl = 0;
         child->ptrace = 0;
-        if (unlikely(ptrace) && (current->ptrace & PT_PTRACED)) {
+        child->parent = child->real_parent;
+
+        if (unlikely(ptrace) && current->ptrace) {
                 child->ptrace = current->ptrace;
                 __ptrace_link(child, current->parent);
-        }
 
-#ifdef CONFIG_HAVE_HW_BREAKPOINT
-        atomic_set(&child->ptrace_bp_refcnt, 1);
-#endif
+                if (child->ptrace & PT_SEIZED)
+                        task_set_jobctl_pending(child, JOBCTL_TRAP_STOP);
+                else
+                        sigaddset(&child->pending.signal, SIGSTOP);
+
+                set_tsk_thread_flag(child, TIF_SIGPENDING);
+        }
 }
 
 /**
diff --git a/include/linux/pwm_backlight.h b/include/linux/pwm_backlight.h
index 5e3e25a3c9c..63d2df43e61 100644
--- a/include/linux/pwm_backlight.h
+++ b/include/linux/pwm_backlight.h
@@ -14,6 +14,7 @@ struct platform_pwm_backlight_data {
         unsigned int pwm_period_ns;
         int (*init)(struct device *dev);
         int (*notify)(struct device *dev, int brightness);
+        void (*notify_after)(struct device *dev, int brightness);
         void (*exit)(struct device *dev);
         int (*check_fb)(struct device *dev, struct fb_info *info);
 };
diff --git a/include/linux/quota.h b/include/linux/quota.h
index 9a85412e0db..cb785569903 100644
--- a/include/linux/quota.h
+++ b/include/linux/quota.h
@@ -180,7 +180,7 @@ enum {
 #include <linux/dqblk_v1.h>
 #include <linux/dqblk_v2.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 typedef __kernel_uid32_t qid_t; /* Type in which we store ids in memory */
 typedef long long qsize_t;      /* Type in which we store sizes */
@@ -415,13 +415,5 @@ struct quota_module_name {
         {QFMT_VFS_V0, "quota_v2"},\
         {0, NULL}}
 
-#else
-
-# /* nodep */ include <sys/cdefs.h>
-
-__BEGIN_DECLS
-long quotactl __P ((unsigned int, const char *, int, caddr_t));
-__END_DECLS
-
 #endif /* __KERNEL__ */
 #endif /* _QUOTA_ */
diff --git a/include/linux/radix-tree.h b/include/linux/radix-tree.h
index 23241c2fecc..9d4539c52e5 100644
--- a/include/linux/radix-tree.h
+++ b/include/linux/radix-tree.h
@@ -39,7 +39,15 @@
  * when it is shrunk, before we rcu free the node. See shrink code for
  * details.
  */
-#define RADIX_TREE_INDIRECT_PTR 1
+#define RADIX_TREE_INDIRECT_PTR         1
+/*
+ * A common use of the radix tree is to store pointers to struct pages;
+ * but shmem/tmpfs needs also to store swap entries in the same tree:
+ * those are marked as exceptional entries to distinguish them.
+ * EXCEPTIONAL_ENTRY tests the bit, EXCEPTIONAL_SHIFT shifts content past it.
+ */
+#define RADIX_TREE_EXCEPTIONAL_ENTRY    2
+#define RADIX_TREE_EXCEPTIONAL_SHIFT    2
 
 #define radix_tree_indirect_to_ptr(ptr) \
         radix_tree_indirect_to_ptr((void __force *)(ptr))
@@ -174,6 +182,28 @@ static inline int radix_tree_deref_retry(void *arg)
 }
 
 /**
+ * radix_tree_exceptional_entry - radix_tree_deref_slot gave exceptional entry?
+ * @arg:        value returned by radix_tree_deref_slot
+ * Returns:     0 if well-aligned pointer, non-0 if exceptional entry.
+ */
+static inline int radix_tree_exceptional_entry(void *arg)
+{
+        /* Not unlikely because radix_tree_exception often tested first */
+        return (unsigned long)arg & RADIX_TREE_EXCEPTIONAL_ENTRY;
+}
+
+/**
+ * radix_tree_exception - radix_tree_deref_slot returned either exception?
+ * @arg:        value returned by radix_tree_deref_slot
+ * Returns:     0 if well-aligned pointer, non-0 if either kind of exception.
+ */
+static inline int radix_tree_exception(void *arg)
+{
+        return unlikely((unsigned long)arg &
+                (RADIX_TREE_INDIRECT_PTR | RADIX_TREE_EXCEPTIONAL_ENTRY));
+}
+
+/**
  * radix_tree_replace_slot      - replace item in a slot
  * @pslot:      pointer to slot, returned by radix_tree_lookup_slot
  * @item:       new item to store in the slot.
@@ -194,8 +224,8 @@ void *radix_tree_delete(struct radix_tree_root *, unsigned long);
 unsigned int
 radix_tree_gang_lookup(struct radix_tree_root *root, void **results,
                         unsigned long first_index, unsigned int max_items);
-unsigned int
-radix_tree_gang_lookup_slot(struct radix_tree_root *root, void ***results,
+unsigned int radix_tree_gang_lookup_slot(struct radix_tree_root *root,
+                        void ***results, unsigned long *indices,
                         unsigned long first_index, unsigned int max_items);
 unsigned long radix_tree_next_hole(struct radix_tree_root *root,
                                 unsigned long index, unsigned long max_scan);
@@ -222,6 +252,7 @@ unsigned long radix_tree_range_tag_if_tagged(struct radix_tree_root *root,
                 unsigned long nr_to_tag,
                 unsigned int fromtag, unsigned int totag);
 int radix_tree_tagged(struct radix_tree_root *root, unsigned int tag);
+unsigned long radix_tree_locate_item(struct radix_tree_root *root, void *item);
 
 static inline void radix_tree_preload_end(void)
 {
diff --git a/include/linux/raid/md_p.h b/include/linux/raid/md_p.h
index 75cbf4f62fe..9e65d9e2066 100644
--- a/include/linux/raid/md_p.h
+++ b/include/linux/raid/md_p.h
@@ -245,10 +245,16 @@ struct mdp_superblock_1 {
         __u8    device_uuid[16]; /* user-space setable, ignored by kernel */
         __u8    devflags;       /* per-device flags.  Only one defined...*/
 #define WriteMostly1    1       /* mask for writemostly flag in above */
-        __u8    pad2[64-57];    /* set to 0 when writing */
+        /* Bad block log.  If there are any bad blocks the feature flag is set.
+         * If offset and size are non-zero, that space is reserved and available
+         */
+        __u8    bblog_shift;    /* shift from sectors to block size */
+        __le16  bblog_size;     /* number of sectors reserved for list */
+        __le32  bblog_offset;   /* sector offset from superblock to bblog,
+                                 * signed - not unsigned */
 
         /* array state information - 64 bytes */
-        __le64  utime;          /* 40 bits second, 24 btes microseconds */
+        __le64  utime;          /* 40 bits second, 24 bits microseconds */
         __le64  events;         /* incremented when superblock updated */
         __le64  resync_offset;  /* data before this offset (from data_offset) known to be in sync */
         __le32  sb_csum;        /* checksum up to devs[max_dev] */
@@ -270,8 +276,8 @@ struct mdp_superblock_1 {
                                            * must be honoured
                                            */
 #define MD_FEATURE_RESHAPE_ACTIVE       4
+#define MD_FEATURE_BAD_BLOCKS           8 /* badblock list is not empty */
 
-#define MD_FEATURE_ALL                  (1|2|4)
+#define MD_FEATURE_ALL                  (1|2|4|8)
 
 #endif 
-
diff --git a/include/linux/ramoops.h b/include/linux/ramoops.h
index 0ae68a2c121..484fef81cd3 100644
--- a/include/linux/ramoops.h
+++ b/include/linux/ramoops.h
@@ -10,6 +10,8 @@
 struct ramoops_platform_data {
         unsigned long   mem_size;
         unsigned long   mem_address;
+        unsigned long   record_size;
+        int             dump_oops;
 };
 
 #endif
diff --git a/include/linux/random.h b/include/linux/random.h
index fb7ab9de5f3..d13059f3ea3 100644
--- a/include/linux/random.h
+++ b/include/linux/random.h
@@ -57,17 +57,6 @@ extern void add_interrupt_randomness(int irq);
 extern void get_random_bytes(void *buf, int nbytes);
 void generate_random_uuid(unsigned char uuid_out[16]);
 
-extern __u32 secure_ip_id(__be32 daddr);
-extern u32 secure_ipv4_port_ephemeral(__be32 saddr, __be32 daddr, __be16 dport);
-extern u32 secure_ipv6_port_ephemeral(const __be32 *saddr, const __be32 *daddr,
-                                      __be16 dport);
-extern __u32 secure_tcp_sequence_number(__be32 saddr, __be32 daddr,
-                                        __be16 sport, __be16 dport);
-extern __u32 secure_tcpv6_sequence_number(__be32 *saddr, __be32 *daddr,
-                                          __be16 sport, __be16 dport);
-extern u64 secure_dccp_sequence_number(__be32 saddr, __be32 daddr,
-                                       __be16 sport, __be16 dport);
-
 #ifndef MODULE
 extern const struct file_operations random_fops, urandom_fops;
 #endif
diff --git a/include/linux/rculist.h b/include/linux/rculist.h
index e3beb315517..d079290843a 100644
--- a/include/linux/rculist.h
+++ b/include/linux/rculist.h
@@ -183,7 +183,7 @@ static inline void list_splice_init_rcu(struct list_head *list,
         struct list_head *last = list->prev;
         struct list_head *at = head->next;
 
-        if (list_empty(head))
+        if (list_empty(list))
                 return;
 
         /* "first" and "last" tracking list, so initialize it. */
diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
index 99f9aa7c280..8f4f881a0ad 100644
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -239,7 +239,7 @@ extern int rcu_read_lock_bh_held(void);
  * Check debug_lockdep_rcu_enabled() to prevent false positives during boot
  * and while lockdep is disabled.
  */
-#ifdef CONFIG_PREEMPT
+#ifdef CONFIG_PREEMPT_COUNT
 static inline int rcu_read_lock_sched_held(void)
 {
         int lockdep_opinion = 0;
@@ -250,12 +250,12 @@ static inline int rcu_read_lock_sched_held(void)
                 lockdep_opinion = lock_is_held(&rcu_sched_lock_map);
         return lockdep_opinion || preempt_count() != 0 || irqs_disabled();
 }
-#else /* #ifdef CONFIG_PREEMPT */
+#else /* #ifdef CONFIG_PREEMPT_COUNT */
 static inline int rcu_read_lock_sched_held(void)
 {
         return 1;
 }
-#endif /* #else #ifdef CONFIG_PREEMPT */
+#endif /* #else #ifdef CONFIG_PREEMPT_COUNT */
 
 #else /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
 
@@ -276,17 +276,17 @@ static inline int rcu_read_lock_bh_held(void)
         return 1;
 }
 
-#ifdef CONFIG_PREEMPT
+#ifdef CONFIG_PREEMPT_COUNT
 static inline int rcu_read_lock_sched_held(void)
 {
         return preempt_count() != 0 || irqs_disabled();
 }
-#else /* #ifdef CONFIG_PREEMPT */
+#else /* #ifdef CONFIG_PREEMPT_COUNT */
 static inline int rcu_read_lock_sched_held(void)
 {
         return 1;
 }
-#endif /* #else #ifdef CONFIG_PREEMPT */
+#endif /* #else #ifdef CONFIG_PREEMPT_COUNT */
 
 #endif /* #else #ifdef CONFIG_DEBUG_LOCK_ALLOC */
 
diff --git a/include/linux/reboot.h b/include/linux/reboot.h
index 3005d5a7fce..e0879a70e83 100644
--- a/include/linux/reboot.h
+++ b/include/linux/reboot.h
@@ -39,6 +39,11 @@
 
 #include <linux/notifier.h>
 
+#define SYS_DOWN        0x0001  /* Notify of system down */
+#define SYS_RESTART     SYS_DOWN
+#define SYS_HALT        0x0002  /* Notify of system halt */
+#define SYS_POWER_OFF   0x0003  /* Notify of system power off */
+
 extern int register_reboot_notifier(struct notifier_block *);
 extern int unregister_reboot_notifier(struct notifier_block *);
 
diff --git a/include/linux/regmap.h b/include/linux/regmap.h
new file mode 100644
index 00000000000..9fce3c8eb40
--- /dev/null
+++ b/include/linux/regmap.h
@@ -0,0 +1,217 @@
+#ifndef __LINUX_REGMAP_H
+#define __LINUX_REGMAP_H
+
+/*
+ * Register map access API
+ *
+ * Copyright 2011 Wolfson Microelectronics plc
+ *
+ * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/device.h>
+#include <linux/list.h>
+#include <linux/module.h>
+
+struct i2c_client;
+struct spi_device;
+
+/* An enum of all the supported cache types */
+enum regcache_type {
+        REGCACHE_NONE,
+        REGCACHE_RBTREE,
+        REGCACHE_COMPRESSED
+};
+
+/**
+ * Default value for a register.  We use an array of structs rather
+ * than a simple array as many modern devices have very sparse
+ * register maps.
+ *
+ * @reg: Register address.
+ * @def: Register default value.
+ */
+struct reg_default {
+        unsigned int reg;
+        unsigned int def;
+};
+
+/**
+ * Configuration for the register map of a device.
+ *
+ * @reg_bits: Number of bits in a register address, mandatory.
+ * @pad_bits: Number of bits of padding between register and value.
+ * @val_bits: Number of bits in a register value, mandatory.
+ *
+ * @writeable_reg: Optional callback returning true if the register
+ *                 can be written to.
+ * @readable_reg: Optional callback returning true if the register
+ *                can be read from.
+ * @volatile_reg: Optional callback returning true if the register
+ *                value can't be cached.
+ * @precious_reg: Optional callback returning true if the rgister
+ *                should not be read outside of a call from the driver
+ *                (eg, a clear on read interrupt status register).
+ *
+ * @max_register: Optional, specifies the maximum valid register index.
+ * @reg_defaults: Power on reset values for registers (for use with
+ *                register cache support).
+ * @num_reg_defaults: Number of elements in reg_defaults.
+ *
+ * @read_flag_mask: Mask to be set in the top byte of the register when doing
+ *                  a read.
+ * @write_flag_mask: Mask to be set in the top byte of the register when doing
+ *                   a write. If both read_flag_mask and write_flag_mask are
+ *                   empty the regmap_bus default masks are used.
+ *
+ * @cache_type: The actual cache type.
+ * @reg_defaults_raw: Power on reset values for registers (for use with
+ *                    register cache support).
+ * @num_reg_defaults_raw: Number of elements in reg_defaults_raw.
+ */
+struct regmap_config {
+        int reg_bits;
+        int pad_bits;
+        int val_bits;
+
+        bool (*writeable_reg)(struct device *dev, unsigned int reg);
+        bool (*readable_reg)(struct device *dev, unsigned int reg);
+        bool (*volatile_reg)(struct device *dev, unsigned int reg);
+        bool (*precious_reg)(struct device *dev, unsigned int reg);
+
+        unsigned int max_register;
+        const struct reg_default *reg_defaults;
+        unsigned int num_reg_defaults;
+        enum regcache_type cache_type;
+        const void *reg_defaults_raw;
+        unsigned int num_reg_defaults_raw;
+
+        u8 read_flag_mask;
+        u8 write_flag_mask;
+};
+
+typedef int (*regmap_hw_write)(struct device *dev, const void *data,
+                               size_t count);
+typedef int (*regmap_hw_gather_write)(struct device *dev,
+                                      const void *reg, size_t reg_len,
+                                      const void *val, size_t val_len);
+typedef int (*regmap_hw_read)(struct device *dev,
+                              const void *reg_buf, size_t reg_size,
+                              void *val_buf, size_t val_size);
+
+/**
+ * Description of a hardware bus for the register map infrastructure.
+ *
+ * @write: Write operation.
+ * @gather_write: Write operation with split register/value, return -ENOTSUPP
+ *                if not implemented  on a given device.
+ * @read: Read operation.  Data is returned in the buffer used to transmit
+ *         data.
+ * @read_flag_mask: Mask to be set in the top byte of the register when doing
+ *                  a read.
+ */
+struct regmap_bus {
+        regmap_hw_write write;
+        regmap_hw_gather_write gather_write;
+        regmap_hw_read read;
+        u8 read_flag_mask;
+};
+
+struct regmap *regmap_init(struct device *dev,
+                           const struct regmap_bus *bus,
+                           const struct regmap_config *config);
+struct regmap *regmap_init_i2c(struct i2c_client *i2c,
+                               const struct regmap_config *config);
+struct regmap *regmap_init_spi(struct spi_device *dev,
+                               const struct regmap_config *config);
+
+struct regmap *devm_regmap_init(struct device *dev,
+                                const struct regmap_bus *bus,
+                                const struct regmap_config *config);
+struct regmap *devm_regmap_init_i2c(struct i2c_client *i2c,
+                                    const struct regmap_config *config);
+struct regmap *devm_regmap_init_spi(struct spi_device *dev,
+                                    const struct regmap_config *config);
+
+void regmap_exit(struct regmap *map);
+int regmap_reinit_cache(struct regmap *map,
+                        const struct regmap_config *config);
+int regmap_write(struct regmap *map, unsigned int reg, unsigned int val);
+int regmap_raw_write(struct regmap *map, unsigned int reg,
+                     const void *val, size_t val_len);
+int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
+                        size_t val_count);
+int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val);
+int regmap_raw_read(struct regmap *map, unsigned int reg,
+                    void *val, size_t val_len);
+int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
+                     size_t val_count);
+int regmap_update_bits(struct regmap *map, unsigned int reg,
+                       unsigned int mask, unsigned int val);
+int regmap_update_bits_lazy(struct regmap *map, unsigned int reg,
+                       unsigned int mask, unsigned int val);
+int regmap_update_bits_check(struct regmap *map, unsigned int reg,
+                             unsigned int mask, unsigned int val,
+                             bool *change);
+
+int regcache_sync(struct regmap *map);
+void regcache_cache_only(struct regmap *map, bool enable);
+void regcache_cache_bypass(struct regmap *map, bool enable);
+void regcache_mark_dirty(struct regmap *map);
+
+int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
+                          int num_regs);
+
+/**
+ * Description of an IRQ for the generic regmap irq_chip.
+ *
+ * @reg_offset: Offset of the status/mask register within the bank
+ * @mask:       Mask used to flag/control the register.
+ */
+struct regmap_irq {
+        unsigned int reg_offset;
+        unsigned int mask;
+};
+
+/**
+ * Description of a generic regmap irq_chip.  This is not intended to
+ * handle every possible interrupt controller, but it should handle a
+ * substantial proportion of those that are found in the wild.
+ *
+ * @name:        Descriptive name for IRQ controller.
+ *
+ * @status_base: Base status register address.
+ * @mask_base:   Base mask register address.
+ * @ack_base:    Base ack address.  If zero then the chip is clear on read.
+ *
+ * @num_regs:    Number of registers in each control bank.
+ * @irqs:        Descriptors for individual IRQs.  Interrupt numbers are
+ *               assigned based on the index in the array of the interrupt.
+ * @num_irqs:    Number of descriptors.
+ */
+struct regmap_irq_chip {
+        const char *name;
+
+        unsigned int status_base;
+        unsigned int mask_base;
+        unsigned int ack_base;
+
+        int num_regs;
+
+        const struct regmap_irq *irqs;
+        int num_irqs;
+};
+
+struct regmap_irq_chip_data;
+
+int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
+                        int irq_base, struct regmap_irq_chip *chip,
+                        struct regmap_irq_chip_data **data);
+void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *data);
+int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data);
+
+#endif
diff --git a/include/linux/regulator/consumer.h b/include/linux/regulator/consumer.h
index 9e87c1cb727..8699df6fbb7 100644
--- a/include/linux/regulator/consumer.h
+++ b/include/linux/regulator/consumer.h
@@ -2,6 +2,7 @@
  * consumer.h -- SoC Regulator consumer support.
  *
  * Copyright (C) 2007, 2008 Wolfson Microelectronics PLC.
+ * Copyright (C) 2012 NVIDIA Corporation
  *
  * Author: Liam Girdwood <lrg@slimlogic.co.uk>
  *
@@ -92,6 +93,10 @@
  * FORCE_DISABLE  Regulator forcibly shut down by software.
  * VOLTAGE_CHANGE Regulator voltage changed.
  * DISABLE        Regulator was disabled.
+ * PRE_ENABLE     Regulator is to be enabled
+ * POST_ENABLE    Regulator was enabled
+ * OUT_PRECHANGE  Regulator is enabled and its voltage is to be changed
+ * OUT_POSTCHANGE Regulator is enabled and its voltage was changed
  *
  * NOTE: These events can be OR'ed together when passed into handler.
  */
@@ -104,6 +109,10 @@
 #define REGULATOR_EVENT_FORCE_DISABLE           0x20
 #define REGULATOR_EVENT_VOLTAGE_CHANGE          0x40
 #define REGULATOR_EVENT_DISABLE                 0x80
+#define REGULATOR_EVENT_PRE_ENABLE              0x100
+#define REGULATOR_EVENT_POST_ENABLE             0x200
+#define REGULATOR_EVENT_OUT_PRECHANGE           0x400
+#define REGULATOR_EVENT_OUT_POSTCHANGE          0x800
 
 struct regulator;
 
@@ -122,6 +131,9 @@ struct regulator;
 struct regulator_bulk_data {
         const char *supply;
         struct regulator *consumer;
+
+        /* private: Internal use */
+        int ret;
 };
 
 #if defined(CONFIG_REGULATOR)
@@ -194,6 +206,12 @@ static inline struct regulator *__must_check regulator_get(struct device *dev,
          */
         return NULL;
 }
+static inline struct regulator *__must_check regulator_get_exclusive(
+                struct device *dev, const char *id)
+{
+        /* See comment for regulator_get() stub, above */
+        return NULL;
+}
 static inline void regulator_put(struct regulator *regulator)
 {
 }
@@ -208,6 +226,11 @@ static inline int regulator_disable(struct regulator *regulator)
         return 0;
 }
 
+static inline int regulator_force_disable(struct regulator *regulator)
+{
+        return 0;
+}
+
 static inline int regulator_is_enabled(struct regulator *regulator)
 {
         return 1;
@@ -237,17 +260,45 @@ static inline void regulator_bulk_free(int num_consumers,
 {
 }
 
+static inline int regulator_count_voltages(struct regulator *regulator)
+{
+        return 0;
+}
+
+static inline int regulator_list_voltage(struct regulator *regulator,
+                                         unsigned selector)
+{
+        return 0;
+}
+
+static inline int regulator_is_supported_voltage(struct regulator *regulator,
+                                                 int min_uV, int max_uV)
+{
+        return 0;
+}
+
 static inline int regulator_set_voltage(struct regulator *regulator,
                                         int min_uV, int max_uV)
 {
         return 0;
 }
 
+static inline int regulator_set_voltage_time(struct regulator *regulator,
+                                             int old_uV, int new_uV)
+{
+        return 0;
+}
+
 static inline int regulator_get_voltage(struct regulator *regulator)
 {
         return 0;
 }
 
+static inline int regulator_sync_voltage(struct regulator *regulator)
+{
+        return 0;
+}
+
 static inline int regulator_set_current_limit(struct regulator *regulator,
                                              int min_uA, int max_uA)
 {
diff --git a/include/linux/regulator/driver.h b/include/linux/regulator/driver.h
index 6c433b89c80..1a80bc77517 100644
--- a/include/linux/regulator/driver.h
+++ b/include/linux/regulator/driver.h
@@ -188,18 +188,16 @@ struct regulator_dev {
 
         /* lists we belong to */
         struct list_head list; /* list of all regulators */
-        struct list_head slist; /* list of supplied regulators */
 
         /* lists we own */
         struct list_head consumer_list; /* consumers we supply */
-        struct list_head supply_list; /* regulators we supply */
 
         struct blocking_notifier_head notifier;
         struct mutex mutex; /* consumer lock */
         struct module *owner;
         struct device dev;
         struct regulation_constraints *constraints;
-        struct regulator_dev *supply;   /* for tree */
+        struct regulator *supply;       /* for tree */
 
         void *reg_data;         /* regulator_dev data */
 
diff --git a/include/linux/regulator/fan53555-regulator.h b/include/linux/regulator/fan53555-regulator.h
new file mode 100644
index 00000000000..e2ed83bab4e
--- /dev/null
+++ b/include/linux/regulator/fan53555-regulator.h
@@ -0,0 +1,63 @@
+/*
+ * include/linux/regulator/fan53555.h
+ *
+ * Interface for regulator driver for FairChild fan53555 Processor power supply
+ *
+ * Copyright (C) 2011 NVIDIA Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#ifndef __REGULATOR_FAN53555_H
+#define __REGULATOR_FAN53555_H
+
+#include <linux/regulator/machine.h>
+
+/*
+ * struct fan53555_regulator_platform_data - fan53555 regulator platform data.
+ * When VSEL pin is low, VOUT is set by the VSEL0 register.
+ * When VSEL pin is high, VOUT is set by the VSEL1 register
+ *
+ * @reg_init_data: The regulator init data.
+ * @vsel_id: Select the voltage id register.
+ * @vsel0_buck_en: Software Buck enable when EN=high & VSEL=low
+ * @vsel0_mode: Force PWM mode(1) or Allow auto-PFM mode(0) during light load
+ * @init_vsel0_min_uV: initial micro volts when EN=high & VSEL=low
+ * @init_vsel0_max_uV: initial micro volts when EN=high & VSEL=low
+ * @vsel1_buck_en: Software Buck enable when EN=high & VSEL=high
+ * @vsel1_mode: Force PWM mode(1) or Allow auto-PFM mode(0) during light load
+ * @init_vsel1_min_uV: initial micro volts when EN=high & VSEL=high
+ * @init_vsel1_max_uV: initial micro volts when EN=high & VSEL=high
+ * @output_discharge: when the regulator is disabled, VOUT discharges
+ * @slew_rate: slew rate of trasitioning from a low to high voltage
+ */
+
+struct fan53555_regulator_platform_data {
+        struct regulator_init_data reg_init_data;
+        int vsel_id;
+        unsigned vsel0_buck_en:1;
+        unsigned vsel0_mode:1;
+        int init_vsel0_min_uV;
+        int init_vsel0_max_uV;
+        unsigned vsel1_buck_en:1;
+        unsigned vsel1_mode:1;
+        int init_vsel1_min_uV;
+        int init_vsel1_max_uV;
+        unsigned output_discharge:1;
+        unsigned slew_rate:3;
+};
+
+#endif  /* __REGULATOR_FAN53555_H */
diff --git a/include/linux/regulator/gpio-regulator.h b/include/linux/regulator/gpio-regulator.h
new file mode 100644
index 00000000000..19fbd267406
--- /dev/null
+++ b/include/linux/regulator/gpio-regulator.h
@@ -0,0 +1,87 @@
+/*
+ * gpio-regulator.h
+ *
+ * Copyright 2011 Heiko Stuebner <heiko@sntech.de>
+ *
+ * based on fixed.h
+ *
+ * Copyright 2008 Wolfson Microelectronics PLC.
+ *
+ * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *
+ * Copyright (c) 2009 Nokia Corporation
+ * Roger Quadros <ext-roger.quadros@nokia.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ */
+
+#ifndef __REGULATOR_GPIO_H
+#define __REGULATOR_GPIO_H
+
+struct regulator_init_data;
+
+enum regulator_type;
+
+/**
+ * struct gpio_regulator_state - state description
+ * @value:              microvolts or microamps
+ * @gpios:              bitfield of gpio target-states for the value
+ *
+ * This structure describes a supported setting of the regulator
+ * and the necessary gpio-state to achieve it.
+ *
+ * The n-th bit in the bitfield describes the state of the n-th GPIO
+ * from the gpios-array defined in gpio_regulator_config below.
+ */
+struct gpio_regulator_state {
+        int value;
+        int gpios;
+};
+
+/**
+ * struct gpio_regulator_config - config structure
+ * @supply_name:        Name of the regulator supply
+ * @enable_gpio:        GPIO to use for enable control
+ *                      set to -EINVAL if not used
+ * @enable_high:        Polarity of enable GPIO
+ *                      1 = Active high, 0 = Active low
+ * @enabled_at_boot:    Whether regulator has been enabled at
+ *                      boot or not. 1 = Yes, 0 = No
+ *                      This is used to keep the regulator at
+ *                      the default state
+ * @startup_delay:      Start-up time in microseconds
+ * @gpios:              Array containing the gpios needed to control
+ *                      the setting of the regulator
+ * @nr_gpios:           Number of gpios
+ * @states:             Array of gpio_regulator_state entries describing
+ *                      the gpio state for specific voltages
+ * @nr_states:          Number of states available
+ * @regulator_type:     either REGULATOR_CURRENT or REGULATOR_VOLTAGE
+ * @init_data:          regulator_init_data
+ *
+ * This structure contains gpio-voltage regulator configuration
+ * information that must be passed by platform code to the
+ * gpio-voltage regulator driver.
+ */
+struct gpio_regulator_config {
+        const char *supply_name;
+
+        int enable_gpio;
+        unsigned enable_high:1;
+        unsigned enabled_at_boot:1;
+        unsigned startup_delay;
+
+        struct gpio *gpios;
+        int nr_gpios;
+
+        struct gpio_regulator_state *states;
+        int nr_states;
+
+        enum regulator_type type;
+        struct regulator_init_data *init_data;
+};
+
+#endif
diff --git a/include/linux/regulator/gpio-switch-regulator.h b/include/linux/regulator/gpio-switch-regulator.h
new file mode 100644
index 00000000000..68776b93ef0
--- /dev/null
+++ b/include/linux/regulator/gpio-switch-regulator.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2011, NVIDIA Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#ifndef _GPIO_SWITCH_REGULATOR_H
+#define _GPIO_SWITCH_REGULATOR_H
+
+#include <linux/regulator/machine.h>
+
+/*
+ * struct gpio_switch_regulator_subdev_data - Gpio switch regulator subdevice
+ * data.
+ *
+ * Subdevice data to register a gpio regulator switch device driver.
+ *
+ * @regulator_name: The name of regulator.
+ * @input_supply: Input supply name.
+ * @id: The id of the switch.
+ * @gpio_nr: Gpio nr which controls this switch.
+ * @active_low: true if making gpio low makes voltage output enable.
+ * @init_state: 1 if init_state should be active.
+ * @voltages: Possible voltages to set at output. The values are in millivolt.
+ * @n_voltages: Number of voltages.
+ * @num_consumer_supplies: Number of cosumer supplies.
+ * @consumer_supplies: List of consumer spllies.
+ */
+struct gpio_switch_regulator_subdev_data {
+        const char      *regulator_name;
+        const char      *input_supply;
+        int id;
+        int gpio_nr;
+        int active_low;
+        int pin_group;
+        int init_state;
+        int *voltages;
+        unsigned n_voltages;
+        struct regulator_consumer_supply *consumer_supplies;
+        int num_consumer_supplies;
+        struct regulation_constraints constraints;
+        int (*enable_rail)(struct gpio_switch_regulator_subdev_data *pdata);
+        int (*disable_rail)(struct gpio_switch_regulator_subdev_data *pdata);
+
+};
+
+/**
+ * gpio_switch_regulator_platform_data - platform data for gpio_switch_regulator
+ * @num_subdevs: number of regulators used
+ * @subdevs: pointer to regulators used
+ */
+struct gpio_switch_regulator_platform_data {
+        int num_subdevs;
+        struct gpio_switch_regulator_subdev_data **subdevs;
+};
+
+#endif
diff --git a/include/linux/regulator/max77663-regulator.h b/include/linux/regulator/max77663-regulator.h
new file mode 100644
index 00000000000..d8ab389c425
--- /dev/null
+++ b/include/linux/regulator/max77663-regulator.h
@@ -0,0 +1,131 @@
+/*
+ * include/linux/regulator/max77663-regulator.h
+ * Maxim LDO and Buck regulators driver
+ *
+ * Copyright 2011-2012 Maxim Integrated Products, Inc.
+ * Copyright (C) 2011-2012 NVIDIA Corporation
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ */
+
+#ifndef __LINUX_REGULATOR_MAX77663_REGULATOR_H__
+#define __LINUX_REGULATOR_MAX77663_REGULATOR_H__
+
+#include <linux/regulator/machine.h>
+
+#define max77663_rails(_name)   "max77663_"#_name
+
+enum max77663_regulator_id {
+        MAX77663_REGULATOR_ID_SD0,
+        MAX77663_REGULATOR_ID_DVSSD0,
+        MAX77663_REGULATOR_ID_SD1,
+        MAX77663_REGULATOR_ID_DVSSD1,
+        MAX77663_REGULATOR_ID_SD2,
+        MAX77663_REGULATOR_ID_SD3,
+        MAX77663_REGULATOR_ID_SD4,
+        MAX77663_REGULATOR_ID_LDO0,
+        MAX77663_REGULATOR_ID_LDO1,
+        MAX77663_REGULATOR_ID_LDO2,
+        MAX77663_REGULATOR_ID_LDO3,
+        MAX77663_REGULATOR_ID_LDO4,
+        MAX77663_REGULATOR_ID_LDO5,
+        MAX77663_REGULATOR_ID_LDO6,
+        MAX77663_REGULATOR_ID_LDO7,
+        MAX77663_REGULATOR_ID_LDO8,
+        MAX77663_REGULATOR_ID_NR,
+};
+
+/* FPS Power Up/Down Period */
+enum max77663_regulator_fps_power_period {
+        FPS_POWER_PERIOD_0,
+        FPS_POWER_PERIOD_1,
+        FPS_POWER_PERIOD_2,
+        FPS_POWER_PERIOD_3,
+        FPS_POWER_PERIOD_4,
+        FPS_POWER_PERIOD_5,
+        FPS_POWER_PERIOD_6,
+        FPS_POWER_PERIOD_7,
+        FPS_POWER_PERIOD_DEF = -1,
+};
+
+/* FPS Time Period */
+enum max77663_regulator_fps_time_period {
+        FPS_TIME_PERIOD_20US,
+        FPS_TIME_PERIOD_40US,
+        FPS_TIME_PERIOD_80US,
+        FPS_TIME_PERIOD_160US,
+        FPS_TIME_PERIOD_320US,
+        FPS_TIME_PERIOD_640US,
+        FPS_TIME_PERIOD_1280US,
+        FPS_TIME_PERIOD_2560US,
+        FPS_TIME_PERIOD_DEF = -1,
+};
+
+/* FPS Enable Source */
+enum max77663_regulator_fps_en_src {
+        FPS_EN_SRC_EN0,
+        FPS_EN_SRC_EN1,
+        FPS_EN_SRC_SW,
+        FPS_EN_SRC_RSVD,
+};
+
+/* FPS Source */
+enum max77663_regulator_fps_src {
+        FPS_SRC_0,
+        FPS_SRC_1,
+        FPS_SRC_2,
+        FPS_SRC_NONE,
+        FPS_SRC_DEF = -1,
+};
+
+/*
+ * Flags
+ */
+/* SD0 is controlled by EN2 */
+#define EN2_CTRL_SD0            0x01
+
+/* SD Slew Rate */
+#define SD_SLEW_RATE_SLOWEST    0x02    /*  13.75mV/us */
+#define SD_SLEW_RATE_SLOW       0x04    /*  27.50mV/us */
+#define SD_SLEW_RATE_FAST       0x08    /*  55.00mV/us */
+#define SD_SLEW_RATE_FASTEST    0x10    /* 100.00mV/us */
+#define SD_SLEW_RATE_MASK       0x1E
+
+/* SD Forced PWM Mode */
+#define SD_FORCED_PWM_MODE      0x20
+
+/* SD Failling Slew Rate Active-Discharge Mode */
+#define SD_FSRADE_DISABLE       0x40
+
+/* Group Low-Power Mode */
+#define GLPM_ENABLE             0x80
+
+/* Tracking for LDO4 */
+#define LDO4_EN_TRACKING        0x100
+
+struct max77663_regulator_fps_cfg {
+        enum max77663_regulator_fps_src src;
+        enum max77663_regulator_fps_en_src en_src;
+        enum max77663_regulator_fps_time_period time_period;
+};
+
+struct max77663_regulator_platform_data {
+        struct regulator_init_data init_data;
+        bool init_apply;
+        bool init_enable;
+        int init_uV;
+        enum max77663_regulator_fps_src fps_src;
+        enum max77663_regulator_fps_power_period fps_pu_period;
+        enum max77663_regulator_fps_power_period fps_pd_period;
+
+        int num_fps_cfgs;
+        struct max77663_regulator_fps_cfg *fps_cfgs;
+
+        unsigned int flags;
+};
+
+#endif /* __LINUX_REGULATOR_MAX77663_REGULATOR_H__ */
diff --git a/include/linux/regulator/max8907c-regulator.h b/include/linux/regulator/max8907c-regulator.h
new file mode 100644
index 00000000000..ddc5f0a6033
--- /dev/null
+++ b/include/linux/regulator/max8907c-regulator.h
@@ -0,0 +1,46 @@
+/* linux/regulator/max8907c-regulator.h
+ *
+ * Functions to access MAX8907C power management chip.
+ *
+ * Copyright (C) 2010 Gyungoh Yoo <jack.yoo@maxim-ic.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef __LINUX_REGULATOR_MAX8907C_H
+#define __LINUX_REGULATOR_MAX8907C_H
+
+/* IDs */
+#define MAX8907C_SD1    0
+#define MAX8907C_SD2    1
+#define MAX8907C_SD3    2
+#define MAX8907C_LDO1   3
+#define MAX8907C_LDO2   4
+#define MAX8907C_LDO3   5
+#define MAX8907C_LDO4   6
+#define MAX8907C_LDO5   7
+#define MAX8907C_LDO6   8
+#define MAX8907C_LDO7   9
+#define MAX8907C_LDO8   10
+#define MAX8907C_LDO9   11
+#define MAX8907C_LDO10  12
+#define MAX8907C_LDO11  13
+#define MAX8907C_LDO12  14
+#define MAX8907C_LDO13  15
+#define MAX8907C_LDO14  16
+#define MAX8907C_LDO15  17
+#define MAX8907C_LDO16  18
+#define MAX8907C_LDO17  19
+#define MAX8907C_LDO18  20
+#define MAX8907C_LDO19  21
+#define MAX8907C_LDO20  22
+#define MAX8907C_OUT5V  23
+#define MAX8907C_OUT33V 24
+#define MAX8907C_BBAT   25
+#define MAX8907C_SDBY   26
+#define MAX8907C_VRTC   27
+#define MAX8907C_WLED   27
+
+#endif
diff --git a/include/linux/regulator/ricoh583-regulator.h b/include/linux/regulator/ricoh583-regulator.h
new file mode 100644
index 00000000000..39fdb9e56e0
--- /dev/null
+++ b/include/linux/regulator/ricoh583-regulator.h
@@ -0,0 +1,63 @@
+/*
+ * linux/regulator/ricoh583-regulator.h
+ *
+ * Interface for regulator driver for RICOH583 power management chip.
+ *
+ * Copyright (C) 2011 NVIDIA Corporation
+ *
+ * Copyright (C) 2011 RICOH COMPANY,LTD
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#ifndef __LINUX_REGULATOR_RICOH583_H
+#define __LINUX_REGULATOR_RICOH583_H
+
+#include <linux/regulator/machine.h>
+
+
+#define ricoh583_rails(_name) "RICOH583_"#_name
+
+/* RICHOH Regulator IDs */
+enum regulator_id {
+        RICOH583_ID_DC0,
+        RICOH583_ID_DC1,
+        RICOH583_ID_DC2,
+        RICOH583_ID_DC3,
+        RICOH583_ID_LDO0,
+        RICOH583_ID_LDO1,
+        RICOH583_ID_LDO2,
+        RICOH583_ID_LDO3,
+        RICOH583_ID_LDO4,
+        RICOH583_ID_LDO5,
+        RICOH583_ID_LDO6,
+        RICOH583_ID_LDO7,
+        RICOH583_ID_LDO8,
+        RICOH583_ID_LDO9,
+};
+
+struct ricoh583_regulator_platform_data {
+                struct regulator_init_data regulator;
+                int init_uV;
+                unsigned init_enable:1;
+                unsigned init_apply:1;
+                int deepsleep_uV;
+                int deepsleep_slots;
+                unsigned long ext_pwr_req;
+                unsigned long flags;
+};
+
+#endif
diff --git a/include/linux/regulator/tps62360.h b/include/linux/regulator/tps62360.h
new file mode 100644
index 00000000000..6a5c1b2c751
--- /dev/null
+++ b/include/linux/regulator/tps62360.h
@@ -0,0 +1,57 @@
+/*
+ * tps62360.h -- TI tps62360
+ *
+ * Interface for regulator driver for TI TPS62360 Processor core supply
+ *
+ * Copyright (C) 2012 NVIDIA Corporation
+
+ * Author: Laxman Dewangan <ldewangan@nvidia.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#ifndef __LINUX_REGULATOR_TPS62360_H
+#define __LINUX_REGULATOR_TPS62360_H
+
+#include <linux/regulator/machine.h>
+
+/*
+ * struct tps62360_regulator_platform_data - tps62360 regulator platform data.
+ *
+ * @reg_init_data: The regulator init data.
+ * @en_force_pwm: Enable force pwm or not.
+ * @en_discharge: Enable discharge the output capacitor via internal
+ *                register.
+ * @en_internal_pulldn: internal pull down enable or not.
+ * @vsel0_gpio: Gpio number for vsel0. It should be -1 if this is tied with
+ *              fixed logic.
+ * @vsel1_gpio: Gpio number for vsel1. It should be -1 if this is tied with
+ *              fixed logic.
+ * @vsel0_def_state: Default state of vsel0. 1 if it is high else 0.
+ * @vsel1_def_state: Default state of vsel1. 1 if it is high else 0.
+ */
+struct tps62360_regulator_platform_data {
+        struct regulator_init_data reg_init_data;
+        bool en_force_pwm;
+        bool en_discharge;
+        bool en_internal_pulldn;
+        int vsel0_gpio;
+        int vsel1_gpio;
+        int vsel0_def_state;
+        int vsel1_def_state;
+};
+
+#endif /* __LINUX_REGULATOR_TPS62360_H */
diff --git a/include/linux/regulator/tps6236x-regulator.h b/include/linux/regulator/tps6236x-regulator.h
new file mode 100644
index 00000000000..7e8a3752966
--- /dev/null
+++ b/include/linux/regulator/tps6236x-regulator.h
@@ -0,0 +1,54 @@
+/*
+ * include/linux/regulator/tps6236x.h
+ *
+ * Interface for regulator driver for TI TPS6236x Processor core supply
+ *
+ * Copyright (C) 2011 NVIDIA Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#ifndef __REGULATOR_TPS6236X_H
+#define __REGULATOR_TPS6236X_H
+
+#include <linux/regulator/machine.h>
+
+/*
+ * struct tps6236x_regulator_platform_data - tps6236x regulator platform data.
+ *
+ * @reg_init_data: The regulator init data.
+ * @internal_pd_enable: internal pull down enable or not.
+ * @vsel: Select the voltage id register.
+ * @init_uV: initial micro volts which need to be set.
+ * @init_enable: Enable or do not enable the rails during initialization.
+ * @init_apply: Init parameter applied or not.
+ * @is_force_pwm: Enable force pwm or not. If not then PFM mode configuration
+ *                will be used.
+ * @enable_discharge: Enable discharge the output capacitor via a typ. 300Ohm
+ *                    path
+ */
+
+struct tps6236x_regulator_platform_data {
+        struct regulator_init_data reg_init_data;
+        int internal_pd_enable;
+        int vsel;
+        int init_uV;
+        unsigned init_apply:1;
+        bool is_force_pwm;
+        bool enable_discharge;
+};
+
+#endif /* __REGULATOR_TPS6236X_H */
diff --git a/include/linux/regulator/tps65090-regulator.h b/include/linux/regulator/tps65090-regulator.h
new file mode 100644
index 00000000000..341d53ec994
--- /dev/null
+++ b/include/linux/regulator/tps65090-regulator.h
@@ -0,0 +1,60 @@
+/*
+ * include/linux/regulator/tps65090-regulator.h
+ *
+ * Interface for regulator driver for TI TPS65090 PMIC family
+ *
+ * Copyright (C) 2012 NVIDIA Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to  Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#ifndef __REGULATOR_TPS65090_H
+#define __REGULATOR_TPS65090_H
+
+#include <linux/regulator/machine.h>
+
+#define tps65090_rails(_name) "tps65090_"#_name
+
+enum {
+        TPS65090_ID_DCDC1,
+        TPS65090_ID_DCDC2,
+        TPS65090_ID_DCDC3,
+        TPS65090_ID_FET1,
+        TPS65090_ID_FET2,
+        TPS65090_ID_FET3,
+        TPS65090_ID_FET4,
+        TPS65090_ID_FET5,
+        TPS65090_ID_FET6,
+        TPS65090_ID_FET7,
+};
+
+/*
+ * struct tps65090_regulator_platform_data
+ *
+ * @regulator: The regulator init data.
+ * @init_uV: initial micro volts which need to be set.
+ * @init_enable: Enable or do not enable the rails during initialization.
+ * @init_apply: Init parameter applied or not.
+ * @slew_rate_uV_per_us: Slew rate microvolt per microsec.
+ */
+
+struct tps65090_regulator_platform_data {
+        struct regulator_init_data regulator;
+        int slew_rate_uV_per_us;
+        unsigned int flags;
+};
+
+#endif  /* __REGULATOR_TPS65090_H */
diff --git a/include/linux/regulator/tps6591x-regulator.h b/include/linux/regulator/tps6591x-regulator.h
new file mode 100644
index 00000000000..7f7f647906d
--- /dev/null
+++ b/include/linux/regulator/tps6591x-regulator.h
@@ -0,0 +1,77 @@
+/*
+ * include/linux/regulator/tps6591x-regulator.h
+ *
+ * Interface for regulator driver for TI TPS6591x PMIC family
+ *
+ * Copyright (C) 2011 NVIDIA Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#ifndef __REGULATOR_TPS6591X_H
+#define __REGULATOR_TPS6591X_H
+
+#include <linux/regulator/machine.h>
+
+#define tps6591x_rails(_name) "tps6591x_"#_name
+
+enum {
+        TPS6591X_ID_VIO,
+        TPS6591X_ID_VDD_1,
+        TPS6591X_ID_VDD_2,
+        TPS6591X_ID_VDDCTRL,
+        TPS6591X_ID_LDO_1,
+        TPS6591X_ID_LDO_2,
+        TPS6591X_ID_LDO_3,
+        TPS6591X_ID_LDO_4,
+        TPS6591X_ID_LDO_5,
+        TPS6591X_ID_LDO_6,
+        TPS6591X_ID_LDO_7,
+        TPS6591X_ID_LDO_8,
+};
+
+enum tps6591x_ext_control {
+        EXT_CTRL_NONE = 0x0,
+        EXT_CTRL_EN1,
+        EXT_CTRL_EN2,
+        EXT_CTRL_SLEEP_OFF,
+};
+
+enum tps6591x_config_flags {
+        LDO_LOW_POWER_ON_SUSPEND = 0x1,
+};
+
+/*
+ * struct tps6591x_regulator_platform_data - tps6591x regulator platform data.
+ *
+ * @regulator: The regulator init data.
+ * @init_uV: initial micro volts which need to be set.
+ * @init_enable: Enable or do not enable the rails during initialization.
+ * @init_apply: Init parameter applied or not.
+ * @slew_rate_uV_per_us: Slew rate microvolt per microsec.
+ */
+
+struct tps6591x_regulator_platform_data {
+        struct regulator_init_data regulator;
+        int init_uV;
+        unsigned init_enable:1;
+        unsigned init_apply:1;
+        enum tps6591x_ext_control ectrl;
+        int slew_rate_uV_per_us;
+        unsigned int flags;
+};
+
+#endif  /* __REGULATOR_TPS6591X_H */
diff --git a/include/linux/regulator/tps80031-regulator.h b/include/linux/regulator/tps80031-regulator.h
new file mode 100644
index 00000000000..1670d147fc3
--- /dev/null
+++ b/include/linux/regulator/tps80031-regulator.h
@@ -0,0 +1,89 @@
+/*
+ * include/linux/regulator/tps80031-regulator.h
+ *
+ * Interface for regulator driver for TI TPS80031
+ *
+ * Copyright (C) 2011 NVIDIA Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#ifndef __REGULATOR_TPS80031_H
+#define __REGULATOR_TPS80031_H
+
+#include <linux/regulator/machine.h>
+
+#define tps80031_rails(_name) "tps80031_"#_name
+
+enum {
+        TPS80031_ID_VIO,
+        TPS80031_ID_SMPS1,
+        TPS80031_ID_SMPS2,
+        TPS80031_ID_SMPS3,
+        TPS80031_ID_SMPS4,
+        TPS80031_ID_VANA,
+        TPS80031_ID_LDO1,
+        TPS80031_ID_LDO2,
+        TPS80031_ID_LDO3,
+        TPS80031_ID_LDO4,
+        TPS80031_ID_LDO5,
+        TPS80031_ID_LDO6,
+        TPS80031_ID_LDO7,
+        TPS80031_ID_LDOLN,
+        TPS80031_ID_LDOUSB,
+        TPS80031_ID_VBUS,
+        TPS80031_ID_CHARGER,
+};
+
+
+enum {
+        /* USBLDO input selection */
+        USBLDO_INPUT_VSYS       = 0x00000001,
+        USBLDO_INPUT_PMID       = 0x00000002,
+
+        /* LDO3 output mode */
+        LDO3_OUTPUT_VIB         = 0x00000004,
+
+        /* VBUS configuration */
+        VBUS_DISCHRG_EN_PDN     = 0x00000004,
+        VBUS_SW_ONLY            = 0x00000008,
+        VBUS_SW_N_ID            = 0x00000010,
+};
+
+/*
+ * struct tps80031_regulator_platform_data - tps80031 regulator platform data.
+ *
+ * @regulator: The regulator init data.
+ * @init_uV: initial micro volts which need to be set.
+ * @init_enable: Enable or do not enable the rails during initialization.
+ * @init_apply: Init parameter applied or not.
+ * @ext_ctrl_flag: External control flag for sleep/power request control.
+ * @flags: Configuration flag to configure the rails. It should be ORed of
+ *       above enums.
+ * @delay_us: Delay in microsecond after setting the desired voltage.
+ */
+
+struct tps80031_regulator_platform_data {
+        struct regulator_init_data regulator;
+        int init_uV;
+        unsigned init_enable:1;
+        unsigned init_apply:1;
+        unsigned int ext_ctrl_flag;
+        unsigned int flags;
+        int delay_us;
+};
+
+#endif  /* __REGULATOR_TPS80031_H */
diff --git a/include/linux/reiserfs_acl.h b/include/linux/reiserfs_acl.h
index 3fd8c4506bb..f096b80e73d 100644
--- a/include/linux/reiserfs_acl.h
+++ b/include/linux/reiserfs_acl.h
@@ -59,11 +59,7 @@ extern const struct xattr_handler reiserfs_posix_acl_access_handler;
 #else
 
 #define reiserfs_cache_default_acl(inode) 0
-
-static inline struct posix_acl *reiserfs_get_acl(struct inode *inode, int type)
-{
-        return NULL;
-}
+#define reiserfs_get_acl NULL
 
 static inline int reiserfs_acl_chmod(struct inode *inode)
 {
diff --git a/include/linux/reiserfs_fs.h b/include/linux/reiserfs_fs.h
index eca75df00fe..96d465f8d3e 100644
--- a/include/linux/reiserfs_fs.h
+++ b/include/linux/reiserfs_fs.h
@@ -2332,7 +2332,9 @@ __u32 keyed_hash(const signed char *msg, int len);
 __u32 yura_hash(const signed char *msg, int len);
 __u32 r5_hash(const signed char *msg, int len);
 
+#define reiserfs_set_le_bit             __set_bit_le
 #define reiserfs_test_and_set_le_bit    __test_and_set_bit_le
+#define reiserfs_clear_le_bit           __clear_bit_le
 #define reiserfs_test_and_clear_le_bit  __test_and_clear_bit_le
 #define reiserfs_test_le_bit            test_bit_le
 #define reiserfs_find_next_zero_le_bit  find_next_zero_bit_le
diff --git a/include/linux/reiserfs_xattr.h b/include/linux/reiserfs_xattr.h
index 6deef5dc95f..c2b71473266 100644
--- a/include/linux/reiserfs_xattr.h
+++ b/include/linux/reiserfs_xattr.h
@@ -41,7 +41,7 @@ int reiserfs_xattr_init(struct super_block *sb, int mount_flags);
 int reiserfs_lookup_privroot(struct super_block *sb);
 int reiserfs_delete_xattrs(struct inode *inode);
 int reiserfs_chown_xattrs(struct inode *inode, struct iattr *attrs);
-int reiserfs_permission(struct inode *inode, int mask, unsigned int flags);
+int reiserfs_permission(struct inode *inode, int mask);
 
 #ifdef CONFIG_REISERFS_FS_XATTR
 #define has_xattr_dir(inode) (REISERFS_I(inode)->i_flags & i_has_xattr_dir)
diff --git a/include/linux/ring_buffer.h b/include/linux/ring_buffer.h
index ab38ac80b0f..b891de96000 100644
--- a/include/linux/ring_buffer.h
+++ b/include/linux/ring_buffer.h
@@ -169,7 +169,7 @@ void ring_buffer_set_clock(struct ring_buffer *buffer,
 size_t ring_buffer_page_len(void *page);
 
 
-void *ring_buffer_alloc_read_page(struct ring_buffer *buffer);
+void *ring_buffer_alloc_read_page(struct ring_buffer *buffer, int cpu);
 void ring_buffer_free_read_page(struct ring_buffer *buffer, void *data);
 int ring_buffer_read_page(struct ring_buffer *buffer, void **data_page,
                           size_t len, int cpu, int full);
diff --git a/include/linux/rio_regs.h b/include/linux/rio_regs.h
index 9026b30238f..218168a2b5e 100644
--- a/include/linux/rio_regs.h
+++ b/include/linux/rio_regs.h
@@ -36,12 +36,12 @@
 #define  RIO_PEF_PROCESSOR              0x20000000      /* [I] Processor */
 #define  RIO_PEF_SWITCH                 0x10000000      /* [I] Switch */
 #define  RIO_PEF_MULTIPORT              0x08000000      /* [VI, 2.1] Multiport */
-#define  RIO_PEF_INB_MBOX               0x00f00000      /* [II] Mailboxes */
-#define  RIO_PEF_INB_MBOX0              0x00800000      /* [II] Mailbox 0 */
-#define  RIO_PEF_INB_MBOX1              0x00400000      /* [II] Mailbox 1 */
-#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_INB_MBOX               0x00f00000      /* [II, <= 1.2] Mailboxes */
+#define  RIO_PEF_INB_MBOX0              0x00800000      /* [II, <= 1.2] Mailbox 0 */
+#define  RIO_PEF_INB_MBOX1              0x00400000      /* [II, <= 1.2] Mailbox 1 */
+#define  RIO_PEF_INB_MBOX2              0x00200000      /* [II, <= 1.2] Mailbox 2 */
+#define  RIO_PEF_INB_MBOX3              0x00100000      /* [II, <= 1.2] Mailbox 3 */
+#define  RIO_PEF_INB_DOORBELL           0x00080000      /* [II, <= 1.2] 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 */
@@ -102,7 +102,7 @@
 #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_MBOX_CSR            0x40    /* [II, <= 1.2] Mailbox CSR */
 #define  RIO_MBOX0_AVAIL                0x80000000      /* [II] Mbox 0 avail */
 #define  RIO_MBOX0_FULL                 0x40000000      /* [II] Mbox 0 full */
 #define  RIO_MBOX0_EMPTY                0x20000000      /* [II] Mbox 0 empty */
@@ -128,8 +128,8 @@
 #define  RIO_MBOX3_FAIL                 0x00000008      /* [II] Mbox 3 fail */
 #define  RIO_MBOX3_ERROR                0x00000004      /* [II] Mbox 3 error */
 
-#define RIO_WRITE_PORT_CSR      0x44    /* [I] Write Port CSR */
-#define RIO_DOORBELL_CSR        0x44    /* [II] Doorbell CSR */
+#define RIO_WRITE_PORT_CSR      0x44    /* [I, <= 1.2] Write Port CSR */
+#define RIO_DOORBELL_CSR        0x44    /* [II, <= 1.2] Doorbell CSR */
 #define  RIO_DOORBELL_AVAIL             0x80000000      /* [II] Doorbell avail */
 #define  RIO_DOORBELL_FULL              0x40000000      /* [II] Doorbell full */
 #define  RIO_DOORBELL_EMPTY             0x20000000      /* [II] Doorbell empty */
diff --git a/include/linux/rmi.h b/include/linux/rmi.h
new file mode 100644
index 00000000000..84e121d936a
--- /dev/null
+++ b/include/linux/rmi.h
@@ -0,0 +1,656 @@
+/*
+ * Copyright (c) 2011 Synaptics Incorporated
+ * Copyright (c) 2011 Unixphere
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#ifndef _RMI_H
+#define _RMI_H
+#include <linux/kernel.h>
+#include <linux/lockdep.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/device.h>
+#include <linux/cdev.h>
+#include <linux/mutex.h>
+#include <linux/stat.h>
+#include <linux/wait.h>
+#include <linux/list.h>
+#include <linux/interrupt.h>
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+#include <linux/earlysuspend.h>
+#endif
+
+#ifdef CONFIG_TOUCHSCREEN_SYN_RMI4_SPI
+
+#define CONFIG_RMI4_BUS
+#define CONFIG_RMI4_SPI
+#define CONFIG_RMI4_GENERIC
+#define CONFIG_RMI4_F09
+#define CONFIG_RMI4_F11
+#define CONFIG_RMI4_F19
+#define CONFIG_RMI4_F34
+#define CONFIG_RMI4_F54
+#define CONFIG_RMI4_DEV
+
+#endif
+
+// #define SYNAPTICS_SENSOR_POLL 1
+
+/* Permissions for sysfs attributes.  Since the permissions policy will change
+ * on a global basis in the future, rather than edit all sysfs attrs everywhere
+ * in the driver (and risk screwing that up in the process), we use this handy
+ * set of #defines.  That way when we change the policy for sysfs permissions,
+ * we only need to change them here.
+ */
+#define RMI_RO_ATTR S_IRUGO
+#define RMI_RW_ATTR (S_IRUGO | S_IWUGO)
+#define RMI_WO_ATTR S_IWUGO
+
+#define PDT_START_SCAN_LOCATION 0x00e9
+
+enum rmi_irq_polarity {
+        RMI_IRQ_ACTIVE_LOW = 0,
+        RMI_IRQ_ACTIVE_HIGH = 1
+};
+
+/**
+ * struct rmi_f11_axis_alignmen - target axis alignment
+ * @swap_axes: set to TRUE if desired to swap x- and y-axis
+ * @flip_x: set to TRUE if desired to flip direction on x-axis
+ * @flip_y: set to TRUE if desired to flip direction on y-axis
+ */
+struct rmi_f11_2d_axis_alignment {
+        bool swap_axes;
+        bool flip_x;
+        bool flip_y;
+        int clip_X_low;
+        int clip_Y_low;
+        int clip_X_high;
+        int clip_Y_high;
+        int offset_X;
+        int offset_Y;
+        int rel_report_enabled;
+};
+
+/**
+ * RMI F11 - function control register parameters
+ * Each register that has a specific bit-field setup has an accompanied
+ * register definition so that the setting can be chosen as a one-word
+ * register setting or per-bit setting.
+ */
+union rmi_f11_2d_ctrl0 {
+        struct {
+                u8 reporting_mode:3;
+                u8 abs_pos_filt:1;
+                u8 rel_pos_filt:1;
+                u8 rel_ballistics:1;
+                u8 dribble:1;
+                u8 report_beyond_clip:1;
+        };
+        u8 reg;
+};
+
+union rmi_f11_2d_ctrl1 {
+        struct {
+                u8 palm_detect_thres:4;
+                u8 motion_sensitivity:2;
+                u8 man_track_en:1;
+                u8 man_tracked_finger:1;
+        };
+        u8 reg;
+};
+
+union rmi_f11_2d_ctrl2__3 {
+        struct {
+                u8 delta_x_threshold:8;
+                u8 delta_y_threshold:8;
+        };
+        u8 regs[2];
+};
+
+union rmi_f11_2d_ctrl4 {
+        struct {
+                u8 velocity:8;
+        };
+        u8 reg;
+};
+
+union rmi_f11_2d_ctrl5 {
+        struct {
+                u8 acceleration:8;
+        };
+        u8 reg;
+};
+
+union rmi_f11_2d_ctrl6__7 {
+        struct {
+                u16 sensor_max_x_pos:12;
+        };
+        u8 regs[2];
+};
+
+union rmi_f11_2d_ctrl8__9 {
+        struct {
+                u16 sensor_max_y_pos:12;
+        };
+        u8 regs[2];
+};
+
+union rmi_f11_2d_ctrl10 {
+        struct {
+                u8 single_tap_int_enable:1;
+                u8 tap_n_hold_int_enable:1;
+                u8 double_tap_int_enable:1;
+                u8 early_tap_int_enable:1;
+                u8 flick_int_enable:1;
+                u8 press_int_enable:1;
+                u8 pinch_int_enable:1;
+        };
+        u8 reg;
+};
+
+union rmi_f11_2d_ctrl11 {
+        struct {
+                u8 palm_detect_int_enable:1;
+                u8 rotate_int_enable:1;
+                u8 touch_shape_int_enable:1;
+                u8 scroll_zone_int_enable:1;
+                u8 multi_finger_scroll_int_enable:1;
+        };
+        u8 reg;
+};
+
+union rmi_f11_2d_ctrl12 {
+        struct {
+                u8 sensor_map:7;
+                u8 xy_sel:1;
+        };
+        u8 reg;
+};
+
+union rmi_f11_2d_ctrl14 {
+        struct {
+                u8 sens_adjustment:5;
+                u8 hyst_adjustment:3;
+        };
+        u8 reg;
+};
+
+/* The configuation is controlled as per register which means that if a register
+ * is allocated for ctrl configuration one must make sure that all the bits are
+ * set accordingly for that particular register.
+ */
+struct  rmi_f11_2d_ctrl {
+        union rmi_f11_2d_ctrl0          *ctrl0;
+        union rmi_f11_2d_ctrl1          *ctrl1;
+        union rmi_f11_2d_ctrl2__3       *ctrl2__3;
+        union rmi_f11_2d_ctrl4          *ctrl4;
+        union rmi_f11_2d_ctrl5          *ctrl5;
+        union rmi_f11_2d_ctrl6__7       *ctrl6__7;
+        union rmi_f11_2d_ctrl8__9       *ctrl8__9;
+        union rmi_f11_2d_ctrl10         *ctrl10;
+        union rmi_f11_2d_ctrl11         *ctrl11;
+        union rmi_f11_2d_ctrl12         *ctrl12;
+        u8                              ctrl12_size;
+        union rmi_f11_2d_ctrl14         *ctrl14;
+        u8                              *ctrl15;
+        u8                              *ctrl16;
+        u8                              *ctrl17;
+        u8                              *ctrl18;
+        u8                              *ctrl19;
+};
+
+struct rmi_f19_button_map {
+        unsigned char nbuttons;
+        unsigned char *map;
+};
+
+struct rmi_device_platform_data_spi {
+        int block_delay_us;
+        int split_read_block_delay_us;
+        int read_delay_us;
+        int write_delay_us;
+        int split_read_byte_delay_us;
+        int pre_delay_us;
+        int post_delay_us;
+
+        void *cs_assert_data;
+        int (*cs_assert) (const void *cs_assert_data, const bool assert);
+};
+
+struct rmi_device_platform_data {
+        char *driver_name;
+
+        int irq;
+        enum rmi_irq_polarity irq_polarity;
+        int (*gpio_config)(void *gpio_data, bool configure);
+
+        struct rmi_device_platform_data_spi spi_data;
+
+        /* function handler pdata */
+        struct rmi_f11_2d_ctrl *f11_ctrl;
+        struct rmi_f11_2d_axis_alignment axis_align;
+        struct rmi_f19_button_map *button_map;
+
+#ifdef  CONFIG_PM
+        void *pm_data;
+        int (*pre_suspend) (const void *pm_data);
+        int (*post_resume) (const void *pm_data);
+#endif
+};
+
+/**
+ * struct rmi_function_descriptor - RMI function base addresses
+ * @query_base_addr: The RMI Query base address
+ * @command_base_addr: The RMI Command base address
+ * @control_base_addr: The RMI Control base address
+ * @data_base_addr: The RMI Data base address
+ * @interrupt_source_count: The number of irqs this RMI function needs
+ * @function_number: The RMI function number
+ *
+ * This struct is used when iterating the Page Description Table. The addresses
+ * are 16-bit values to include the current page address.
+ *
+ */
+struct rmi_function_descriptor {
+        u16 query_base_addr;
+        u16 command_base_addr;
+        u16 control_base_addr;
+        u16 data_base_addr;
+        u8 interrupt_source_count;
+        u8 function_number;
+        u8 function_version;
+};
+
+struct rmi_function_container;
+struct rmi_device;
+
+/**
+ * struct rmi_function_handler - an RMI function handler
+ * @func: The RMI function number
+ * @init: Callback for RMI function init
+ * @attention: Callback for RMI function attention
+ * @suspend: Callback for function suspend, returns 0 for success.
+ * @resume: Callback for RMI function resume, returns 0 for success.
+ * @remove: Callback for RMI function removal
+ *
+ * This struct describes the interface of an RMI function. These are
+ * registered to the bus using the rmi_register_function_driver() call.
+ *
+ */
+struct rmi_function_handler {
+        int func;
+        int (*init)(struct rmi_function_container *fc);
+        int (*attention)(struct rmi_function_container *fc, u8 *irq_bits);
+#ifdef CONFIG_PM
+        int (*suspend)(struct rmi_function_container *fc);
+        int (*resume)(struct rmi_function_container *fc);
+#endif
+        void (*remove)(struct rmi_function_container *fc);
+};
+
+/**
+ * struct rmi_function_device - represent an RMI function device
+ * @dev: The device created
+ *
+ * The RMI function device implements the "psuedo" device that represents
+ * an RMI4 function like function 0x11, function 0x34, etc. and is really
+ * a placeholder to be able to create sysfs attributes for each function
+ * in order to facilitate communication between user code and RMI4 functions.
+ *
+ */
+struct rmi_function_device {
+        struct device dev;
+};
+
+/**
+ * struct rmi_function_container - an element in a function handler list
+ * @list: The list
+ * @fd: The function descriptor of the RMI function
+ * @rmi_dev: Pointer to the RMI device associated with this function container
+ * @fh: The callbacks connected to this function
+ * @num_of_irqs: The number of irqs needed by this function
+ * @irq_pos: The position in the irq bitfield this function holds
+ * @data: Private data pointer
+ *
+ */
+struct rmi_function_container {
+        struct list_head list;
+
+        struct rmi_function_descriptor fd;
+        struct rmi_device *rmi_dev;
+        struct rmi_function_handler *fh;
+        struct device dev;
+
+        int num_of_irqs;
+        int irq_pos;
+        u8 *irq_mask;
+
+        void *data;
+};
+#define to_rmi_function_container(d) \
+                container_of(d, struct rmi_function_container, dev);
+#define to_rmi_function_device(d) \
+                container_of(d, struct rmi_function_device, dev);
+
+
+#ifdef CONFIG_RMI4_DEV
+
+#define RMI_CHAR_DEV_TMPBUF_SZ 128
+#define RMI_REG_ADDR_PAGE_SELECT 0xFF
+
+struct rmi_char_dev {
+        /* mutex for file operation*/
+        struct mutex mutex_file_op;
+        /* main char dev structure */
+        struct cdev main_dev;
+
+        /* register address for RMI protocol */
+        /* filp->f_pos */
+
+        /* pointer to the corresponding phys device info for this sensor */
+        /* The phys device has the pointers to read, write, etc. */
+        struct rmi_phys_device *phys;
+        /* reference count */
+        int ref_count;
+};
+
+int rmi_char_dev_register(struct rmi_phys_device *phys);
+void rmi_char_dev_unregister(struct rmi_phys_device *phys);
+
+#endif /*CONFIG_RMI4_DEV*/
+
+
+
+/**
+ * struct rmi_driver - represents an RMI driver
+ * @driver: Device driver model driver
+ * @probe: Callback for device probe
+ * @remove: Callback for device removal
+ * @shutdown: Callback for device shutdown
+ * @irq_handler: Callback for handling irqs
+ * @fh_add: Callback for function handler add
+ * @fh_remove: Callback for function handler remove
+ * @get_func_irq_mask: Callback for calculating interrupt mask
+ * @store_irq_mask: Callback for storing and replacing interrupt mask
+ * @restore_irq_mask: Callback for restoring previously stored interrupt mask
+ * @data: Private data pointer
+ *
+ * The RMI driver implements a driver on the RMI bus.
+ *
+ */
+struct rmi_driver {
+        struct device_driver driver;
+
+        int (*probe)(struct rmi_device *rmi_dev);
+        int (*remove)(struct rmi_device *rmi_dev);
+        void (*shutdown)(struct rmi_device *rmi_dev);
+        int (*irq_handler)(struct rmi_device *rmi_dev, int irq);
+        void (*fh_add)(struct rmi_device *rmi_dev,
+                       struct rmi_function_handler *fh);
+        void (*fh_remove)(struct rmi_device *rmi_dev,
+                          struct rmi_function_handler *fh);
+        u8* (*get_func_irq_mask)(struct rmi_device *rmi_dev,
+                            struct rmi_function_container *fc);
+        int (*store_irq_mask)(struct rmi_device *rmi_dev, u8* new_interupts);
+        int (*restore_irq_mask)(struct rmi_device *rmi_dev);
+        void *data;
+};
+#define to_rmi_driver(d) \
+        container_of(d, struct rmi_driver, driver);
+
+/** struct rmi_phys_info - diagnostic information about the RMI physical
+ * device, used in the phys sysfs file.
+ * @proto String indicating the protocol being used.
+ * @tx_count Number of transmit operations.
+ * @tx_bytes Number of bytes transmitted.
+ * @tx_errs  Number of errors encountered during transmit operations.
+ * @rx_count Number of receive operations.
+ * @rx_bytes Number of bytes received.
+ * @rx_errs  Number of errors encountered during receive operations.
+ * @att_count Number of times ATTN assertions have been handled.
+ */
+struct rmi_phys_info {
+        char *proto;
+        long tx_count;
+        long tx_bytes;
+        long tx_errs;
+        long rx_count;
+        long rx_bytes;
+        long rx_errs;
+        long attn_count;
+};
+
+/**
+ * struct rmi_phys_device - represent an RMI physical device
+ * @dev: Pointer to the communication device, e.g. i2c or spi
+ * @rmi_dev: Pointer to the RMI device
+ * @write: Callback for write
+ * @write_block: Callback for writing a block of data
+ * @read: Callback for read
+ * @read_block: Callback for reading a block of data
+ * @data: Private data pointer
+ *
+ * The RMI physical device implements the glue between different communication
+ * buses such as I2C and SPI.
+ *
+ */
+struct rmi_phys_device {
+        struct device *dev;
+        struct rmi_device *rmi_dev;
+
+        int (*write)(struct rmi_phys_device *phys, u16 addr, u8 data);
+        int (*write_block)(struct rmi_phys_device *phys, u16 addr, u8 *buf,
+                           int len);
+        int (*read)(struct rmi_phys_device *phys, u16 addr, u8 *buf);
+        int (*read_block)(struct rmi_phys_device *phys, u16 addr, u8 *buf,
+                          int len);
+
+        int (*enable_device) (struct rmi_phys_device *phys);
+        void (*disable_device) (struct rmi_phys_device *phys);
+
+        void *data;
+
+        struct rmi_phys_info info;
+
+#ifdef CONFIG_RMI4_DEV
+        /* pointer to attention char device and char device */
+        struct rmi_char_dev *char_dev;
+        struct class *rmi_char_device_class;
+#endif /*CONFIG_RMI4_DEV*/
+};
+
+/**
+ * struct rmi_device - represents an RMI device
+ * @dev: The device created for the RMI bus
+ * @driver: Pointer to associated driver
+ * @phys: Pointer to the physical interface
+ * @early_suspend_handler: Pointers to early_suspend and late_resume, if
+ * configured.
+ *
+ * This structs represent an RMI device.
+ *
+ */
+struct rmi_device {
+        struct device dev;
+
+        struct rmi_driver *driver;
+        struct rmi_phys_device *phys;
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+        struct early_suspend early_suspend_handler;
+#endif
+};
+#define to_rmi_device(d) container_of(d, struct rmi_device, dev);
+#define to_rmi_platform_data(d) ((d)->phys->dev->platform_data);
+
+static inline void rmi_set_driverdata(struct rmi_device *d, void *data)
+{
+        dev_set_drvdata(&d->dev, data);
+}
+
+static inline void *rmi_get_driverdata(struct rmi_device *d)
+{
+        return dev_get_drvdata(&d->dev);
+}
+
+/**
+ * rmi_read - RMI read byte
+ * @d: Pointer to an RMI device
+ * @addr: The address to read from
+ * @buf: The read buffer
+ *
+ * Reads a byte of data using the underlaying physical protocol in to buf. It
+ * returns zero or a negative error code.
+ */
+static inline int rmi_read(struct rmi_device *d, u16 addr, u8 *buf)
+{
+        return d->phys->read(d->phys, addr, buf);
+}
+
+/**
+ * rmi_read_block - RMI read block
+ * @d: Pointer to an RMI device
+ * @addr: The start address to read from
+ * @buf: The read buffer
+ * @len: Length of the read buffer
+ *
+ * Reads a block of byte data using the underlaying physical protocol in to buf.
+ * It returns the amount of bytes read or a negative error code.
+ */
+static inline int rmi_read_block(struct rmi_device *d, u16 addr, u8 *buf,
+                                 int len)
+{
+        return d->phys->read_block(d->phys, addr, buf, len);
+}
+
+/**
+ * rmi_write - RMI write byte
+ * @d: Pointer to an RMI device
+ * @addr: The address to write to
+ * @data: The data to write
+ *
+ * Writes a byte from buf using the underlaying physical protocol. It
+ * returns zero or a negative error code.
+ */
+static inline int rmi_write(struct rmi_device *d, u16 addr, u8 data)
+{
+        return d->phys->write(d->phys, addr, data);
+}
+
+/**
+ * rmi_write_block - RMI write block
+ * @d: Pointer to an RMI device
+ * @addr: The start address to write to
+ * @buf: The write buffer
+ * @len: Length of the write buffer
+ *
+ * Writes a block of byte data from buf using the underlaying physical protocol.
+ * It returns the amount of bytes written or a negative error code.
+ */
+static inline int rmi_write_block(struct rmi_device *d, u16 addr, u8 *buf,
+                                  int len)
+{
+        return d->phys->write_block(d->phys, addr, buf, len);
+}
+
+/**
+ * rmi_register_driver - register rmi driver
+ * @driver: the driver to register
+ *
+ * This function registers an RMI driver to the RMI bus.
+ */
+int rmi_register_driver(struct rmi_driver *driver);
+
+/**
+ * rmi_unregister_driver - unregister rmi driver
+ * @driver: the driver to unregister
+ *
+ * This function unregisters an RMI driver to the RMI bus.
+ */
+void rmi_unregister_driver(struct rmi_driver *driver);
+
+/**
+ * rmi_register_phys_device - register a physical device connection
+ * @phys: the physical driver to register
+ *
+ * This function registers a physical driver to the RMI bus. These drivers
+ * provide a communication layer for the drivers connected to the bus, e.g.
+ * I2C, SPI and so on.
+ */
+int rmi_register_phys_device(struct rmi_phys_device *phys);
+
+/**
+ * rmi_unregister_phys_device - unregister a physical device connection
+ * @phys: the physical driver to unregister
+ *
+ * This function unregisters a physical driver from the RMI bus.
+ */
+void rmi_unregister_phys_device(struct rmi_phys_device *phys);
+
+/**
+ * rmi_register_function_driver - register an RMI function driver
+ * @fh: the function handler to register
+ *
+ * This function registers support for a new RMI function to the bus. All
+ * drivers on the bus will be notified of the presence of the new function
+ * driver.
+ */
+int rmi_register_function_driver(struct rmi_function_handler *fh);
+
+/**
+ * rmi_unregister_function_driver - unregister an RMI function driver
+ * @fh: the function handler to unregister
+ *
+ * This function unregisters a RMI function from the RMI bus. All drivers on
+ * the bus will be notified of the removal of a function driver.
+ */
+void rmi_unregister_function_driver(struct rmi_function_handler *fh);
+
+/**
+ * rmi_get_function_handler - get a pointer to specified RMI function
+ * @id: the RMI function id
+ *
+ * This function gets the specified RMI function handler from the list of
+ * supported functions.
+ */
+struct rmi_function_handler *rmi_get_function_handler(int id);
+
+/* Utility routine to handle writes to read-only attributes.  Hopefully
+ * this will never happen, but if the user does something stupid, we
+ * don't want to accept it quietly.
+ */
+ssize_t rmi_store_error(struct device *dev,
+                        struct device_attribute *attr,
+                        const char *buf, size_t count);
+
+/* Utility routine to handle reads to write-only attributes.  Hopefully
+ * this will never happen, but if the user does something stupid, we
+ * don't want to accept it quietly.
+ */
+ssize_t rmi_show_error(struct device *dev,
+                       struct device_attribute *attr,
+                       char *buf);
+
+/* utility function for bit access of u8*'s */
+void u8_set_bit(u8 *target, int pos);
+void u8_clear_bit(u8 *target, int pos);
+bool u8_is_set(u8 *target, int pos);
+bool u8_is_any_set(u8 *target, int size);
+void u8_or(u8 *dest, u8* target1, u8* target2, int size);
+void u8_and(u8 *dest, u8* target1, u8* target2, int size);
+#endif
diff --git a/include/linux/rtc.h b/include/linux/rtc.h
index b27ebea2566..93f4d035076 100644
--- a/include/linux/rtc.h
+++ b/include/linux/rtc.h
@@ -97,6 +97,9 @@ struct rtc_pll_info {
 #define RTC_AF 0x20     /* Alarm interrupt */
 #define RTC_UF 0x10     /* Update interrupt for 1Hz RTC */
 
+
+#define RTC_MAX_FREQ    8192
+
 #ifdef __KERNEL__
 
 #include <linux/types.h>
diff --git a/include/linux/rtmutex.h b/include/linux/rtmutex.h
index 8d522ffeda3..de17134244f 100644
--- a/include/linux/rtmutex.h
+++ b/include/linux/rtmutex.h
@@ -66,7 +66,7 @@ struct hrtimer_sleeper;
 
 #define __RT_MUTEX_INITIALIZER(mutexname) \
         { .wait_lock = __RAW_SPIN_LOCK_UNLOCKED(mutexname.wait_lock) \
-        , .wait_list = PLIST_HEAD_INIT_RAW(mutexname.wait_list, mutexname.wait_lock) \
+        , .wait_list = PLIST_HEAD_INIT(mutexname.wait_list) \
         , .owner = NULL \
         __DEBUG_RT_MUTEX_INITIALIZER(mutexname)}
 
@@ -100,7 +100,7 @@ extern void rt_mutex_unlock(struct rt_mutex *lock);
 
 #ifdef CONFIG_RT_MUTEXES
 # define INIT_RT_MUTEXES(tsk)                                           \
-        .pi_waiters     = PLIST_HEAD_INIT(tsk.pi_waiters, tsk.pi_lock), \
+        .pi_waiters     = PLIST_HEAD_INIT(tsk.pi_waiters),      \
         INIT_RT_MUTEX_DEBUG(tsk)
 #else
 # define INIT_RT_MUTEXES(tsk)
diff --git a/include/linux/rtnetlink.h b/include/linux/rtnetlink.h
index bbad657a372..8e872ead88b 100644
--- a/include/linux/rtnetlink.h
+++ b/include/linux/rtnetlink.h
@@ -585,6 +585,8 @@ enum rtnetlink_groups {
 #define RTNLGRP_PHONET_IFADDR   RTNLGRP_PHONET_IFADDR
         RTNLGRP_PHONET_ROUTE,
 #define RTNLGRP_PHONET_ROUTE    RTNLGRP_PHONET_ROUTE
+        RTNLGRP_DCB,
+#define RTNLGRP_DCB             RTNLGRP_DCB
         __RTNLGRP_MAX
 };
 #define RTNLGRP_MAX     (__RTNLGRP_MAX - 1)
@@ -758,8 +760,7 @@ extern int lockdep_rtnl_is_held(void);
  * or RTNL. Note : Please prefer rtnl_dereference() or rcu_dereference()
  */
 #define rcu_dereference_rtnl(p)                                 \
-        rcu_dereference_check(p, rcu_read_lock_held() ||        \
-                                 lockdep_rtnl_is_held())
+        rcu_dereference_check(p, lockdep_rtnl_is_held())
 
 /**
  * rtnl_dereference - fetch RCU pointer when updates are prevented by RTNL
diff --git a/include/linux/rwsem.h b/include/linux/rwsem.h
index a8afe9cd000..6a6741440cb 100644
--- a/include/linux/rwsem.h
+++ b/include/linux/rwsem.h
@@ -15,7 +15,7 @@
 #include <linux/spinlock.h>
 
 #include <asm/system.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 struct rw_semaphore;
 
@@ -124,19 +124,9 @@ extern void downgrade_write(struct rw_semaphore *sem);
  */
 extern void down_read_nested(struct rw_semaphore *sem, int subclass);
 extern void down_write_nested(struct rw_semaphore *sem, int subclass);
-/*
- * Take/release a lock when not the owner will release it.
- *
- * [ This API should be avoided as much as possible - the
- *   proper abstraction for this case is completions. ]
- */
-extern void down_read_non_owner(struct rw_semaphore *sem);
-extern void up_read_non_owner(struct rw_semaphore *sem);
 #else
 # define down_read_nested(sem, subclass)                down_read(sem)
 # define down_write_nested(sem, subclass)       down_write(sem)
-# define down_read_non_owner(sem)               down_read(sem)
-# define up_read_non_owner(sem)                 up_read(sem)
 #endif
 
 #endif /* _LINUX_RWSEM_H */
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 2b094bdaafa..096834c7c63 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -1298,7 +1298,7 @@ struct task_struct {
         int exit_state;
         int exit_code, exit_signal;
         int pdeath_signal;  /*  The signal sent when the parent dies  */
-        unsigned int group_stop;        /* GROUP_STOP_*, siglock protected */
+        unsigned int jobctl;    /* JOBCTL_*, siglock protected */
         /* ??? */
         unsigned int personality;
         unsigned did_exec:1;
@@ -1518,7 +1518,6 @@ struct task_struct {
         short il_next;
         short pref_node_fork;
 #endif
-        atomic_t fs_excl;       /* holding fs exclusive resources */
         struct rcu_head rcu;
 
         /*
@@ -1769,6 +1768,9 @@ static inline void put_task_struct(struct task_struct *t)
 extern void task_times(struct task_struct *p, cputime_t *ut, cputime_t *st);
 extern void thread_group_times(struct task_struct *p, cputime_t *ut, cputime_t *st);
 
+extern int task_free_register(struct notifier_block *n);
+extern int task_free_unregister(struct notifier_block *n);
+
 /*
  * Per process flags
  */
@@ -1783,6 +1785,7 @@ extern void thread_group_times(struct task_struct *p, cputime_t *ut, cputime_t *
 #define PF_DUMPCORE     0x00000200      /* dumped core */
 #define PF_SIGNALED     0x00000400      /* killed by a signal */
 #define PF_MEMALLOC     0x00000800      /* Allocating memory */
+#define PF_NPROC_EXCEEDED 0x00001000    /* set_user noticed that RLIMIT_NPROC was exceeded */
 #define PF_USED_MATH    0x00002000      /* if unset the fpu must be initialized before use */
 #define PF_FREEZING     0x00004000      /* freeze in progress. do not account to load */
 #define PF_NOFREEZE     0x00008000      /* this thread should not be frozen */
@@ -1828,15 +1831,34 @@ extern void thread_group_times(struct task_struct *p, cputime_t *ut, cputime_t *
 #define used_math() tsk_used_math(current)
 
 /*
- * task->group_stop flags
+ * task->jobctl flags
  */
-#define GROUP_STOP_SIGMASK      0xffff    /* signr of the last group stop */
-#define GROUP_STOP_PENDING      (1 << 16) /* task should stop for group stop */
-#define GROUP_STOP_CONSUME      (1 << 17) /* consume group stop count */
-#define GROUP_STOP_TRAPPING     (1 << 18) /* switching from STOPPED to TRACED */
-#define GROUP_STOP_DEQUEUED     (1 << 19) /* stop signal dequeued */
-
-extern void task_clear_group_stop_pending(struct task_struct *task);
+#define JOBCTL_STOP_SIGMASK     0xffff  /* signr of the last group stop */
+
+#define JOBCTL_STOP_DEQUEUED_BIT 16     /* stop signal dequeued */
+#define JOBCTL_STOP_PENDING_BIT 17      /* task should stop for group stop */
+#define JOBCTL_STOP_CONSUME_BIT 18      /* consume group stop count */
+#define JOBCTL_TRAP_STOP_BIT    19      /* trap for STOP */
+#define JOBCTL_TRAP_NOTIFY_BIT  20      /* trap for NOTIFY */
+#define JOBCTL_TRAPPING_BIT     21      /* switching to TRACED */
+#define JOBCTL_LISTENING_BIT    22      /* ptracer is listening for events */
+
+#define JOBCTL_STOP_DEQUEUED    (1 << JOBCTL_STOP_DEQUEUED_BIT)
+#define JOBCTL_STOP_PENDING     (1 << JOBCTL_STOP_PENDING_BIT)
+#define JOBCTL_STOP_CONSUME     (1 << JOBCTL_STOP_CONSUME_BIT)
+#define JOBCTL_TRAP_STOP        (1 << JOBCTL_TRAP_STOP_BIT)
+#define JOBCTL_TRAP_NOTIFY      (1 << JOBCTL_TRAP_NOTIFY_BIT)
+#define JOBCTL_TRAPPING         (1 << JOBCTL_TRAPPING_BIT)
+#define JOBCTL_LISTENING        (1 << JOBCTL_LISTENING_BIT)
+
+#define JOBCTL_TRAP_MASK        (JOBCTL_TRAP_STOP | JOBCTL_TRAP_NOTIFY)
+#define JOBCTL_PENDING_MASK     (JOBCTL_STOP_PENDING | JOBCTL_TRAP_MASK)
+
+extern bool task_set_jobctl_pending(struct task_struct *task,
+                                    unsigned int mask);
+extern void task_clear_jobctl_trapping(struct task_struct *task);
+extern void task_clear_jobctl_pending(struct task_struct *task,
+                                      unsigned int mask);
 
 #ifdef CONFIG_PREEMPT_RCU
 
@@ -1952,7 +1974,6 @@ static inline void disable_sched_clock_irqtime(void) {}
 
 extern unsigned long long
 task_sched_runtime(struct task_struct *task);
-extern unsigned long long thread_group_sched_runtime(struct task_struct *task);
 
 /* sched_exec is called by processes performing an exec */
 #ifdef CONFIG_SMP
@@ -2166,7 +2187,7 @@ extern int kill_pid_info_as_uid(int, struct siginfo *, struct pid *, uid_t, uid_
 extern int kill_pgrp(struct pid *pid, int sig, int priv);
 extern int kill_pid(struct pid *pid, int sig, int priv);
 extern int kill_proc_info(int, struct siginfo *, pid_t);
-extern int do_notify_parent(struct task_struct *, int);
+extern __must_check bool do_notify_parent(struct task_struct *, int);
 extern void __wake_up_parent(struct task_struct *p, struct task_struct *parent);
 extern void force_sig(int, struct task_struct *);
 extern int send_sig(int, struct task_struct *, int);
@@ -2290,8 +2311,10 @@ static inline int get_nr_threads(struct task_struct *tsk)
         return tsk->signal->nr_threads;
 }
 
-/* de_thread depends on thread_group_leader not being a pid based check */
-#define thread_group_leader(p)  (p == p->group_leader)
+static inline bool thread_group_leader(struct task_struct *p)
+{
+        return p->exit_signal >= 0;
+}
 
 /* Do to the insanities of de_thread it is possible for a process
  * to have the pid of the thread group leader without actually being
@@ -2324,11 +2347,6 @@ static inline int thread_group_empty(struct task_struct *p)
 #define delay_group_leader(p) \
                 (thread_group_leader(p) && !thread_group_empty(p))
 
-static inline int task_detached(struct task_struct *p)
-{
-        return p->exit_signal == -1;
-}
-
 /*
  * Protects ->fs, ->files, ->mm, ->group_info, ->comm, keyring
  * subscriptions and synchronises with wait4().  Also used in procfs.  Also
@@ -2526,7 +2544,7 @@ extern int _cond_resched(void);
 
 extern int __cond_resched_lock(spinlock_t *lock);
 
-#ifdef CONFIG_PREEMPT
+#ifdef CONFIG_PREEMPT_COUNT
 #define PREEMPT_LOCK_OFFSET     PREEMPT_OFFSET
 #else
 #define PREEMPT_LOCK_OFFSET     0
diff --git a/include/linux/seccomp.h b/include/linux/seccomp.h
index 167c33361d9..cc7a4e9cc7a 100644
--- a/include/linux/seccomp.h
+++ b/include/linux/seccomp.h
@@ -19,6 +19,11 @@ static inline void secure_computing(int this_syscall)
 extern long prctl_get_seccomp(void);
 extern long prctl_set_seccomp(unsigned long);
 
+static inline int seccomp_mode(seccomp_t *s)
+{
+        return s->mode;
+}
+
 #else /* CONFIG_SECCOMP */
 
 #include <linux/errno.h>
@@ -37,6 +42,11 @@ static inline long prctl_set_seccomp(unsigned long arg2)
         return -EINVAL;
 }
 
+static inline int seccomp_mode(seccomp_t *s)
+{
+        return 0;
+}
+
 #endif /* CONFIG_SECCOMP */
 
 #endif /* _LINUX_SECCOMP_H */
diff --git a/include/linux/security.h b/include/linux/security.h
index 8ce59ef3e5a..ebd2a53a3d0 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -1456,7 +1456,7 @@ struct security_operations {
                              struct inode *new_dir, struct dentry *new_dentry);
         int (*inode_readlink) (struct dentry *dentry);
         int (*inode_follow_link) (struct dentry *dentry, struct nameidata *nd);
-        int (*inode_permission) (struct inode *inode, int mask, unsigned flags);
+        int (*inode_permission) (struct inode *inode, int mask);
         int (*inode_setattr)    (struct dentry *dentry, struct iattr *attr);
         int (*inode_getattr) (struct vfsmount *mnt, struct dentry *dentry);
         int (*inode_setxattr) (struct dentry *dentry, const char *name,
@@ -1720,7 +1720,6 @@ int security_inode_rename(struct inode *old_dir, struct dentry *old_dentry,
 int security_inode_readlink(struct dentry *dentry);
 int security_inode_follow_link(struct dentry *dentry, struct nameidata *nd);
 int security_inode_permission(struct inode *inode, int mask);
-int security_inode_exec_permission(struct inode *inode, unsigned int flags);
 int security_inode_setattr(struct dentry *dentry, struct iattr *attr);
 int security_inode_getattr(struct vfsmount *mnt, struct dentry *dentry);
 int security_inode_setxattr(struct dentry *dentry, const char *name,
@@ -2113,12 +2112,6 @@ static inline int security_inode_permission(struct inode *inode, int mask)
         return 0;
 }
 
-static inline int security_inode_exec_permission(struct inode *inode,
-                                                  unsigned int flags)
-{
-        return 0;
-}
-
 static inline int security_inode_setattr(struct dentry *dentry,
                                           struct iattr *attr)
 {
diff --git a/include/linux/sem.h b/include/linux/sem.h
index f2961afa2f6..1feb2de2ee5 100644
--- a/include/linux/sem.h
+++ b/include/linux/sem.h
@@ -77,7 +77,7 @@ struct  seminfo {
 #define SEMUSZ  20              /* sizeof struct sem_undo */
 
 #ifdef __KERNEL__
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <linux/rcupdate.h>
 #include <linux/cache.h>
 
diff --git a/include/linux/seq_file.h b/include/linux/seq_file.h
index 03c0232b416..be720cd2038 100644
--- a/include/linux/seq_file.h
+++ b/include/linux/seq_file.h
@@ -23,6 +23,7 @@ struct seq_file {
         u64 version;
         struct mutex lock;
         const struct seq_operations *op;
+        int poll_event;
         void *private;
 };
 
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index a5c31146a33..0d239897b2f 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -245,6 +245,7 @@ struct uart_ops {
         void            (*pm)(struct uart_port *, unsigned int state,
                               unsigned int oldstate);
         int             (*set_wake)(struct uart_port *, unsigned int state);
+        void            (*wake_peer)(struct uart_port *);
 
         /*
          * Return a string describing the type of the port
diff --git a/include/linux/serial_reg.h b/include/linux/serial_reg.h
index c75bda37c18..543e361b15c 100644
--- a/include/linux/serial_reg.h
+++ b/include/linux/serial_reg.h
@@ -2,10 +2,10 @@
  * include/linux/serial_reg.h
  *
  * Copyright (C) 1992, 1994 by Theodore Ts'o.
- * 
- * Redistribution of this file is permitted under the terms of the GNU 
+ *
+ * Redistribution of this file is permitted under the terms of the GNU
  * Public License (GPL)
- * 
+ *
  * These are the UART port assignments, expressed as offsets from the base
  * register.  These assignments should hold for any serial port based on
  * a 8250, 16450, or 16550(A).
@@ -86,7 +86,7 @@
 
 #define UART_LCR        3       /* Out: Line Control Register */
 /*
- * Note: if the word length is 5 bits (UART_LCR_WLEN5), then setting 
+ * Note: if the word length is 5 bits (UART_LCR_WLEN5), then setting
  * UART_LCR_STOP will select 1.5 stop bits, not 2 stop bits.
  */
 #define UART_LCR_DLAB           0x80 /* Divisor latch access bit */
@@ -110,8 +110,10 @@
 #define UART_MCR        4       /* Out: Modem Control Register */
 #define UART_MCR_CLKSEL         0x80 /* Divide clock by 4 (TI16C752, EFR[4]=1) */
 #define UART_MCR_TCRTLR         0x40 /* Access TCR/TLR (TI16C752, EFR[4]=1) */
+#define UART_MCR_HW_RTS         0x40 /* Enable hw control of RTS (Tegra UART) */
 #define UART_MCR_XONANY         0x20 /* Enable Xon Any (TI16C752, EFR[4]=1) */
 #define UART_MCR_AFE            0x20 /* Enable auto-RTS/CTS (TI16C550C/TI16C750) */
+#define UART_MCR_HW_CTS         0x20 /* Enable HW based CTS control (Tegra UART)*/
 #define UART_MCR_LOOP           0x10 /* Enable loopback test mode */
 #define UART_MCR_OUT2           0x08 /* Out2 complement */
 #define UART_MCR_OUT1           0x04 /* Out1 complement */
diff --git a/include/linux/serial_sci.h b/include/linux/serial_sci.h
index a2afc9fbe18..8bffe9ae2ca 100644
--- a/include/linux/serial_sci.h
+++ b/include/linux/serial_sci.h
@@ -8,6 +8,8 @@
  * Generic header for SuperH SCI(F) (used by sh/sh64/h8300 and related parts)
  */
 
+#define SCIx_NOT_SUPPORTED      (-1)
+
 enum {
         SCBRR_ALGO_1,           /* ((clk + 16 * bps) / (16 * bps) - 1) */
         SCBRR_ALGO_2,           /* ((clk + 16 * bps) / (32 * bps) - 1) */
@@ -25,6 +27,28 @@ enum {
 #define SCSCR_CKE1      (1 << 1)
 #define SCSCR_CKE0      (1 << 0)
 
+/* SCxSR SCI */
+#define SCI_TDRE  0x80
+#define SCI_RDRF  0x40
+#define SCI_ORER  0x20
+#define SCI_FER   0x10
+#define SCI_PER   0x08
+#define SCI_TEND  0x04
+
+#define SCI_DEFAULT_ERROR_MASK (SCI_PER | SCI_FER)
+
+/* SCxSR SCIF */
+#define SCIF_ER    0x0080
+#define SCIF_TEND  0x0040
+#define SCIF_TDFE  0x0020
+#define SCIF_BRK   0x0010
+#define SCIF_FER   0x0008
+#define SCIF_PER   0x0004
+#define SCIF_RDF   0x0002
+#define SCIF_DR    0x0001
+
+#define SCIF_DEFAULT_ERROR_MASK (SCIF_PER | SCIF_FER | SCIF_ER | SCIF_BRK)
+
 /* Offsets into the sci_port->irqs array */
 enum {
         SCIx_ERI_IRQ,
@@ -32,6 +56,24 @@ enum {
         SCIx_TXI_IRQ,
         SCIx_BRI_IRQ,
         SCIx_NR_IRQS,
+
+        SCIx_MUX_IRQ = SCIx_NR_IRQS,    /* special case */
+};
+
+enum {
+        SCIx_PROBE_REGTYPE,
+
+        SCIx_SCI_REGTYPE,
+        SCIx_IRDA_REGTYPE,
+        SCIx_SCIFA_REGTYPE,
+        SCIx_SCIFB_REGTYPE,
+        SCIx_SH3_SCIF_REGTYPE,
+        SCIx_SH4_SCIF_REGTYPE,
+        SCIx_SH4_SCIF_NO_SCSPTR_REGTYPE,
+        SCIx_SH4_SCIF_FIFODATA_REGTYPE,
+        SCIx_SH7705_SCIF_REGTYPE,
+
+        SCIx_NR_REGTYPES,
 };
 
 #define SCIx_IRQ_MUXED(irq)             \
@@ -42,8 +84,29 @@ enum {
         [SCIx_BRI_IRQ]  = (irq),        \
 }
 
+#define SCIx_IRQ_IS_MUXED(port)                 \
+        ((port)->cfg->irqs[SCIx_ERI_IRQ] ==     \
+         (port)->cfg->irqs[SCIx_RXI_IRQ]) ||    \
+        ((port)->cfg->irqs[SCIx_ERI_IRQ] &&     \
+         !(port)->cfg->irqs[SCIx_RXI_IRQ])
+/*
+ * SCI register subset common for all port types.
+ * Not all registers will exist on all parts.
+ */
+enum {
+        SCSMR, SCBRR, SCSCR, SCxSR,
+        SCFCR, SCFDR, SCxTDR, SCxRDR,
+        SCLSR, SCTFDR, SCRFDR, SCSPTR,
+
+        SCIx_NR_REGS,
+};
+
 struct device;
 
+struct plat_sci_port_ops {
+        void (*init_pins)(struct uart_port *, unsigned int cflag);
+};
+
 /*
  * Platform device specific platform_data struct
  */
@@ -56,6 +119,18 @@ struct plat_sci_port {
         unsigned int    scbrr_algo_id;          /* SCBRR calculation algo */
         unsigned int    scscr;                  /* SCSCR initialization */
 
+        /*
+         * Platform overrides if necessary, defaults otherwise.
+         */
+        int             overrun_bit;
+        unsigned int    error_mask;
+
+        int             port_reg;
+        unsigned char   regshift;
+        unsigned char   regtype;
+
+        struct plat_sci_port_ops        *ops;
+
         struct device   *dma_dev;
 
         unsigned int    dma_slave_tx;
diff --git a/include/linux/sh_clk.h b/include/linux/sh_clk.h
index 9a52f72527d..3ccf18648d0 100644
--- a/include/linux/sh_clk.h
+++ b/include/linux/sh_clk.h
@@ -147,4 +147,8 @@ int sh_clk_div4_reparent_register(struct clk *clks, int nr,
 int sh_clk_div6_register(struct clk *clks, int nr);
 int sh_clk_div6_reparent_register(struct clk *clks, int nr);
 
+#define CLKDEV_CON_ID(_id, _clk) { .con_id = _id, .clk = _clk }
+#define CLKDEV_DEV_ID(_id, _clk) { .dev_id = _id, .clk = _clk }
+#define CLKDEV_ICK_ID(_cid, _did, _clk) { .con_id = _cid, .dev_id = _did, .clk = _clk }
+
 #endif /* __SH_CLOCK_H */
diff --git a/include/linux/sh_dma.h b/include/linux/sh_dma.h
index b08cd4efa15..cb2dd118cc0 100644
--- a/include/linux/sh_dma.h
+++ b/include/linux/sh_dma.h
@@ -62,6 +62,12 @@ struct sh_dmae_pdata {
         const unsigned int *ts_shift;
         int ts_shift_num;
         u16 dmaor_init;
+        unsigned int chcr_offset;
+        u32 chcr_ie_bit;
+
+        unsigned int dmaor_is_32bit:1;
+        unsigned int needs_tend_set:1;
+        unsigned int no_dmars:1;
 };
 
 /* DMA register */
@@ -71,6 +77,8 @@ struct sh_dmae_pdata {
 #define CHCR    0x0C
 #define DMAOR   0x40
 
+#define TEND    0x18 /* USB-DMAC */
+
 /* DMAOR definitions */
 #define DMAOR_AE        0x00000004
 #define DMAOR_NMIF      0x00000002
diff --git a/include/linux/shm.h b/include/linux/shm.h
index eca6235a46c..92808b86703 100644
--- a/include/linux/shm.h
+++ b/include/linux/shm.h
@@ -95,6 +95,9 @@ struct shmid_kernel /* private to the kernel */
         pid_t                   shm_cprid;
         pid_t                   shm_lprid;
         struct user_struct      *mlock_user;
+
+        /* The task created the shm object.  NULL if the task is dead. */
+        struct task_struct      *shm_creator;
 };
 
 /* shm_mode upper byte flags */
@@ -106,6 +109,7 @@ struct shmid_kernel /* private to the kernel */
 #ifdef CONFIG_SYSVIPC
 long do_shmat(int shmid, char __user *shmaddr, int shmflg, unsigned long *addr);
 extern int is_file_shm_hugepages(struct file *file);
+extern void exit_shm(struct task_struct *task);
 #else
 static inline long do_shmat(int shmid, char __user *shmaddr,
                                 int shmflg, unsigned long *addr)
@@ -116,6 +120,9 @@ static inline int is_file_shm_hugepages(struct file *file)
 {
         return 0;
 }
+static inline void exit_shm(struct task_struct *task)
+{
+}
 #endif
 
 #endif /* __KERNEL__ */
diff --git a/include/linux/shmem_fs.h b/include/linux/shmem_fs.h
index aa08fa8fd79..9291ac3cc62 100644
--- a/include/linux/shmem_fs.h
+++ b/include/linux/shmem_fs.h
@@ -8,22 +8,15 @@
 
 /* inode in-kernel data */
 
-#define SHMEM_NR_DIRECT 16
-
-#define SHMEM_SYMLINK_INLINE_LEN (SHMEM_NR_DIRECT * sizeof(swp_entry_t))
-
 struct shmem_inode_info {
         spinlock_t              lock;
         unsigned long           flags;
         unsigned long           alloced;        /* data pages alloced to file */
-        unsigned long           swapped;        /* subtotal assigned to swap */
-        unsigned long           next_index;     /* highest alloced index + 1 */
-        struct shared_policy    policy;         /* NUMA memory alloc policy */
-        struct page             *i_indirect;    /* top indirect blocks page */
         union {
-                swp_entry_t     i_direct[SHMEM_NR_DIRECT]; /* first blocks */
-                char            inline_symlink[SHMEM_SYMLINK_INLINE_LEN];
+                unsigned long   swapped;        /* subtotal assigned to swap */
+                char            *symlink;       /* unswappable short symlink */
         };
+        struct shared_policy    policy;         /* NUMA memory alloc policy */
         struct list_head        swaplist;       /* chain of maybes on swap */
         struct list_head        xattr_list;     /* list of shmem_xattr */
         struct inode            vfs_inode;
@@ -49,7 +42,7 @@ static inline struct shmem_inode_info *SHMEM_I(struct inode *inode)
 /*
  * Functions in mm/shmem.c called directly from elsewhere:
  */
-extern int init_tmpfs(void);
+extern int shmem_init(void);
 extern int shmem_fill_super(struct super_block *sb, void *data, int silent);
 extern struct file *shmem_file_setup(const char *name,
                                         loff_t size, unsigned long flags);
@@ -59,8 +52,6 @@ extern struct page *shmem_read_mapping_page_gfp(struct address_space *mapping,
                                         pgoff_t index, gfp_t gfp_mask);
 extern void shmem_truncate_range(struct inode *inode, loff_t start, loff_t end);
 extern int shmem_unuse(swp_entry_t entry, struct page *page);
-extern void mem_cgroup_get_shmem_target(struct inode *inode, pgoff_t pgoff,
-                                        struct page **pagep, swp_entry_t *ent);
 
 static inline struct page *shmem_read_mapping_page(
                                 struct address_space *mapping, pgoff_t index)
diff --git a/include/linux/shrinker.h b/include/linux/shrinker.h
new file mode 100644
index 00000000000..a83833a1f7a
--- /dev/null
+++ b/include/linux/shrinker.h
@@ -0,0 +1,43 @@
+#ifndef _LINUX_SHRINKER_H
+#define _LINUX_SHRINKER_H
+
+/*
+ * This struct is used to pass information from page reclaim to the shrinkers.
+ * We consolidate the values for easier extention later.
+ */
+struct shrink_control {
+        gfp_t gfp_mask;
+
+        /* How many slab objects shrinker() should scan and try to reclaim */
+        unsigned long nr_to_scan;
+};
+
+/*
+ * A callback you can register to apply pressure to ageable caches.
+ *
+ * 'sc' is passed shrink_control which includes a count 'nr_to_scan'
+ * and a 'gfpmask'.  It should look through the least-recently-used
+ * 'nr_to_scan' entries and attempt to free them up.  It should return
+ * the number of objects which remain in the cache.  If it returns -1, it means
+ * it cannot do any scanning at this time (eg. there is a risk of deadlock).
+ * The callback must not return -1 if nr_to_scan is zero.
+ *
+ * The 'gfpmask' refers to the allocation we are currently trying to
+ * fulfil.
+ *
+ * Note that 'shrink' will be passed nr_to_scan == 0 when the VM is
+ * querying the cache size, so a fastpath for that case is appropriate.
+ */
+struct shrinker {
+        int (*shrink)(struct shrinker *, struct shrink_control *sc);
+        int seeks;      /* seeks to recreate an obj */
+        long batch;     /* reclaim batch size, 0 = default */
+
+        /* These are for internal use */
+        struct list_head list;
+        long nr;        /* objs pending delete */
+};
+#define DEFAULT_SEEKS 2 /* A good number if you don't know better. */
+extern void register_shrinker(struct shrinker *);
+extern void unregister_shrinker(struct shrinker *);
+#endif
diff --git a/include/linux/sigma.h b/include/linux/sigma.h
index e2accb3164d..d0de882c0d9 100644
--- a/include/linux/sigma.h
+++ b/include/linux/sigma.h
@@ -24,7 +24,7 @@ struct sigma_firmware {
 struct sigma_firmware_header {
         unsigned char magic[7];
         u8 version;
-        u32 crc;
+        __le32 crc;
 };
 
 enum {
@@ -40,19 +40,14 @@ enum {
 struct sigma_action {
         u8 instr;
         u8 len_hi;
-        u16 len;
-        u16 addr;
+        __le16 len;
+        __be16 addr;
         unsigned char payload[];
 };
 
 static inline u32 sigma_action_len(struct sigma_action *sa)
 {
-        return (sa->len_hi << 16) | sa->len;
-}
-
-static inline size_t sigma_action_size(struct sigma_action *sa, u32 payload_len)
-{
-        return sizeof(*sa) + payload_len + (payload_len % 2);
+        return (sa->len_hi << 16) | le16_to_cpu(sa->len);
 }
 
 extern int process_sigma_firmware(struct i2c_client *client, const char *name);
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index c0a4f3ab0cc..0f966460a34 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -20,7 +20,7 @@
 #include <linux/time.h>
 #include <linux/cache.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <asm/types.h>
 #include <linux/spinlock.h>
 #include <linux/net.h>
@@ -187,6 +187,20 @@ enum {
 
         /* ensure the originating sk reference is available on driver level */
         SKBTX_DRV_NEEDS_SK_REF = 1 << 3,
+
+        /* device driver supports TX zero-copy buffers */
+        SKBTX_DEV_ZEROCOPY = 1 << 4,
+};
+
+/*
+ * The callback notifies userspace to release buffers when skb DMA is done in
+ * lower device, the skb last reference should be 0 when calling this.
+ * The desc is used to track userspace buffer index.
+ */
+struct ubuf_info {
+        void (*callback)(void *);
+        void *arg;
+        unsigned long desc;
 };
 
 /* This data is invariant across clones and lives at
@@ -211,6 +225,7 @@ struct skb_shared_info {
         /* Intermediate layers must ensure that destructor_arg
          * remains valid until skb destructor */
         void *          destructor_arg;
+
         /* must be last field, see pskb_expand_head() */
         skb_frag_t      frags[MAX_SKB_FRAGS];
 };
@@ -270,15 +285,12 @@ typedef unsigned char *sk_buff_data_t;
  *      struct sk_buff - socket buffer
  *      @next: Next buffer in list
  *      @prev: Previous buffer in list
- *      @sk: Socket we are owned by
  *      @tstamp: Time we arrived
+ *      @sk: Socket we are owned by
  *      @dev: Device we arrived on/are leaving by
- *      @transport_header: Transport layer header
- *      @network_header: Network layer header
- *      @mac_header: Link layer header
+ *      @cb: Control buffer. Free for use by every layer. Put private vars here
  *      @_skb_refdst: destination entry (with norefcount bit)
  *      @sp: the security path, used for xfrm
- *      @cb: Control buffer. Free for use by every layer. Put private vars here
  *      @len: Length of actual data
  *      @data_len: Data length
  *      @mac_len: Length of link layer header
@@ -286,40 +298,45 @@ typedef unsigned char *sk_buff_data_t;
  *      @csum: Checksum (must include start/offset pair)
  *      @csum_start: Offset from skb->head where checksumming should start
  *      @csum_offset: Offset from csum_start where checksum should be stored
+ *      @priority: Packet queueing priority
  *      @local_df: allow local fragmentation
  *      @cloned: Head may be cloned (check refcnt to be sure)
+ *      @ip_summed: Driver fed us an IP checksum
  *      @nohdr: Payload reference only, must not modify header
+ *      @nfctinfo: Relationship of this skb to the connection
  *      @pkt_type: Packet class
  *      @fclone: skbuff clone status
- *      @ip_summed: Driver fed us an IP checksum
- *      @priority: Packet queueing priority
- *      @users: User count - see {datagram,tcp}.c
- *      @protocol: Packet protocol from driver
- *      @truesize: Buffer size 
- *      @head: Head of buffer
- *      @data: Data head pointer
- *      @tail: Tail pointer
- *      @end: End pointer
- *      @destructor: Destruct function
- *      @mark: Generic packet mark
- *      @nfct: Associated connection, if any
  *      @ipvs_property: skbuff is owned by ipvs
  *      @peeked: this packet has been seen already, so stats have been
  *              done for it, don't do them again
  *      @nf_trace: netfilter packet trace flag
- *      @nfctinfo: Relationship of this skb to the connection
+ *      @protocol: Packet protocol from driver
+ *      @destructor: Destruct function
+ *      @nfct: Associated connection, if any
  *      @nfct_reasm: netfilter conntrack re-assembly pointer
  *      @nf_bridge: Saved data about a bridged frame - see br_netfilter.c
  *      @skb_iif: ifindex of device we arrived on
- *      @rxhash: the packet hash computed on receive
- *      @queue_mapping: Queue mapping for multiqueue devices
  *      @tc_index: Traffic control index
  *      @tc_verd: traffic control verdict
+ *      @rxhash: the packet hash computed on receive
+ *      @queue_mapping: Queue mapping for multiqueue devices
  *      @ndisc_nodetype: router type (from link layer)
+ *      @ooo_okay: allow the mapping of a socket to a queue to be changed
  *      @dma_cookie: a cookie to one of several possible DMA operations
  *              done by skb DMA functions
  *      @secmark: security marking
+ *      @mark: Generic packet mark
+ *      @dropcount: total number of sk_receive_queue overflows
  *      @vlan_tci: vlan tag control information
+ *      @transport_header: Transport layer header
+ *      @network_header: Network layer header
+ *      @mac_header: Link layer header
+ *      @tail: Tail pointer
+ *      @end: End pointer
+ *      @head: Head of buffer
+ *      @data: Data head pointer
+ *      @truesize: Buffer size
+ *      @users: User count - see {datagram,tcp}.c
  */
 
 struct sk_buff {
@@ -507,6 +524,7 @@ static inline struct sk_buff *alloc_skb_fclone(unsigned int size,
 extern bool skb_recycle_check(struct sk_buff *skb, int skb_size);
 
 extern struct sk_buff *skb_morph(struct sk_buff *dst, struct sk_buff *src);
+extern int skb_copy_ubufs(struct sk_buff *skb, gfp_t gfp_mask);
 extern struct sk_buff *skb_clone(struct sk_buff *skb,
                                  gfp_t priority);
 extern struct sk_buff *skb_copy(const struct sk_buff *skb,
@@ -1562,16 +1580,22 @@ static inline struct sk_buff *netdev_alloc_skb(struct net_device *dev,
         return __netdev_alloc_skb(dev, length, GFP_ATOMIC);
 }
 
-static inline struct sk_buff *netdev_alloc_skb_ip_align(struct net_device *dev,
-                unsigned int length)
+static inline struct sk_buff *__netdev_alloc_skb_ip_align(struct net_device *dev,
+                unsigned int length, gfp_t gfp)
 {
-        struct sk_buff *skb = netdev_alloc_skb(dev, length + NET_IP_ALIGN);
+        struct sk_buff *skb = __netdev_alloc_skb(dev, length + NET_IP_ALIGN, gfp);
 
         if (NET_IP_ALIGN && skb)
                 skb_reserve(skb, NET_IP_ALIGN);
         return skb;
 }
 
+static inline struct sk_buff *netdev_alloc_skb_ip_align(struct net_device *dev,
+                unsigned int length)
+{
+        return __netdev_alloc_skb_ip_align(dev, length, GFP_ATOMIC);
+}
+
 /**
  *      __netdev_alloc_page - allocate a page for ps-rx on a specific device
  *      @dev: network device to receive on
@@ -1996,8 +2020,13 @@ static inline bool skb_defer_rx_timestamp(struct sk_buff *skb)
 /**
  * skb_complete_tx_timestamp() - deliver cloned skb with tx timestamps
  *
+ * PHY drivers may accept clones of transmitted packets for
+ * timestamping via their phy_driver.txtstamp method. These drivers
+ * must call this function to return the skb back to the stack, with
+ * or without a timestamp.
+ *
  * @skb: clone of the the original outgoing packet
- * @hwtstamps: hardware time stamps
+ * @hwtstamps: hardware time stamps, may be NULL if not available
  *
  */
 void skb_complete_tx_timestamp(struct sk_buff *skb,
@@ -2028,8 +2057,7 @@ static inline void sw_tx_timestamp(struct sk_buff *skb)
  * skb_tx_timestamp() - Driver hook for transmit timestamping
  *
  * Ethernet MAC Drivers should call this function in their hard_xmit()
- * function as soon as possible after giving the sk_buff to the MAC
- * hardware, but before freeing the sk_buff.
+ * function immediately before giving the sk_buff to the MAC hardware.
  *
  * @skb: A socket buffer.
  */
@@ -2266,5 +2294,6 @@ static inline void skb_checksum_none_assert(struct sk_buff *skb)
 }
 
 bool skb_partial_csum_set(struct sk_buff *skb, u16 start, u16 off);
+
 #endif  /* __KERNEL__ */
 #endif  /* _LINUX_SKBUFF_H */
diff --git a/include/linux/slab.h b/include/linux/slab.h
index ad4dd1c8d30..573c809c33d 100644
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@ -134,6 +134,26 @@ unsigned int kmem_cache_size(struct kmem_cache *);
 #define KMALLOC_MAX_ORDER       (KMALLOC_SHIFT_HIGH - PAGE_SHIFT)
 
 /*
+ * Some archs want to perform DMA into kmalloc caches and need a guaranteed
+ * alignment larger than the alignment of a 64-bit integer.
+ * Setting ARCH_KMALLOC_MINALIGN in arch headers allows that.
+ */
+#ifdef ARCH_DMA_MINALIGN
+#define ARCH_KMALLOC_MINALIGN ARCH_DMA_MINALIGN
+#else
+#define ARCH_KMALLOC_MINALIGN __alignof__(unsigned long long)
+#endif
+
+/*
+ * Setting ARCH_SLAB_MINALIGN in arch headers allows a different alignment.
+ * Intended for arches that get misalignment faults even for 64 bit integer
+ * aligned buffers.
+ */
+#ifndef ARCH_SLAB_MINALIGN
+#define ARCH_SLAB_MINALIGN __alignof__(unsigned long long)
+#endif
+
+/*
  * Common kmalloc functions provided by all allocators
  */
 void * __must_check __krealloc(const void *, size_t, gfp_t);
diff --git a/include/linux/slab_def.h b/include/linux/slab_def.h
index 83203ae9390..d00e0bacda9 100644
--- a/include/linux/slab_def.h
+++ b/include/linux/slab_def.h
@@ -18,53 +18,25 @@
 #include <trace/events/kmem.h>
 
 /*
- * Enforce a minimum alignment for the kmalloc caches.
- * Usually, the kmalloc caches are cache_line_size() aligned, except when
- * DEBUG and FORCED_DEBUG are enabled, then they are BYTES_PER_WORD aligned.
- * Some archs want to perform DMA into kmalloc caches and need a guaranteed
- * alignment larger than the alignment of a 64-bit integer.
- * ARCH_KMALLOC_MINALIGN allows that.
- * Note that increasing this value may disable some debug features.
- */
-#ifdef ARCH_DMA_MINALIGN
-#define ARCH_KMALLOC_MINALIGN ARCH_DMA_MINALIGN
-#else
-#define ARCH_KMALLOC_MINALIGN __alignof__(unsigned long long)
-#endif
-
-#ifndef ARCH_SLAB_MINALIGN
-/*
- * Enforce a minimum alignment for all caches.
- * Intended for archs that get misalignment faults even for BYTES_PER_WORD
- * aligned buffers. Includes ARCH_KMALLOC_MINALIGN.
- * If possible: Do not enable this flag for CONFIG_DEBUG_SLAB, it disables
- * some debug features.
- */
-#define ARCH_SLAB_MINALIGN 0
-#endif
-
-/*
  * struct kmem_cache
  *
  * manages a cache.
  */
 
 struct kmem_cache {
-/* 1) per-cpu data, touched during every alloc/free */
-        struct array_cache *array[NR_CPUS];
-/* 2) Cache tunables. Protected by cache_chain_mutex */
+/* 1) Cache tunables. Protected by cache_chain_mutex */
         unsigned int batchcount;
         unsigned int limit;
         unsigned int shared;
 
         unsigned int buffer_size;
         u32 reciprocal_buffer_size;
-/* 3) touched by every alloc & free from the backend */
+/* 2) touched by every alloc & free from the backend */
 
         unsigned int flags;             /* constant flags */
         unsigned int num;               /* # of objs per slab */
 
-/* 4) cache_grow/shrink */
+/* 3) cache_grow/shrink */
         /* order of pgs per slab (2^n) */
         unsigned int gfporder;
 
@@ -80,11 +52,11 @@ struct kmem_cache {
         /* constructor func */
         void (*ctor)(void *obj);
 
-/* 5) cache creation/removal */
+/* 4) cache creation/removal */
         const char *name;
         struct list_head next;
 
-/* 6) statistics */
+/* 5) statistics */
 #ifdef CONFIG_DEBUG_SLAB
         unsigned long num_active;
         unsigned long num_allocations;
@@ -111,16 +83,18 @@ struct kmem_cache {
         int obj_size;
 #endif /* CONFIG_DEBUG_SLAB */
 
+/* 6) per-cpu/per-node data, touched during every alloc/free */
         /*
-         * We put nodelists[] at the end of kmem_cache, because we want to size
-         * this array to nr_node_ids slots instead of MAX_NUMNODES
+         * We put array[] at the end of kmem_cache, because we want to size
+         * this array to nr_cpu_ids slots instead of NR_CPUS
          * (see kmem_cache_init())
-         * We still use [MAX_NUMNODES] and not [1] or [0] because cache_cache
-         * is statically defined, so we reserve the max number of nodes.
+         * We still use [NR_CPUS] and not [1] or [0] because cache_cache
+         * is statically defined, so we reserve the max number of cpus.
          */
-        struct kmem_list3 *nodelists[MAX_NUMNODES];
+        struct kmem_list3 **nodelists;
+        struct array_cache *array[NR_CPUS];
         /*
-         * Do not add fields after nodelists[]
+         * Do not add fields after array[]
          */
 };
 
diff --git a/include/linux/slob_def.h b/include/linux/slob_def.h
index 4382db09df4..0ec00b39d00 100644
--- a/include/linux/slob_def.h
+++ b/include/linux/slob_def.h
@@ -1,16 +1,6 @@
 #ifndef __LINUX_SLOB_DEF_H
 #define __LINUX_SLOB_DEF_H
 
-#ifdef ARCH_DMA_MINALIGN
-#define ARCH_KMALLOC_MINALIGN ARCH_DMA_MINALIGN
-#else
-#define ARCH_KMALLOC_MINALIGN __alignof__(unsigned long)
-#endif
-
-#ifndef ARCH_SLAB_MINALIGN
-#define ARCH_SLAB_MINALIGN __alignof__(unsigned long)
-#endif
-
 void *kmem_cache_alloc_node(struct kmem_cache *, gfp_t flags, int node);
 
 static __always_inline void *kmem_cache_alloc(struct kmem_cache *cachep,
diff --git a/include/linux/slub_def.h b/include/linux/slub_def.h
index c8668d161dd..f58d6413d23 100644
--- a/include/linux/slub_def.h
+++ b/include/linux/slub_def.h
@@ -24,6 +24,7 @@ enum stat_item {
         ALLOC_FROM_PARTIAL,     /* Cpu slab acquired from partial list */
         ALLOC_SLAB,             /* Cpu slab acquired from page allocator */
         ALLOC_REFILL,           /* Refill cpu slab from slab freelist */
+        ALLOC_NODE_MISMATCH,    /* Switching cpu slab */
         FREE_SLAB,              /* Slab freed to the page allocator */
         CPUSLAB_FLUSH,          /* Abandoning of the cpu slab */
         DEACTIVATE_FULL,        /* Cpu slab was full when deactivated */
@@ -31,8 +32,10 @@ enum stat_item {
         DEACTIVATE_TO_HEAD,     /* Cpu slab was moved to the head of partials */
         DEACTIVATE_TO_TAIL,     /* Cpu slab was moved to the tail of partials */
         DEACTIVATE_REMOTE_FREES,/* Slab contained remotely freed objects */
+        DEACTIVATE_BYPASS,      /* Implicit deactivation */
         ORDER_FALLBACK,         /* Number of times fallback was necessary */
         CMPXCHG_DOUBLE_CPU_FAIL,/* Failure of this_cpu_cmpxchg_double */
+        CMPXCHG_DOUBLE_FAIL,    /* Number of times that cmpxchg double did not match */
         NR_SLUB_STAT_ITEMS };
 
 struct kmem_cache_cpu {
@@ -113,16 +116,6 @@ struct kmem_cache {
 
 #define KMALLOC_SHIFT_LOW ilog2(KMALLOC_MIN_SIZE)
 
-#ifdef ARCH_DMA_MINALIGN
-#define ARCH_KMALLOC_MINALIGN ARCH_DMA_MINALIGN
-#else
-#define ARCH_KMALLOC_MINALIGN __alignof__(unsigned long long)
-#endif
-
-#ifndef ARCH_SLAB_MINALIGN
-#define ARCH_SLAB_MINALIGN __alignof__(unsigned long long)
-#endif
-
 /*
  * Maximum kmalloc object size handled by SLUB. Larger object allocations
  * are passed through to the page allocator. The page allocator "fastpath"
@@ -228,6 +221,19 @@ kmalloc_order(size_t size, gfp_t flags, unsigned int order)
         return ret;
 }
 
+/**
+ * Calling this on allocated memory will check that the memory
+ * is expected to be in use, and print warnings if not.
+ */
+#ifdef CONFIG_SLUB_DEBUG
+extern bool verify_mem_not_deleted(const void *x);
+#else
+static inline bool verify_mem_not_deleted(const void *x)
+{
+        return true;
+}
+#endif
+
 #ifdef CONFIG_TRACING
 extern void *
 kmem_cache_alloc_trace(struct kmem_cache *s, gfp_t gfpflags, size_t size);
diff --git a/include/linux/smb349-charger.h b/include/linux/smb349-charger.h
new file mode 100644
index 00000000000..116f036baf1
--- /dev/null
+++ b/include/linux/smb349-charger.h
@@ -0,0 +1,63 @@
+/*
+ * include/linux/smb349-charger.h
+ *
+ * Battery charger driver interface for Summit SMB349
+ *
+ * Copyright (C) 2012 NVIDIA Corporation
+ *
+ * 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;
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#ifndef __LINUX_SMB349_CHARGER_H
+#define __LINUX_SMB349_CHARGER_H
+
+#include <linux/regulator/machine.h>
+
+enum charging_states {
+        idle,
+        progress,
+        completed,
+        stopped,
+};
+
+enum charger_type {
+        AC,
+        USB,
+};
+
+typedef void (*charging_callback_t)(enum charging_states state,
+enum charger_type chrg_type, void *args);
+
+struct smb349_charger {
+        struct i2c_client       *client;
+        struct device   *dev;
+        void    *charger_cb_data;
+        enum charging_states state;
+        enum charger_type chrg_type;
+        charging_callback_t     charger_cb;
+};
+
+int smb349_battery_online(void);
+typedef void (*callback_t)(enum usb_otg_state to,
+                enum usb_otg_state from, void *args);
+/*
+ * Register callback function for the client.
+ * Used by fuel-gauge driver to get battery charging properties.
+ */
+extern int register_callback(charging_callback_t cb, void *args);
+extern int register_otg_callback(callback_t cb, void *args);
+extern int update_charger_status(void);
+
+#endif /*__LINUX_SMB349_CHARGER_H */
diff --git a/include/linux/snmp.h b/include/linux/snmp.h
index 12b2b18e50c..e16557a357e 100644
--- a/include/linux/snmp.h
+++ b/include/linux/snmp.h
@@ -231,6 +231,8 @@ enum
         LINUX_MIB_TCPDEFERACCEPTDROP,
         LINUX_MIB_IPRPFILTER, /* IP Reverse Path Filter (rp_filter) */
         LINUX_MIB_TCPTIMEWAITOVERFLOW,          /* TCPTimeWaitOverflow */
+        LINUX_MIB_TCPREQQFULLDOCOOKIES,         /* TCPReqQFullDoCookies */
+        LINUX_MIB_TCPREQQFULLDROP,              /* TCPReqQFullDrop */
         __LINUX_MIB_MAX
 };
 
diff --git a/include/linux/socket.h b/include/linux/socket.h
index 4ef98e422fd..d0e77f607a7 100644
--- a/include/linux/socket.h
+++ b/include/linux/socket.h
@@ -8,8 +8,10 @@
 #define _K_SS_ALIGNSIZE (__alignof__ (struct sockaddr *))
                                 /* Implementation specific desired alignment */
 
+typedef unsigned short __kernel_sa_family_t;
+
 struct __kernel_sockaddr_storage {
-        unsigned short  ss_family;              /* address family */
+        __kernel_sa_family_t    ss_family;              /* address family */
         /* Following field(s) are implementation specific */
         char            __data[_K_SS_MAXSIZE - sizeof(unsigned short)];
                                 /* space to achieve desired size, */
@@ -35,7 +37,7 @@ struct seq_file;
 extern void socket_seq_show(struct seq_file *seq);
 #endif
 
-typedef unsigned short  sa_family_t;
+typedef __kernel_sa_family_t    sa_family_t;
 
 /*
  *      1003.1g requires sa_family_t and that sa_data is char.
@@ -192,7 +194,8 @@ struct ucred {
 #define AF_IEEE802154   36      /* IEEE802154 sockets           */
 #define AF_CAIF         37      /* CAIF sockets                 */
 #define AF_ALG          38      /* Algorithm sockets            */
-#define AF_MAX          39      /* For now.. */
+#define AF_NFC          39      /* NFC sockets                  */
+#define AF_MAX          40      /* For now.. */
 
 /* Protocol families, same as address families. */
 #define PF_UNSPEC       AF_UNSPEC
@@ -234,6 +237,7 @@ struct ucred {
 #define PF_IEEE802154   AF_IEEE802154
 #define PF_CAIF         AF_CAIF
 #define PF_ALG          AF_ALG
+#define PF_NFC          AF_NFC
 #define PF_MAX          AF_MAX
 
 /* Maximum queue length specifiable by listen.  */
diff --git a/include/linux/sockios.h b/include/linux/sockios.h
index 7997a506ad4..f7ffe36db03 100644
--- a/include/linux/sockios.h
+++ b/include/linux/sockios.h
@@ -65,6 +65,7 @@
 #define SIOCDIFADDR     0x8936          /* delete PA address            */
 #define SIOCSIFHWBROADCAST      0x8937  /* set hardware broadcast addr  */
 #define SIOCGIFCOUNT    0x8938          /* get number of devices */
+#define SIOCKILLADDR    0x8939          /* kill sockets with this local addr */
 
 #define SIOCGIFBR       0x8940          /* Bridging support             */
 #define SIOCSIFBR       0x8941          /* Set bridging options         */
diff --git a/include/linux/sonet.h b/include/linux/sonet.h
index 67ad11fcf88..de8832dd272 100644
--- a/include/linux/sonet.h
+++ b/include/linux/sonet.h
@@ -58,7 +58,7 @@ struct sonet_stats {
 
 #ifdef __KERNEL__
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 struct k_sonet_stats {
 #define __HANDLE_ITEM(i) atomic_t i
diff --git a/include/linux/spi-tegra.h b/include/linux/spi-tegra.h
new file mode 100644
index 00000000000..38096500551
--- /dev/null
+++ b/include/linux/spi-tegra.h
@@ -0,0 +1,50 @@
+/*
+ * include/linux/spi-tegra.c
+ *
+ * Copyright (C) 2011 NVIDIA Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#ifndef _LINUX_SPI_TEGRA_H
+#define _LINUX_SPI_TEGRA_H
+
+#include <linux/clk.h>
+
+struct spi_clk_parent {
+        const char *name;
+        struct clk *parent_clk;
+        unsigned long fixed_clk_rate;
+};
+
+struct tegra_spi_platform_data {
+        bool is_dma_based;
+        int max_dma_buffer;
+        bool is_clkon_always;
+        unsigned int max_rate;
+        struct spi_clk_parent *parent_clk_list;
+        int  parent_clk_count;
+};
+
+/* Controller data from device to pass some info like
+ * hw based chip select can be used or not and if yes
+ * then CS hold and setup time. */
+struct tegra_spi_device_controller_data {
+        bool is_hw_based_cs;
+        int cs_setup_clk_count;
+        int cs_hold_clk_count;
+};
+
+#endif /* _LINUX_SPI_TEGRA_H */
diff --git a/include/linux/spi/74x164.h b/include/linux/spi/74x164.h
index d85c52f294a..0aa6acc7331 100644
--- a/include/linux/spi/74x164.h
+++ b/include/linux/spi/74x164.h
@@ -1,8 +1,6 @@
 #ifndef LINUX_SPI_74X164_H
 #define LINUX_SPI_74X164_H
 
-#define GEN_74X164_DRIVER_NAME "74x164"
-
 struct gen_74x164_chip_platform_data {
         /* number assigned to the first GPIO */
         unsigned        base;
diff --git a/include/linux/spi/mcp23s08.h b/include/linux/spi/mcp23s08.h
index c42cff8ca19..2d676d5aaa8 100644
--- a/include/linux/spi/mcp23s08.h
+++ b/include/linux/spi/mcp23s08.h
@@ -22,13 +22,4 @@ struct mcp23s08_platform_data {
          * base to base+15 (or base+31 for s17 variant).
          */
         unsigned        base;
-
-        void            *context;       /* param to setup/teardown */
-
-        int             (*setup)(struct spi_device *spi,
-                                        int gpio, unsigned ngpio,
-                                        void *context);
-        int             (*teardown)(struct spi_device *spi,
-                                        int gpio, unsigned ngpio,
-                                        void *context);
 };
diff --git a/include/linux/spi/rm31080a_ts.h b/include/linux/spi/rm31080a_ts.h
new file mode 100644
index 00000000000..13323a6f2ec
--- /dev/null
+++ b/include/linux/spi/rm31080a_ts.h
@@ -0,0 +1,44 @@
+#ifndef _RM31080A_TS_H_
+#define _RM31080A_TS_H_
+
+#define ENABLE_RAW_DATA_QUEUE
+
+#define RM_IOCTL_REPORT_POINT    0x1001
+#define RM_IOCTL_SET_HAL_PID     0x1002
+#define RM_IOCTL_INIT_START      0x1003
+#define RM_IOCTL_INIT_END        0x1004
+#define RM_IOCTL_FINISH_CALC     0x1005
+#define RM_IOCTL_SCRIBER_CTRL    0x1006
+#define RM_IOCTL_READ_RAW_DATA   0x1007
+#define RM_IOCTL_AUTOSCAN_CTRL   0x1008
+#define RM_IOCTL_NOISE_CHECK     0x1009
+#define RM_IOCTL_GET_PARAMETER   0x100A
+#define RM_IOCTL_SET_PARAMETER   0x100B
+
+#define RM_INPUT_RESOLUTION_X    4096
+#define RM_INPUT_RESOLUTION_Y    4096
+
+#define RM_TS_SIGNAL            44
+#define RM_TS_MAX_POINTS        16
+
+#define RM_SIGNAL_INTR          0x00000001
+#define RM_SIGNAL_SUSPEND       0x00000002
+#define RM_SIGNAL_RESUME        0x00000003
+
+typedef struct {
+        unsigned char ucTouchCount;
+        unsigned char ucID[RM_TS_MAX_POINTS];
+        unsigned short usX[RM_TS_MAX_POINTS];
+        unsigned short usY[RM_TS_MAX_POINTS];
+        unsigned short usZ[RM_TS_MAX_POINTS];
+} rm_touch_event;
+
+
+struct rm_spi_ts_platform_data{
+        int gpio_reset;
+        int x_size;
+        int y_size;
+        unsigned char* config;
+};
+
+#endif                          //_RM31080A_TS_H_
diff --git a/include/linux/spinlock.h b/include/linux/spinlock.h
index 0b22d51258e..7df6c17b028 100644
--- a/include/linux/spinlock.h
+++ b/include/linux/spinlock.h
@@ -384,7 +384,7 @@ static inline void assert_spin_locked(spinlock_t *lock)
  * Pull the atomic_t declaration:
  * (asm-mips/atomic.h needs above definitions)
  */
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 /**
  * atomic_dec_and_lock - lock on reaching reference count zero
  * @atomic: the atomic counter
diff --git a/include/linux/splice.h b/include/linux/splice.h
index 997c3b4c212..26e5b613ded 100644
--- a/include/linux/splice.h
+++ b/include/linux/splice.h
@@ -88,5 +88,7 @@ extern ssize_t splice_direct_to_actor(struct file *, struct splice_desc *,
 extern int splice_grow_spd(struct pipe_inode_info *, struct splice_pipe_desc *);
 extern void splice_shrink_spd(struct pipe_inode_info *,
                                 struct splice_pipe_desc *);
+extern void spd_release_page(struct splice_pipe_desc *, unsigned int);
 
+extern const struct pipe_buf_operations page_cache_pipe_buf_ops;
 #endif
diff --git a/include/linux/ssb/ssb.h b/include/linux/ssb/ssb.h
index 252e4482178..8623217f84d 100644
--- a/include/linux/ssb/ssb.h
+++ b/include/linux/ssb/ssb.h
@@ -27,6 +27,8 @@ struct ssb_sprom {
         u8 et1mdcport;          /* MDIO for enet1 */
         u8 board_rev;           /* Board revision number from SPROM. */
         u8 country_code;        /* Country Code */
+        u16 leddc_on_time;      /* LED Powersave Duty Cycle On Count */
+        u16 leddc_off_time;     /* LED Powersave Duty Cycle Off Count */
         u8 ant_available_a;     /* 2GHz antenna available bits (up to 4) */
         u8 ant_available_bg;    /* 5GHz antenna available bits (up to 4) */
         u16 pa0b0;
@@ -99,7 +101,7 @@ struct ssb_sprom {
 struct ssb_boardinfo {
         u16 vendor;
         u16 type;
-        u16 rev;
+        u8  rev;
 };
 
 
diff --git a/include/linux/ssb/ssb_driver_chipcommon.h b/include/linux/ssb/ssb_driver_chipcommon.h
index a08d693d832..1a6b0045b06 100644
--- a/include/linux/ssb/ssb_driver_chipcommon.h
+++ b/include/linux/ssb/ssb_driver_chipcommon.h
@@ -8,7 +8,7 @@
  * gpio interface, extbus, and support for serial and parallel flashes.
  *
  * Copyright 2005, Broadcom Corporation
- * Copyright 2006, Michael Buesch <mb@bu3sch.de>
+ * Copyright 2006, Michael Buesch <m@bues.ch>
  *
  * Licensed under the GPL version 2. See COPYING for details.
  */
diff --git a/include/linux/stacktrace.h b/include/linux/stacktrace.h
index 25310f1d7f3..115b570e3bf 100644
--- a/include/linux/stacktrace.h
+++ b/include/linux/stacktrace.h
@@ -14,8 +14,8 @@ struct stack_trace {
 };
 
 extern void save_stack_trace(struct stack_trace *trace);
-extern void save_stack_trace_regs(struct stack_trace *trace,
-                                  struct pt_regs *regs);
+extern void save_stack_trace_regs(struct pt_regs *regs,
+                                  struct stack_trace *trace);
 extern void save_stack_trace_tsk(struct task_struct *tsk,
                                 struct stack_trace *trace);
 
diff --git a/include/linux/stmmac.h b/include/linux/stmmac.h
index 9529e49b038..0dddc9e42b6 100644
--- a/include/linux/stmmac.h
+++ b/include/linux/stmmac.h
@@ -28,11 +28,21 @@
 
 #include <linux/platform_device.h>
 
-/* platform data for platform device structure's platform_data field */
+/* Platfrom data for platform device structure's platform_data field */
+
+struct stmmac_mdio_bus_data {
+        int bus_id;
+        int (*phy_reset)(void *priv);
+        unsigned int phy_mask;
+        int *irqs;
+        int probed_phy_irq;
+};
 
-/* Private data for the STM on-board ethernet driver */
 struct plat_stmmacenet_data {
         int bus_id;
+        int phy_addr;
+        int interface;
+        struct stmmac_mdio_bus_data *mdio_bus_data;
         int pbl;
         int clk_csr;
         int has_gmac;
@@ -40,6 +50,7 @@ struct plat_stmmacenet_data {
         int tx_coe;
         int bugged_jumbo;
         int pmt;
+        int force_sf_dma_mode;
         void (*fix_mac_speed)(void *priv, unsigned int speed);
         void (*bus_setup)(void __iomem *ioaddr);
         int (*init)(struct platform_device *pdev);
@@ -47,14 +58,4 @@ struct plat_stmmacenet_data {
         void *custom_cfg;
         void *bsp_priv;
 };
-
-struct plat_stmmacphy_data {
-        int bus_id;
-        int phy_addr;
-        unsigned int phy_mask;
-        int interface;
-        int (*phy_reset)(void *priv);
-        void *priv;
-};
 #endif
-
diff --git a/include/linux/stop_machine.h b/include/linux/stop_machine.h
index 092dc9b1ce7..2d04ea91676 100644
--- a/include/linux/stop_machine.h
+++ b/include/linux/stop_machine.h
@@ -94,7 +94,7 @@ static inline int try_stop_cpus(const struct cpumask *cpumask,
  * stop_machine "Bogolock": stop the entire machine, disable
  * interrupts.  This is a very heavy lock, which is equivalent to
  * grabbing every spinlock (and more).  So the "read" side to such a
- * lock is anything which disables preeempt.
+ * lock is anything which disables preemption.
  */
 #if defined(CONFIG_STOP_MACHINE) && defined(CONFIG_SMP)
 
@@ -124,15 +124,19 @@ int stop_machine(int (*fn)(void *), void *data, const struct cpumask *cpus);
  */
 int __stop_machine(int (*fn)(void *), void *data, const struct cpumask *cpus);
 
+int stop_machine_from_inactive_cpu(int (*fn)(void *), void *data,
+                                   const struct cpumask *cpus);
+
 #else    /* CONFIG_STOP_MACHINE && CONFIG_SMP */
 
 static inline int __stop_machine(int (*fn)(void *), void *data,
                                  const struct cpumask *cpus)
 {
+        unsigned long flags;
         int ret;
-        local_irq_disable();
+        local_irq_save(flags);
         ret = fn(data);
-        local_irq_enable();
+        local_irq_restore(flags);
         return ret;
 }
 
@@ -142,5 +146,11 @@ static inline int stop_machine(int (*fn)(void *), void *data,
         return __stop_machine(fn, data, cpus);
 }
 
+static inline int stop_machine_from_inactive_cpu(int (*fn)(void *), void *data,
+                                                 const struct cpumask *cpus)
+{
+        return __stop_machine(fn, data, cpus);
+}
+
 #endif  /* CONFIG_STOP_MACHINE && CONFIG_SMP */
 #endif  /* _LINUX_STOP_MACHINE */
diff --git a/include/linux/sunrpc/auth.h b/include/linux/sunrpc/auth.h
index 8521067ed4f..febc4dbec2c 100644
--- a/include/linux/sunrpc/auth.h
+++ b/include/linux/sunrpc/auth.h
@@ -15,7 +15,7 @@
 #include <linux/sunrpc/msg_prot.h>
 #include <linux/sunrpc/xdr.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <linux/rcupdate.h>
 
 /* size of the nodename buffer */
diff --git a/include/linux/sunrpc/bc_xprt.h b/include/linux/sunrpc/bc_xprt.h
index 082884295f8..f7f3ce340c0 100644
--- a/include/linux/sunrpc/bc_xprt.h
+++ b/include/linux/sunrpc/bc_xprt.h
@@ -31,7 +31,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <linux/sunrpc/xprt.h>
 #include <linux/sunrpc/sched.h>
 
-#ifdef CONFIG_NFS_V4_1
+#ifdef CONFIG_SUNRPC_BACKCHANNEL
 struct rpc_rqst *xprt_alloc_bc_request(struct rpc_xprt *xprt);
 void xprt_free_bc_request(struct rpc_rqst *req);
 int xprt_setup_backchannel(struct rpc_xprt *, unsigned int min_reqs);
@@ -47,7 +47,7 @@ static inline int svc_is_backchannel(const struct svc_rqst *rqstp)
                 return 1;
         return 0;
 }
-#else /* CONFIG_NFS_V4_1 */
+#else /* CONFIG_SUNRPC_BACKCHANNEL */
 static inline int xprt_setup_backchannel(struct rpc_xprt *xprt,
                                          unsigned int min_reqs)
 {
@@ -62,6 +62,6 @@ static inline int svc_is_backchannel(const struct svc_rqst *rqstp)
 static inline void xprt_free_bc_request(struct rpc_rqst *req)
 {
 }
-#endif /* CONFIG_NFS_V4_1 */
+#endif /* CONFIG_SUNRPC_BACKCHANNEL */
 #endif /* _LINUX_SUNRPC_BC_XPRT_H */
 
diff --git a/include/linux/sunrpc/cache.h b/include/linux/sunrpc/cache.h
index 8d2eef1a858..5efd8cef389 100644
--- a/include/linux/sunrpc/cache.h
+++ b/include/linux/sunrpc/cache.h
@@ -15,7 +15,7 @@
 
 #include <linux/kref.h>
 #include <linux/slab.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <linux/proc_fs.h>
 
 /*
@@ -256,13 +256,4 @@ static inline time_t get_expiry(char **bpp)
         return rv - boot.tv_sec;
 }
 
-#ifdef CONFIG_NFSD_DEPRECATED
-static inline void sunrpc_invalidate(struct cache_head *h,
-                                     struct cache_detail *detail)
-{
-        h->expiry_time = seconds_since_boot() - 1;
-        detail->nextcheck = seconds_since_boot();
-}
-#endif /* CONFIG_NFSD_DEPRECATED */
-
 #endif /*  _LINUX_SUNRPC_CACHE_H_ */
diff --git a/include/linux/sunrpc/rpc_pipe_fs.h b/include/linux/sunrpc/rpc_pipe_fs.h
index cf14db975da..e4ea43058d8 100644
--- a/include/linux/sunrpc/rpc_pipe_fs.h
+++ b/include/linux/sunrpc/rpc_pipe_fs.h
@@ -44,6 +44,8 @@ RPC_I(struct inode *inode)
         return container_of(inode, struct rpc_inode, vfs_inode);
 }
 
+extern ssize_t rpc_pipe_generic_upcall(struct file *, struct rpc_pipe_msg *,
+                                       char __user *, size_t);
 extern int rpc_queue_upcall(struct inode *, struct rpc_pipe_msg *);
 
 struct rpc_clnt;
diff --git a/include/linux/sunrpc/sched.h b/include/linux/sunrpc/sched.h
index fe2d8e6b923..e7756896f3c 100644
--- a/include/linux/sunrpc/sched.h
+++ b/include/linux/sunrpc/sched.h
@@ -227,6 +227,10 @@ void		rpc_init_wait_queue(struct rpc_wait_queue *, const char *);
 void            rpc_destroy_wait_queue(struct rpc_wait_queue *);
 void            rpc_sleep_on(struct rpc_wait_queue *, struct rpc_task *,
                                         rpc_action action);
+void            rpc_sleep_on_priority(struct rpc_wait_queue *,
+                                        struct rpc_task *,
+                                        rpc_action action,
+                                        int priority);
 void            rpc_wake_up_queued_task(struct rpc_wait_queue *,
                                         struct rpc_task *);
 void            rpc_wake_up(struct rpc_wait_queue *);
diff --git a/include/linux/sunrpc/svc.h b/include/linux/sunrpc/svc.h
index ea29330b78b..223588a976a 100644
--- a/include/linux/sunrpc/svc.h
+++ b/include/linux/sunrpc/svc.h
@@ -92,7 +92,7 @@ struct svc_serv {
         struct module *         sv_module;      /* optional module to count when
                                                  * adding threads */
         svc_thread_fn           sv_function;    /* main function for threads */
-#if defined(CONFIG_NFS_V4_1)
+#if defined(CONFIG_SUNRPC_BACKCHANNEL)
         struct list_head        sv_cb_list;     /* queue for callback requests
                                                  * that arrive over the same
                                                  * connection */
@@ -100,7 +100,7 @@ struct svc_serv {
         wait_queue_head_t       sv_cb_waitq;    /* sleep here if there are no
                                                  * entries in the svc_cb_list */
         struct svc_xprt         *sv_bc_xprt;    /* callback on fore channel */
-#endif /* CONFIG_NFS_V4_1 */
+#endif /* CONFIG_SUNRPC_BACKCHANNEL */
 };
 
 /*
@@ -273,6 +273,7 @@ struct svc_rqst {
         /* Catering to nfsd */
         struct auth_domain *    rq_client;      /* RPC peer info */
         struct auth_domain *    rq_gssclient;   /* "gss/"-style peer info */
+        int                     rq_cachetype;
         struct svc_cacherep *   rq_cacherep;    /* cache info */
         int                     rq_splice_ok;   /* turned off in gss privacy
                                                  * to prevent encrypting page
diff --git a/include/linux/sunrpc/timer.h b/include/linux/sunrpc/timer.h
index a67fd734c73..697d6e69d61 100644
--- a/include/linux/sunrpc/timer.h
+++ b/include/linux/sunrpc/timer.h
@@ -9,7 +9,7 @@
 #ifndef _LINUX_SUNRPC_TIMER_H
 #define _LINUX_SUNRPC_TIMER_H
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 struct rpc_rtt {
         unsigned long timeo;    /* default timeout value */
diff --git a/include/linux/sunrpc/xdr.h b/include/linux/sunrpc/xdr.h
index a20970ef9e4..af70af33354 100644
--- a/include/linux/sunrpc/xdr.h
+++ b/include/linux/sunrpc/xdr.h
@@ -191,6 +191,8 @@ extern int xdr_decode_array2(struct xdr_buf *buf, unsigned int base,
                              struct xdr_array2_desc *desc);
 extern int xdr_encode_array2(struct xdr_buf *buf, unsigned int base,
                              struct xdr_array2_desc *desc);
+extern void _copy_from_pages(char *p, struct page **pages, size_t pgbase,
+                             size_t len);
 
 /*
  * Provide some simple tools for XDR buffer overflow-checking etc.
diff --git a/include/linux/sunrpc/xprt.h b/include/linux/sunrpc/xprt.h
index 81cce3b3ee6..15518a152ac 100644
--- a/include/linux/sunrpc/xprt.h
+++ b/include/linux/sunrpc/xprt.h
@@ -22,6 +22,7 @@
 #define RPC_MIN_SLOT_TABLE      (2U)
 #define RPC_DEF_SLOT_TABLE      (16U)
 #define RPC_MAX_SLOT_TABLE      (128U)
+#define RPC_MAX_SLOT_TABLE_LIMIT        (65536U)
 
 /*
  * This describes a timeout strategy
@@ -100,18 +101,18 @@ struct rpc_rqst {
         ktime_t                 rq_xtime;       /* transmit time stamp */
         int                     rq_ntrans;
 
-#if defined(CONFIG_NFS_V4_1)
+#if defined(CONFIG_SUNRPC_BACKCHANNEL)
         struct list_head        rq_bc_list;     /* Callback service list */
         unsigned long           rq_bc_pa_state; /* Backchannel prealloc state */
         struct list_head        rq_bc_pa_list;  /* Backchannel prealloc list */
-#endif /* CONFIG_NFS_V4_1 */
+#endif /* CONFIG_SUNRPC_BACKCHANEL */
 };
 #define rq_svec                 rq_snd_buf.head
 #define rq_slen                 rq_snd_buf.len
 
 struct rpc_xprt_ops {
         void            (*set_buffer_size)(struct rpc_xprt *xprt, size_t sndsize, size_t rcvsize);
-        int             (*reserve_xprt)(struct rpc_task *task);
+        int             (*reserve_xprt)(struct rpc_xprt *xprt, struct rpc_task *task);
         void            (*release_xprt)(struct rpc_xprt *xprt, struct rpc_task *task);
         void            (*rpcbind)(struct rpc_task *task);
         void            (*set_port)(struct rpc_xprt *xprt, unsigned short port);
@@ -164,12 +165,12 @@ struct rpc_xprt {
 
         struct rpc_wait_queue   binding;        /* requests waiting on rpcbind */
         struct rpc_wait_queue   sending;        /* requests waiting to send */
-        struct rpc_wait_queue   resend;         /* requests waiting to resend */
         struct rpc_wait_queue   pending;        /* requests in flight */
         struct rpc_wait_queue   backlog;        /* waiting for slot */
         struct list_head        free;           /* free slots */
-        struct rpc_rqst *       slot;           /* slot table storage */
-        unsigned int            max_reqs;       /* total slots */
+        unsigned int            max_reqs;       /* max number of slots */
+        unsigned int            min_reqs;       /* min number of slots */
+        atomic_t                num_reqs;       /* total slots */
         unsigned long           state;          /* transport state */
         unsigned char           shutdown   : 1, /* being shut down */
                                 resvport   : 1; /* use a reserved port */
@@ -200,7 +201,7 @@ struct rpc_xprt {
         u32                     xid;            /* Next XID value to use */
         struct rpc_task *       snd_task;       /* Task blocked in send */
         struct svc_xprt         *bc_xprt;       /* NFSv4.1 backchannel */
-#if defined(CONFIG_NFS_V4_1)
+#if defined(CONFIG_SUNRPC_BACKCHANNEL)
         struct svc_serv         *bc_serv;       /* The RPC service which will */
                                                 /* process the callback */
         unsigned int            bc_alloc_count; /* Total number of preallocs */
@@ -208,7 +209,7 @@ struct rpc_xprt {
                                                  * items */
         struct list_head        bc_pa_list;     /* List of preallocated
                                                  * backchannel rpc_rqst's */
-#endif /* CONFIG_NFS_V4_1 */
+#endif /* CONFIG_SUNRPC_BACKCHANNEL */
         struct list_head        recv;
 
         struct {
@@ -228,15 +229,15 @@ struct rpc_xprt {
         const char              *address_strings[RPC_DISPLAY_MAX];
 };
 
-#if defined(CONFIG_NFS_V4_1)
+#if defined(CONFIG_SUNRPC_BACKCHANNEL)
 /*
  * Backchannel flags
  */
 #define RPC_BC_PA_IN_USE        0x0001          /* Preallocated backchannel */
                                                 /* buffer in use */
-#endif /* CONFIG_NFS_V4_1 */
+#endif /* CONFIG_SUNRPC_BACKCHANNEL */
 
-#if defined(CONFIG_NFS_V4_1)
+#if defined(CONFIG_SUNRPC_BACKCHANNEL)
 static inline int bc_prealloc(struct rpc_rqst *req)
 {
         return test_bit(RPC_BC_PA_IN_USE, &req->rq_bc_pa_state);
@@ -246,7 +247,7 @@ static inline int bc_prealloc(struct rpc_rqst *req)
 {
         return 0;
 }
-#endif /* CONFIG_NFS_V4_1 */
+#endif /* CONFIG_SUNRPC_BACKCHANNEL */
 
 struct xprt_create {
         int                     ident;          /* XPRT_TRANSPORT identifier */
@@ -271,8 +272,8 @@ struct xprt_class {
 struct rpc_xprt         *xprt_create_transport(struct xprt_create *args);
 void                    xprt_connect(struct rpc_task *task);
 void                    xprt_reserve(struct rpc_task *task);
-int                     xprt_reserve_xprt(struct rpc_task *task);
-int                     xprt_reserve_xprt_cong(struct rpc_task *task);
+int                     xprt_reserve_xprt(struct rpc_xprt *xprt, struct rpc_task *task);
+int                     xprt_reserve_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task);
 int                     xprt_prepare_transmit(struct rpc_task *task);
 void                    xprt_transmit(struct rpc_task *task);
 void                    xprt_end_transmit(struct rpc_task *task);
@@ -282,7 +283,9 @@ void			xprt_release_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task);
 void                    xprt_release(struct rpc_task *task);
 struct rpc_xprt *       xprt_get(struct rpc_xprt *xprt);
 void                    xprt_put(struct rpc_xprt *xprt);
-struct rpc_xprt *       xprt_alloc(struct net *net, int size, int max_req);
+struct rpc_xprt *       xprt_alloc(struct net *net, size_t size,
+                                unsigned int num_prealloc,
+                                unsigned int max_req);
 void                    xprt_free(struct rpc_xprt *);
 
 static inline __be32 *xprt_skip_transport_header(struct rpc_xprt *xprt, __be32 *p)
@@ -321,7 +324,6 @@ void			xprt_conditional_disconnect(struct rpc_xprt *xprt, unsigned int cookie);
 #define XPRT_CLOSING            (6)
 #define XPRT_CONNECTION_ABORT   (7)
 #define XPRT_CONNECTION_CLOSE   (8)
-#define XPRT_INITIALIZED        (9)
 
 static inline void xprt_set_connected(struct rpc_xprt *xprt)
 {
diff --git a/include/linux/suspend.h b/include/linux/suspend.h
index 083ffea7ba1..6bbcef22e10 100644
--- a/include/linux/suspend.h
+++ b/include/linux/suspend.h
@@ -92,6 +92,13 @@ typedef int __bitwise suspend_state_t;
  *      @enter() and @wake(), even if any of them fails.  It is executed after
  *      a failing @prepare.
  *
+ * @suspend_again: Returns whether the system should suspend again (true) or
+ *      not (false). If the platform wants to poll sensors or execute some
+ *      code during suspended without invoking userspace and most of devices,
+ *      suspend_again callback is the place assuming that periodic-wakeup or
+ *      alarm-wakeup is already setup. This allows to execute some codes while
+ *      being kept suspended in the view of userland and devices.
+ *
  * @end: Called by the PM core right after resuming devices, to indicate to
  *      the platform that the system has returned to the working state or
  *      the transition to the sleep state has been aborted.
@@ -113,6 +120,7 @@ struct platform_suspend_ops {
         int (*enter)(suspend_state_t state);
         void (*wake)(void);
         void (*finish)(void);
+        bool (*suspend_again)(void);
         void (*end)(void);
         void (*recover)(void);
 };
@@ -260,6 +268,14 @@ static inline int hibernate(void) { return -ENOSYS; }
 static inline bool system_entering_hibernation(void) { return false; }
 #endif /* CONFIG_HIBERNATION */
 
+/* Hibernation and suspend events */
+#define PM_HIBERNATION_PREPARE  0x0001 /* Going to hibernate */
+#define PM_POST_HIBERNATION     0x0002 /* Hibernation finished */
+#define PM_SUSPEND_PREPARE      0x0003 /* Going to suspend the system */
+#define PM_POST_SUSPEND         0x0004 /* Suspend finished */
+#define PM_RESTORE_PREPARE      0x0005 /* Going to restore a saved image */
+#define PM_POST_RESTORE         0x0006 /* Restore failed */
+
 #ifdef CONFIG_PM_SLEEP
 void save_processor_state(void);
 void restore_processor_state(void);
diff --git a/include/linux/swap.h b/include/linux/swap.h
index a273468f828..c71f84bb62e 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -9,7 +9,7 @@
 #include <linux/sched.h>
 #include <linux/node.h>
 
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <asm/page.h>
 
 struct notifier_block;
@@ -251,15 +251,13 @@ static inline void lru_cache_add_file(struct page *page)
 /* linux/mm/vmscan.c */
 extern unsigned long try_to_free_pages(struct zonelist *zonelist, int order,
                                         gfp_t gfp_mask, nodemask_t *mask);
+extern int __isolate_lru_page(struct page *page, int mode, int file);
 extern unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *mem,
-                                                  gfp_t gfp_mask, bool noswap,
-                                                  unsigned int swappiness);
+                                                  gfp_t gfp_mask, bool noswap);
 extern unsigned long mem_cgroup_shrink_node_zone(struct mem_cgroup *mem,
                                                 gfp_t gfp_mask, bool noswap,
-                                                unsigned int swappiness,
                                                 struct zone *zone,
                                                 unsigned long *nr_scanned);
-extern int __isolate_lru_page(struct page *page, int mode, int file);
 extern unsigned long shrink_all_memory(unsigned long nr_pages);
 extern int vm_swappiness;
 extern int remove_mapping(struct address_space *mapping, struct page *page);
@@ -299,7 +297,14 @@ static inline void scan_unevictable_unregister_node(struct node *node)
 
 extern int kswapd_run(int nid);
 extern void kswapd_stop(int nid);
-
+#ifdef CONFIG_CGROUP_MEM_RES_CTLR
+extern int mem_cgroup_swappiness(struct mem_cgroup *mem);
+#else
+static inline int mem_cgroup_swappiness(struct mem_cgroup *mem)
+{
+        return vm_swappiness;
+}
+#endif
 #ifdef CONFIG_SWAP
 /* linux/mm/page_io.c */
 extern int swap_readpage(struct page *);
diff --git a/include/linux/swapops.h b/include/linux/swapops.h
index cd42e30b7c6..2189d3ffc85 100644
--- a/include/linux/swapops.h
+++ b/include/linux/swapops.h
@@ -1,3 +1,8 @@
+#ifndef _LINUX_SWAPOPS_H
+#define _LINUX_SWAPOPS_H
+
+#include <linux/radix-tree.h>
+
 /*
  * swapcache pages are stored in the swapper_space radix tree.  We want to
  * get good packing density in that tree, so the index should be dense in
@@ -76,6 +81,22 @@ static inline pte_t swp_entry_to_pte(swp_entry_t entry)
         return __swp_entry_to_pte(arch_entry);
 }
 
+static inline swp_entry_t radix_to_swp_entry(void *arg)
+{
+        swp_entry_t entry;
+
+        entry.val = (unsigned long)arg >> RADIX_TREE_EXCEPTIONAL_SHIFT;
+        return entry;
+}
+
+static inline void *swp_to_radix_entry(swp_entry_t entry)
+{
+        unsigned long value;
+
+        value = entry.val << RADIX_TREE_EXCEPTIONAL_SHIFT;
+        return (void *)(value | RADIX_TREE_EXCEPTIONAL_ENTRY);
+}
+
 #ifdef CONFIG_MIGRATION
 static inline swp_entry_t make_migration_entry(struct page *page, int write)
 {
@@ -169,3 +190,5 @@ static inline int non_swap_entry(swp_entry_t entry)
         return 0;
 }
 #endif
+
+#endif /* _LINUX_SWAPOPS_H */
diff --git a/include/linux/switch.h b/include/linux/switch.h
new file mode 100644
index 00000000000..3e4c748e343
--- /dev/null
+++ b/include/linux/switch.h
@@ -0,0 +1,53 @@
+/*
+ *  Switch class driver
+ *
+ * Copyright (C) 2008 Google, Inc.
+ * Author: Mike Lockwood <lockwood@android.com>
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+*/
+
+#ifndef __LINUX_SWITCH_H__
+#define __LINUX_SWITCH_H__
+
+struct switch_dev {
+        const char      *name;
+        struct device   *dev;
+        int             index;
+        int             state;
+
+        ssize_t (*print_name)(struct switch_dev *sdev, char *buf);
+        ssize_t (*print_state)(struct switch_dev *sdev, char *buf);
+};
+
+struct gpio_switch_platform_data {
+        const char *name;
+        unsigned        gpio;
+
+        /* if NULL, switch_dev.name will be printed */
+        const char *name_on;
+        const char *name_off;
+        /* if NULL, "0" or "1" will be printed */
+        const char *state_on;
+        const char *state_off;
+};
+
+extern int switch_dev_register(struct switch_dev *sdev);
+extern void switch_dev_unregister(struct switch_dev *sdev);
+
+static inline int switch_get_state(struct switch_dev *sdev)
+{
+        return sdev->state;
+}
+
+extern void switch_set_state(struct switch_dev *sdev, int state);
+
+#endif /* __LINUX_SWITCH_H__ */
diff --git a/include/linux/synaptics_i2c_rmi.h b/include/linux/synaptics_i2c_rmi.h
new file mode 100644
index 00000000000..5539cc52077
--- /dev/null
+++ b/include/linux/synaptics_i2c_rmi.h
@@ -0,0 +1,55 @@
+/*
+ * include/linux/synaptics_i2c_rmi.h - platform data structure for f75375s sensor
+ *
+ * Copyright (C) 2008 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _LINUX_SYNAPTICS_I2C_RMI_H
+#define _LINUX_SYNAPTICS_I2C_RMI_H
+
+#define SYNAPTICS_I2C_RMI_NAME "synaptics-rmi-ts"
+
+enum {
+        SYNAPTICS_FLIP_X = 1UL << 0,
+        SYNAPTICS_FLIP_Y = 1UL << 1,
+        SYNAPTICS_SWAP_XY = 1UL << 2,
+        SYNAPTICS_SNAP_TO_INACTIVE_EDGE = 1UL << 3,
+};
+
+struct synaptics_i2c_rmi_platform_data {
+        uint32_t version;       /* Use this entry for panels with */
+                                /* (major << 8 | minor) version or above. */
+                                /* If non-zero another array entry follows */
+        int (*power)(int on);   /* Only valid in first array entry */
+        uint32_t flags;
+        unsigned long irqflags;
+        uint32_t inactive_left; /* 0x10000 = screen width */
+        uint32_t inactive_right; /* 0x10000 = screen width */
+        uint32_t inactive_top; /* 0x10000 = screen height */
+        uint32_t inactive_bottom; /* 0x10000 = screen height */
+        uint32_t snap_left_on; /* 0x10000 = screen width */
+        uint32_t snap_left_off; /* 0x10000 = screen width */
+        uint32_t snap_right_on; /* 0x10000 = screen width */
+        uint32_t snap_right_off; /* 0x10000 = screen width */
+        uint32_t snap_top_on; /* 0x10000 = screen height */
+        uint32_t snap_top_off; /* 0x10000 = screen height */
+        uint32_t snap_bottom_on; /* 0x10000 = screen height */
+        uint32_t snap_bottom_off; /* 0x10000 = screen height */
+        uint32_t fuzz_x; /* 0x10000 = screen width */
+        uint32_t fuzz_y; /* 0x10000 = screen height */
+        int fuzz_p;
+        int fuzz_w;
+        int8_t sensitivity_adjust;
+};
+
+#endif /* _LINUX_SYNAPTICS_I2C_RMI_H */
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 8c03b98df5f..1ff0ec2a5e8 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -702,9 +702,6 @@ asmlinkage long sys_sysctl(struct __sysctl_args __user *args);
 asmlinkage long sys_sysinfo(struct sysinfo __user *info);
 asmlinkage long sys_sysfs(int option,
                                 unsigned long arg1, unsigned long arg2);
-asmlinkage long sys_nfsservctl(int cmd,
-                                struct nfsctl_arg __user *arg,
-                                void __user *res);
 asmlinkage long sys_syslog(int type, char __user *buf, int len);
 asmlinkage long sys_uselib(const char __user *library);
 asmlinkage long sys_ni_syscall(void);
diff --git a/include/linux/sysfs.h b/include/linux/sysfs.h
index e2696d76a59..d7d2f215814 100644
--- a/include/linux/sysfs.h
+++ b/include/linux/sysfs.h
@@ -17,7 +17,7 @@
 #include <linux/list.h>
 #include <linux/lockdep.h>
 #include <linux/kobject_ns.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 struct kobject;
 struct module;
diff --git a/include/linux/tc_ematch/tc_em_meta.h b/include/linux/tc_ematch/tc_em_meta.h
index 7138962664f..b11f8ce2d3c 100644
--- a/include/linux/tc_ematch/tc_em_meta.h
+++ b/include/linux/tc_ematch/tc_em_meta.h
@@ -67,7 +67,7 @@ enum {
         TCF_META_ID_SK_FORWARD_ALLOCS,
         TCF_META_ID_SK_SNDBUF,
         TCF_META_ID_SK_ALLOCS,
-        TCF_META_ID_SK_ROUTE_CAPS,
+        __TCF_META_ID_SK_ROUTE_CAPS,    /* unimplemented but in ABI already */
         TCF_META_ID_SK_HASH,
         TCF_META_ID_SK_LINGERTIME,
         TCF_META_ID_SK_ACK_BACKLOG,
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index e64f4c67d0e..531ede8006d 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -282,6 +282,7 @@ struct tcp_request_sock {
 #endif
         u32                             rcv_isn;
         u32                             snt_isn;
+        u32                             snt_synack; /* synack sent time */
 };
 
 static inline struct tcp_request_sock *tcp_rsk(const struct request_sock *req)
diff --git a/include/linux/tegra_audio.h b/include/linux/tegra_audio.h
new file mode 100644
index 00000000000..6416cd01861
--- /dev/null
+++ b/include/linux/tegra_audio.h
@@ -0,0 +1,80 @@
+/* include/linux/tegra_audio.h
+ *
+ * Copyright (C) 2010 Google, Inc.
+ *
+ * Author:
+ *     Iliyan Malchev <malchev@google.com>
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _TEGRA_AUDIO_H
+#define _TEGRA_AUDIO_H
+
+#include <linux/ioctl.h>
+
+#define TEGRA_AUDIO_MAGIC 't'
+
+#define TEGRA_AUDIO_IN_START _IO(TEGRA_AUDIO_MAGIC, 0)
+#define TEGRA_AUDIO_IN_STOP  _IO(TEGRA_AUDIO_MAGIC, 1)
+
+struct tegra_audio_in_config {
+        int rate;
+        int stereo;
+};
+
+struct dam_srate {
+        unsigned int in_sample_rate;
+        unsigned int out_sample_rate;
+        unsigned int audio_bits;
+        unsigned int client_bits;
+        unsigned int audio_channels;
+        unsigned int client_channels;
+        unsigned int apbif_chan;
+};
+
+#define TEGRA_AUDIO_IN_SET_CONFIG       _IOW(TEGRA_AUDIO_MAGIC, 2, \
+                        const struct tegra_audio_in_config *)
+#define TEGRA_AUDIO_IN_GET_CONFIG       _IOR(TEGRA_AUDIO_MAGIC, 3, \
+                        struct tegra_audio_in_config *)
+
+#define TEGRA_AUDIO_IN_SET_NUM_BUFS     _IOW(TEGRA_AUDIO_MAGIC, 4, \
+                        const unsigned int *)
+#define TEGRA_AUDIO_IN_GET_NUM_BUFS     _IOW(TEGRA_AUDIO_MAGIC, 5, \
+                        unsigned int *)
+#define TEGRA_AUDIO_OUT_SET_NUM_BUFS    _IOW(TEGRA_AUDIO_MAGIC, 6, \
+                        const unsigned int *)
+#define TEGRA_AUDIO_OUT_GET_NUM_BUFS    _IOW(TEGRA_AUDIO_MAGIC, 7, \
+                        unsigned int *)
+
+#define TEGRA_AUDIO_OUT_FLUSH           _IO(TEGRA_AUDIO_MAGIC, 10)
+
+#define TEGRA_AUDIO_BIT_FORMAT_DEFAULT 0
+#define TEGRA_AUDIO_BIT_FORMAT_DSP 1
+#define TEGRA_AUDIO_SET_BIT_FORMAT      _IOW(TEGRA_AUDIO_MAGIC, 11, \
+                        const unsigned int *)
+#define TEGRA_AUDIO_GET_BIT_FORMAT      _IOR(TEGRA_AUDIO_MAGIC, 12, \
+                        unsigned int *)
+
+#define DAM_SRC_START   _IOW(TEGRA_AUDIO_MAGIC, 13, struct dam_srate *)
+#define DAM_SRC_STOP    _IO(TEGRA_AUDIO_MAGIC, 14)
+#define DAM_MIXING_START        _IOW(TEGRA_AUDIO_MAGIC, 15, struct dam_srate *)
+#define DAM_MIXING_STOP _IO(TEGRA_AUDIO_MAGIC, 16)
+#define DAM_SET_MIXING_FLAG     _IO(TEGRA_AUDIO_MAGIC, 17)
+
+#define I2S_START       _IOW(TEGRA_AUDIO_MAGIC, 15, struct i2s_pcm_format *)
+#define I2S_STOP        _IOW(TEGRA_AUDIO_MAGIC, 16, struct i2s_pcm_format *)
+#define I2S_LOOPBACK    _IOW(TEGRA_AUDIO_MAGIC, 17, unsigned int *)
+#define I2S_MODE_I2S    _IOW(TEGRA_AUDIO_MAGIC, 18, unsigned int *)
+
+extern bool tegra_is_voice_call_active();
+
+#endif/*_CPCAP_AUDIO_H*/
diff --git a/include/linux/tegra_avp.h b/include/linux/tegra_avp.h
new file mode 100644
index 00000000000..9dc92f82136
--- /dev/null
+++ b/include/linux/tegra_avp.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2010 Google, Inc.
+ * Author: Dima Zavin <dima@android.com>
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef __LINUX_TEGRA_AVP_H
+#define __LINUX_TEGRA_AVP_H
+
+#include <linux/ioctl.h>
+#include <linux/types.h>
+
+#define TEGRA_AVP_LIB_MAX_NAME          32
+#define TEGRA_AVP_LIB_MAX_ARGS          220 /* DO NOT CHANGE THIS! */
+
+struct tegra_avp_lib {
+        char            name[TEGRA_AVP_LIB_MAX_NAME];
+        void __user     *args;
+        size_t          args_len;
+        int             greedy;
+        unsigned long   handle;
+};
+
+struct tegra_avp_platform_data {
+        unsigned long emc_clk_rate;
+};
+#define TEGRA_AVP_IOCTL_MAGIC           'r'
+
+#define TEGRA_AVP_IOCTL_LOAD_LIB        _IOWR(TEGRA_AVP_IOCTL_MAGIC, 0x40, struct tegra_avp_lib)
+#define TEGRA_AVP_IOCTL_UNLOAD_LIB      _IOW(TEGRA_AVP_IOCTL_MAGIC, 0x41, unsigned long)
+
+#define TEGRA_AVP_IOCTL_MIN_NR          _IOC_NR(TEGRA_AVP_IOCTL_LOAD_LIB)
+#define TEGRA_AVP_IOCTL_MAX_NR          _IOC_NR(TEGRA_AVP_IOCTL_UNLOAD_LIB)
+
+#endif
diff --git a/include/linux/tegra_caif.h b/include/linux/tegra_caif.h
new file mode 100644
index 00000000000..fed67499def
--- /dev/null
+++ b/include/linux/tegra_caif.h
@@ -0,0 +1,34 @@
+/* include/linux/tegra_caif.h
+ *
+ * Copyright (C) 2011 NVIDIA Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#ifndef _TEGRA_CAIF_H_
+#define _TEGRA_CAIF_H_
+
+/* The GPIO details needed by the rainbow caif */
+struct tegra_caif_platform_data {
+        int reset;
+        int power;
+        int awr;
+        int cwr;
+        int spi_int;
+        int spi_ss;
+};
+
+#endif /* _TEGRA_CAIF_H_ */
+
diff --git a/include/linux/tegra_ion.h b/include/linux/tegra_ion.h
new file mode 100644
index 00000000000..73e190908b8
--- /dev/null
+++ b/include/linux/tegra_ion.h
@@ -0,0 +1,91 @@
+/*
+ * include/linux/tegra_ion.h
+ *
+ * Copyright (C) 2011, NVIDIA Corporation.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * 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.
+ *
+ */
+
+#include <linux/types.h>
+#include <linux/ion.h>
+
+#if !defined(__KERNEL__)
+#define __user
+#endif
+
+#ifndef _LINUX_TEGRA_ION_H
+#define _LINUX_TEGRA_ION_H
+
+struct tegra_ion_id_data {
+        struct ion_handle *handle;
+        unsigned long id;
+        size_t size;
+};
+
+struct tegra_ion_pin_data {
+        struct ion_handle **handles; /* array of handles to pin/unpin */
+        unsigned long *addr; /* array pf addresses to return */
+        unsigned long count; /* number of entries in handles */
+};
+
+/* Cache operations. */
+enum {
+        TEGRA_ION_CACHE_OP_WB = 0,
+        TEGRA_ION_CACHE_OP_INV,
+        TEGRA_ION_CACHE_OP_WB_INV,
+};
+
+struct tegra_ion_cache_maint_data {
+        unsigned long addr;
+        struct ion_handle *handle;
+        size_t len;
+        unsigned int op;
+};
+
+struct tegra_ion_rw_data {
+        unsigned long addr; /* user pointer*/
+        struct ion_handle *handle;
+        unsigned int offset; /* offset into handle mem */
+        unsigned int elem_size; /* individual atome size */
+        unsigned int mem_stride; /*delta in bytes between atoms in handle mem*/
+        unsigned int user_stride; /* delta in bytes between atoms in user */
+        unsigned int count; /* number of atoms to copy */
+};
+
+struct tegra_ion_get_params_data {
+        struct ion_handle *handle;
+        size_t size;
+        unsigned int align;
+        unsigned int heap;
+        unsigned long addr;
+};
+
+/* Custom Ioctl's. */
+enum {
+        TEGRA_ION_ALLOC_FROM_ID = 0,
+        TEGRA_ION_GET_ID,
+        TEGRA_ION_PIN,
+        TEGRA_ION_UNPIN,
+        TEGRA_ION_CACHE_MAINT,
+        TEGRA_ION_READ,
+        TEGRA_ION_WRITE,
+        TEGRA_ION_GET_PARAM,
+};
+
+/* List of heaps in the system. */
+enum {
+        TEGRA_ION_HEAP_CARVEOUT = 0,
+        TEGRA_ION_HEAP_IRAM,
+        TEGRA_ION_HEAP_VPR,
+        TEGRA_ION_HEAP_IOMMU
+};
+
+#endif /* _LINUX_TEGRA_ION_H */
diff --git a/include/linux/tegra_mediaserver.h b/include/linux/tegra_mediaserver.h
new file mode 100644
index 00000000000..f28473baf63
--- /dev/null
+++ b/include/linux/tegra_mediaserver.h
@@ -0,0 +1,112 @@
+/* include/linux/tegra_mediaserver.h
+ *
+ * Media Server driver for NVIDIA Tegra SoCs
+ *
+ * Copyright (c) 2011, NVIDIA Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+
+#ifndef _TEGRA_MEDIASERVER_H
+#define _TEGRA_MEDIASERVER_H
+
+#include <linux/ioctl.h>
+
+#define TEGRA_MEDIASERVER_MAGIC 'm'
+#define TEGRA_MEDIASERVER_IOCTL_ALLOC \
+        _IOWR(TEGRA_MEDIASERVER_MAGIC, 0x40, \
+              union tegra_mediaserver_alloc_info)
+
+enum tegra_mediaserver_resource_type {
+        TEGRA_MEDIASERVER_RESOURCE_BLOCK = 0,
+        TEGRA_MEDIASERVER_RESOURCE_IRAM,
+};
+
+enum tegra_mediaserver_block_type {
+        TEGRA_MEDIASERVER_BLOCK_AUDDEC = 0,
+        TEGRA_MEDIASERVER_BLOCK_VIDDEC,
+};
+
+enum tegra_mediaserver_iram_type {
+        TEGRA_MEDIASERVER_IRAM_SCRATCH = 0,
+        TEGRA_MEDIASERVER_IRAM_SHARED,
+};
+
+
+struct tegra_mediaserver_block_info {
+        int nvmm_block_handle;
+        int avp_block_handle;
+        int avp_block_library_handle;
+        int service_handle;
+        int service_library_handle;
+};
+
+struct tegra_mediaserver_iram_info {
+        unsigned long rm_handle;
+        int physical_address;
+};
+
+union tegra_mediaserver_alloc_info {
+        struct {
+                int tegra_mediaserver_resource_type;
+
+                union {
+                        struct tegra_mediaserver_block_info block;
+
+                        struct {
+                                int tegra_mediaserver_iram_type;
+                                int alignment;
+                                size_t size;
+                        } iram;
+                } u;
+        } in;
+
+        struct {
+                union {
+                        struct {
+                                int count;
+                        } block;
+
+                        struct tegra_mediaserver_iram_info iram;
+                } u;
+        } out;
+};
+
+
+#define TEGRA_MEDIASERVER_IOCTL_FREE \
+        _IOR(TEGRA_MEDIASERVER_MAGIC, 0x41, union tegra_mediaserver_free_info)
+
+union tegra_mediaserver_free_info {
+        struct {
+                int tegra_mediaserver_resource_type;
+
+                union {
+                        int nvmm_block_handle;
+                        int iram_rm_handle;
+                } u;
+        } in;
+};
+
+
+#define TEGRA_MEDIASERVER_IOCTL_UPDATE_BLOCK_INFO       \
+        _IOR(TEGRA_MEDIASERVER_MAGIC, 0x45, \
+             union tegra_mediaserver_update_block_info)
+
+union tegra_mediaserver_update_block_info {
+        struct tegra_mediaserver_block_info in;
+};
+#endif
+
diff --git a/include/linux/tegra_nvavp.h b/include/linux/tegra_nvavp.h
new file mode 100644
index 00000000000..32dc4c62b4b
--- /dev/null
+++ b/include/linux/tegra_nvavp.h
@@ -0,0 +1,84 @@
+/*
+ * include/linux/tegra_nvavp.h
+ *
+ * Copyright (C) 2011 NVIDIA Corp.
+ *
+ * This file is licensed under the terms of the GNU General Public License
+ * version 2. This program is licensed "as is" without any warranty of any
+ * kind, whether express or implied.
+ */
+
+#ifndef __LINUX_TEGRA_NVAVP_H
+#define __LINUX_TEGRA_NVAVP_H
+
+#include <linux/ioctl.h>
+#include <linux/types.h>
+
+#define NVAVP_MAX_RELOCATION_COUNT 64
+
+/* avp submit flags */
+#define NVAVP_FLAG_NONE         0x00000000
+#define NVAVP_UCODE_EXT         0x00000001 /*use external ucode provided */
+
+enum {
+        NVAVP_MODULE_ID_AVP     = 2,
+        NVAVP_MODULE_ID_VCP     = 3,
+        NVAVP_MODULE_ID_BSEA    = 27,
+        NVAVP_MODULE_ID_VDE     = 28,
+        NVAVP_MODULE_ID_MPE     = 29,
+        NVAVP_MODULE_ID_EMC     = 75,
+};
+
+struct nvavp_cmdbuf {
+        __u32 mem;
+        __u32 offset;
+        __u32 words;
+};
+
+struct nvavp_reloc {
+        __u32 cmdbuf_mem;
+        __u32 cmdbuf_offset;
+        __u32 target;
+        __u32 target_offset;
+};
+
+struct nvavp_syncpt {
+        __u32 id;
+        __u32 value;
+};
+
+struct nvavp_pushbuffer_submit_hdr {
+        struct nvavp_cmdbuf     cmdbuf;
+        struct nvavp_reloc      *relocs;
+        __u32                   num_relocs;
+        struct nvavp_syncpt     *syncpt;
+        __u32                   flags;
+};
+
+struct nvavp_set_nvmap_fd_args {
+        __u32 fd;
+};
+
+struct nvavp_clock_args {
+        __u32 id;
+        __u32 rate;
+};
+
+#define NVAVP_IOCTL_MAGIC               'n'
+
+#define NVAVP_IOCTL_SET_NVMAP_FD        _IOW(NVAVP_IOCTL_MAGIC, 0x60, \
+                                        struct nvavp_set_nvmap_fd_args)
+#define NVAVP_IOCTL_GET_SYNCPOINT_ID    _IOR(NVAVP_IOCTL_MAGIC, 0x61, \
+                                        __u32)
+#define NVAVP_IOCTL_PUSH_BUFFER_SUBMIT  _IOWR(NVAVP_IOCTL_MAGIC, 0x63, \
+                                        struct nvavp_pushbuffer_submit_hdr)
+#define NVAVP_IOCTL_SET_CLOCK           _IOWR(NVAVP_IOCTL_MAGIC, 0x64, \
+                                        struct nvavp_clock_args)
+#define NVAVP_IOCTL_GET_CLOCK           _IOR(NVAVP_IOCTL_MAGIC, 0x65, \
+                                        struct nvavp_clock_args)
+
+
+#define NVAVP_IOCTL_MIN_NR              _IOC_NR(NVAVP_IOCTL_SET_NVMAP_FD)
+#define NVAVP_IOCTL_MAX_NR              _IOC_NR(NVAVP_IOCTL_GET_CLOCK)
+
+#endif /* __LINUX_TEGRA_NVAVP_H */
diff --git a/include/linux/tegra_pwm_bl.h b/include/linux/tegra_pwm_bl.h
new file mode 100644
index 00000000000..71a81f2eda8
--- /dev/null
+++ b/include/linux/tegra_pwm_bl.h
@@ -0,0 +1,31 @@
+/* Tegra PWM backlight data *
+ *
+ * Copyright (C) 2011 NVIDIA Corporation
+ * Author: Renuka Apte <rapte@nvidia.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+
+#ifndef TEGRA_PWM_BL_H
+#define TEGRA_PWM_BL_H
+
+#include <linux/backlight.h>
+
+struct platform_tegra_pwm_backlight_data {
+        int which_dc;
+        int which_pwm;
+        void (*switch_to_sfio)(int);
+        int gpio_conf_to_sfio;
+        unsigned int dft_brightness;
+        unsigned int max_brightness;
+        unsigned int period;
+        unsigned int clk_div;
+        unsigned int clk_select;
+        int (*notify)(struct device *dev, int brightness);
+        int (*check_fb)(struct device *dev, struct fb_info *info);
+};
+
+#endif /* TERGA_PWM_BL_H */
diff --git a/include/linux/tegra_rpc.h b/include/linux/tegra_rpc.h
new file mode 100644
index 00000000000..16e6367cf56
--- /dev/null
+++ b/include/linux/tegra_rpc.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2010 Google, Inc.
+ *
+ * Author:
+ *   Dima Zavin <dima@android.com>
+ *
+ * Based on original code from NVIDIA, and a partial rewrite by:
+ *   Gary King <gking@nvidia.com>
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef __LINUX_TEGRA_RPC_H
+#define __LINUX_TEGRA_RPC_H
+
+#define TEGRA_RPC_MAX_MSG_LEN           256
+
+/* Note: the actual size of the name in the protocol message is 16 bytes,
+ * but that is because the name there is not NUL terminated, only NUL
+ * padded. */
+#define TEGRA_RPC_MAX_NAME_LEN          17
+
+struct tegra_rpc_port_desc {
+        char name[TEGRA_RPC_MAX_NAME_LEN];
+        int notify_fd; /* fd representing a trpc_sema to signal when a
+                        * message has been received */
+};
+
+#define TEGRA_RPC_IOCTL_MAGIC           'r'
+
+#define TEGRA_RPC_IOCTL_PORT_CREATE     _IOW(TEGRA_RPC_IOCTL_MAGIC, 0x20, struct tegra_rpc_port_desc)
+#define TEGRA_RPC_IOCTL_PORT_GET_NAME   _IOR(TEGRA_RPC_IOCTL_MAGIC, 0x21, char *)
+#define TEGRA_RPC_IOCTL_PORT_CONNECT    _IOR(TEGRA_RPC_IOCTL_MAGIC, 0x22, long)
+#define TEGRA_RPC_IOCTL_PORT_LISTEN     _IOR(TEGRA_RPC_IOCTL_MAGIC, 0x23, long)
+
+#define TEGRA_RPC_IOCTL_MIN_NR          _IOC_NR(TEGRA_RPC_IOCTL_PORT_CREATE)
+#define TEGRA_RPC_IOCTL_MAX_NR          _IOC_NR(TEGRA_RPC_IOCTL_PORT_LISTEN)
+
+#endif
diff --git a/include/linux/tegra_sema.h b/include/linux/tegra_sema.h
new file mode 100644
index 00000000000..7b423b6cb5c
--- /dev/null
+++ b/include/linux/tegra_sema.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2010 Google, Inc.
+ *
+ * Author:
+ *   Dima Zavin <dima@android.com>
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef __LINUX_TEGRA_SEMA_H
+#define __LINUX_TEGRA_SEMA_H
+
+/* this shares the magic with the tegra RPC and AVP drivers.
+ *  See include/linux/tegra_avp.h and include/linux/tegra_rpc.h */
+#define TEGRA_SEMA_IOCTL_MAGIC          'r'
+
+/* If IOCTL_WAIT is interrupted by a signal and the timeout was not -1,
+ * then the value pointed to by the argument will be updated with the amount
+ * of time remaining for the wait. */
+#define TEGRA_SEMA_IOCTL_WAIT           _IOW(TEGRA_SEMA_IOCTL_MAGIC, 0x30, long *)
+#define TEGRA_SEMA_IOCTL_SIGNAL         _IO(TEGRA_SEMA_IOCTL_MAGIC, 0x31)
+
+#define TEGRA_SEMA_IOCTL_MIN_NR         _IOC_NR(TEGRA_SEMA_IOCTL_WAIT)
+#define TEGRA_SEMA_IOCTL_MAX_NR         _IOC_NR(TEGRA_SEMA_IOCTL_SIGNAL)
+
+#endif
diff --git a/include/linux/tegra_spdif.h b/include/linux/tegra_spdif.h
new file mode 100644
index 00000000000..8d7f6457a0d
--- /dev/null
+++ b/include/linux/tegra_spdif.h
@@ -0,0 +1,56 @@
+/* include/linux/tegra_spdif.h
+ *
+ * SPDIF audio driver for NVIDIA Tegra SoCs
+ *
+ * Copyright (c) 2008-2009, NVIDIA Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#ifndef _TEGRA_SPDIF_H
+#define _TEGRA_SPDIF_H
+
+#include <linux/ioctl.h>
+
+#define TEGRA_SPDIF_MAGIC 's'
+
+
+
+struct tegra_audio_buf_config {
+        unsigned size; /* order */
+        unsigned threshold; /* order */
+        unsigned chunk; /* order */
+};
+
+
+
+#define TEGRA_AUDIO_OUT_SET_BUF_CONFIG  _IOW(TEGRA_SPDIF_MAGIC, 0, \
+                        const struct tegra_audio_buf_config *)
+#define TEGRA_AUDIO_OUT_GET_BUF_CONFIG  _IOR(TEGRA_SPDIF_MAGIC, 1, \
+                        struct tegra_audio_buf_config *)
+
+#define TEGRA_AUDIO_OUT_GET_ERROR_COUNT _IOR(TEGRA_SPDIF_MAGIC, 2, \
+                        unsigned *)
+
+struct tegra_audio_out_preload {
+        void *data;
+        size_t len;
+        size_t len_written;
+};
+
+#define TEGRA_AUDIO_OUT_PRELOAD_FIFO    _IOWR(TEGRA_SPDIF_MAGIC, 3, \
+                        struct tegra_audio_out_preload *)
+
+#endif/*_TEGRA_SPDIF_H*/
diff --git a/include/linux/tegra_uart.h b/include/linux/tegra_uart.h
new file mode 100644
index 00000000000..38912ea9706
--- /dev/null
+++ b/include/linux/tegra_uart.h
@@ -0,0 +1,44 @@
+/* include/linux/tegra_uart.h
+ *
+ * Copyright (C) 2011 NVIDIA Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#ifndef _TEGRA_UART_H_
+#define _TEGRA_UART_H_
+
+#include <linux/clk.h>
+
+struct uart_clk_parent {
+        const char      *name;
+        struct clk      *parent_clk;
+        unsigned long   fixed_clk_rate;
+};
+
+struct tegra_uart_platform_data {
+        void (*wake_peer)(struct uart_port *);
+        struct uart_clk_parent *parent_clk_list;
+        int parent_clk_count;
+        bool is_loopback;
+};
+
+int tegra_uart_is_tx_empty(struct uart_port *);
+void tegra_uart_request_clock_on(struct uart_port *);
+void tegra_uart_set_mctrl(struct uart_port *, unsigned int);
+void tegra_uart_request_clock_off(struct uart_port *uport);
+
+#endif /* _TEGRA_UART_H_ */
+
diff --git a/include/linux/thermal.h b/include/linux/thermal.h
index d3ec89fb412..47b4a27e6e9 100644
--- a/include/linux/thermal.h
+++ b/include/linux/thermal.h
@@ -85,22 +85,6 @@ struct thermal_cooling_device {
                                 ((long)t-2732+5)/10 : ((long)t-2732-5)/10)
 #define CELSIUS_TO_KELVIN(t)    ((t)*10+2732)
 
-#if defined(CONFIG_THERMAL_HWMON)
-/* thermal zone devices with the same type share one hwmon device */
-struct thermal_hwmon_device {
-        char type[THERMAL_NAME_LENGTH];
-        struct device *device;
-        int count;
-        struct list_head tz_list;
-        struct list_head node;
-};
-
-struct thermal_hwmon_attr {
-        struct device_attribute attr;
-        char name[16];
-};
-#endif
-
 struct thermal_zone_device {
         int id;
         char type[THERMAL_NAME_LENGTH];
@@ -120,12 +104,6 @@ struct thermal_zone_device {
         struct mutex lock;      /* protect cooling devices list */
         struct list_head node;
         struct delayed_work poll_queue;
-#if defined(CONFIG_THERMAL_HWMON)
-        struct list_head hwmon_node;
-        struct thermal_hwmon_device *hwmon;
-        struct thermal_hwmon_attr temp_input;   /* hwmon sys attr */
-        struct thermal_hwmon_attr temp_crit;    /* hwmon sys attr */
-#endif
 };
 /* Adding event notification support elements */
 #define THERMAL_GENL_FAMILY_NAME                "thermal_event"
diff --git a/include/linux/ti_wilink_st.h b/include/linux/ti_wilink_st.h
index b004e557caa..1c68538840f 100644
--- a/include/linux/ti_wilink_st.h
+++ b/include/linux/ti_wilink_st.h
@@ -24,7 +24,9 @@
 
 #ifndef TI_WILINK_ST_H
 #define TI_WILINK_ST_H
+#include <linux/wakelock.h>
 
+#include <linux/serial_core.h>
 /**
  * enum proto-type - The protocol on WiLink chips which share a
  *      common physical interface like UART.
@@ -156,6 +158,7 @@ struct st_data_s {
         unsigned long ll_state;
         void *kim_data;
         struct tty_struct *tty;
+        struct wake_lock st_wk_lock;
 };
 
 /*
@@ -371,6 +374,8 @@ struct hci_command {
 #define LL_WAKE_UP_IND  0x32
 #define LL_WAKE_UP_ACK  0x33
 
+#define HCILL_SLEEP_MODE_OPCODE 0xFD0C
+
 /* initialize and de-init ST LL */
 long st_ll_init(struct st_data_s *);
 long st_ll_deinit(struct st_data_s *);
@@ -386,9 +391,17 @@ void st_ll_disable(struct st_data_s *);
  * various funcs used by ST core to set/get the various PM states
  * of the chip.
  */
+
+#ifdef CONFIG_TI_ST
 unsigned long st_ll_getstate(struct st_data_s *);
+#else
+static inline unsigned long st_ll_getstate(struct st_data_s *ll){ return 0; }
+#endif
 unsigned long st_ll_sleep_state(struct st_data_s *, unsigned char);
 void st_ll_wakeup(struct st_data_s *);
+int bluesleep_start(struct uart_port *);
+void bluesleep_stop(void);
+
 
 /*
  * header information used by st_core.c for FM and GPS
@@ -410,7 +423,28 @@ struct gps_event_hdr {
         u16 plen;
 } __attribute__ ((packed));
 
-/* platform data */
+/**
+ * struct ti_st_plat_data - platform data shared between ST driver and
+ *      platform specific board file which adds the ST device.
+ * @nshutdown_gpio: Host's GPIO line to which chip's BT_EN is connected.
+ * @dev_name: The UART/TTY name to which chip is interfaced. (eg: /dev/ttyS1)
+ * @flow_cntrl: Should always be 1, since UART's CTS/RTS is used for PM
+ *      purposes.
+ * @baud_rate: The baud rate supported by the Host UART controller, this will
+ *      be shared across with the chip via a HCI VS command from User-Space Init
+ *      Mgr application.
+ * @suspend:
+ * @resume: legacy PM routines hooked to platform specific board file, so as
+ *      to take chip-host interface specific action.
+ * @chip_enable:
+ * @chip_disable: Platform/Interface specific mux mode setting, GPIO
+ *      configuring, Host side PM disabling etc.. can be done here.
+ * @chip_asleep:
+ * @chip_awake: Chip specific deep sleep states is communicated to Host
+ *      specific board-xx.c to take actions such as cut UART clocks when chip
+ *      asleep or run host faster when chip awake etc..
+ *
+ */
 struct ti_st_plat_data {
         long nshutdown_gpio;
         unsigned char dev_name[UART_DEV_NAME_LEN]; /* uart name */
diff --git a/include/linux/tps80031-charger.h b/include/linux/tps80031-charger.h
new file mode 100644
index 00000000000..26c228edc30
--- /dev/null
+++ b/include/linux/tps80031-charger.h
@@ -0,0 +1,62 @@
+/*
+ * include/linux/tps80031-charger.h
+ *
+ * Battery charger driver interface for TI TPS80031 PMIC
+ *
+ * Copyright (C) 2011 NVIDIA Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#ifndef __LINUX_TPS80031_CHARGER_H
+#define __LINUX_TPS80031_CHARGER_H
+
+#include <linux/regulator/machine.h>
+
+enum charging_states {
+        charging_state_idle,
+        charging_state_charging_in_progress,
+        charging_state_charging_completed,
+        charging_state_charging_stopped,
+};
+
+/**
+ * Callback type definition which is called when any state changed in the
+ * charging.
+ */
+typedef void (*charging_callback_t)(enum charging_states state, void *args);
+
+struct tps80031_charger_platform_data {
+        int regulator_id;
+        int max_charge_volt_mV;
+        int max_charge_current_mA;
+        int charging_term_current_mA;
+        int refresh_time;
+        int irq_base;
+        int watch_time_sec;
+        struct regulator_consumer_supply *consumer_supplies;
+        int num_consumer_supplies;
+        int (*board_init)(void *board_data);
+        void *board_data;
+};
+
+/**
+ * Register the callback function for the client. This callback gets called
+ * when there is any change in the chanrging states.
+ */
+extern int register_charging_state_callback(charging_callback_t cb, void *args);
+
+#endif /*__LINUX_TPS80031_CHARGER_H */
diff --git a/include/linux/tracedump.h b/include/linux/tracedump.h
new file mode 100644
index 00000000000..9e86946e354
--- /dev/null
+++ b/include/linux/tracedump.h
@@ -0,0 +1,43 @@
+/*
+ * include/linux/tracedump.h
+ *
+ * Copyright (c) 2011, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ */
+
+#ifndef _LINUX_KERNEL_TRACEDUMP_H
+#define _LINUX_KERNEL_TRACEDUMP_H
+
+/* tracedump
+ * This module provides additional mechanisms for retreiving tracing data.
+ * For details on configurations, parameters and usage, see tracedump.txt.
+ */
+
+#define TD_NO_PRINT 0
+#define TD_PRINT_CONSOLE 1
+#define TD_PRINT_USER 2
+
+/* Dump the tracer to console */
+int tracedump_dump(size_t max_out);
+
+/* Dumping functions */
+int tracedump_init(void);
+ssize_t tracedump_all(int print_to);
+ssize_t tracedump_next(size_t max_out, int print_to);
+int tracedump_reset(void);
+int tracedump_deinit(void);
+
+#endif /* _LINUX_KERNEL_TRACEDUMP_H */
diff --git a/include/linux/tracehook.h b/include/linux/tracehook.h
index e95f5236611..a71a2927a6a 100644
--- a/include/linux/tracehook.h
+++ b/include/linux/tracehook.h
@@ -51,27 +51,12 @@
 #include <linux/security.h>
 struct linux_binprm;
 
-/**
- * tracehook_expect_breakpoints - guess if task memory might be touched
- * @task:               current task, making a new mapping
- *
- * Return nonzero if @task is expected to want breakpoint insertion in
- * its memory at some point.  A zero return is no guarantee it won't
- * be done, but this is a hint that it's known to be likely.
- *
- * May be called with @task->mm->mmap_sem held for writing.
- */
-static inline int tracehook_expect_breakpoints(struct task_struct *task)
-{
-        return (task_ptrace(task) & PT_PTRACED) != 0;
-}
-
 /*
  * ptrace report for syscall entry and exit looks identical.
  */
 static inline void ptrace_report_syscall(struct pt_regs *regs)
 {
-        int ptrace = task_ptrace(current);
+        int ptrace = current->ptrace;
 
         if (!(ptrace & PT_PTRACED))
                 return;
@@ -145,229 +130,6 @@ static inline void tracehook_report_syscall_exit(struct pt_regs *regs, int step)
 }
 
 /**
- * tracehook_unsafe_exec - check for exec declared unsafe due to tracing
- * @task:               current task doing exec
- *
- * Return %LSM_UNSAFE_* bits applied to an exec because of tracing.
- *
- * @task->signal->cred_guard_mutex is held by the caller through the do_execve().
- */
-static inline int tracehook_unsafe_exec(struct task_struct *task)
-{
-        int unsafe = 0;
-        int ptrace = task_ptrace(task);
-        if (ptrace & PT_PTRACED) {
-                if (ptrace & PT_PTRACE_CAP)
-                        unsafe |= LSM_UNSAFE_PTRACE_CAP;
-                else
-                        unsafe |= LSM_UNSAFE_PTRACE;
-        }
-        return unsafe;
-}
-
-/**
- * tracehook_tracer_task - return the task that is tracing the given task
- * @tsk:                task to consider
- *
- * Returns NULL if no one is tracing @task, or the &struct task_struct
- * pointer to its tracer.
- *
- * Must called under rcu_read_lock().  The pointer returned might be kept
- * live only by RCU.  During exec, this may be called with task_lock()
- * held on @task, still held from when tracehook_unsafe_exec() was called.
- */
-static inline struct task_struct *tracehook_tracer_task(struct task_struct *tsk)
-{
-        if (task_ptrace(tsk) & PT_PTRACED)
-                return rcu_dereference(tsk->parent);
-        return NULL;
-}
-
-/**
- * tracehook_report_exec - a successful exec was completed
- * @fmt:                &struct linux_binfmt that performed the exec
- * @bprm:               &struct linux_binprm containing exec details
- * @regs:               user-mode register state
- *
- * An exec just completed, we are shortly going to return to user mode.
- * The freshly initialized register state can be seen and changed in @regs.
- * The name, file and other pointers in @bprm are still on hand to be
- * inspected, but will be freed as soon as this returns.
- *
- * Called with no locks, but with some kernel resources held live
- * and a reference on @fmt->module.
- */
-static inline void tracehook_report_exec(struct linux_binfmt *fmt,
-                                         struct linux_binprm *bprm,
-                                         struct pt_regs *regs)
-{
-        if (!ptrace_event(PT_TRACE_EXEC, PTRACE_EVENT_EXEC, 0) &&
-            unlikely(task_ptrace(current) & PT_PTRACED))
-                send_sig(SIGTRAP, current, 0);
-}
-
-/**
- * tracehook_report_exit - task has begun to exit
- * @exit_code:          pointer to value destined for @current->exit_code
- *
- * @exit_code points to the value passed to do_exit(), which tracing
- * might change here.  This is almost the first thing in do_exit(),
- * before freeing any resources or setting the %PF_EXITING flag.
- *
- * Called with no locks held.
- */
-static inline void tracehook_report_exit(long *exit_code)
-{
-        ptrace_event(PT_TRACE_EXIT, PTRACE_EVENT_EXIT, *exit_code);
-}
-
-/**
- * tracehook_prepare_clone - prepare for new child to be cloned
- * @clone_flags:        %CLONE_* flags from clone/fork/vfork system call
- *
- * This is called before a new user task is to be cloned.
- * Its return value will be passed to tracehook_finish_clone().
- *
- * Called with no locks held.
- */
-static inline int tracehook_prepare_clone(unsigned clone_flags)
-{
-        if (clone_flags & CLONE_UNTRACED)
-                return 0;
-
-        if (clone_flags & CLONE_VFORK) {
-                if (current->ptrace & PT_TRACE_VFORK)
-                        return PTRACE_EVENT_VFORK;
-        } else if ((clone_flags & CSIGNAL) != SIGCHLD) {
-                if (current->ptrace & PT_TRACE_CLONE)
-                        return PTRACE_EVENT_CLONE;
-        } else if (current->ptrace & PT_TRACE_FORK)
-                return PTRACE_EVENT_FORK;
-
-        return 0;
-}
-
-/**
- * tracehook_finish_clone - new child created and being attached
- * @child:              new child task
- * @clone_flags:        %CLONE_* flags from clone/fork/vfork system call
- * @trace:              return value from tracehook_prepare_clone()
- *
- * This is called immediately after adding @child to its parent's children list.
- * The @trace value is that returned by tracehook_prepare_clone().
- *
- * Called with current's siglock and write_lock_irq(&tasklist_lock) held.
- */
-static inline void tracehook_finish_clone(struct task_struct *child,
-                                          unsigned long clone_flags, int trace)
-{
-        ptrace_init_task(child, (clone_flags & CLONE_PTRACE) || trace);
-}
-
-/**
- * tracehook_report_clone - in parent, new child is about to start running
- * @regs:               parent's user register state
- * @clone_flags:        flags from parent's system call
- * @pid:                new child's PID in the parent's namespace
- * @child:              new child task
- *
- * Called after a child is set up, but before it has been started running.
- * This is not a good place to block, because the child has not started
- * yet.  Suspend the child here if desired, and then block in
- * tracehook_report_clone_complete().  This must prevent the child from
- * self-reaping if tracehook_report_clone_complete() uses the @child
- * pointer; otherwise it might have died and been released by the time
- * tracehook_report_clone_complete() is called.
- *
- * Called with no locks held, but the child cannot run until this returns.
- */
-static inline void tracehook_report_clone(struct pt_regs *regs,
-                                          unsigned long clone_flags,
-                                          pid_t pid, struct task_struct *child)
-{
-        if (unlikely(task_ptrace(child))) {
-                /*
-                 * It doesn't matter who attached/attaching to this
-                 * task, the pending SIGSTOP is right in any case.
-                 */
-                sigaddset(&child->pending.signal, SIGSTOP);
-                set_tsk_thread_flag(child, TIF_SIGPENDING);
-        }
-}
-
-/**
- * tracehook_report_clone_complete - new child is running
- * @trace:              return value from tracehook_prepare_clone()
- * @regs:               parent's user register state
- * @clone_flags:        flags from parent's system call
- * @pid:                new child's PID in the parent's namespace
- * @child:              child task, already running
- *
- * This is called just after the child has started running.  This is
- * just before the clone/fork syscall returns, or blocks for vfork
- * child completion if @clone_flags has the %CLONE_VFORK bit set.
- * The @child pointer may be invalid if a self-reaping child died and
- * tracehook_report_clone() took no action to prevent it from self-reaping.
- *
- * Called with no locks held.
- */
-static inline void tracehook_report_clone_complete(int trace,
-                                                   struct pt_regs *regs,
-                                                   unsigned long clone_flags,
-                                                   pid_t pid,
-                                                   struct task_struct *child)
-{
-        if (unlikely(trace))
-                ptrace_event(0, trace, pid);
-}
-
-/**
- * tracehook_report_vfork_done - vfork parent's child has exited or exec'd
- * @child:              child task, already running
- * @pid:                new child's PID in the parent's namespace
- *
- * Called after a %CLONE_VFORK parent has waited for the child to complete.
- * The clone/vfork system call will return immediately after this.
- * The @child pointer may be invalid if a self-reaping child died and
- * tracehook_report_clone() took no action to prevent it from self-reaping.
- *
- * Called with no locks held.
- */
-static inline void tracehook_report_vfork_done(struct task_struct *child,
-                                               pid_t pid)
-{
-        ptrace_event(PT_TRACE_VFORK_DONE, PTRACE_EVENT_VFORK_DONE, pid);
-}
-
-/**
- * tracehook_prepare_release_task - task is being reaped, clean up tracing
- * @task:               task in %EXIT_DEAD state
- *
- * This is called in release_task() just before @task gets finally reaped
- * and freed.  This would be the ideal place to remove and clean up any
- * tracing-related state for @task.
- *
- * Called with no locks held.
- */
-static inline void tracehook_prepare_release_task(struct task_struct *task)
-{
-}
-
-/**
- * tracehook_finish_release_task - final tracing clean-up
- * @task:               task in %EXIT_DEAD state
- *
- * This is called in release_task() when @task is being in the middle of
- * being reaped.  After this, there must be no tracing entanglements.
- *
- * Called with write_lock_irq(&tasklist_lock) held.
- */
-static inline void tracehook_finish_release_task(struct task_struct *task)
-{
-        ptrace_release_task(task);
-}
-
-/**
  * tracehook_signal_handler - signal handler setup is complete
  * @sig:                number of signal being delivered
  * @info:               siginfo_t of signal being delivered
@@ -390,151 +152,6 @@ static inline void tracehook_signal_handler(int sig, siginfo_t *info,
                 ptrace_notify(SIGTRAP);
 }
 
-/**
- * tracehook_consider_ignored_signal - suppress short-circuit of ignored signal
- * @task:               task receiving the signal
- * @sig:                signal number being sent
- *
- * Return zero iff tracing doesn't care to examine this ignored signal,
- * so it can short-circuit normal delivery and never even get queued.
- *
- * Called with @task->sighand->siglock held.
- */
-static inline int tracehook_consider_ignored_signal(struct task_struct *task,
-                                                    int sig)
-{
-        return (task_ptrace(task) & PT_PTRACED) != 0;
-}
-
-/**
- * tracehook_consider_fatal_signal - suppress special handling of fatal signal
- * @task:               task receiving the signal
- * @sig:                signal number being sent
- *
- * Return nonzero to prevent special handling of this termination signal.
- * Normally handler for signal is %SIG_DFL.  It can be %SIG_IGN if @sig is
- * ignored, in which case force_sig() is about to reset it to %SIG_DFL.
- * When this returns zero, this signal might cause a quick termination
- * that does not give the debugger a chance to intercept the signal.
- *
- * Called with or without @task->sighand->siglock held.
- */
-static inline int tracehook_consider_fatal_signal(struct task_struct *task,
-                                                  int sig)
-{
-        return (task_ptrace(task) & PT_PTRACED) != 0;
-}
-
-/**
- * tracehook_force_sigpending - let tracing force signal_pending(current) on
- *
- * Called when recomputing our signal_pending() flag.  Return nonzero
- * to force the signal_pending() flag on, so that tracehook_get_signal()
- * will be called before the next return to user mode.
- *
- * Called with @current->sighand->siglock held.
- */
-static inline int tracehook_force_sigpending(void)
-{
-        return 0;
-}
-
-/**
- * tracehook_get_signal - deliver synthetic signal to traced task
- * @task:               @current
- * @regs:               task_pt_regs(@current)
- * @info:               details of synthetic signal
- * @return_ka:          sigaction for synthetic signal
- *
- * Return zero to check for a real pending signal normally.
- * Return -1 after releasing the siglock to repeat the check.
- * Return a signal number to induce an artificial signal delivery,
- * setting *@info and *@return_ka to specify its details and behavior.
- *
- * The @return_ka->sa_handler value controls the disposition of the
- * signal, no matter the signal number.  For %SIG_DFL, the return value
- * is a representative signal to indicate the behavior (e.g. %SIGTERM
- * for death, %SIGQUIT for core dump, %SIGSTOP for job control stop,
- * %SIGTSTP for stop unless in an orphaned pgrp), but the signal number
- * reported will be @info->si_signo instead.
- *
- * Called with @task->sighand->siglock held, before dequeuing pending signals.
- */
-static inline int tracehook_get_signal(struct task_struct *task,
-                                       struct pt_regs *regs,
-                                       siginfo_t *info,
-                                       struct k_sigaction *return_ka)
-{
-        return 0;
-}
-
-/**
- * tracehook_finish_jctl - report about return from job control stop
- *
- * This is called by do_signal_stop() after wakeup.
- */
-static inline void tracehook_finish_jctl(void)
-{
-}
-
-#define DEATH_REAP                      -1
-#define DEATH_DELAYED_GROUP_LEADER      -2
-
-/**
- * tracehook_notify_death - task is dead, ready to notify parent
- * @task:               @current task now exiting
- * @death_cookie:       value to pass to tracehook_report_death()
- * @group_dead:         nonzero if this was the last thread in the group to die
- *
- * A return value >= 0 means call do_notify_parent() with that signal
- * number.  Negative return value can be %DEATH_REAP to self-reap right
- * now, or %DEATH_DELAYED_GROUP_LEADER to a zombie without notifying our
- * parent.  Note that a return value of 0 means a do_notify_parent() call
- * that sends no signal, but still wakes up a parent blocked in wait*().
- *
- * Called with write_lock_irq(&tasklist_lock) held.
- */
-static inline int tracehook_notify_death(struct task_struct *task,
-                                         void **death_cookie, int group_dead)
-{
-        if (task_detached(task))
-                return task->ptrace ? SIGCHLD : DEATH_REAP;
-
-        /*
-         * If something other than our normal parent is ptracing us, then
-         * send it a SIGCHLD instead of honoring exit_signal.  exit_signal
-         * only has special meaning to our real parent.
-         */
-        if (thread_group_empty(task) && !ptrace_reparented(task))
-                return task->exit_signal;
-
-        return task->ptrace ? SIGCHLD : DEATH_DELAYED_GROUP_LEADER;
-}
-
-/**
- * tracehook_report_death - task is dead and ready to be reaped
- * @task:               @current task now exiting
- * @signal:             return value from tracheook_notify_death()
- * @death_cookie:       value passed back from tracehook_notify_death()
- * @group_dead:         nonzero if this was the last thread in the group to die
- *
- * Thread has just become a zombie or is about to self-reap.  If positive,
- * @signal is the signal number just sent to the parent (usually %SIGCHLD).
- * If @signal is %DEATH_REAP, this thread will self-reap.  If @signal is
- * %DEATH_DELAYED_GROUP_LEADER, this is a delayed_group_leader() zombie.
- * The @death_cookie was passed back by tracehook_notify_death().
- *
- * If normal reaping is not inhibited, @task->exit_state might be changing
- * in parallel.
- *
- * Called without locks.
- */
-static inline void tracehook_report_death(struct task_struct *task,
-                                          int signal, void *death_cookie,
-                                          int group_dead)
-{
-}
-
 #ifdef TIF_NOTIFY_RESUME
 /**
  * set_notify_resume - cause tracehook_notify_resume() to be called
diff --git a/include/linux/tracelevel.h b/include/linux/tracelevel.h
new file mode 100644
index 00000000000..ac3351c6ed8
--- /dev/null
+++ b/include/linux/tracelevel.h
@@ -0,0 +1,42 @@
+/*
+ * include/linux/tracelevel.c
+ *
+ * Copyright (c) 2011, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ */
+
+#ifndef _TRACELEVEL_H
+#define _TRACELEVEL_H
+
+/* tracelevel allows a subsystem author to add priorities to
+ * trace_events. For usage details, see tracelevel.txt.
+ */
+
+#define TRACELEVEL_ERR 3
+#define TRACELEVEL_WARN 2
+#define TRACELEVEL_INFO 1
+#define TRACELEVEL_DEBUG 0
+
+#define TRACELEVEL_MAX TRACELEVEL_ERR
+#define TRACELEVEL_DEFAULT TRACELEVEL_ERR
+
+int __tracelevel_register(char *name, unsigned int level);
+int tracelevel_set_level(int level);
+
+#define tracelevel_register(name, level)        \
+        __tracelevel_register(#name, level)
+
+#endif /* _TRACELEVEL_H */
diff --git a/include/linux/tty.h b/include/linux/tty.h
index d6f05292e45..969daca2107 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -5,24 +5,6 @@
  * 'tty.h' defines some structures used by tty_io.c and some defines.
  */
 
-#ifdef __KERNEL__
-#include <linux/fs.h>
-#include <linux/major.h>
-#include <linux/termios.h>
-#include <linux/workqueue.h>
-#include <linux/tty_driver.h>
-#include <linux/tty_ldisc.h>
-#include <linux/mutex.h>
-
-#include <asm/system.h>
-
-
-/*
- * (Note: the *_driver.minor_start values 1, 64, 128, 192 are
- * hardcoded at present.)
- */
-#define NR_UNIX98_PTY_DEFAULT   4096      /* Default maximum for Unix98 ptys */
-#define NR_UNIX98_PTY_MAX       (1 << MINORBITS) /* Absolute limit */
 #define NR_LDISCS               30
 
 /* line disciplines */
@@ -53,6 +35,25 @@
 #define N_TRACESINK     23      /* Trace data routing for MIPI P1149.7 */
 #define N_TRACEROUTER   24      /* Trace data routing for MIPI P1149.7 */
 
+#ifdef __KERNEL__
+#include <linux/fs.h>
+#include <linux/major.h>
+#include <linux/termios.h>
+#include <linux/workqueue.h>
+#include <linux/tty_driver.h>
+#include <linux/tty_ldisc.h>
+#include <linux/mutex.h>
+
+#include <asm/system.h>
+
+
+/*
+ * (Note: the *_driver.minor_start values 1, 64, 128, 192 are
+ * hardcoded at present.)
+ */
+#define NR_UNIX98_PTY_DEFAULT   4096      /* Default maximum for Unix98 ptys */
+#define NR_UNIX98_PTY_MAX       (1 << MINORBITS) /* Absolute limit */
+
 /*
  * This character is the same as _POSIX_VDISABLE: it cannot be used as
  * a c_cc[] character, but indicates that a particular special character
@@ -294,7 +295,7 @@ struct tty_struct {
         void *driver_data;
         struct list_head tty_files;
 
-#define N_TTY_BUF_SIZE 4096
+#define N_TTY_BUF_SIZE 32768
 
         /*
          * The following is data for the N_TTY line discipline.  For
@@ -420,6 +421,8 @@ extern void tty_driver_flush_buffer(struct tty_struct *tty);
 extern void tty_throttle(struct tty_struct *tty);
 extern void tty_unthrottle(struct tty_struct *tty);
 extern int tty_do_resize(struct tty_struct *tty, struct winsize *ws);
+extern void tty_driver_remove_tty(struct tty_driver *driver,
+                                  struct tty_struct *tty);
 extern void tty_shutdown(struct tty_struct *tty);
 extern void tty_free_termios(struct tty_struct *tty);
 extern int is_current_pgrp_orphaned(void);
@@ -470,7 +473,9 @@ extern void proc_clear_tty(struct task_struct *p);
 extern struct tty_struct *get_current_tty(void);
 extern void tty_default_fops(struct file_operations *fops);
 extern struct tty_struct *alloc_tty_struct(void);
-extern int tty_add_file(struct tty_struct *tty, struct file *file);
+extern int tty_alloc_file(struct file *file);
+extern void tty_add_file(struct tty_struct *tty, struct file *file);
+extern void tty_free_file(struct file *file);
 extern void free_tty_struct(struct tty_struct *tty);
 extern void initialize_tty_struct(struct tty_struct *tty,
                 struct tty_driver *driver, int idx);
diff --git a/include/linux/tty_driver.h b/include/linux/tty_driver.h
index 9deeac85524..ecdaeb98b29 100644
--- a/include/linux/tty_driver.h
+++ b/include/linux/tty_driver.h
@@ -47,6 +47,9 @@
  *
  *      This routine is called synchronously when a particular tty device
  *      is closed for the last time freeing up the resources.
+ *      Note that tty_shutdown() is not called if ops->shutdown is defined.
+ *      This means one is responsible to take care of calling ops->remove (e.g.
+ *      via tty_driver_remove_tty) and releasing tty->termios.
  *
  *
  * void (*cleanup)(struct tty_struct * tty);
diff --git a/include/linux/uid_stat.h b/include/linux/uid_stat.h
new file mode 100644
index 00000000000..6bd6c4e52d1
--- /dev/null
+++ b/include/linux/uid_stat.h
@@ -0,0 +1,29 @@
+/* include/linux/uid_stat.h
+ *
+ * Copyright (C) 2008-2009 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef __uid_stat_h
+#define __uid_stat_h
+
+/* Contains definitions for resource tracking per uid. */
+
+#ifdef CONFIG_UID_STAT
+int uid_stat_tcp_snd(uid_t uid, int size);
+int uid_stat_tcp_rcv(uid_t uid, int size);
+#else
+#define uid_stat_tcp_snd(uid, size) do {} while (0);
+#define uid_stat_tcp_rcv(uid, size) do {} while (0);
+#endif
+
+#endif /* _LINUX_UID_STAT_H */
diff --git a/include/linux/usb.h b/include/linux/usb.h
index 73c7df48960..b08e04cf202 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -1202,6 +1202,7 @@ struct urb {
         void *transfer_buffer;          /* (in) associated data buffer */
         dma_addr_t transfer_dma;        /* (in) dma addr for transfer_buffer */
         struct scatterlist *sg;         /* (in) scatter gather buffer list */
+        int num_mapped_sgs;             /* (internal) mapped sg entries */
         int num_sgs;                    /* (in) number of entries in the sg list */
         u32 transfer_buffer_length;     /* (in) data buffer length */
         u32 actual_length;              /* (return) actual transfer length */
diff --git a/include/linux/usb/ch9.h b/include/linux/usb/ch9.h
index 0fd3fbdd828..cf65b5cff72 100644
--- a/include/linux/usb/ch9.h
+++ b/include/linux/usb/ch9.h
@@ -583,8 +583,26 @@ struct usb_ss_ep_comp_descriptor {
 } __attribute__ ((packed));
 
 #define USB_DT_SS_EP_COMP_SIZE          6
+
 /* Bits 4:0 of bmAttributes if this is a bulk endpoint */
-#define USB_SS_MAX_STREAMS(p)           (1 << ((p) & 0x1f))
+static inline int
+usb_ss_max_streams(const struct usb_ss_ep_comp_descriptor *comp)
+{
+        int             max_streams;
+
+        if (!comp)
+                return 0;
+
+        max_streams = comp->bmAttributes & 0x1f;
+
+        if (!max_streams)
+                return 0;
+
+        max_streams = 1 << max_streams;
+
+        return max_streams;
+}
+
 /* Bits 1:0 of bmAttributes if this is an isoc endpoint */
 #define USB_SS_MULT(p)                  (1 + ((p) & 0x3))
 
diff --git a/include/linux/usb/composite.h b/include/linux/usb/composite.h
index b78cba466d3..6938a8608cf 100644
--- a/include/linux/usb/composite.h
+++ b/include/linux/usb/composite.h
@@ -59,6 +59,10 @@ struct usb_configuration;
  * @hs_descriptors: Table of high speed descriptors, using interface and
  *      string identifiers assigned during @bind().  If this pointer is null,
  *      the function will not be available at high speed.
+ * @ss_descriptors: Table of super speed descriptors, using interface and
+ *      string identifiers assigned during @bind(). If this
+ *      pointer is null after initiation, the function will not
+ *      be available at super speed.
  * @config: assigned when @usb_add_function() is called; this is the
  *      configuration with which this function is associated.
  * @bind: Before the gadget can register, all of its functions bind() to the
@@ -77,6 +81,10 @@ struct usb_configuration;
  * @setup: Used for interface-specific control requests.
  * @suspend: Notifies functions when the host stops sending USB traffic.
  * @resume: Notifies functions when the host restarts USB traffic.
+ * @get_status: Returns function status as a reply to
+ *      GetStatus() request when the recepient is Interface.
+ * @func_suspend: callback to be called when
+ *      SetFeature(FUNCTION_SUSPEND) is reseived
  *
  * A single USB function uses one or more interfaces, and should in most
  * cases support operation at both full and high speeds.  Each function is
@@ -106,6 +114,7 @@ struct usb_function {
         struct usb_gadget_strings       **strings;
         struct usb_descriptor_header    **descriptors;
         struct usb_descriptor_header    **hs_descriptors;
+        struct usb_descriptor_header    **ss_descriptors;
 
         struct usb_configuration        *config;
 
@@ -132,6 +141,10 @@ struct usb_function {
         void                    (*suspend)(struct usb_function *);
         void                    (*resume)(struct usb_function *);
 
+        /* USB 3.0 additions */
+        int                     (*get_status)(struct usb_function *);
+        int                     (*func_suspend)(struct usb_function *,
+                                                u8 suspend_opt);
         /* private: */
         /* internals */
         struct list_head                list;
@@ -145,20 +158,8 @@ int usb_function_activate(struct usb_function *);
 
 int usb_interface_id(struct usb_configuration *, struct usb_function *);
 
-/**
- * ep_choose - select descriptor endpoint at current device speed
- * @g: gadget, connected and running at some speed
- * @hs: descriptor to use for high speed operation
- * @fs: descriptor to use for full or low speed operation
- */
-static inline struct usb_endpoint_descriptor *
-ep_choose(struct usb_gadget *g, struct usb_endpoint_descriptor *hs,
-                struct usb_endpoint_descriptor *fs)
-{
-        if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
-                return hs;
-        return fs;
-}
+int config_ep_by_speed(struct usb_gadget *g, struct usb_function *f,
+                        struct usb_ep *_ep);
 
 #define MAX_CONFIG_INTERFACES           16      /* arbitrary; max 255 */
 
@@ -231,6 +232,7 @@ struct usb_configuration {
         struct list_head        list;
         struct list_head        functions;
         u8                      next_interface_id;
+        unsigned                superspeed:1;
         unsigned                highspeed:1;
         unsigned                fullspeed:1;
         struct usb_function     *interface[MAX_CONFIG_INTERFACES];
@@ -240,6 +242,9 @@ int usb_add_config(struct usb_composite_dev *,
                 struct usb_configuration *,
                 int (*)(struct usb_configuration *));
 
+int usb_remove_config(struct usb_composite_dev *,
+                struct usb_configuration *);
+
 /**
  * struct usb_composite_driver - groups configurations into a gadget
  * @name: For diagnostics, identifies the driver.
@@ -252,6 +257,7 @@ int usb_add_config(struct usb_composite_dev *,
  *      identifiers.
  * @strings: tables of strings, keyed by identifiers assigned during bind()
  *      and language IDs provided in control requests
+ * @max_speed: Highest speed the driver supports.
  * @needs_serial: set to 1 if the gadget needs userspace to provide
  *      a serial number.  If one is not provided, warning will be printed.
  * @unbind: Reverses bind; called as a side effect of unregistering
@@ -279,6 +285,7 @@ struct usb_composite_driver {
         const char                              *iManufacturer;
         const struct usb_device_descriptor      *dev;
         struct usb_gadget_strings               **strings;
+        enum usb_device_speed                   max_speed;
         unsigned                needs_serial:1;
 
         int                     (*unbind)(struct usb_composite_dev *);
diff --git a/include/linux/usb/f_accessory.h b/include/linux/usb/f_accessory.h
new file mode 100644
index 00000000000..5b2dcf9728e
--- /dev/null
+++ b/include/linux/usb/f_accessory.h
@@ -0,0 +1,83 @@
+/*
+ * Gadget Function Driver for Android USB accessories
+ *
+ * Copyright (C) 2011 Google, Inc.
+ * Author: Mike Lockwood <lockwood@android.com>
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef __LINUX_USB_F_ACCESSORY_H
+#define __LINUX_USB_F_ACCESSORY_H
+
+/* Use Google Vendor ID when in accessory mode */
+#define USB_ACCESSORY_VENDOR_ID 0x18D1
+
+
+/* Product ID to use when in accessory mode */
+#define USB_ACCESSORY_PRODUCT_ID 0x2D00
+
+/* Product ID to use when in accessory mode and adb is enabled */
+#define USB_ACCESSORY_ADB_PRODUCT_ID 0x2D01
+
+/* Indexes for strings sent by the host via ACCESSORY_SEND_STRING */
+#define ACCESSORY_STRING_MANUFACTURER   0
+#define ACCESSORY_STRING_MODEL          1
+#define ACCESSORY_STRING_DESCRIPTION    2
+#define ACCESSORY_STRING_VERSION        3
+#define ACCESSORY_STRING_URI            4
+#define ACCESSORY_STRING_SERIAL         5
+
+/* Control request for retrieving device's protocol version (currently 1)
+ *
+ *      requestType:    USB_DIR_IN | USB_TYPE_VENDOR
+ *      request:        ACCESSORY_GET_PROTOCOL
+ *      value:          0
+ *      index:          0
+ *      data            version number (16 bits little endian)
+ */
+#define ACCESSORY_GET_PROTOCOL  51
+
+/* Control request for host to send a string to the device
+ *
+ *      requestType:    USB_DIR_OUT | USB_TYPE_VENDOR
+ *      request:        ACCESSORY_SEND_STRING
+ *      value:          0
+ *      index:          string ID
+ *      data            zero terminated UTF8 string
+ *
+ *  The device can later retrieve these strings via the
+ *  ACCESSORY_GET_STRING_* ioctls
+ */
+#define ACCESSORY_SEND_STRING   52
+
+/* Control request for starting device in accessory mode.
+ * The host sends this after setting all its strings to the device.
+ *
+ *      requestType:    USB_DIR_OUT | USB_TYPE_VENDOR
+ *      request:        ACCESSORY_START
+ *      value:          0
+ *      index:          0
+ *      data            none
+ */
+#define ACCESSORY_START         53
+
+/* ioctls for retrieving strings set by the host */
+#define ACCESSORY_GET_STRING_MANUFACTURER   _IOW('M', 1, char[256])
+#define ACCESSORY_GET_STRING_MODEL          _IOW('M', 2, char[256])
+#define ACCESSORY_GET_STRING_DESCRIPTION    _IOW('M', 3, char[256])
+#define ACCESSORY_GET_STRING_VERSION        _IOW('M', 4, char[256])
+#define ACCESSORY_GET_STRING_URI            _IOW('M', 5, char[256])
+#define ACCESSORY_GET_STRING_SERIAL         _IOW('M', 6, char[256])
+/* returns 1 if there is a start request pending */
+#define ACCESSORY_IS_START_REQUESTED        _IO('M', 7)
+
+#endif /* __LINUX_USB_F_ACCESSORY_H */
diff --git a/include/linux/usb/f_mtp.h b/include/linux/usb/f_mtp.h
new file mode 100644
index 00000000000..7422b17c6eb
--- /dev/null
+++ b/include/linux/usb/f_mtp.h
@@ -0,0 +1,75 @@
+/*
+ * Gadget Function Driver for MTP
+ *
+ * Copyright (C) 2010 Google, Inc.
+ * Author: Mike Lockwood <lockwood@android.com>
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef __LINUX_USB_F_MTP_H
+#define __LINUX_USB_F_MTP_H
+
+#include <linux/ioctl.h>
+
+#ifdef __KERNEL__
+
+struct mtp_data_header {
+        /* length of packet, including this header */
+        uint32_t        length;
+        /* container type (2 for data packet) */
+        uint16_t        type;
+        /* MTP command code */
+        uint16_t    command;
+        /* MTP transaction ID */
+        uint32_t        transaction_id;
+};
+
+#endif /* __KERNEL__ */
+
+struct mtp_file_range {
+        /* file descriptor for file to transfer */
+        int                     fd;
+        /* offset in file for start of transfer */
+        loff_t          offset;
+        /* number of bytes to transfer */
+        int64_t         length;
+        /* MTP command ID for data header,
+         * used only for MTP_SEND_FILE_WITH_HEADER
+         */
+        uint16_t        command;
+        /* MTP transaction ID for data header,
+         * used only for MTP_SEND_FILE_WITH_HEADER
+         */
+        uint32_t        transaction_id;
+};
+
+struct mtp_event {
+        /* size of the event */
+        size_t          length;
+        /* event data to send */
+        void            *data;
+};
+
+/* Sends the specified file range to the host */
+#define MTP_SEND_FILE              _IOW('M', 0, struct mtp_file_range)
+/* Receives data from the host and writes it to a file.
+ * The file is created if it does not exist.
+ */
+#define MTP_RECEIVE_FILE           _IOW('M', 1, struct mtp_file_range)
+/* Sends an event to the host via the interrupt endpoint */
+#define MTP_SEND_EVENT             _IOW('M', 3, struct mtp_event)
+/* Sends the specified file range to the host,
+ * with a 12 byte MTP data packet header at the beginning.
+ */
+#define MTP_SEND_FILE_WITH_HEADER  _IOW('M', 4, struct mtp_file_range)
+
+#endif /* __LINUX_USB_F_MTP_H */
diff --git a/include/linux/usb/gadget.h b/include/linux/usb/gadget.h
index dd1571db55e..087f4b93183 100644
--- a/include/linux/usb/gadget.h
+++ b/include/linux/usb/gadget.h
@@ -15,7 +15,13 @@
 #ifndef __LINUX_USB_GADGET_H
 #define __LINUX_USB_GADGET_H
 
+#include <linux/device.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/list.h>
 #include <linux/slab.h>
+#include <linux/types.h>
+#include <linux/usb/ch9.h>
 
 struct usb_ep;
 
@@ -27,6 +33,7 @@ struct usb_ep;
  *      field, and the usb controller needs one, it is responsible
  *      for mapping and unmapping the buffer.
  * @length: Length of that data
+ * @stream_id: The stream id, when USB3.0 bulk streams are being used
  * @no_interrupt: If true, hints that no completion irq is needed.
  *      Helpful sometimes with deep request queues that are handled
  *      directly by DMA controllers.
@@ -81,6 +88,7 @@ struct usb_request {
         unsigned                length;
         dma_addr_t              dma;
 
+        unsigned                stream_id:16;
         unsigned                no_interrupt:1;
         unsigned                zero:1;
         unsigned                short_not_ok:1;
@@ -131,8 +139,17 @@ struct usb_ep_ops {
  * @maxpacket:The maximum packet size used on this endpoint.  The initial
  *      value can sometimes be reduced (hardware allowing), according to
  *      the endpoint descriptor used to configure the endpoint.
- * @driver_data:for use by the gadget driver.  all other fields are
- *      read-only to gadget drivers.
+ * @max_streams: The maximum number of streams supported
+ *      by this EP (0 - 16, actual number is 2^n)
+ * @mult: multiplier, 'mult' value for SS Isoc EPs
+ * @maxburst: the maximum number of bursts supported by this EP (for usb3)
+ * @driver_data:for use by the gadget driver.
+ * @address: used to identify the endpoint when finding descriptor that
+ *      matches connection speed
+ * @desc: endpoint descriptor.  This pointer is set before the endpoint is
+ *      enabled and remains valid until the endpoint is disabled.
+ * @comp_desc: In case of SuperSpeed support, this is the endpoint companion
+ *      descriptor that is used to configure the endpoint
  *
  * the bus controller driver lists all the general purpose endpoints in
  * gadget->ep_list.  the control endpoint (gadget->ep0) is not in that list,
@@ -145,6 +162,12 @@ struct usb_ep {
         const struct usb_ep_ops *ops;
         struct list_head        ep_list;
         unsigned                maxpacket:16;
+        unsigned                max_streams:16;
+        unsigned                mult:2;
+        unsigned                maxburst:4;
+        u8                      address;
+        const struct usb_endpoint_descriptor    *desc;
+        const struct usb_ss_ep_comp_descriptor  *comp_desc;
 };
 
 /*-------------------------------------------------------------------------*/
@@ -153,11 +176,8 @@ struct usb_ep {
  * usb_ep_enable - configure endpoint, making it usable
  * @ep:the endpoint being configured.  may not be the endpoint named "ep0".
  *      drivers discover endpoints through the ep_list of a usb_gadget.
- * @desc:descriptor for desired behavior.  caller guarantees this pointer
- *      remains valid until the endpoint is disabled; the data byte order
- *      is little-endian (usb-standard).
  *
- * when configurations are set, or when interface settings change, the driver
+ * When configurations are set, or when interface settings change, the driver
  * will enable or disable the relevant endpoints.  while it is enabled, an
  * endpoint may be used for i/o until the driver receives a disconnect() from
  * the host or until the endpoint is disabled.
@@ -172,10 +192,9 @@ struct usb_ep {
  *
  * returns zero, or a negative error code.
  */
-static inline int usb_ep_enable(struct usb_ep *ep,
-                                const struct usb_endpoint_descriptor *desc)
+static inline int usb_ep_enable(struct usb_ep *ep)
 {
-        return ep->ops->enable(ep, desc);
+        return ep->ops->enable(ep, ep->desc);
 }
 
 /**
@@ -416,7 +435,16 @@ static inline void usb_ep_fifo_flush(struct usb_ep *ep)
 
 /*-------------------------------------------------------------------------*/
 
+struct usb_dcd_config_params {
+        __u8  bU1devExitLat;    /* U1 Device exit Latency */
+#define USB_DEFULT_U1_DEV_EXIT_LAT      0x01    /* Less then 1 microsec */
+        __le16 bU2DevExitLat;   /* U2 Device exit Latency */
+#define USB_DEFULT_U2_DEV_EXIT_LAT      0x1F4   /* Less then 500 microsec */
+};
+
+
 struct usb_gadget;
+struct usb_gadget_driver;
 
 /* the rest of the api to the controller hardware: device operations,
  * which don't involve endpoints (or i/o).
@@ -430,6 +458,16 @@ struct usb_gadget_ops {
         int     (*pullup) (struct usb_gadget *, int is_on);
         int     (*ioctl)(struct usb_gadget *,
                                 unsigned code, unsigned long param);
+        void    (*get_config_params)(struct usb_dcd_config_params *);
+        int     (*udc_start)(struct usb_gadget *,
+                        struct usb_gadget_driver *);
+        int     (*udc_stop)(struct usb_gadget *,
+                        struct usb_gadget_driver *);
+
+        /* Those two are deprecated */
+        int     (*start)(struct usb_gadget_driver *,
+                        int (*bind)(struct usb_gadget *));
+        int     (*stop)(struct usb_gadget_driver *);
 };
 
 /**
@@ -521,6 +559,24 @@ static inline int gadget_is_dualspeed(struct usb_gadget *g)
 }
 
 /**
+ * gadget_is_superspeed() - return true if the hardware handles
+ * supperspeed
+ * @g: controller that might support supper speed
+ */
+static inline int gadget_is_superspeed(struct usb_gadget *g)
+{
+#ifdef CONFIG_USB_GADGET_SUPERSPEED
+        /*
+         * runtime test would check "g->is_superspeed" ... that might be
+         * useful to work around hardware bugs, but is mostly pointless
+         */
+        return 1;
+#else
+        return 0;
+#endif
+}
+
+/**
  * gadget_is_otg - return true iff the hardware is OTG-ready
  * @g: controller that might have a Mini-AB connector
  *
@@ -821,6 +877,9 @@ int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
  */
 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver);
 
+extern int usb_add_gadget_udc(struct device *parent, struct usb_gadget *gadget);
+extern void usb_del_gadget_udc(struct usb_gadget *gadget);
+
 /*-------------------------------------------------------------------------*/
 
 /* utility to simplify dealing with string descriptors */
@@ -870,12 +929,6 @@ int usb_gadget_config_buf(const struct usb_config_descriptor *config,
 struct usb_descriptor_header **usb_copy_descriptors(
                 struct usb_descriptor_header **);
 
-/* return copy of endpoint descriptor given original descriptor set */
-struct usb_endpoint_descriptor *usb_find_endpoint(
-        struct usb_descriptor_header **src,
-        struct usb_descriptor_header **copy,
-        struct usb_endpoint_descriptor *match);
-
 /**
  * usb_free_descriptors - free descriptors returned by usb_copy_descriptors()
  * @v: vector of descriptors
@@ -892,6 +945,11 @@ static inline void usb_free_descriptors(struct usb_descriptor_header **v)
 extern struct usb_ep *usb_ep_autoconfig(struct usb_gadget *,
                         struct usb_endpoint_descriptor *);
 
+
+extern struct usb_ep *usb_ep_autoconfig_ss(struct usb_gadget *,
+                        struct usb_endpoint_descriptor *,
+                        struct usb_ss_ep_comp_descriptor *);
+
 extern void usb_ep_autoconfig_reset(struct usb_gadget *);
 
 #endif /* __LINUX_USB_GADGET_H */
diff --git a/include/linux/usb/hcd.h b/include/linux/usb/hcd.h
index 0097136ba45..c0ecc5a2ef9 100644
--- a/include/linux/usb/hcd.h
+++ b/include/linux/usb/hcd.h
@@ -178,7 +178,7 @@ struct usb_hcd {
          * this structure.
          */
         unsigned long hcd_priv[0]
-                        __attribute__ ((aligned(sizeof(unsigned long))));
+                        __attribute__ ((aligned(sizeof(s64))));
 };
 
 /* 2.4 does this a bit differently ... */
diff --git a/include/linux/usb/m66592.h b/include/linux/usb/m66592.h
index cda9625e7df..a4ba31ab2fe 100644
--- a/include/linux/usb/m66592.h
+++ b/include/linux/usb/m66592.h
@@ -38,6 +38,8 @@ struct m66592_platdata {
         /* (external controller only) one = 3.3V, zero = 1.5V */
         unsigned        vif:1;
 
+        /* (external controller only) set one = WR0_N shorted to WR1_N */
+        unsigned        wr0_shorted_to_wr1:1;
 };
 
 #endif /* __LINUX_USB_M66592_H */
diff --git a/include/linux/usb/otg_id.h b/include/linux/usb/otg_id.h
new file mode 100644
index 00000000000..f9f5189a73b
--- /dev/null
+++ b/include/linux/usb/otg_id.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2011 Google, Inc.
+ *
+ * Author:
+ *      Colin Cross <ccross@android.com>
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef __LINUX_USB_OTG_ID_H
+#define __LINUX_USB_OTG_ID_H
+
+#include <linux/notifier.h>
+#include <linux/plist.h>
+
+/**
+ * otg_id_notifier_block
+ *
+ * @priority: Order the notifications will be called in.  Higher numbers
+ *    get called first.
+ * @detect: Called during otg_id_notify.  Return OTG_ID_HANDLED if the USB cable
+ *    has been identified
+ * @proxy_wait: Called during otg_id_notify if a previous handler returns
+ *    OTG_ID_PROXY_WAIT.  This should wait on ID change then call otg_id_notify.
+ *    This is used when a handler knows what's connected but can't detect
+ *    the change itself.
+ * @cancel: Called after detect has returned OTG_ID_HANDLED to ask it to
+ *    release detection resources to allow a new identification to occur.
+ */
+
+struct otg_id_notifier_block {
+        int priority;
+        int (*detect)(struct otg_id_notifier_block *otg_id_nb);
+        int (*proxy_wait)(struct otg_id_notifier_block *otg_id_nb);
+        void (*cancel)(struct otg_id_notifier_block *otg_id_nb);
+        struct plist_node p;
+};
+
+#define OTG_ID_PROXY_WAIT 2
+#define OTG_ID_HANDLED 1
+#define OTG_ID_UNHANDLED 0
+
+int otg_id_register_notifier(struct otg_id_notifier_block *otg_id_nb);
+void otg_id_unregister_notifier(struct otg_id_notifier_block *otg_id_nb);
+
+void otg_id_notify(void);
+int otg_id_suspend(void);
+void otg_id_resume(void);
+
+#endif /* __LINUX_USB_OTG_ID_H */
diff --git a/include/linux/usb/r8a66597.h b/include/linux/usb/r8a66597.h
index 26d21673405..b6b8660d0c6 100644
--- a/include/linux/usb/r8a66597.h
+++ b/include/linux/usb/r8a66597.h
@@ -3,7 +3,7 @@
  *
  * Copyright (C) 2009  Renesas Solutions Corp.
  *
- * Author : Yoshihiro Shimoda <shimoda.yoshihiro@renesas.com>
+ * Author : Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -31,6 +31,9 @@ struct r8a66597_platdata {
         /* This callback can control port power instead of DVSTCTR register. */
         void (*port_power)(int port, int power);
 
+        /* This parameter is for BUSWAIT */
+        u16             buswait;
+
         /* set one = on chip controller, set zero = external controller */
         unsigned        on_chip:1;
 
@@ -42,6 +45,9 @@ struct r8a66597_platdata {
 
         /* set one = big endian, set zero = little endian */
         unsigned        endian:1;
+
+        /* (external controller only) set one = WR0_N shorted to WR1_N */
+        unsigned        wr0_shorted_to_wr1:1;
 };
 
 /* Register definitions */
diff --git a/include/linux/usb/renesas_usbhs.h b/include/linux/usb/renesas_usbhs.h
index 3a7f1d982dd..8977431259c 100644
--- a/include/linux/usb/renesas_usbhs.h
+++ b/include/linux/usb/renesas_usbhs.h
@@ -110,6 +110,23 @@ struct renesas_usbhs_driver_param {
          * delay time from notify_hotplug callback
          */
         int detection_delay;
+
+        /*
+         * option:
+         *
+         * dma id for dmaengine
+         */
+        int d0_tx_id;
+        int d0_rx_id;
+        int d1_tx_id;
+        int d1_rx_id;
+
+        /*
+         * option:
+         *
+         * pio <--> dma border.
+         */
+        int pio_dma_border; /* default is 64byte */
 };
 
 /*
diff --git a/include/linux/usb/usbnet.h b/include/linux/usb/usbnet.h
index 605b0aa8d85..6939637e787 100644
--- a/include/linux/usb/usbnet.h
+++ b/include/linux/usb/usbnet.h
@@ -98,7 +98,7 @@ struct driver_info {
 
 #define FLAG_LINK_INTR  0x0800          /* updates link (carrier) status */
 
-#define FLAG_POINTTOPOINT 0x1000        /* possibly use "usb%d" names */
+#define FLAG_POINTTOPOINT       0x1000  /* possibly use "usb%d" names */
 
 /*
  * Indicates to usbnet, that USB driver accumulates multiple IP packets.
@@ -106,6 +106,7 @@ struct driver_info {
  */
 #define FLAG_MULTI_PACKET       0x2000
 #define FLAG_RX_ASSEMBLE        0x4000  /* rx packets may span >1 frames */
+#define FLAG_RMNET              0x8000  /* use "rmnet%d" names */
 
         /* init device ... can sleep, or cause probe() failure */
         int     (*bind)(struct usbnet *, struct usb_interface *);
diff --git a/include/linux/version.h b/include/linux/version.h
new file mode 100644
index 00000000000..6afe5dfae5a
--- /dev/null
+++ b/include/linux/version.h
@@ -0,0 +1,2 @@
+#define LINUX_VERSION_CODE 196874
+#define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
index 8a4c309d234..fca24cc5043 100644
--- a/include/linux/videodev2.h
+++ b/include/linux/videodev2.h
@@ -376,7 +376,16 @@ struct v4l2_pix_format {
 #define V4L2_PIX_FMT_MJPEG    v4l2_fourcc('M', 'J', 'P', 'G') /* Motion-JPEG   */
 #define V4L2_PIX_FMT_JPEG     v4l2_fourcc('J', 'P', 'E', 'G') /* JFIF JPEG     */
 #define V4L2_PIX_FMT_DV       v4l2_fourcc('d', 'v', 's', 'd') /* 1394          */
-#define V4L2_PIX_FMT_MPEG     v4l2_fourcc('M', 'P', 'E', 'G') /* MPEG-1/2/4    */
+#define V4L2_PIX_FMT_MPEG     v4l2_fourcc('M', 'P', 'E', 'G') /* MPEG-1/2/4 Multiplexed */
+#define V4L2_PIX_FMT_H264     v4l2_fourcc('H', '2', '6', '4') /* H264 with start codes */
+#define V4L2_PIX_FMT_H264_NO_SC v4l2_fourcc('A', 'V', 'C', '1') /* H264 without start codes */
+#define V4L2_PIX_FMT_H263     v4l2_fourcc('H', '2', '6', '3') /* H263          */
+#define V4L2_PIX_FMT_MPEG1    v4l2_fourcc('M', 'P', 'G', '1') /* MPEG-1 ES     */
+#define V4L2_PIX_FMT_MPEG2    v4l2_fourcc('M', 'P', 'G', '2') /* MPEG-2 ES     */
+#define V4L2_PIX_FMT_MPEG4    v4l2_fourcc('M', 'P', 'G', '4') /* MPEG-4 ES     */
+#define V4L2_PIX_FMT_XVID     v4l2_fourcc('X', 'V', 'I', 'D') /* Xvid           */
+#define V4L2_PIX_FMT_VC1_ANNEX_G v4l2_fourcc('V', 'C', '1', 'G') /* SMPTE 421M Annex G compliant stream */
+#define V4L2_PIX_FMT_VC1_ANNEX_L v4l2_fourcc('V', 'C', '1', 'L') /* SMPTE 421M Annex L compliant stream */
 
 /*  Vendor-specific formats   */
 #define V4L2_PIX_FMT_CPIA1    v4l2_fourcc('C', 'P', 'I', 'A') /* cpia1 YUV */
@@ -402,6 +411,7 @@ struct v4l2_pix_format {
 #define V4L2_PIX_FMT_CIT_YYVYUY v4l2_fourcc('C', 'I', 'T', 'V') /* one line of Y then 1 line of VYUY */
 #define V4L2_PIX_FMT_KONICA420  v4l2_fourcc('K', 'O', 'N', 'I') /* YUV420 planar in blocks of 256 pixels */
 #define V4L2_PIX_FMT_JPGL       v4l2_fourcc('J', 'P', 'G', 'L') /* JPEG-Lite */
+#define V4L2_PIX_FMT_SE401      v4l2_fourcc('S', '4', '0', '1') /* se401 janggu compressed rgb */
 
 /*
  *      F O R M A T   E N U M E R A T I O N
@@ -1026,6 +1036,7 @@ struct v4l2_ext_controls {
 #define V4L2_CTRL_CLASS_MPEG 0x00990000 /* MPEG-compression controls */
 #define V4L2_CTRL_CLASS_CAMERA 0x009a0000       /* Camera class controls */
 #define V4L2_CTRL_CLASS_FM_TX 0x009b0000        /* FM Modulator control class */
+#define V4L2_CTRL_CLASS_FLASH 0x009c0000        /* Camera flash controls */
 
 #define V4L2_CTRL_ID_MASK         (0x0fffffff)
 #define V4L2_CTRL_ID2CLASS(id)    ((id) & 0x0fff0000UL)
@@ -1039,6 +1050,7 @@ enum v4l2_ctrl_type {
         V4L2_CTRL_TYPE_INTEGER64     = 5,
         V4L2_CTRL_TYPE_CTRL_CLASS    = 6,
         V4L2_CTRL_TYPE_STRING        = 7,
+        V4L2_CTRL_TYPE_BITMASK       = 8,
 };
 
 /*  Used in the VIDIOC_QUERYCTRL ioctl for querying controls */
@@ -1144,14 +1156,19 @@ enum v4l2_colorfx {
 #define V4L2_CID_ILLUMINATORS_1                 (V4L2_CID_BASE+37)
 #define V4L2_CID_ILLUMINATORS_2                 (V4L2_CID_BASE+38)
 
+#define V4L2_CID_MIN_BUFFERS_FOR_CAPTURE        (V4L2_CID_BASE+39)
+#define V4L2_CID_MIN_BUFFERS_FOR_OUTPUT         (V4L2_CID_BASE+40)
+
 /* last CID + 1 */
-#define V4L2_CID_LASTP1                         (V4L2_CID_BASE+39)
+#define V4L2_CID_LASTP1                         (V4L2_CID_BASE+41)
+
+/* Minimum number of buffer neede by the device */
 
 /*  MPEG-class control IDs defined by V4L2 */
 #define V4L2_CID_MPEG_BASE                      (V4L2_CTRL_CLASS_MPEG | 0x900)
 #define V4L2_CID_MPEG_CLASS                     (V4L2_CTRL_CLASS_MPEG | 1)
 
-/*  MPEG streams */
+/*  MPEG streams, specific to multiplexed streams */
 #define V4L2_CID_MPEG_STREAM_TYPE               (V4L2_CID_MPEG_BASE+0)
 enum v4l2_mpeg_stream_type {
         V4L2_MPEG_STREAM_TYPE_MPEG2_PS   = 0, /* MPEG-2 program stream */
@@ -1173,7 +1190,7 @@ enum v4l2_mpeg_stream_vbi_fmt {
         V4L2_MPEG_STREAM_VBI_FMT_IVTV = 1,  /* VBI in private packets, IVTV format */
 };
 
-/*  MPEG audio */
+/*  MPEG audio controls specific to multiplexed streams  */
 #define V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ       (V4L2_CID_MPEG_BASE+100)
 enum v4l2_mpeg_audio_sampling_freq {
         V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100 = 0,
@@ -1289,7 +1306,7 @@ enum v4l2_mpeg_audio_ac3_bitrate {
         V4L2_MPEG_AUDIO_AC3_BITRATE_640K = 18,
 };
 
-/*  MPEG video */
+/*  MPEG video controls specific to multiplexed streams */
 #define V4L2_CID_MPEG_VIDEO_ENCODING            (V4L2_CID_MPEG_BASE+200)
 enum v4l2_mpeg_video_encoding {
         V4L2_MPEG_VIDEO_ENCODING_MPEG_1     = 0,
@@ -1317,6 +1334,141 @@ enum v4l2_mpeg_video_bitrate_mode {
 #define V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION (V4L2_CID_MPEG_BASE+209)
 #define V4L2_CID_MPEG_VIDEO_MUTE                (V4L2_CID_MPEG_BASE+210)
 #define V4L2_CID_MPEG_VIDEO_MUTE_YUV            (V4L2_CID_MPEG_BASE+211)
+#define V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE             (V4L2_CID_MPEG_BASE+212)
+#define V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER        (V4L2_CID_MPEG_BASE+213)
+#define V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB             (V4L2_CID_MPEG_BASE+214)
+#define V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE                     (V4L2_CID_MPEG_BASE+215)
+#define V4L2_CID_MPEG_VIDEO_HEADER_MODE                         (V4L2_CID_MPEG_BASE+216)
+enum v4l2_mpeg_video_header_mode {
+        V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE                    = 0,
+        V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME       = 1,
+
+};
+#define V4L2_CID_MPEG_VIDEO_MAX_REF_PIC                 (V4L2_CID_MPEG_BASE+217)
+#define V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE                (V4L2_CID_MPEG_BASE+218)
+#define V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES       (V4L2_CID_MPEG_BASE+219)
+#define V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB          (V4L2_CID_MPEG_BASE+220)
+#define V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE            (V4L2_CID_MPEG_BASE+221)
+enum v4l2_mpeg_video_multi_slice_mode {
+        V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE         = 0,
+        V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_MB          = 1,
+        V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_BYTES       = 2,
+};
+#define V4L2_CID_MPEG_VIDEO_VBV_SIZE                    (V4L2_CID_MPEG_BASE+222)
+#define V4L2_CID_MPEG_VIDEO_H263_I_FRAME_QP             (V4L2_CID_MPEG_BASE+300)
+#define V4L2_CID_MPEG_VIDEO_H263_P_FRAME_QP             (V4L2_CID_MPEG_BASE+301)
+#define V4L2_CID_MPEG_VIDEO_H263_B_FRAME_QP             (V4L2_CID_MPEG_BASE+302)
+#define V4L2_CID_MPEG_VIDEO_H263_MIN_QP                 (V4L2_CID_MPEG_BASE+303)
+#define V4L2_CID_MPEG_VIDEO_H263_MAX_QP                 (V4L2_CID_MPEG_BASE+304)
+#define V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP             (V4L2_CID_MPEG_BASE+350)
+#define V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP             (V4L2_CID_MPEG_BASE+351)
+#define V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP             (V4L2_CID_MPEG_BASE+352)
+#define V4L2_CID_MPEG_VIDEO_H264_MIN_QP                 (V4L2_CID_MPEG_BASE+353)
+#define V4L2_CID_MPEG_VIDEO_H264_MAX_QP                 (V4L2_CID_MPEG_BASE+354)
+#define V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM          (V4L2_CID_MPEG_BASE+355)
+#define V4L2_CID_MPEG_VIDEO_H264_CPB_SIZE               (V4L2_CID_MPEG_BASE+356)
+#define V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE           (V4L2_CID_MPEG_BASE+357)
+enum v4l2_mpeg_video_h264_entropy_mode {
+        V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CAVLC = 0,
+        V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CABAC = 1,
+};
+#define V4L2_CID_MPEG_VIDEO_H264_I_PERIOD               (V4L2_CID_MPEG_BASE+358)
+#define V4L2_CID_MPEG_VIDEO_H264_LEVEL                  (V4L2_CID_MPEG_BASE+359)
+enum v4l2_mpeg_video_h264_level {
+        V4L2_MPEG_VIDEO_H264_LEVEL_1_0  = 0,
+        V4L2_MPEG_VIDEO_H264_LEVEL_1B   = 1,
+        V4L2_MPEG_VIDEO_H264_LEVEL_1_1  = 2,
+        V4L2_MPEG_VIDEO_H264_LEVEL_1_2  = 3,
+        V4L2_MPEG_VIDEO_H264_LEVEL_1_3  = 4,
+        V4L2_MPEG_VIDEO_H264_LEVEL_2_0  = 5,
+        V4L2_MPEG_VIDEO_H264_LEVEL_2_1  = 6,
+        V4L2_MPEG_VIDEO_H264_LEVEL_2_2  = 7,
+        V4L2_MPEG_VIDEO_H264_LEVEL_3_0  = 8,
+        V4L2_MPEG_VIDEO_H264_LEVEL_3_1  = 9,
+        V4L2_MPEG_VIDEO_H264_LEVEL_3_2  = 10,
+        V4L2_MPEG_VIDEO_H264_LEVEL_4_0  = 11,
+        V4L2_MPEG_VIDEO_H264_LEVEL_4_1  = 12,
+        V4L2_MPEG_VIDEO_H264_LEVEL_4_2  = 13,
+        V4L2_MPEG_VIDEO_H264_LEVEL_5_0  = 14,
+        V4L2_MPEG_VIDEO_H264_LEVEL_5_1  = 15,
+};
+#define V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA      (V4L2_CID_MPEG_BASE+360)
+#define V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA       (V4L2_CID_MPEG_BASE+361)
+#define V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE       (V4L2_CID_MPEG_BASE+362)
+enum v4l2_mpeg_video_h264_loop_filter_mode {
+        V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLED                           = 0,
+        V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED                          = 1,
+        V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED_AT_SLICE_BOUNDARY        = 2,
+};
+#define V4L2_CID_MPEG_VIDEO_H264_PROFILE                (V4L2_CID_MPEG_BASE+363)
+enum v4l2_mpeg_video_h264_profile {
+        V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE                   = 0,
+        V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE       = 1,
+        V4L2_MPEG_VIDEO_H264_PROFILE_MAIN                       = 2,
+        V4L2_MPEG_VIDEO_H264_PROFILE_EXTENDED                   = 3,
+        V4L2_MPEG_VIDEO_H264_PROFILE_HIGH                       = 4,
+        V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_10                    = 5,
+        V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_422                   = 6,
+        V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_444_PREDICTIVE        = 7,
+        V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_10_INTRA              = 8,
+        V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_422_INTRA             = 9,
+        V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_444_INTRA             = 10,
+        V4L2_MPEG_VIDEO_H264_PROFILE_CAVLC_444_INTRA            = 11,
+        V4L2_MPEG_VIDEO_H264_PROFILE_SCALABLE_BASELINE          = 12,
+        V4L2_MPEG_VIDEO_H264_PROFILE_SCALABLE_HIGH              = 13,
+        V4L2_MPEG_VIDEO_H264_PROFILE_SCALABLE_HIGH_INTRA        = 14,
+        V4L2_MPEG_VIDEO_H264_PROFILE_STEREO_HIGH                = 15,
+        V4L2_MPEG_VIDEO_H264_PROFILE_MULTIVIEW_HIGH             = 16,
+};
+#define V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_HEIGHT     (V4L2_CID_MPEG_BASE+364)
+#define V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_WIDTH      (V4L2_CID_MPEG_BASE+365)
+#define V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE         (V4L2_CID_MPEG_BASE+366)
+#define V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC            (V4L2_CID_MPEG_BASE+367)
+enum v4l2_mpeg_video_h264_vui_sar_idc {
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_UNSPECIFIED    = 0,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_1x1            = 1,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_12x11          = 2,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_10x11          = 3,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_16x11          = 4,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_40x33          = 5,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_24x11          = 6,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_20x11          = 7,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_32x11          = 8,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_80x33          = 9,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_18x11          = 10,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_15x11          = 11,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_64x33          = 12,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_160x99         = 13,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_4x3            = 14,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_3x2            = 15,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_2x1            = 16,
+        V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_EXTENDED       = 17,
+};
+#define V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP    (V4L2_CID_MPEG_BASE+400)
+#define V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP    (V4L2_CID_MPEG_BASE+401)
+#define V4L2_CID_MPEG_VIDEO_MPEG4_B_FRAME_QP    (V4L2_CID_MPEG_BASE+402)
+#define V4L2_CID_MPEG_VIDEO_MPEG4_MIN_QP        (V4L2_CID_MPEG_BASE+403)
+#define V4L2_CID_MPEG_VIDEO_MPEG4_MAX_QP        (V4L2_CID_MPEG_BASE+404)
+#define V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL         (V4L2_CID_MPEG_BASE+405)
+enum v4l2_mpeg_video_mpeg4_level {
+        V4L2_MPEG_VIDEO_MPEG4_LEVEL_0   = 0,
+        V4L2_MPEG_VIDEO_MPEG4_LEVEL_0B  = 1,
+        V4L2_MPEG_VIDEO_MPEG4_LEVEL_1   = 2,
+        V4L2_MPEG_VIDEO_MPEG4_LEVEL_2   = 3,
+        V4L2_MPEG_VIDEO_MPEG4_LEVEL_3   = 4,
+        V4L2_MPEG_VIDEO_MPEG4_LEVEL_3B  = 5,
+        V4L2_MPEG_VIDEO_MPEG4_LEVEL_4   = 6,
+        V4L2_MPEG_VIDEO_MPEG4_LEVEL_5   = 7,
+};
+#define V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE       (V4L2_CID_MPEG_BASE+406)
+enum v4l2_mpeg_video_mpeg4_profile {
+        V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE                            = 0,
+        V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_SIMPLE                   = 1,
+        V4L2_MPEG_VIDEO_MPEG4_PROFILE_CORE                              = 2,
+        V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE_SCALABLE                   = 3,
+        V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_CODING_EFFICIENCY        = 4,
+};
+#define V4L2_CID_MPEG_VIDEO_MPEG4_QPEL          (V4L2_CID_MPEG_BASE+407)
 
 /*  MPEG-class control IDs specific to the CX2341x driver as defined by V4L2 */
 #define V4L2_CID_MPEG_CX2341X_BASE                              (V4L2_CTRL_CLASS_MPEG | 0x1000)
@@ -1359,6 +1511,33 @@ enum v4l2_mpeg_cx2341x_video_median_filter_type {
 #define V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP    (V4L2_CID_MPEG_CX2341X_BASE+10)
 #define V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS         (V4L2_CID_MPEG_CX2341X_BASE+11)
 
+/*  MPEG-class control IDs specific to the Samsung MFC 5.1 driver as defined by V4L2 */
+#define V4L2_CID_MPEG_MFC51_BASE                                (V4L2_CTRL_CLASS_MPEG | 0x1100)
+
+#define V4L2_CID_MPEG_MFC51_VIDEO_DECODER_H264_DISPLAY_DELAY            (V4L2_CID_MPEG_MFC51_BASE+0)
+#define V4L2_CID_MPEG_MFC51_VIDEO_DECODER_H264_DISPLAY_DELAY_ENABLE     (V4L2_CID_MPEG_MFC51_BASE+1)
+#define V4L2_CID_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE                       (V4L2_CID_MPEG_MFC51_BASE+2)
+enum v4l2_mpeg_mfc51_video_frame_skip_mode {
+        V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_DISABLED          = 0,
+        V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_LEVEL_LIMIT       = 1,
+        V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_BUF_LIMIT         = 2,
+};
+#define V4L2_CID_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE                      (V4L2_CID_MPEG_MFC51_BASE+3)
+enum v4l2_mpeg_mfc51_video_force_frame_type {
+        V4L2_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE_DISABLED         = 0,
+        V4L2_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE_I_FRAME          = 1,
+        V4L2_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE_NOT_CODED        = 2,
+};
+#define V4L2_CID_MPEG_MFC51_VIDEO_PADDING                               (V4L2_CID_MPEG_MFC51_BASE+4)
+#define V4L2_CID_MPEG_MFC51_VIDEO_PADDING_YUV                           (V4L2_CID_MPEG_MFC51_BASE+5)
+#define V4L2_CID_MPEG_MFC51_VIDEO_RC_FIXED_TARGET_BIT                   (V4L2_CID_MPEG_MFC51_BASE+6)
+#define V4L2_CID_MPEG_MFC51_VIDEO_RC_REACTION_COEFF                     (V4L2_CID_MPEG_MFC51_BASE+7)
+#define V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_ACTIVITY             (V4L2_CID_MPEG_MFC51_BASE+50)
+#define V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_DARK                 (V4L2_CID_MPEG_MFC51_BASE+51)
+#define V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_SMOOTH               (V4L2_CID_MPEG_MFC51_BASE+52)
+#define V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_STATIC               (V4L2_CID_MPEG_MFC51_BASE+53)
+#define V4L2_CID_MPEG_MFC51_VIDEO_H264_NUM_REF_PIC_FOR_P                (V4L2_CID_MPEG_MFC51_BASE+54)
+
 /*  Camera class control IDs */
 #define V4L2_CID_CAMERA_CLASS_BASE      (V4L2_CTRL_CLASS_CAMERA | 0x900)
 #define V4L2_CID_CAMERA_CLASS           (V4L2_CTRL_CLASS_CAMERA | 1)
@@ -1427,6 +1606,41 @@ enum v4l2_preemphasis {
 #define V4L2_CID_TUNE_POWER_LEVEL               (V4L2_CID_FM_TX_CLASS_BASE + 113)
 #define V4L2_CID_TUNE_ANTENNA_CAPACITOR         (V4L2_CID_FM_TX_CLASS_BASE + 114)
 
+/* Flash and privacy (indicator) light controls */
+#define V4L2_CID_FLASH_CLASS_BASE               (V4L2_CTRL_CLASS_FLASH | 0x900)
+#define V4L2_CID_FLASH_CLASS                    (V4L2_CTRL_CLASS_FLASH | 1)
+
+#define V4L2_CID_FLASH_LED_MODE                 (V4L2_CID_FLASH_CLASS_BASE + 1)
+enum v4l2_flash_led_mode {
+        V4L2_FLASH_LED_MODE_NONE,
+        V4L2_FLASH_LED_MODE_FLASH,
+        V4L2_FLASH_LED_MODE_TORCH,
+};
+
+#define V4L2_CID_FLASH_STROBE_SOURCE            (V4L2_CID_FLASH_CLASS_BASE + 2)
+enum v4l2_flash_strobe_source {
+        V4L2_FLASH_STROBE_SOURCE_SOFTWARE,
+        V4L2_FLASH_STROBE_SOURCE_EXTERNAL,
+};
+
+#define V4L2_CID_FLASH_STROBE                   (V4L2_CID_FLASH_CLASS_BASE + 3)
+#define V4L2_CID_FLASH_STROBE_STOP              (V4L2_CID_FLASH_CLASS_BASE + 4)
+#define V4L2_CID_FLASH_STROBE_STATUS            (V4L2_CID_FLASH_CLASS_BASE + 5)
+
+#define V4L2_CID_FLASH_TIMEOUT                  (V4L2_CID_FLASH_CLASS_BASE + 6)
+#define V4L2_CID_FLASH_INTENSITY                (V4L2_CID_FLASH_CLASS_BASE + 7)
+#define V4L2_CID_FLASH_TORCH_INTENSITY          (V4L2_CID_FLASH_CLASS_BASE + 8)
+#define V4L2_CID_FLASH_INDICATOR_INTENSITY      (V4L2_CID_FLASH_CLASS_BASE + 9)
+
+#define V4L2_CID_FLASH_FAULT                    (V4L2_CID_FLASH_CLASS_BASE + 10)
+#define V4L2_FLASH_FAULT_OVER_VOLTAGE           (1 << 0)
+#define V4L2_FLASH_FAULT_TIMEOUT                (1 << 1)
+#define V4L2_FLASH_FAULT_OVER_TEMPERATURE       (1 << 2)
+#define V4L2_FLASH_FAULT_SHORT_CIRCUIT          (1 << 3)
+
+#define V4L2_CID_FLASH_CHARGE                   (V4L2_CID_FLASH_CLASS_BASE + 11)
+#define V4L2_CID_FLASH_READY                    (V4L2_CID_FLASH_CLASS_BASE + 12)
+
 /*
  *      T U N I N G
  */
@@ -1791,6 +2005,7 @@ struct v4l2_streamparm {
 #define V4L2_EVENT_ALL                          0
 #define V4L2_EVENT_VSYNC                        1
 #define V4L2_EVENT_EOS                          2
+#define V4L2_EVENT_CTRL                         3
 #define V4L2_EVENT_PRIVATE_START                0x08000000
 
 /* Payload for V4L2_EVENT_VSYNC */
@@ -1799,21 +2014,46 @@ struct v4l2_event_vsync {
         __u8 field;
 } __attribute__ ((packed));
 
+/* Payload for V4L2_EVENT_CTRL */
+#define V4L2_EVENT_CTRL_CH_VALUE                (1 << 0)
+#define V4L2_EVENT_CTRL_CH_FLAGS                (1 << 1)
+
+struct v4l2_event_ctrl {
+        __u32 changes;
+        __u32 type;
+        union {
+                __s32 value;
+                __s64 value64;
+        };
+        __u32 flags;
+        __s32 minimum;
+        __s32 maximum;
+        __s32 step;
+        __s32 default_value;
+};
+
 struct v4l2_event {
         __u32                           type;
         union {
                 struct v4l2_event_vsync vsync;
+                struct v4l2_event_ctrl  ctrl;
                 __u8                    data[64];
         } u;
         __u32                           pending;
         __u32                           sequence;
         struct timespec                 timestamp;
-        __u32                           reserved[9];
+        __u32                           id;
+        __u32                           reserved[8];
 };
 
+#define V4L2_EVENT_SUB_FL_SEND_INITIAL          (1 << 0)
+#define V4L2_EVENT_SUB_FL_ALLOW_FEEDBACK        (1 << 1)
+
 struct v4l2_event_subscription {
         __u32                           type;
-        __u32                           reserved[7];
+        __u32                           id;
+        __u32                           flags;
+        __u32                           reserved[5];
 };
 
 /*
diff --git a/include/linux/virtio_net.h b/include/linux/virtio_net.h
index 136040bba3e..970d5a2a904 100644
--- a/include/linux/virtio_net.h
+++ b/include/linux/virtio_net.h
@@ -63,6 +63,7 @@ struct virtio_net_config {
  * specify GSO or CSUM features, you can simply ignore the header. */
 struct virtio_net_hdr {
 #define VIRTIO_NET_HDR_F_NEEDS_CSUM     1       // Use csum_start, csum_offset
+#define VIRTIO_NET_HDR_F_DATA_VALID     2       // Csum is valid
         __u8 flags;
 #define VIRTIO_NET_HDR_GSO_NONE         0       // Not a GSO frame
 #define VIRTIO_NET_HDR_GSO_TCPV4        1       // GSO frame, IPv4 TCP (TSO)
diff --git a/include/linux/vmalloc.h b/include/linux/vmalloc.h
index 9332e52ea8c..687fb11e201 100644
--- a/include/linux/vmalloc.h
+++ b/include/linux/vmalloc.h
@@ -13,6 +13,7 @@ struct vm_area_struct;		/* vma defining user mapping in mm_types.h */
 #define VM_MAP          0x00000004      /* vmap()ed pages */
 #define VM_USERMAP      0x00000008      /* suitable for remap_vmalloc_range */
 #define VM_VPAGES       0x00000010      /* buffer for pages was vmalloc'ed */
+#define VM_UNLIST       0x00000020      /* vm_struct is not listed in vmlist */
 /* bits [20..32] reserved for arch specific ioremap internals */
 
 /*
diff --git a/include/linux/vmstat.h b/include/linux/vmstat.h
index bcd942fa611..65efb92da99 100644
--- a/include/linux/vmstat.h
+++ b/include/linux/vmstat.h
@@ -6,7 +6,7 @@
 #include <linux/mm.h>
 #include <linux/mmzone.h>
 #include <linux/vm_event_item.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 extern int sysctl_stat_interval;
 
diff --git a/include/linux/vt.h b/include/linux/vt.h
index d5dd0bc408f..30a8dd9c83f 100644
--- a/include/linux/vt.h
+++ b/include/linux/vt.h
@@ -86,6 +86,13 @@ struct vt_setactivate {
 
 #ifdef __KERNEL__
 
+/* Virtual Terminal events. */
+#define VT_ALLOCATE             0x0001 /* Console got allocated */
+#define VT_DEALLOCATE           0x0002 /* Console will be deallocated */
+#define VT_WRITE                0x0003 /* A char got output */
+#define VT_UPDATE               0x0004 /* A bigger update occurred */
+#define VT_PREWRITE             0x0005 /* A char is about to be written to the console */
+
 #ifdef CONFIG_VT_CONSOLE
 
 extern int vt_kmsg_redirect(int new);
diff --git a/include/linux/vt_kern.h b/include/linux/vt_kern.h
index 4d05e14ea60..c2164fad008 100644
--- a/include/linux/vt_kern.h
+++ b/include/linux/vt_kern.h
@@ -137,7 +137,7 @@ int vty_init(const struct file_operations *console_fops);
 
 static inline bool vt_force_oops_output(struct vc_data *vc)
 {
-        if (oops_in_progress && vc->vc_panic_force_write)
+        if (oops_in_progress && vc->vc_panic_force_write  && panic_timeout >= 0)
                 return true;
         return false;
 }
diff --git a/include/linux/wakelock.h b/include/linux/wakelock.h
new file mode 100644
index 00000000000..a096d24ada1
--- /dev/null
+++ b/include/linux/wakelock.h
@@ -0,0 +1,91 @@
+/* include/linux/wakelock.h
+ *
+ * Copyright (C) 2007-2008 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _LINUX_WAKELOCK_H
+#define _LINUX_WAKELOCK_H
+
+#include <linux/list.h>
+#include <linux/ktime.h>
+
+/* A wake_lock prevents the system from entering suspend or other low power
+ * states when active. If the type is set to WAKE_LOCK_SUSPEND, the wake_lock
+ * prevents a full system suspend. If the type is WAKE_LOCK_IDLE, low power
+ * states that cause large interrupt latencies or that disable a set of
+ * interrupts will not entered from idle until the wake_locks are released.
+ */
+
+enum {
+        WAKE_LOCK_SUSPEND, /* Prevent suspend */
+        WAKE_LOCK_IDLE,    /* Prevent low power idle */
+        WAKE_LOCK_TYPE_COUNT
+};
+
+struct wake_lock {
+#ifdef CONFIG_HAS_WAKELOCK
+        struct list_head    link;
+        int                 flags;
+        const char         *name;
+        unsigned long       expires;
+#ifdef CONFIG_WAKELOCK_STAT
+        struct {
+                int             count;
+                int             expire_count;
+                int             wakeup_count;
+                ktime_t         total_time;
+                ktime_t         prevent_suspend_time;
+                ktime_t         max_time;
+                ktime_t         last_time;
+        } stat;
+#endif
+#endif
+};
+
+#ifdef CONFIG_HAS_WAKELOCK
+
+void wake_lock_init(struct wake_lock *lock, int type, const char *name);
+void wake_lock_destroy(struct wake_lock *lock);
+void wake_lock(struct wake_lock *lock);
+void wake_lock_timeout(struct wake_lock *lock, long timeout);
+void wake_unlock(struct wake_lock *lock);
+
+/* wake_lock_active returns a non-zero value if the wake_lock is currently
+ * locked. If the wake_lock has a timeout, it does not check the timeout
+ * but if the timeout had aready been checked it will return 0.
+ */
+int wake_lock_active(struct wake_lock *lock);
+
+/* has_wake_lock returns 0 if no wake locks of the specified type are active,
+ * and non-zero if one or more wake locks are held. Specifically it returns
+ * -1 if one or more wake locks with no timeout are active or the
+ * number of jiffies until all active wake locks time out.
+ */
+long has_wake_lock(int type);
+
+#else
+
+static inline void wake_lock_init(struct wake_lock *lock, int type,
+                                        const char *name) {}
+static inline void wake_lock_destroy(struct wake_lock *lock) {}
+static inline void wake_lock(struct wake_lock *lock) {}
+static inline void wake_lock_timeout(struct wake_lock *lock, long timeout) {}
+static inline void wake_unlock(struct wake_lock *lock) {}
+
+static inline int wake_lock_active(struct wake_lock *lock) { return 0; }
+static inline long has_wake_lock(int type) { return 0; }
+
+#endif
+
+#endif
+
diff --git a/include/linux/watchdog.h b/include/linux/watchdog.h
index 011bcfeb9f0..111843f88b2 100644
--- a/include/linux/watchdog.h
+++ b/include/linux/watchdog.h
@@ -59,6 +59,84 @@ struct watchdog_info {
 #define WATCHDOG_NOWAYOUT       0
 #endif
 
+struct watchdog_ops;
+struct watchdog_device;
+
+/** struct watchdog_ops - The watchdog-devices operations
+ *
+ * @owner:      The module owner.
+ * @start:      The routine for starting the watchdog device.
+ * @stop:       The routine for stopping the watchdog device.
+ * @ping:       The routine that sends a keepalive ping to the watchdog device.
+ * @status:     The routine that shows the status of the watchdog device.
+ * @set_timeout:The routine for setting the watchdog devices timeout value.
+ * @ioctl:      The routines that handles extra ioctl calls.
+ *
+ * The watchdog_ops structure contains a list of low-level operations
+ * that control a watchdog device. It also contains the module that owns
+ * these operations. The start and stop function are mandatory, all other
+ * functions are optonal.
+ */
+struct watchdog_ops {
+        struct module *owner;
+        /* mandatory operations */
+        int (*start)(struct watchdog_device *);
+        int (*stop)(struct watchdog_device *);
+        /* optional operations */
+        int (*ping)(struct watchdog_device *);
+        unsigned int (*status)(struct watchdog_device *);
+        int (*set_timeout)(struct watchdog_device *, unsigned int);
+        long (*ioctl)(struct watchdog_device *, unsigned int, unsigned long);
+};
+
+/** struct watchdog_device - The structure that defines a watchdog device
+ *
+ * @info:       Pointer to a watchdog_info structure.
+ * @ops:        Pointer to the list of watchdog operations.
+ * @bootstatus: Status of the watchdog device at boot.
+ * @timeout:    The watchdog devices timeout value.
+ * @min_timeout:The watchdog devices minimum timeout value.
+ * @max_timeout:The watchdog devices maximum timeout value.
+ * @driver-data:Pointer to the drivers private data.
+ * @status:     Field that contains the devices internal status bits.
+ *
+ * The watchdog_device structure contains all information about a
+ * watchdog timer device.
+ *
+ * The driver-data field may not be accessed directly. It must be accessed
+ * via the watchdog_set_drvdata and watchdog_get_drvdata helpers.
+ */
+struct watchdog_device {
+        const struct watchdog_info *info;
+        const struct watchdog_ops *ops;
+        unsigned int bootstatus;
+        unsigned int timeout;
+        unsigned int min_timeout;
+        unsigned int max_timeout;
+        void *driver_data;
+        unsigned long status;
+/* Bit numbers for status flags */
+#define WDOG_ACTIVE             0       /* Is the watchdog running/active */
+#define WDOG_DEV_OPEN           1       /* Opened via /dev/watchdog ? */
+#define WDOG_ALLOW_RELEASE      2       /* Did we receive the magic char ? */
+#define WDOG_NO_WAY_OUT         3       /* Is 'nowayout' feature set ? */
+};
+
+/* Use the following functions to manipulate watchdog driver specific data */
+static inline void watchdog_set_drvdata(struct watchdog_device *wdd, void *data)
+{
+        wdd->driver_data = data;
+}
+
+static inline void *watchdog_get_drvdata(struct watchdog_device *wdd)
+{
+        return wdd->driver_data;
+}
+
+/* drivers/watchdog/core/watchdog_core.c */
+extern int watchdog_register_device(struct watchdog_device *);
+extern void watchdog_unregister_device(struct watchdog_device *);
+
 #endif  /* __KERNEL__ */
 
 #endif  /* ifndef _LINUX_WATCHDOG_H */
diff --git a/include/linux/wifi_tiwlan.h b/include/linux/wifi_tiwlan.h
new file mode 100644
index 00000000000..f07e0679fb8
--- /dev/null
+++ b/include/linux/wifi_tiwlan.h
@@ -0,0 +1,27 @@
+/* include/linux/wifi_tiwlan.h
+ *
+ * Copyright (C) 2008 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+#ifndef _LINUX_WIFI_TIWLAN_H_
+#define _LINUX_WIFI_TIWLAN_H_
+
+#include <linux/wlan_plat.h>
+
+#define WMPA_NUMBER_OF_SECTIONS 3
+#define WMPA_NUMBER_OF_BUFFERS  160
+#define WMPA_SECTION_HEADER     24
+#define WMPA_SECTION_SIZE_0     (WMPA_NUMBER_OF_BUFFERS * 64)
+#define WMPA_SECTION_SIZE_1     (WMPA_NUMBER_OF_BUFFERS * 256)
+#define WMPA_SECTION_SIZE_2     (WMPA_NUMBER_OF_BUFFERS * 2048)
+
+#endif
diff --git a/include/linux/wl127x-rfkill.h b/include/linux/wl127x-rfkill.h
new file mode 100644
index 00000000000..9057ec63d5d
--- /dev/null
+++ b/include/linux/wl127x-rfkill.h
@@ -0,0 +1,35 @@
+/*
+ * Bluetooth TI wl127x rfkill power control via GPIO
+ *
+ * Copyright (C) 2009 Motorola, Inc.
+ * Copyright (C) 2008 Texas Instruments
+ * Initial code: Pavan Savoy <pavan.savoy@gmail.com> (wl127x_power.c)
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#ifndef _LINUX_WL127X_RFKILL_H
+#define _LINUX_WL127X_RFKILL_H
+
+#include <linux/rfkill.h>
+
+struct wl127x_rfkill_platform_data {
+        int nshutdown_gpio;
+
+        struct rfkill *rfkill;  /* for driver only */
+};
+
+#endif
diff --git a/include/linux/wl12xx.h b/include/linux/wl12xx.h
index 4b697395326..0f559ae411c 100644
--- a/include/linux/wl12xx.h
+++ b/include/linux/wl12xx.h
@@ -34,6 +34,7 @@ enum {
         WL12XX_REFCLOCK_26_XTAL = 5, /* 26 MHz, XTAL */
 };
 
+
 /* TCXO clock values */
 enum {
         WL12XX_TCXOCLOCK_19_2   = 0, /* 19.2MHz */
@@ -48,6 +49,7 @@ enum {
 
 struct wl12xx_platform_data {
         void (*set_power)(bool enable);
+        void (*set_carddetect)(bool enable);
         /* SDIO only: IRQ number if WLAN_IRQ line is used, 0 for SDIO IRQs */
         int irq;
         bool use_eeprom;
diff --git a/include/linux/wlan_plat.h b/include/linux/wlan_plat.h
new file mode 100644
index 00000000000..40ec3482d1e
--- /dev/null
+++ b/include/linux/wlan_plat.h
@@ -0,0 +1,27 @@
+/* include/linux/wlan_plat.h
+ *
+ * Copyright (C) 2010 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+#ifndef _LINUX_WLAN_PLAT_H_
+#define _LINUX_WLAN_PLAT_H_
+
+struct wifi_platform_data {
+        int (*set_power)(int val);
+        int (*set_reset)(int val);
+        int (*set_carddetect)(int val);
+        void *(*mem_prealloc)(int section, unsigned long size);
+        int (*get_mac_addr)(unsigned char *buf);
+        void *(*get_country_code)(char *ccode);
+};
+
+#endif
diff --git a/include/linux/wm97xx.h b/include/linux/wm97xx.h
index 38e8c4d9289..fd98bb96821 100644
--- a/include/linux/wm97xx.h
+++ b/include/linux/wm97xx.h
@@ -38,7 +38,11 @@
 #define WM97XX_ADCSEL_X         0x1000  /* x coord measurement */
 #define WM97XX_ADCSEL_Y         0x2000  /* y coord measurement */
 #define WM97XX_ADCSEL_PRES      0x3000  /* pressure measurement */
-#define WM97XX_ADCSEL_MASK      0x7000
+#define WM97XX_AUX_ID1          0x4000
+#define WM97XX_AUX_ID2          0x5000
+#define WM97XX_AUX_ID3          0x6000
+#define WM97XX_AUX_ID4          0x7000
+#define WM97XX_ADCSEL_MASK      0x7000  /* ADC selection mask */
 #define WM97XX_COO              0x0800  /* enable coordinate mode */
 #define WM97XX_CTC              0x0400  /* enable continuous mode */
 #define WM97XX_CM_RATE_93       0x0000  /* 93.75Hz continuous rate */
@@ -61,13 +65,6 @@
 #define WM97XX_PRP_DET_DIG      0xc000  /* setect on, digitise on */
 #define WM97XX_RPR              0x2000  /* wake up on pen down */
 #define WM97XX_PEN_DOWN         0x8000  /* pen is down */
-#define WM97XX_ADCSRC_MASK      0x7000  /* ADC source mask */
-
-#define WM97XX_AUX_ID1          0x8001
-#define WM97XX_AUX_ID2          0x8002
-#define WM97XX_AUX_ID3          0x8003
-#define WM97XX_AUX_ID4          0x8004
-
 
 /* WM9712 Bits */
 #define WM9712_45W              0x1000  /* set for 5-wire touchscreen */
diff --git a/include/linux/workqueue.h b/include/linux/workqueue.h
index f584aba78ca..0d556deb497 100644
--- a/include/linux/workqueue.h
+++ b/include/linux/workqueue.h
@@ -10,7 +10,7 @@
 #include <linux/bitops.h>
 #include <linux/lockdep.h>
 #include <linux/threads.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 struct workqueue_struct;
 
@@ -255,7 +255,7 @@ enum {
         WQ_HIGHPRI              = 1 << 4, /* high priority */
         WQ_CPU_INTENSIVE        = 1 << 5, /* cpu instensive workqueue */
 
-        WQ_DYING                = 1 << 6, /* internal: workqueue is dying */
+        WQ_DRAINING             = 1 << 6, /* internal: workqueue is draining */
         WQ_RESCUER              = 1 << 7, /* internal: workqueue has rescuer */
 
         WQ_MAX_ACTIVE           = 512,    /* I like 512, better ideas? */
@@ -355,6 +355,7 @@ extern int queue_delayed_work_on(int cpu, struct workqueue_struct *wq,
                         struct delayed_work *work, unsigned long delay);
 
 extern void flush_workqueue(struct workqueue_struct *wq);
+extern void drain_workqueue(struct workqueue_struct *wq);
 extern void flush_scheduled_work(void);
 
 extern int schedule_work(struct work_struct *work);
@@ -412,21 +413,6 @@ static inline bool __cancel_delayed_work(struct delayed_work *work)
         return ret;
 }
 
-/* Obsolete. use cancel_delayed_work_sync() */
-static inline __deprecated
-void cancel_rearming_delayed_workqueue(struct workqueue_struct *wq,
-                                        struct delayed_work *work)
-{
-        cancel_delayed_work_sync(work);
-}
-
-/* Obsolete. use cancel_delayed_work_sync() */
-static inline __deprecated
-void cancel_rearming_delayed_work(struct delayed_work *work)
-{
-        cancel_delayed_work_sync(work);
-}
-
 #ifndef CONFIG_SMP
 static inline long work_on_cpu(unsigned int cpu, long (*fn)(void *), void *arg)
 {
diff --git a/include/linux/writeback.h b/include/linux/writeback.h
index 17e7ccc322a..2b8963ff0f3 100644
--- a/include/linux/writeback.h
+++ b/include/linux/writeback.h
@@ -7,9 +7,28 @@
 #include <linux/sched.h>
 #include <linux/fs.h>
 
-struct backing_dev_info;
+/*
+ * The 1/4 region under the global dirty thresh is for smooth dirty throttling:
+ *
+ *      (thresh - thresh/DIRTY_FULL_SCOPE, thresh)
+ *
+ * Further beyond, all dirtier tasks will enter a loop waiting (possibly long
+ * time) for the dirty pages to drop, unless written enough pages.
+ *
+ * The global dirty threshold is normally equal to the global dirty limit,
+ * except when the system suddenly allocates a lot of anonymous memory and
+ * knocks down the global dirty threshold quickly, in which case the global
+ * dirty limit will follow down slowly to prevent livelocking all dirtier tasks.
+ */
+#define DIRTY_SCOPE             8
+#define DIRTY_FULL_SCOPE        (DIRTY_SCOPE / 2)
 
-extern spinlock_t inode_wb_list_lock;
+/*
+ * 4MB minimal write chunk size
+ */
+#define MIN_WRITEBACK_PAGES     (4096UL >> (PAGE_CACHE_SHIFT - 10))
+
+struct backing_dev_info;
 
 /*
  * fs/fs-writeback.c
@@ -26,11 +45,6 @@ enum writeback_sync_modes {
  */
 struct writeback_control {
         enum writeback_sync_modes sync_mode;
-        unsigned long *older_than_this; /* If !NULL, only write back inodes
-                                           older than this */
-        unsigned long wb_start;         /* Time writeback_inodes_wb was
-                                           called. This is needed to avoid
-                                           extra jobs and livelock */
         long nr_to_write;               /* Write this many pages, and decrement
                                            this for each page written */
         long pages_skipped;             /* Pages which were not written */
@@ -43,13 +57,11 @@ struct writeback_control {
         loff_t range_start;
         loff_t range_end;
 
-        unsigned nonblocking:1;         /* Don't get stuck on request queues */
-        unsigned encountered_congestion:1; /* An output: a queue is full */
         unsigned for_kupdate:1;         /* A kupdate writeback */
         unsigned for_background:1;      /* A background writeback */
+        unsigned tagged_writepages:1;   /* tag-and-write to avoid livelock */
         unsigned for_reclaim:1;         /* Invoked from the page allocator */
         unsigned range_cyclic:1;        /* range_start is cyclic */
-        unsigned more_io:1;             /* more io to be dispatched */
 };
 
 /*
@@ -62,8 +74,7 @@ void writeback_inodes_sb_nr(struct super_block *, unsigned long nr);
 int writeback_inodes_sb_if_idle(struct super_block *);
 int writeback_inodes_sb_nr_if_idle(struct super_block *, unsigned long nr);
 void sync_inodes_sb(struct super_block *);
-void writeback_inodes_wb(struct bdi_writeback *wb,
-                struct writeback_control *wbc);
+long writeback_inodes_wb(struct bdi_writeback *wb, long nr_pages);
 long wb_do_writeback(struct bdi_writeback *wb, int force_wait);
 void wakeup_flusher_threads(long nr_pages);
 
@@ -94,6 +105,8 @@ static inline void laptop_sync_completion(void) { }
 #endif
 void throttle_vm_writeout(gfp_t gfp_mask);
 
+extern unsigned long global_dirty_limit;
+
 /* These are exported to sysctl. */
 extern int dirty_background_ratio;
 extern unsigned long dirty_background_bytes;
@@ -128,6 +141,13 @@ void global_dirty_limits(unsigned long *pbackground, unsigned long *pdirty);
 unsigned long bdi_dirty_limit(struct backing_dev_info *bdi,
                                unsigned long dirty);
 
+void __bdi_update_bandwidth(struct backing_dev_info *bdi,
+                            unsigned long thresh,
+                            unsigned long dirty,
+                            unsigned long bdi_thresh,
+                            unsigned long bdi_dirty,
+                            unsigned long start_time);
+
 void page_writeback_init(void);
 void balance_dirty_pages_ratelimited_nr(struct address_space *mapping,
                                         unsigned long nr_pages_dirtied);
diff --git a/include/linux/zorro.h b/include/linux/zorro.h
index 7bf9db525e9..dff42025649 100644
--- a/include/linux/zorro.h
+++ b/include/linux/zorro.h
@@ -187,7 +187,7 @@ extern struct zorro_dev *zorro_find_device(zorro_id id,
 
 #define zorro_resource_start(z) ((z)->resource.start)
 #define zorro_resource_end(z)   ((z)->resource.end)
-#define zorro_resource_len(z)   ((z)->resource.end-(z)->resource.start+1)
+#define zorro_resource_len(z)   (resource_size(&(z)->resource))
 #define zorro_resource_flags(z) ((z)->resource.flags)
 
 #define zorro_request_device(z, name) \