200 files changed, 5854 insertions, 976 deletions

diff --git a/include/linux/Kbuild b/include/linux/Kbuild
index 75cf611641e6..01f636275057 100644
--- a/include/linux/Kbuild
+++ b/include/linux/Kbuild
@@ -4,6 +4,7 @@ header-y += caif/
 header-y += dvb/
 header-y += hdlc/
 header-y += isdn/
+header-y += mmc/
 header-y += nfsd/
 header-y += raid/
 header-y += spi/
@@ -302,6 +303,7 @@ header-y += ppp-comp.h
 header-y += ppp_defs.h
 header-y += pps.h
 header-y += prctl.h
+header-y += ptp_clock.h
 header-y += ptrace.h
 header-y += qnx4_fs.h
 header-y += qnxtypes.h
@@ -372,6 +374,7 @@ header-y += unistd.h
 header-y += usbdevice_fs.h
 header-y += utime.h
 header-y += utsname.h
+header-y += uvcvideo.h
 header-y += v4l2-mediabus.h
 header-y += v4l2-subdev.h
 header-y += veth.h
diff --git a/include/linux/alarmtimer.h b/include/linux/alarmtimer.h
new file mode 100644
index 000000000000..c5d6095b46f8
--- /dev/null
+++ b/include/linux/alarmtimer.h
@@ -0,0 +1,40 @@
+#ifndef _LINUX_ALARMTIMER_H
+#define _LINUX_ALARMTIMER_H
+
+#include <linux/time.h>
+#include <linux/hrtimer.h>
+#include <linux/timerqueue.h>
+#include <linux/rtc.h>
+
+enum alarmtimer_type {
+        ALARM_REALTIME,
+        ALARM_BOOTTIME,
+
+        ALARM_NUMTYPE,
+};
+
+/**
+ * struct alarm - Alarm timer structure
+ * @node:       timerqueue node for adding to the event list this value
+ *              also includes the expiration time.
+ * @period:     Period for recuring alarms
+ * @function:   Function pointer to be executed when the timer fires.
+ * @type:       Alarm type (BOOTTIME/REALTIME)
+ * @enabled:    Flag that represents if the alarm is set to fire or not
+ * @data:       Internal data value.
+ */
+struct alarm {
+        struct timerqueue_node  node;
+        ktime_t                 period;
+        void                    (*function)(struct alarm *);
+        enum alarmtimer_type    type;
+        bool                    enabled;
+        void                    *data;
+};
+
+void alarm_init(struct alarm *alarm, enum alarmtimer_type type,
+                void (*function)(struct alarm *));
+void alarm_start(struct alarm *alarm, ktime_t start, ktime_t period);
+void alarm_cancel(struct alarm *alarm);
+
+#endif
diff --git a/include/linux/ath9k_platform.h b/include/linux/ath9k_platform.h
index b847fc7b93f9..60a7c49dcb49 100644
--- a/include/linux/ath9k_platform.h
+++ b/include/linux/ath9k_platform.h
@@ -23,6 +23,13 @@
 
 struct ath9k_platform_data {
         u16 eeprom_data[ATH9K_PLAT_EEP_MAX_WORDS];
+        u8 *macaddr;
+
+        int led_pin;
+        u32 gpio_mask;
+        u32 gpio_val;
+
+        bool is_clk_25mhz;
 };
 
 #endif /* _LINUX_ATH9K_PLATFORM_H */
diff --git a/include/linux/bcma/bcma.h b/include/linux/bcma/bcma.h
new file mode 100644
index 000000000000..08763e4e848f
--- /dev/null
+++ b/include/linux/bcma/bcma.h
@@ -0,0 +1,224 @@
+#ifndef LINUX_BCMA_H_
+#define LINUX_BCMA_H_
+
+#include <linux/pci.h>
+#include <linux/mod_devicetable.h>
+
+#include <linux/bcma/bcma_driver_chipcommon.h>
+#include <linux/bcma/bcma_driver_pci.h>
+
+#include "bcma_regs.h"
+
+struct bcma_device;
+struct bcma_bus;
+
+enum bcma_hosttype {
+        BCMA_HOSTTYPE_NONE,
+        BCMA_HOSTTYPE_PCI,
+        BCMA_HOSTTYPE_SDIO,
+};
+
+struct bcma_chipinfo {
+        u16 id;
+        u8 rev;
+        u8 pkg;
+};
+
+struct bcma_host_ops {
+        u8 (*read8)(struct bcma_device *core, u16 offset);
+        u16 (*read16)(struct bcma_device *core, u16 offset);
+        u32 (*read32)(struct bcma_device *core, u16 offset);
+        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);
+        /* Agent ops */
+        u32 (*aread32)(struct bcma_device *core, u16 offset);
+        void (*awrite32)(struct bcma_device *core, u16 offset, u32 value);
+};
+
+/* Core manufacturers */
+#define BCMA_MANUF_ARM                  0x43B
+#define BCMA_MANUF_MIPS                 0x4A7
+#define BCMA_MANUF_BCM                  0x4BF
+
+/* Core class values. */
+#define BCMA_CL_SIM                     0x0
+#define BCMA_CL_EROM                    0x1
+#define BCMA_CL_CORESIGHT               0x9
+#define BCMA_CL_VERIF                   0xB
+#define BCMA_CL_OPTIMO                  0xD
+#define BCMA_CL_GEN                     0xE
+#define BCMA_CL_PRIMECELL               0xF
+
+/* Core-ID values. */
+#define BCMA_CORE_OOB_ROUTER            0x367   /* Out of band */
+#define BCMA_CORE_INVALID               0x700
+#define BCMA_CORE_CHIPCOMMON            0x800
+#define BCMA_CORE_ILINE20               0x801
+#define BCMA_CORE_SRAM                  0x802
+#define BCMA_CORE_SDRAM                 0x803
+#define BCMA_CORE_PCI                   0x804
+#define BCMA_CORE_MIPS                  0x805
+#define BCMA_CORE_ETHERNET              0x806
+#define BCMA_CORE_V90                   0x807
+#define BCMA_CORE_USB11_HOSTDEV         0x808
+#define BCMA_CORE_ADSL                  0x809
+#define BCMA_CORE_ILINE100              0x80A
+#define BCMA_CORE_IPSEC                 0x80B
+#define BCMA_CORE_UTOPIA                0x80C
+#define BCMA_CORE_PCMCIA                0x80D
+#define BCMA_CORE_INTERNAL_MEM          0x80E
+#define BCMA_CORE_MEMC_SDRAM            0x80F
+#define BCMA_CORE_OFDM                  0x810
+#define BCMA_CORE_EXTIF                 0x811
+#define BCMA_CORE_80211                 0x812
+#define BCMA_CORE_PHY_A                 0x813
+#define BCMA_CORE_PHY_B                 0x814
+#define BCMA_CORE_PHY_G                 0x815
+#define BCMA_CORE_MIPS_3302             0x816
+#define BCMA_CORE_USB11_HOST            0x817
+#define BCMA_CORE_USB11_DEV             0x818
+#define BCMA_CORE_USB20_HOST            0x819
+#define BCMA_CORE_USB20_DEV             0x81A
+#define BCMA_CORE_SDIO_HOST             0x81B
+#define BCMA_CORE_ROBOSWITCH            0x81C
+#define BCMA_CORE_PARA_ATA              0x81D
+#define BCMA_CORE_SATA_XORDMA           0x81E
+#define BCMA_CORE_ETHERNET_GBIT         0x81F
+#define BCMA_CORE_PCIE                  0x820
+#define BCMA_CORE_PHY_N                 0x821
+#define BCMA_CORE_SRAM_CTL              0x822
+#define BCMA_CORE_MINI_MACPHY           0x823
+#define BCMA_CORE_ARM_1176              0x824
+#define BCMA_CORE_ARM_7TDMI             0x825
+#define BCMA_CORE_PHY_LP                0x826
+#define BCMA_CORE_PMU                   0x827
+#define BCMA_CORE_PHY_SSN               0x828
+#define BCMA_CORE_SDIO_DEV              0x829
+#define BCMA_CORE_ARM_CM3               0x82A
+#define BCMA_CORE_PHY_HT                0x82B
+#define BCMA_CORE_MIPS_74K              0x82C
+#define BCMA_CORE_MAC_GBIT              0x82D
+#define BCMA_CORE_DDR12_MEM_CTL         0x82E
+#define BCMA_CORE_PCIE_RC               0x82F   /* PCIe Root Complex */
+#define BCMA_CORE_OCP_OCP_BRIDGE        0x830
+#define BCMA_CORE_SHARED_COMMON         0x831
+#define BCMA_CORE_OCP_AHB_BRIDGE        0x832
+#define BCMA_CORE_SPI_HOST              0x833
+#define BCMA_CORE_I2S                   0x834
+#define BCMA_CORE_SDR_DDR1_MEM_CTL      0x835   /* SDR/DDR1 memory controller core */
+#define BCMA_CORE_SHIM                  0x837   /* SHIM component in ubus/6362 */
+#define BCMA_CORE_DEFAULT               0xFFF
+
+#define BCMA_MAX_NR_CORES               16
+
+struct bcma_device {
+        struct bcma_bus *bus;
+        struct bcma_device_id id;
+
+        struct device dev;
+        bool dev_registered;
+
+        u8 core_index;
+
+        u32 addr;
+        u32 wrap;
+
+        void *drvdata;
+        struct list_head list;
+};
+
+static inline void *bcma_get_drvdata(struct bcma_device *core)
+{
+        return core->drvdata;
+}
+static inline void bcma_set_drvdata(struct bcma_device *core, void *drvdata)
+{
+        core->drvdata = drvdata;
+}
+
+struct bcma_driver {
+        const char *name;
+        const struct bcma_device_id *id_table;
+
+        int (*probe)(struct bcma_device *dev);
+        void (*remove)(struct bcma_device *dev);
+        int (*suspend)(struct bcma_device *dev, pm_message_t state);
+        int (*resume)(struct bcma_device *dev);
+        void (*shutdown)(struct bcma_device *dev);
+
+        struct device_driver drv;
+};
+extern
+int __bcma_driver_register(struct bcma_driver *drv, struct module *owner);
+static inline int bcma_driver_register(struct bcma_driver *drv)
+{
+        return __bcma_driver_register(drv, THIS_MODULE);
+}
+extern void bcma_driver_unregister(struct bcma_driver *drv);
+
+struct bcma_bus {
+        /* The MMIO area. */
+        void __iomem *mmio;
+
+        const struct bcma_host_ops *ops;
+
+        enum bcma_hosttype hosttype;
+        union {
+                /* Pointer to the PCI bus (only for BCMA_HOSTTYPE_PCI) */
+                struct pci_dev *host_pci;
+                /* Pointer to the SDIO device (only for BCMA_HOSTTYPE_SDIO) */
+                struct sdio_func *host_sdio;
+        };
+
+        struct bcma_chipinfo chipinfo;
+
+        struct bcma_device *mapped_core;
+        struct list_head cores;
+        u8 nr_cores;
+
+        struct bcma_drv_cc drv_cc;
+        struct bcma_drv_pci drv_pci;
+};
+
+extern inline u32 bcma_read8(struct bcma_device *core, u16 offset)
+{
+        return core->bus->ops->read8(core, offset);
+}
+extern inline u32 bcma_read16(struct bcma_device *core, u16 offset)
+{
+        return core->bus->ops->read16(core, offset);
+}
+extern inline u32 bcma_read32(struct bcma_device *core, u16 offset)
+{
+        return core->bus->ops->read32(core, offset);
+}
+extern inline
+void bcma_write8(struct bcma_device *core, u16 offset, u32 value)
+{
+        core->bus->ops->write8(core, offset, value);
+}
+extern inline
+void bcma_write16(struct bcma_device *core, u16 offset, u32 value)
+{
+        core->bus->ops->write16(core, offset, value);
+}
+extern inline
+void bcma_write32(struct bcma_device *core, u16 offset, u32 value)
+{
+        core->bus->ops->write32(core, offset, value);
+}
+extern inline u32 bcma_aread32(struct bcma_device *core, u16 offset)
+{
+        return core->bus->ops->aread32(core, offset);
+}
+extern inline
+void bcma_awrite32(struct bcma_device *core, u16 offset, u32 value)
+{
+        core->bus->ops->awrite32(core, offset, value);
+}
+
+extern bool bcma_core_is_enabled(struct bcma_device *core);
+extern int bcma_core_enable(struct bcma_device *core, u32 flags);
+
+#endif /* LINUX_BCMA_H_ */
diff --git a/include/linux/bcma/bcma_driver_chipcommon.h b/include/linux/bcma/bcma_driver_chipcommon.h
new file mode 100644
index 000000000000..083c3b6cd5ce
--- /dev/null
+++ b/include/linux/bcma/bcma_driver_chipcommon.h
@@ -0,0 +1,302 @@
+#ifndef LINUX_BCMA_DRIVER_CC_H_
+#define LINUX_BCMA_DRIVER_CC_H_
+
+/** ChipCommon core registers. **/
+#define BCMA_CC_ID                      0x0000
+#define  BCMA_CC_ID_ID                  0x0000FFFF
+#define  BCMA_CC_ID_ID_SHIFT            0
+#define  BCMA_CC_ID_REV                 0x000F0000
+#define  BCMA_CC_ID_REV_SHIFT           16
+#define  BCMA_CC_ID_PKG                 0x00F00000
+#define  BCMA_CC_ID_PKG_SHIFT           20
+#define  BCMA_CC_ID_NRCORES             0x0F000000
+#define  BCMA_CC_ID_NRCORES_SHIFT       24
+#define  BCMA_CC_ID_TYPE                0xF0000000
+#define  BCMA_CC_ID_TYPE_SHIFT          28
+#define BCMA_CC_CAP                     0x0004          /* Capabilities */
+#define  BCMA_CC_CAP_NRUART             0x00000003      /* # of UARTs */
+#define  BCMA_CC_CAP_MIPSEB             0x00000004      /* MIPS in BigEndian Mode */
+#define  BCMA_CC_CAP_UARTCLK            0x00000018      /* UART clock select */
+#define   BCMA_CC_CAP_UARTCLK_INT       0x00000008      /* UARTs are driven by internal divided clock */
+#define  BCMA_CC_CAP_UARTGPIO           0x00000020      /* UARTs on GPIO 15-12 */
+#define  BCMA_CC_CAP_EXTBUS             0x000000C0      /* External buses present */
+#define  BCMA_CC_CAP_FLASHT             0x00000700      /* Flash Type */
+#define   BCMA_CC_FLASHT_NONE           0x00000000      /* No flash */
+#define   BCMA_CC_FLASHT_STSER          0x00000100      /* ST serial flash */
+#define   BCMA_CC_FLASHT_ATSER          0x00000200      /* Atmel serial flash */
+#define   BCMA_CC_FLASHT_PARA           0x00000700      /* Parallel flash */
+#define  BCMA_CC_CAP_PLLT               0x00038000      /* PLL Type */
+#define   BCMA_PLLTYPE_NONE             0x00000000
+#define   BCMA_PLLTYPE_1                0x00010000      /* 48Mhz base, 3 dividers */
+#define   BCMA_PLLTYPE_2                0x00020000      /* 48Mhz, 4 dividers */
+#define   BCMA_PLLTYPE_3                0x00030000      /* 25Mhz, 2 dividers */
+#define   BCMA_PLLTYPE_4                0x00008000      /* 48Mhz, 4 dividers */
+#define   BCMA_PLLTYPE_5                0x00018000      /* 25Mhz, 4 dividers */
+#define   BCMA_PLLTYPE_6                0x00028000      /* 100/200 or 120/240 only */
+#define   BCMA_PLLTYPE_7                0x00038000      /* 25Mhz, 4 dividers */
+#define  BCMA_CC_CAP_PCTL               0x00040000      /* Power Control */
+#define  BCMA_CC_CAP_OTPS               0x00380000      /* OTP size */
+#define  BCMA_CC_CAP_OTPS_SHIFT         19
+#define  BCMA_CC_CAP_OTPS_BASE          5
+#define  BCMA_CC_CAP_JTAGM              0x00400000      /* JTAG master present */
+#define  BCMA_CC_CAP_BROM               0x00800000      /* Internal boot ROM active */
+#define  BCMA_CC_CAP_64BIT              0x08000000      /* 64-bit Backplane */
+#define  BCMA_CC_CAP_PMU                0x10000000      /* PMU available (rev >= 20) */
+#define  BCMA_CC_CAP_ECI                0x20000000      /* ECI available (rev >= 20) */
+#define  BCMA_CC_CAP_SPROM              0x40000000      /* SPROM present */
+#define BCMA_CC_CORECTL                 0x0008
+#define  BCMA_CC_CORECTL_UARTCLK0       0x00000001      /* Drive UART with internal clock */
+#define  BCMA_CC_CORECTL_SE             0x00000002      /* sync clk out enable (corerev >= 3) */
+#define  BCMA_CC_CORECTL_UARTCLKEN      0x00000008      /* UART clock enable (rev >= 21) */
+#define BCMA_CC_BIST                    0x000C
+#define BCMA_CC_OTPS                    0x0010          /* OTP status */
+#define  BCMA_CC_OTPS_PROGFAIL          0x80000000
+#define  BCMA_CC_OTPS_PROTECT           0x00000007
+#define  BCMA_CC_OTPS_HW_PROTECT        0x00000001
+#define  BCMA_CC_OTPS_SW_PROTECT        0x00000002
+#define  BCMA_CC_OTPS_CID_PROTECT       0x00000004
+#define BCMA_CC_OTPC                    0x0014          /* OTP control */
+#define  BCMA_CC_OTPC_RECWAIT           0xFF000000
+#define  BCMA_CC_OTPC_PROGWAIT          0x00FFFF00
+#define  BCMA_CC_OTPC_PRW_SHIFT         8
+#define  BCMA_CC_OTPC_MAXFAIL           0x00000038
+#define  BCMA_CC_OTPC_VSEL              0x00000006
+#define  BCMA_CC_OTPC_SELVL             0x00000001
+#define BCMA_CC_OTPP                    0x0018          /* OTP prog */
+#define  BCMA_CC_OTPP_COL               0x000000FF
+#define  BCMA_CC_OTPP_ROW               0x0000FF00
+#define  BCMA_CC_OTPP_ROW_SHIFT         8
+#define  BCMA_CC_OTPP_READERR           0x10000000
+#define  BCMA_CC_OTPP_VALUE             0x20000000
+#define  BCMA_CC_OTPP_READ              0x40000000
+#define  BCMA_CC_OTPP_START             0x80000000
+#define  BCMA_CC_OTPP_BUSY              0x80000000
+#define BCMA_CC_IRQSTAT                 0x0020
+#define BCMA_CC_IRQMASK                 0x0024
+#define  BCMA_CC_IRQ_GPIO               0x00000001      /* gpio intr */
+#define  BCMA_CC_IRQ_EXT                0x00000002      /* ro: ext intr pin (corerev >= 3) */
+#define  BCMA_CC_IRQ_WDRESET            0x80000000      /* watchdog reset occurred */
+#define BCMA_CC_CHIPCTL                 0x0028          /* Rev >= 11 only */
+#define BCMA_CC_CHIPSTAT                0x002C          /* Rev >= 11 only */
+#define BCMA_CC_JCMD                    0x0030          /* Rev >= 10 only */
+#define  BCMA_CC_JCMD_START             0x80000000
+#define  BCMA_CC_JCMD_BUSY              0x80000000
+#define  BCMA_CC_JCMD_PAUSE             0x40000000
+#define  BCMA_CC_JCMD0_ACC_MASK         0x0000F000
+#define  BCMA_CC_JCMD0_ACC_IRDR         0x00000000
+#define  BCMA_CC_JCMD0_ACC_DR           0x00001000
+#define  BCMA_CC_JCMD0_ACC_IR           0x00002000
+#define  BCMA_CC_JCMD0_ACC_RESET        0x00003000
+#define  BCMA_CC_JCMD0_ACC_IRPDR        0x00004000
+#define  BCMA_CC_JCMD0_ACC_PDR          0x00005000
+#define  BCMA_CC_JCMD0_IRW_MASK         0x00000F00
+#define  BCMA_CC_JCMD_ACC_MASK          0x000F0000      /* Changes for corerev 11 */
+#define  BCMA_CC_JCMD_ACC_IRDR          0x00000000
+#define  BCMA_CC_JCMD_ACC_DR            0x00010000
+#define  BCMA_CC_JCMD_ACC_IR            0x00020000
+#define  BCMA_CC_JCMD_ACC_RESET         0x00030000
+#define  BCMA_CC_JCMD_ACC_IRPDR         0x00040000
+#define  BCMA_CC_JCMD_ACC_PDR           0x00050000
+#define  BCMA_CC_JCMD_IRW_MASK          0x00001F00
+#define  BCMA_CC_JCMD_IRW_SHIFT         8
+#define  BCMA_CC_JCMD_DRW_MASK          0x0000003F
+#define BCMA_CC_JIR                     0x0034          /* Rev >= 10 only */
+#define BCMA_CC_JDR                     0x0038          /* Rev >= 10 only */
+#define BCMA_CC_JCTL                    0x003C          /* Rev >= 10 only */
+#define  BCMA_CC_JCTL_FORCE_CLK         4               /* Force clock */
+#define  BCMA_CC_JCTL_EXT_EN            2               /* Enable external targets */
+#define  BCMA_CC_JCTL_EN                1               /* Enable Jtag master */
+#define BCMA_CC_FLASHCTL                0x0040
+#define  BCMA_CC_FLASHCTL_START         0x80000000
+#define  BCMA_CC_FLASHCTL_BUSY          BCMA_CC_FLASHCTL_START
+#define BCMA_CC_FLASHADDR               0x0044
+#define BCMA_CC_FLASHDATA               0x0048
+#define BCMA_CC_BCAST_ADDR              0x0050
+#define BCMA_CC_BCAST_DATA              0x0054
+#define BCMA_CC_GPIOPULLUP              0x0058          /* Rev >= 20 only */
+#define BCMA_CC_GPIOPULLDOWN            0x005C          /* Rev >= 20 only */
+#define BCMA_CC_GPIOIN                  0x0060
+#define BCMA_CC_GPIOOUT                 0x0064
+#define BCMA_CC_GPIOOUTEN               0x0068
+#define BCMA_CC_GPIOCTL                 0x006C
+#define BCMA_CC_GPIOPOL                 0x0070
+#define BCMA_CC_GPIOIRQ                 0x0074
+#define BCMA_CC_WATCHDOG                0x0080
+#define BCMA_CC_GPIOTIMER               0x0088          /* LED powersave (corerev >= 16) */
+#define  BCMA_CC_GPIOTIMER_OFFTIME      0x0000FFFF
+#define  BCMA_CC_GPIOTIMER_OFFTIME_SHIFT        0
+#define  BCMA_CC_GPIOTIMER_ONTIME       0xFFFF0000
+#define  BCMA_CC_GPIOTIMER_ONTIME_SHIFT 16
+#define BCMA_CC_GPIOTOUTM               0x008C          /* LED powersave (corerev >= 16) */
+#define BCMA_CC_CLOCK_N                 0x0090
+#define BCMA_CC_CLOCK_SB                0x0094
+#define BCMA_CC_CLOCK_PCI               0x0098
+#define BCMA_CC_CLOCK_M2                0x009C
+#define BCMA_CC_CLOCK_MIPS              0x00A0
+#define BCMA_CC_CLKDIV                  0x00A4          /* Rev >= 3 only */
+#define  BCMA_CC_CLKDIV_SFLASH          0x0F000000
+#define  BCMA_CC_CLKDIV_SFLASH_SHIFT    24
+#define  BCMA_CC_CLKDIV_OTP             0x000F0000
+#define  BCMA_CC_CLKDIV_OTP_SHIFT       16
+#define  BCMA_CC_CLKDIV_JTAG            0x00000F00
+#define  BCMA_CC_CLKDIV_JTAG_SHIFT      8
+#define  BCMA_CC_CLKDIV_UART            0x000000FF
+#define BCMA_CC_CAP_EXT                 0x00AC          /* Capabilities */
+#define BCMA_CC_PLLONDELAY              0x00B0          /* Rev >= 4 only */
+#define BCMA_CC_FREFSELDELAY            0x00B4          /* Rev >= 4 only */
+#define BCMA_CC_SLOWCLKCTL              0x00B8          /* 6 <= Rev <= 9 only */
+#define  BCMA_CC_SLOWCLKCTL_SRC         0x00000007      /* slow clock source mask */
+#define   BCMA_CC_SLOWCLKCTL_SRC_LPO    0x00000000      /* source of slow clock is LPO */
+#define   BCMA_CC_SLOWCLKCTL_SRC_XTAL   0x00000001      /* source of slow clock is crystal */
+#define   BCMA_CC_SLOECLKCTL_SRC_PCI    0x00000002      /* source of slow clock is PCI */
+#define  BCMA_CC_SLOWCLKCTL_LPOFREQ     0x00000200      /* LPOFreqSel, 1: 160Khz, 0: 32KHz */
+#define  BCMA_CC_SLOWCLKCTL_LPOPD       0x00000400      /* LPOPowerDown, 1: LPO is disabled, 0: LPO is enabled */
+#define  BCMA_CC_SLOWCLKCTL_FSLOW       0x00000800      /* ForceSlowClk, 1: sb/cores running on slow clock, 0: power logic control */
+#define  BCMA_CC_SLOWCLKCTL_IPLL        0x00001000      /* IgnorePllOffReq, 1/0: power logic ignores/honors PLL clock disable requests from core */
+#define  BCMA_CC_SLOWCLKCTL_ENXTAL      0x00002000      /* XtalControlEn, 1/0: power logic does/doesn't disable crystal when appropriate */
+#define  BCMA_CC_SLOWCLKCTL_XTALPU      0x00004000      /* XtalPU (RO), 1/0: crystal running/disabled */
+#define  BCMA_CC_SLOWCLKCTL_CLKDIV      0xFFFF0000      /* ClockDivider (SlowClk = 1/(4+divisor)) */
+#define  BCMA_CC_SLOWCLKCTL_CLKDIV_SHIFT        16
+#define BCMA_CC_SYSCLKCTL               0x00C0          /* Rev >= 3 only */
+#define  BCMA_CC_SYSCLKCTL_IDLPEN       0x00000001      /* ILPen: Enable Idle Low Power */
+#define  BCMA_CC_SYSCLKCTL_ALPEN        0x00000002      /* ALPen: Enable Active Low Power */
+#define  BCMA_CC_SYSCLKCTL_PLLEN        0x00000004      /* ForcePLLOn */
+#define  BCMA_CC_SYSCLKCTL_FORCEALP     0x00000008      /* Force ALP (or HT if ALPen is not set */
+#define  BCMA_CC_SYSCLKCTL_FORCEHT      0x00000010      /* Force HT */
+#define  BCMA_CC_SYSCLKCTL_CLKDIV       0xFFFF0000      /* ClkDiv  (ILP = 1/(4+divisor)) */
+#define  BCMA_CC_SYSCLKCTL_CLKDIV_SHIFT 16
+#define BCMA_CC_CLKSTSTR                0x00C4          /* Rev >= 3 only */
+#define BCMA_CC_EROM                    0x00FC
+#define BCMA_CC_PCMCIA_CFG              0x0100
+#define BCMA_CC_PCMCIA_MEMWAIT          0x0104
+#define BCMA_CC_PCMCIA_ATTRWAIT         0x0108
+#define BCMA_CC_PCMCIA_IOWAIT           0x010C
+#define BCMA_CC_IDE_CFG                 0x0110
+#define BCMA_CC_IDE_MEMWAIT             0x0114
+#define BCMA_CC_IDE_ATTRWAIT            0x0118
+#define BCMA_CC_IDE_IOWAIT              0x011C
+#define BCMA_CC_PROG_CFG                0x0120
+#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 */
+#define BCMA_CC_HW_WORKAROUND           0x01E4 /* Hardware workaround (rev >= 20) */
+#define BCMA_CC_UART0_DATA              0x0300
+#define BCMA_CC_UART0_IMR               0x0304
+#define BCMA_CC_UART0_FCR               0x0308
+#define BCMA_CC_UART0_LCR               0x030C
+#define BCMA_CC_UART0_MCR               0x0310
+#define BCMA_CC_UART0_LSR               0x0314
+#define BCMA_CC_UART0_MSR               0x0318
+#define BCMA_CC_UART0_SCRATCH           0x031C
+#define BCMA_CC_UART1_DATA              0x0400
+#define BCMA_CC_UART1_IMR               0x0404
+#define BCMA_CC_UART1_FCR               0x0408
+#define BCMA_CC_UART1_LCR               0x040C
+#define BCMA_CC_UART1_MCR               0x0410
+#define BCMA_CC_UART1_LSR               0x0414
+#define BCMA_CC_UART1_MSR               0x0418
+#define BCMA_CC_UART1_SCRATCH           0x041C
+/* PMU registers (rev >= 20) */
+#define BCMA_CC_PMU_CTL                 0x0600 /* PMU control */
+#define  BCMA_CC_PMU_CTL_ILP_DIV        0xFFFF0000 /* ILP div mask */
+#define  BCMA_CC_PMU_CTL_ILP_DIV_SHIFT  16
+#define  BCMA_CC_PMU_CTL_NOILPONW       0x00000200 /* No ILP on wait */
+#define  BCMA_CC_PMU_CTL_HTREQEN        0x00000100 /* HT req enable */
+#define  BCMA_CC_PMU_CTL_ALPREQEN       0x00000080 /* ALP req enable */
+#define  BCMA_CC_PMU_CTL_XTALFREQ       0x0000007C /* Crystal freq */
+#define  BCMA_CC_PMU_CTL_XTALFREQ_SHIFT 2
+#define  BCMA_CC_PMU_CTL_ILPDIVEN       0x00000002 /* ILP div enable */
+#define  BCMA_CC_PMU_CTL_LPOSEL         0x00000001 /* LPO sel */
+#define BCMA_CC_PMU_CAP                 0x0604 /* PMU capabilities */
+#define  BCMA_CC_PMU_CAP_REVISION       0x000000FF /* Revision mask */
+#define BCMA_CC_PMU_STAT                0x0608 /* PMU status */
+#define  BCMA_CC_PMU_STAT_INTPEND       0x00000040 /* Interrupt pending */
+#define  BCMA_CC_PMU_STAT_SBCLKST       0x00000030 /* Backplane clock status? */
+#define  BCMA_CC_PMU_STAT_HAVEALP       0x00000008 /* ALP available */
+#define  BCMA_CC_PMU_STAT_HAVEHT        0x00000004 /* HT available */
+#define  BCMA_CC_PMU_STAT_RESINIT       0x00000003 /* Res init */
+#define BCMA_CC_PMU_RES_STAT            0x060C /* PMU res status */
+#define BCMA_CC_PMU_RES_PEND            0x0610 /* PMU res pending */
+#define BCMA_CC_PMU_TIMER               0x0614 /* PMU timer */
+#define BCMA_CC_PMU_MINRES_MSK          0x0618 /* PMU min res mask */
+#define BCMA_CC_PMU_MAXRES_MSK          0x061C /* PMU max res mask */
+#define BCMA_CC_PMU_RES_TABSEL          0x0620 /* PMU res table sel */
+#define BCMA_CC_PMU_RES_DEPMSK          0x0624 /* PMU res dep mask */
+#define BCMA_CC_PMU_RES_UPDNTM          0x0628 /* PMU res updown timer */
+#define BCMA_CC_PMU_RES_TIMER           0x062C /* PMU res timer */
+#define BCMA_CC_PMU_CLKSTRETCH          0x0630 /* PMU clockstretch */
+#define BCMA_CC_PMU_WATCHDOG            0x0634 /* PMU watchdog */
+#define BCMA_CC_PMU_RES_REQTS           0x0640 /* PMU res req timer sel */
+#define BCMA_CC_PMU_RES_REQT            0x0644 /* PMU res req timer */
+#define BCMA_CC_PMU_RES_REQM            0x0648 /* PMU res req mask */
+#define BCMA_CC_CHIPCTL_ADDR            0x0650
+#define BCMA_CC_CHIPCTL_DATA            0x0654
+#define BCMA_CC_REGCTL_ADDR             0x0658
+#define BCMA_CC_REGCTL_DATA             0x065C
+#define BCMA_CC_PLLCTL_ADDR             0x0660
+#define BCMA_CC_PLLCTL_DATA             0x0664
+
+/* Data for the PMU, if available.
+ * Check availability with ((struct bcma_chipcommon)->capabilities & BCMA_CC_CAP_PMU)
+ */
+struct bcma_chipcommon_pmu {
+        u8 rev;                 /* PMU revision */
+        u32 crystalfreq;        /* The active crystal frequency (in kHz) */
+};
+
+struct bcma_drv_cc {
+        struct bcma_device *core;
+        u32 status;
+        u32 capabilities;
+        u32 capabilities_ext;
+        /* Fast Powerup Delay constant */
+        u16 fast_pwrup_delay;
+        struct bcma_chipcommon_pmu pmu;
+};
+
+/* Register access */
+#define bcma_cc_read32(cc, offset) \
+        bcma_read32((cc)->core, offset)
+#define bcma_cc_write32(cc, offset, val) \
+        bcma_write32((cc)->core, offset, val)
+
+#define bcma_cc_mask32(cc, offset, mask) \
+        bcma_cc_write32(cc, offset, bcma_cc_read32(cc, offset) & (mask))
+#define bcma_cc_set32(cc, offset, set) \
+        bcma_cc_write32(cc, offset, bcma_cc_read32(cc, offset) | (set))
+#define bcma_cc_maskset32(cc, offset, mask, set) \
+        bcma_cc_write32(cc, offset, (bcma_cc_read32(cc, offset) & (mask)) | (set))
+
+extern void bcma_core_chipcommon_init(struct bcma_drv_cc *cc);
+
+extern void bcma_chipco_suspend(struct bcma_drv_cc *cc);
+extern void bcma_chipco_resume(struct bcma_drv_cc *cc);
+
+extern void bcma_chipco_watchdog_timer_set(struct bcma_drv_cc *cc,
+                                          u32 ticks);
+
+void bcma_chipco_irq_mask(struct bcma_drv_cc *cc, u32 mask, u32 value);
+
+u32 bcma_chipco_irq_status(struct bcma_drv_cc *cc, u32 mask);
+
+/* Chipcommon GPIO pin access. */
+u32 bcma_chipco_gpio_in(struct bcma_drv_cc *cc, u32 mask);
+u32 bcma_chipco_gpio_out(struct bcma_drv_cc *cc, u32 mask, u32 value);
+u32 bcma_chipco_gpio_outen(struct bcma_drv_cc *cc, u32 mask, u32 value);
+u32 bcma_chipco_gpio_control(struct bcma_drv_cc *cc, u32 mask, u32 value);
+u32 bcma_chipco_gpio_intmask(struct bcma_drv_cc *cc, u32 mask, u32 value);
+u32 bcma_chipco_gpio_polarity(struct bcma_drv_cc *cc, u32 mask, u32 value);
+
+/* PMU support */
+extern void bcma_pmu_init(struct bcma_drv_cc *cc);
+
+#endif /* LINUX_BCMA_DRIVER_CC_H_ */
diff --git a/include/linux/bcma/bcma_driver_pci.h b/include/linux/bcma/bcma_driver_pci.h
new file mode 100644
index 000000000000..b7e191cf00ec
--- /dev/null
+++ b/include/linux/bcma/bcma_driver_pci.h
@@ -0,0 +1,89 @@
+#ifndef LINUX_BCMA_DRIVER_PCI_H_
+#define LINUX_BCMA_DRIVER_PCI_H_
+
+#include <linux/types.h>
+
+struct pci_dev;
+
+/** PCI core registers. **/
+#define BCMA_CORE_PCI_CTL                       0x0000  /* PCI Control */
+#define  BCMA_CORE_PCI_CTL_RST_OE               0x00000001 /* PCI_RESET Output Enable */
+#define  BCMA_CORE_PCI_CTL_RST                  0x00000002 /* PCI_RESET driven out to pin */
+#define  BCMA_CORE_PCI_CTL_CLK_OE               0x00000004 /* Clock gate Output Enable */
+#define  BCMA_CORE_PCI_CTL_CLK                  0x00000008 /* Gate for clock driven out to pin */
+#define BCMA_CORE_PCI_ARBCTL                    0x0010  /* PCI Arbiter Control */
+#define  BCMA_CORE_PCI_ARBCTL_INTERN            0x00000001 /* Use internal arbiter */
+#define  BCMA_CORE_PCI_ARBCTL_EXTERN            0x00000002 /* Use external arbiter */
+#define  BCMA_CORE_PCI_ARBCTL_PARKID            0x00000006 /* Mask, selects which agent is parked on an idle bus */
+#define   BCMA_CORE_PCI_ARBCTL_PARKID_LAST      0x00000000 /* Last requestor */
+#define   BCMA_CORE_PCI_ARBCTL_PARKID_4710      0x00000002 /* 4710 */
+#define   BCMA_CORE_PCI_ARBCTL_PARKID_EXT0      0x00000004 /* External requestor 0 */
+#define   BCMA_CORE_PCI_ARBCTL_PARKID_EXT1      0x00000006 /* External requestor 1 */
+#define BCMA_CORE_PCI_ISTAT                     0x0020  /* Interrupt status */
+#define  BCMA_CORE_PCI_ISTAT_INTA               0x00000001 /* PCI INTA# */
+#define  BCMA_CORE_PCI_ISTAT_INTB               0x00000002 /* PCI INTB# */
+#define  BCMA_CORE_PCI_ISTAT_SERR               0x00000004 /* PCI SERR# (write to clear) */
+#define  BCMA_CORE_PCI_ISTAT_PERR               0x00000008 /* PCI PERR# (write to clear) */
+#define  BCMA_CORE_PCI_ISTAT_PME                0x00000010 /* PCI PME# */
+#define BCMA_CORE_PCI_IMASK                     0x0024  /* Interrupt mask */
+#define  BCMA_CORE_PCI_IMASK_INTA               0x00000001 /* PCI INTA# */
+#define  BCMA_CORE_PCI_IMASK_INTB               0x00000002 /* PCI INTB# */
+#define  BCMA_CORE_PCI_IMASK_SERR               0x00000004 /* PCI SERR# */
+#define  BCMA_CORE_PCI_IMASK_PERR               0x00000008 /* PCI PERR# */
+#define  BCMA_CORE_PCI_IMASK_PME                0x00000010 /* PCI PME# */
+#define BCMA_CORE_PCI_MBOX                      0x0028  /* Backplane to PCI Mailbox */
+#define  BCMA_CORE_PCI_MBOX_F0_0                0x00000100 /* PCI function 0, INT 0 */
+#define  BCMA_CORE_PCI_MBOX_F0_1                0x00000200 /* PCI function 0, INT 1 */
+#define  BCMA_CORE_PCI_MBOX_F1_0                0x00000400 /* PCI function 1, INT 0 */
+#define  BCMA_CORE_PCI_MBOX_F1_1                0x00000800 /* PCI function 1, INT 1 */
+#define  BCMA_CORE_PCI_MBOX_F2_0                0x00001000 /* PCI function 2, INT 0 */
+#define  BCMA_CORE_PCI_MBOX_F2_1                0x00002000 /* PCI function 2, INT 1 */
+#define  BCMA_CORE_PCI_MBOX_F3_0                0x00004000 /* PCI function 3, INT 0 */
+#define  BCMA_CORE_PCI_MBOX_F3_1                0x00008000 /* PCI function 3, INT 1 */
+#define BCMA_CORE_PCI_BCAST_ADDR                0x0050  /* Backplane Broadcast Address */
+#define  BCMA_CORE_PCI_BCAST_ADDR_MASK          0x000000FF
+#define BCMA_CORE_PCI_BCAST_DATA                0x0054  /* Backplane Broadcast Data */
+#define BCMA_CORE_PCI_GPIO_IN                   0x0060  /* rev >= 2 only */
+#define BCMA_CORE_PCI_GPIO_OUT                  0x0064  /* rev >= 2 only */
+#define BCMA_CORE_PCI_GPIO_ENABLE               0x0068  /* rev >= 2 only */
+#define BCMA_CORE_PCI_GPIO_CTL                  0x006C  /* rev >= 2 only */
+#define BCMA_CORE_PCI_SBTOPCI0                  0x0100  /* Backplane to PCI translation 0 (sbtopci0) */
+#define  BCMA_CORE_PCI_SBTOPCI0_MASK            0xFC000000
+#define BCMA_CORE_PCI_SBTOPCI1                  0x0104  /* Backplane to PCI translation 1 (sbtopci1) */
+#define  BCMA_CORE_PCI_SBTOPCI1_MASK            0xFC000000
+#define BCMA_CORE_PCI_SBTOPCI2                  0x0108  /* Backplane to PCI translation 2 (sbtopci2) */
+#define  BCMA_CORE_PCI_SBTOPCI2_MASK            0xC0000000
+#define BCMA_CORE_PCI_PCICFG0                   0x0400  /* PCI config space 0 (rev >= 8) */
+#define BCMA_CORE_PCI_PCICFG1                   0x0500  /* PCI config space 1 (rev >= 8) */
+#define BCMA_CORE_PCI_PCICFG2                   0x0600  /* PCI config space 2 (rev >= 8) */
+#define BCMA_CORE_PCI_PCICFG3                   0x0700  /* PCI config space 3 (rev >= 8) */
+#define BCMA_CORE_PCI_SPROM(wordoffset)         (0x0800 + ((wordoffset) * 2)) /* SPROM shadow area (72 bytes) */
+
+/* SBtoPCIx */
+#define BCMA_CORE_PCI_SBTOPCI_MEM               0x00000000
+#define BCMA_CORE_PCI_SBTOPCI_IO                0x00000001
+#define BCMA_CORE_PCI_SBTOPCI_CFG0              0x00000002
+#define BCMA_CORE_PCI_SBTOPCI_CFG1              0x00000003
+#define BCMA_CORE_PCI_SBTOPCI_PREF              0x00000004 /* Prefetch enable */
+#define BCMA_CORE_PCI_SBTOPCI_BURST             0x00000008 /* Burst enable */
+#define BCMA_CORE_PCI_SBTOPCI_MRM               0x00000020 /* Memory Read Multiple */
+#define BCMA_CORE_PCI_SBTOPCI_RC                0x00000030 /* Read Command mask (rev >= 11) */
+#define  BCMA_CORE_PCI_SBTOPCI_RC_READ          0x00000000 /* Memory read */
+#define  BCMA_CORE_PCI_SBTOPCI_RC_READL         0x00000010 /* Memory read line */
+#define  BCMA_CORE_PCI_SBTOPCI_RC_READM         0x00000020 /* Memory read multiple */
+
+/* PCIcore specific boardflags */
+#define BCMA_CORE_PCI_BFL_NOPCI                 0x00000400 /* Board leaves PCI floating */
+
+struct bcma_drv_pci {
+        struct bcma_device *core;
+        u8 setup_done:1;
+};
+
+/* Register access */
+#define pcicore_read32(pc, offset)              bcma_read32((pc)->core, offset)
+#define pcicore_write32(pc, offset, val)        bcma_write32((pc)->core, offset, val)
+
+extern void bcma_core_pci_init(struct bcma_drv_pci *pc);
+
+#endif /* LINUX_BCMA_DRIVER_PCI_H_ */
diff --git a/include/linux/bcma/bcma_regs.h b/include/linux/bcma/bcma_regs.h
new file mode 100644
index 000000000000..f82d88a960ce
--- /dev/null
+++ b/include/linux/bcma/bcma_regs.h
@@ -0,0 +1,34 @@
+#ifndef LINUX_BCMA_REGS_H_
+#define LINUX_BCMA_REGS_H_
+
+/* Agent registers (common for every core) */
+#define BCMA_IOCTL                      0x0408
+#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_RESET_CTL                  0x0800
+#define  BCMA_RESET_CTL_RESET           0x0001
+
+/* BCMA PCI config space registers. */
+#define BCMA_PCI_PMCSR                  0x44
+#define  BCMA_PCI_PE                    0x100
+#define BCMA_PCI_BAR0_WIN               0x80    /* Backplane address space 0 */
+#define BCMA_PCI_BAR1_WIN               0x84    /* Backplane address space 1 */
+#define BCMA_PCI_SPROMCTL               0x88    /* SPROM control */
+#define  BCMA_PCI_SPROMCTL_WE           0x10    /* SPROM write enable */
+#define BCMA_PCI_BAR1_CONTROL           0x8c    /* Address space 1 burst control */
+#define BCMA_PCI_IRQS                   0x90    /* PCI interrupts */
+#define BCMA_PCI_IRQMASK                0x94    /* PCI IRQ control and mask (pcirev >= 6 only) */
+#define BCMA_PCI_BACKPLANE_IRQS         0x98    /* Backplane Interrupts */
+#define BCMA_PCI_BAR0_WIN2              0xAC
+#define BCMA_PCI_GPIO_IN                0xB0    /* GPIO Input (pcirev >= 3 only) */
+#define BCMA_PCI_GPIO_OUT               0xB4    /* GPIO Output (pcirev >= 3 only) */
+#define BCMA_PCI_GPIO_OUT_ENABLE        0xB8    /* GPIO Output Enable/Disable (pcirev >= 3 only) */
+#define  BCMA_PCI_GPIO_SCS              0x10    /* PCI config space bit 4 for 4306c0 slow clock source */
+#define  BCMA_PCI_GPIO_HWRAD            0x20    /* PCI config space GPIO 13 for hw radio disable */
+#define  BCMA_PCI_GPIO_XTAL             0x40    /* PCI config space GPIO 14 for Xtal powerup */
+#define  BCMA_PCI_GPIO_PLL              0x80    /* PCI config space GPIO 15 for PLL powerdown */
+
+#endif /* LINUX_BCMA_REGS_H_ */
diff --git a/include/linux/binfmts.h b/include/linux/binfmts.h
index c3d6512eded1..8845613fd7e3 100644
--- a/include/linux/binfmts.h
+++ b/include/linux/binfmts.h
@@ -60,10 +60,6 @@ struct linux_binprm {
         unsigned long loader, exec;
 };
 
-extern void acct_arg_size(struct linux_binprm *bprm, unsigned long pages);
-extern struct page *get_arg_page(struct linux_binprm *bprm, unsigned long pos,
-                                        int write);
-
 #define BINPRM_FLAGS_ENFORCE_NONDUMP_BIT 0
 #define BINPRM_FLAGS_ENFORCE_NONDUMP (1 << BINPRM_FLAGS_ENFORCE_NONDUMP_BIT)
 
diff --git a/include/linux/bitmap.h b/include/linux/bitmap.h
index daf8c480c786..dcafe0bf0005 100644
--- a/include/linux/bitmap.h
+++ b/include/linux/bitmap.h
@@ -55,7 +55,8 @@
  * bitmap_parse(buf, buflen, dst, nbits)        Parse bitmap dst from kernel buf
  * bitmap_parse_user(ubuf, ulen, dst, nbits)    Parse bitmap dst from user buf
  * bitmap_scnlistprintf(buf, len, src, nbits)   Print bitmap src as list to buf
- * bitmap_parselist(buf, dst, nbits)            Parse bitmap dst from list
+ * bitmap_parselist(buf, dst, nbits)            Parse bitmap dst from kernel buf
+ * bitmap_parselist_user(buf, dst, nbits)       Parse bitmap dst from user buf
  * bitmap_find_free_region(bitmap, bits, order) Find and allocate bit region
  * bitmap_release_region(bitmap, pos, order)    Free specified bit region
  * bitmap_allocate_region(bitmap, pos, order)   Allocate specified bit region
@@ -129,6 +130,8 @@ extern int bitmap_scnlistprintf(char *buf, unsigned int len,
                         const unsigned long *src, int nbits);
 extern int bitmap_parselist(const char *buf, unsigned long *maskp,
                         int nmaskbits);
+extern int bitmap_parselist_user(const char __user *ubuf, unsigned int ulen,
+                        unsigned long *dst, int nbits);
 extern void bitmap_remap(unsigned long *dst, const unsigned long *src,
                 const unsigned long *old, const unsigned long *new, int bits);
 extern int bitmap_bitremap(int oldbit,
diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h
index be50d9e70a7d..2a7cea53ca0d 100644
--- a/include/linux/blk_types.h
+++ b/include/linux/blk_types.h
@@ -151,7 +151,6 @@ enum rq_flag_bits {
         __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_ON_PLUG,          /* on plug list */
         __REQ_NR_BITS,          /* stops here */
 };
 
@@ -192,6 +191,5 @@ enum rq_flag_bits {
 #define REQ_IO_STAT             (1 << __REQ_IO_STAT)
 #define REQ_MIXED_MERGE         (1 << __REQ_MIXED_MERGE)
 #define REQ_SECURE              (1 << __REQ_SECURE)
-#define REQ_ON_PLUG             (1 << __REQ_ON_PLUG)
 
 #endif /* __LINUX_BLK_TYPES_H */
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 2ad95fa1d130..ae9091a68480 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -257,7 +257,7 @@ struct queue_limits {
         unsigned char           misaligned;
         unsigned char           discard_misaligned;
         unsigned char           cluster;
-        signed char             discard_zeroes_data;
+        unsigned char           discard_zeroes_data;
 };
 
 struct request_queue
@@ -364,6 +364,8 @@ struct request_queue
          * for flush operations
          */
         unsigned int            flush_flags;
+        unsigned int            flush_not_queueable:1;
+        unsigned int            flush_queue_delayed:1;
         unsigned int            flush_pending_idx:1;
         unsigned int            flush_running_idx:1;
         unsigned long           flush_pending_since;
@@ -843,6 +845,7 @@ extern void blk_queue_softirq_done(struct request_queue *, softirq_done_fn *);
 extern void blk_queue_rq_timed_out(struct request_queue *, rq_timed_out_fn *);
 extern void blk_queue_rq_timeout(struct request_queue *, unsigned int);
 extern void blk_queue_flush(struct request_queue *q, unsigned int flush);
+extern void blk_queue_flush_queueable(struct request_queue *q, bool queueable);
 extern struct backing_dev_info *blk_get_backing_dev_info(struct block_device *bdev);
 
 extern int blk_rq_map_sg(struct request_queue *, struct request *, struct scatterlist *);
@@ -1066,13 +1069,16 @@ static inline int queue_limit_discard_alignment(struct queue_limits *lim, sector
 {
         unsigned int alignment = (sector << 9) & (lim->discard_granularity - 1);
 
+        if (!lim->max_discard_sectors)
+                return 0;
+
         return (lim->discard_granularity + lim->discard_alignment - alignment)
                 & (lim->discard_granularity - 1);
 }
 
 static inline unsigned int queue_discard_zeroes_data(struct request_queue *q)
 {
-        if (q->limits.discard_zeroes_data == 1)
+        if (q->limits.max_discard_sectors && q->limits.discard_zeroes_data == 1)
                 return 1;
 
         return 0;
@@ -1111,6 +1117,11 @@ static inline unsigned int block_size(struct block_device *bdev)
         return bdev->bd_block_size;
 }
 
+static inline bool queue_flush_queueable(struct request_queue *q)
+{
+        return !q->flush_not_queueable;
+}
+
 typedef struct {struct page *v;} Sector;
 
 unsigned char *read_dev_sector(struct block_device *, sector_t, Sector *);
diff --git a/include/linux/bootmem.h b/include/linux/bootmem.h
index b8613e806aa9..ab344a521105 100644
--- a/include/linux/bootmem.h
+++ b/include/linux/bootmem.h
@@ -99,22 +99,31 @@ extern void *__alloc_bootmem_low_node(pg_data_t *pgdat,
                                       unsigned long align,
                                       unsigned long goal);
 
+#ifdef CONFIG_NO_BOOTMEM
+/* We are using top down, so it is safe to use 0 here */
+#define BOOTMEM_LOW_LIMIT 0
+#else
+#define BOOTMEM_LOW_LIMIT __pa(MAX_DMA_ADDRESS)
+#endif
+
 #define alloc_bootmem(x) \
-        __alloc_bootmem(x, SMP_CACHE_BYTES, __pa(MAX_DMA_ADDRESS))
+        __alloc_bootmem(x, SMP_CACHE_BYTES, BOOTMEM_LOW_LIMIT)
 #define alloc_bootmem_align(x, align) \
-        __alloc_bootmem(x, align, __pa(MAX_DMA_ADDRESS))
+        __alloc_bootmem(x, align, BOOTMEM_LOW_LIMIT)
 #define alloc_bootmem_nopanic(x) \
-        __alloc_bootmem_nopanic(x, SMP_CACHE_BYTES, __pa(MAX_DMA_ADDRESS))
+        __alloc_bootmem_nopanic(x, SMP_CACHE_BYTES, BOOTMEM_LOW_LIMIT)
 #define alloc_bootmem_pages(x) \
-        __alloc_bootmem(x, PAGE_SIZE, __pa(MAX_DMA_ADDRESS))
+        __alloc_bootmem(x, PAGE_SIZE, BOOTMEM_LOW_LIMIT)
 #define alloc_bootmem_pages_nopanic(x) \
-        __alloc_bootmem_nopanic(x, PAGE_SIZE, __pa(MAX_DMA_ADDRESS))
+        __alloc_bootmem_nopanic(x, PAGE_SIZE, BOOTMEM_LOW_LIMIT)
 #define alloc_bootmem_node(pgdat, x) \
-        __alloc_bootmem_node(pgdat, x, SMP_CACHE_BYTES, __pa(MAX_DMA_ADDRESS))
+        __alloc_bootmem_node(pgdat, x, SMP_CACHE_BYTES, BOOTMEM_LOW_LIMIT)
+#define alloc_bootmem_node_nopanic(pgdat, x) \
+        __alloc_bootmem_node_nopanic(pgdat, x, SMP_CACHE_BYTES, BOOTMEM_LOW_LIMIT)
 #define alloc_bootmem_pages_node(pgdat, x) \
-        __alloc_bootmem_node(pgdat, x, PAGE_SIZE, __pa(MAX_DMA_ADDRESS))
+        __alloc_bootmem_node(pgdat, x, PAGE_SIZE, BOOTMEM_LOW_LIMIT)
 #define alloc_bootmem_pages_node_nopanic(pgdat, x) \
-        __alloc_bootmem_node_nopanic(pgdat, x, PAGE_SIZE, __pa(MAX_DMA_ADDRESS))
+        __alloc_bootmem_node_nopanic(pgdat, x, PAGE_SIZE, BOOTMEM_LOW_LIMIT)
 
 #define alloc_bootmem_low(x) \
         __alloc_bootmem_low(x, SMP_CACHE_BYTES, 0)
diff --git a/include/linux/bsearch.h b/include/linux/bsearch.h
new file mode 100644
index 000000000000..90b1aa867224
--- /dev/null
+++ b/include/linux/bsearch.h
@@ -0,0 +1,9 @@
+#ifndef _LINUX_BSEARCH_H
+#define _LINUX_BSEARCH_H
+
+#include <linux/types.h>
+
+void *bsearch(const void *key, const void *base, size_t num, size_t size,
+              int (*cmp)(const void *key, const void *elt));
+
+#endif /* _LINUX_BSEARCH_H */
diff --git a/include/linux/c2port.h b/include/linux/c2port.h
index 2a5cd867c365..a2f7d7413f30 100644
--- a/include/linux/c2port.h
+++ b/include/linux/c2port.h
@@ -60,9 +60,6 @@ struct c2port_ops {
  * Exported functions
  */
 
-#define to_class_dev(obj) container_of((obj), struct class_device, kobj)
-#define to_c2port_device(obj) container_of((obj), struct c2port_device, class)
-
 extern struct c2port_device *c2port_device_register(char *name,
                                         struct c2port_ops *ops, void *devdata);
 extern void c2port_device_unregister(struct c2port_device *dev);
diff --git a/include/linux/can/core.h b/include/linux/can/core.h
index 6f70a6d3a16e..5ce6b5d62ecc 100644
--- a/include/linux/can/core.h
+++ b/include/linux/can/core.h
@@ -44,8 +44,8 @@ struct can_proto {
 
 /* function prototypes for the CAN networklayer core (af_can.c) */
 
-extern int  can_proto_register(struct can_proto *cp);
-extern void can_proto_unregister(struct can_proto *cp);
+extern int  can_proto_register(const struct can_proto *cp);
+extern void can_proto_unregister(const struct can_proto *cp);
 
 extern int  can_rx_register(struct net_device *dev, canid_t can_id,
                             canid_t mask,
diff --git a/include/linux/capability.h b/include/linux/capability.h
index 16ee8b49a200..c42112350003 100644
--- a/include/linux/capability.h
+++ b/include/linux/capability.h
@@ -355,7 +355,12 @@ struct cpu_vfs_cap_data {
 
 #define CAP_SYSLOG           34
 
-#define CAP_LAST_CAP         CAP_SYSLOG
+/* Allow triggering something that will wake the system */
+
+#define CAP_WAKE_ALARM            35
+
+
+#define CAP_LAST_CAP         CAP_WAKE_ALARM
 
 #define cap_valid(x) ((x) >= 0 && (x) <= CAP_LAST_CAP)
 
@@ -412,7 +417,6 @@ extern const kernel_cap_t __cap_init_eff_set;
 
 # define CAP_EMPTY_SET    ((kernel_cap_t){{ 0, 0 }})
 # define CAP_FULL_SET     ((kernel_cap_t){{ ~0, ~0 }})
-# define CAP_INIT_EFF_SET ((kernel_cap_t){{ ~CAP_TO_MASK(CAP_SETPCAP), ~0 }})
 # define CAP_FS_SET       ((kernel_cap_t){{ CAP_FS_MASK_B0 \
                                     | CAP_TO_MASK(CAP_LINUX_IMMUTABLE), \
                                     CAP_FS_MASK_B1 } })
@@ -422,11 +426,7 @@ extern const kernel_cap_t __cap_init_eff_set;
 
 #endif /* _KERNEL_CAPABILITY_U32S != 2 */
 
-#define CAP_INIT_INH_SET    CAP_EMPTY_SET
-
 # define cap_clear(c)         do { (c) = __cap_empty_set; } while (0)
-# define cap_set_full(c)      do { (c) = __cap_full_set; } while (0)
-# define cap_set_init_eff(c)  do { (c) = __cap_init_eff_set; } while (0)
 
 #define cap_raise(c, flag)  ((c).cap[CAP_TO_INDEX(flag)] |= CAP_TO_MASK(flag))
 #define cap_lower(c, flag)  ((c).cap[CAP_TO_INDEX(flag)] &= ~CAP_TO_MASK(flag))
@@ -546,18 +546,7 @@ extern bool has_capability_noaudit(struct task_struct *t, int cap);
 extern bool capable(int cap);
 extern bool ns_capable(struct user_namespace *ns, int cap);
 extern bool task_ns_capable(struct task_struct *t, int cap);
-
-/**
- * nsown_capable - Check superior capability to one's own user_ns
- * @cap: The capability in question
- *
- * Return true if the current task has the given superior capability
- * targeted at its own user namespace.
- */
-static inline bool nsown_capable(int cap)
-{
-        return ns_capable(current_user_ns(), cap);
-}
+extern bool nsown_capable(int cap);
 
 /* audit system wants to get cap info from files as well */
 extern int get_vfs_caps_from_disk(const struct dentry *dentry, struct cpu_vfs_cap_data *cpu_caps);
diff --git a/include/linux/ceph/ceph_fs.h b/include/linux/ceph/ceph_fs.h
index b8e995fbd867..b8c60694b2b0 100644
--- a/include/linux/ceph/ceph_fs.h
+++ b/include/linux/ceph/ceph_fs.h
@@ -313,6 +313,7 @@ enum {
         CEPH_MDS_OP_GETATTR    = 0x00101,
         CEPH_MDS_OP_LOOKUPHASH = 0x00102,
         CEPH_MDS_OP_LOOKUPPARENT = 0x00103,
+        CEPH_MDS_OP_LOOKUPINO  = 0x00104,
 
         CEPH_MDS_OP_SETXATTR   = 0x01105,
         CEPH_MDS_OP_RMXATTR    = 0x01106,
diff --git a/include/linux/clockchips.h b/include/linux/clockchips.h
index fc53492b6ad7..d6733e27af34 100644
--- a/include/linux/clockchips.h
+++ b/include/linux/clockchips.h
@@ -56,46 +56,52 @@ enum clock_event_nofitiers {
 
 /**
  * struct clock_event_device - clock event device descriptor
- * @name:               ptr to clock event name
- * @features:           features
+ * @event_handler:      Assigned by the framework to be called by the low
+ *                      level handler of the event source
+ * @set_next_event:     set next event function
+ * @next_event:         local storage for the next event in oneshot mode
  * @max_delta_ns:       maximum delta value in ns
  * @min_delta_ns:       minimum delta value in ns
  * @mult:               nanosecond to cycles multiplier
  * @shift:              nanoseconds to cycles divisor (power of two)
+ * @mode:               operating mode assigned by the management code
+ * @features:           features
+ * @retries:            number of forced programming retries
+ * @set_mode:           set mode function
+ * @broadcast:          function to broadcast events
+ * @min_delta_ticks:    minimum delta value in ticks stored for reconfiguration
+ * @max_delta_ticks:    maximum delta value in ticks stored for reconfiguration
+ * @name:               ptr to clock event name
  * @rating:             variable to rate clock event devices
  * @irq:                IRQ number (only for non CPU local devices)
  * @cpumask:            cpumask to indicate for which CPUs this device works
- * @set_next_event:     set next event function
- * @set_mode:           set mode function
- * @event_handler:      Assigned by the framework to be called by the low
- *                      level handler of the event source
- * @broadcast:          function to broadcast events
  * @list:               list head for the management code
- * @mode:               operating mode assigned by the management code
- * @next_event:         local storage for the next event in oneshot mode
- * @retries:            number of forced programming retries
  */
 struct clock_event_device {
-        const char              *name;
-        unsigned int            features;
+        void                    (*event_handler)(struct clock_event_device *);
+        int                     (*set_next_event)(unsigned long evt,
+                                                  struct clock_event_device *);
+        ktime_t                 next_event;
         u64                     max_delta_ns;
         u64                     min_delta_ns;
         u32                     mult;
         u32                     shift;
+        enum clock_event_mode   mode;
+        unsigned int            features;
+        unsigned long           retries;
+
+        void                    (*broadcast)(const struct cpumask *mask);
+        void                    (*set_mode)(enum clock_event_mode mode,
+                                            struct clock_event_device *);
+        unsigned long           min_delta_ticks;
+        unsigned long           max_delta_ticks;
+
+        const char              *name;
         int                     rating;
         int                     irq;
         const struct cpumask    *cpumask;
-        int                     (*set_next_event)(unsigned long evt,
-                                                  struct clock_event_device *);
-        void                    (*set_mode)(enum clock_event_mode mode,
-                                            struct clock_event_device *);
-        void                    (*event_handler)(struct clock_event_device *);
-        void                    (*broadcast)(const struct cpumask *mask);
         struct list_head        list;
-        enum clock_event_mode   mode;
-        ktime_t                 next_event;
-        unsigned long           retries;
-};
+} ____cacheline_aligned;
 
 /*
  * Calculate a multiplication factor for scaled math, which is used to convert
@@ -122,6 +128,12 @@ extern u64 clockevent_delta2ns(unsigned long latch,
                                struct clock_event_device *evt);
 extern void clockevents_register_device(struct clock_event_device *dev);
 
+extern void clockevents_config_and_register(struct clock_event_device *dev,
+                                            u32 freq, unsigned long min_delta,
+                                            unsigned long max_delta);
+
+extern int clockevents_update_freq(struct clock_event_device *ce, u32 freq);
+
 extern void clockevents_exchange_device(struct clock_event_device *old,
                                         struct clock_event_device *new);
 extern void clockevents_set_mode(struct clock_event_device *dev,
diff --git a/include/linux/clocksource.h b/include/linux/clocksource.h
index c37b21ad5a3b..d4646b48dc4a 100644
--- a/include/linux/clocksource.h
+++ b/include/linux/clocksource.h
@@ -159,42 +159,38 @@ extern u64 timecounter_cyc2time(struct timecounter *tc,
  */
 struct clocksource {
         /*
-         * First part of structure is read mostly
+         * Hotpath data, fits in a single cache line when the
+         * clocksource itself is cacheline aligned.
          */
-        char *name;
-        struct list_head list;
-        int rating;
         cycle_t (*read)(struct clocksource *cs);
-        int (*enable)(struct clocksource *cs);
-        void (*disable)(struct clocksource *cs);
+        cycle_t cycle_last;
         cycle_t mask;
         u32 mult;
         u32 shift;
         u64 max_idle_ns;
-        unsigned long flags;
-        cycle_t (*vread)(void);
-        void (*suspend)(struct clocksource *cs);
-        void (*resume)(struct clocksource *cs);
+
 #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)
 #endif
-
-        /*
-         * Second part is written at each timer interrupt
-         * Keep it in a different cache line to dirty no
-         * more than one cache line.
-         */
-        cycle_t cycle_last ____cacheline_aligned_in_smp;
+        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;
+        void (*suspend)(struct clocksource *cs);
+        void (*resume)(struct clocksource *cs);
 
 #ifdef CONFIG_CLOCKSOURCE_WATCHDOG
         /* Watchdog related data, used by the framework */
         struct list_head wd_list;
         cycle_t wd_last;
 #endif
-};
+} ____cacheline_aligned;
 
 /*
  * Clock source flags bits::
@@ -341,4 +337,14 @@ static inline void update_vsyscall_tz(void)
 
 extern void timekeeping_notify(struct clocksource *clock);
 
+extern cycle_t clocksource_mmio_readl_up(struct clocksource *);
+extern cycle_t clocksource_mmio_readl_down(struct clocksource *);
+extern cycle_t clocksource_mmio_readw_up(struct clocksource *);
+extern cycle_t clocksource_mmio_readw_down(struct clocksource *);
+
+extern int clocksource_mmio_init(void __iomem *, const char *,
+        unsigned long, int, unsigned, cycle_t (*)(struct clocksource *));
+
+extern int clocksource_i8253_init(void);
+
 #endif /* _LINUX_CLOCKSOURCE_H */
diff --git a/include/linux/compat.h b/include/linux/compat.h
index 5778b559d59c..ddcb7db38e67 100644
--- a/include/linux/compat.h
+++ b/include/linux/compat.h
@@ -12,6 +12,8 @@
 #include <linux/sem.h>
 #include <linux/socket.h>
 #include <linux/if.h>
+#include <linux/fs.h>
+#include <linux/aio_abi.h>      /* for aio_context_t */
 
 #include <asm/compat.h>
 #include <asm/siginfo.h>
@@ -26,7 +28,7 @@ typedef __compat_gid32_t	compat_gid_t;
 struct compat_sel_arg_struct;
 struct rusage;
 
-struct compat_itimerspec { 
+struct compat_itimerspec {
         struct compat_timespec it_interval;
         struct compat_timespec it_value;
 };
@@ -70,9 +72,9 @@ struct compat_timex {
         compat_long_t stbcnt;
         compat_int_t tai;
 
-        compat_int_t :32; compat_int_t :32; compat_int_t :32; compat_int_t :32;
-        compat_int_t :32; compat_int_t :32; compat_int_t :32; compat_int_t :32;
-        compat_int_t :32; compat_int_t :32; compat_int_t :32;
+        compat_int_t:32; compat_int_t:32; compat_int_t:32; compat_int_t:32;
+        compat_int_t:32; compat_int_t:32; compat_int_t:32; compat_int_t:32;
+        compat_int_t:32; compat_int_t:32; compat_int_t:32;
 };
 
 #define _COMPAT_NSIG_WORDS      (_COMPAT_NSIG / _COMPAT_NSIG_BPW)
@@ -81,8 +83,10 @@ typedef struct {
         compat_sigset_word      sig[_COMPAT_NSIG_WORDS];
 } compat_sigset_t;
 
-extern int get_compat_timespec(struct timespec *, const struct compat_timespec __user *);
-extern int put_compat_timespec(const struct timespec *, struct compat_timespec __user *);
+extern int get_compat_timespec(struct timespec *,
+                               const struct compat_timespec __user *);
+extern int put_compat_timespec(const struct timespec *,
+                               struct compat_timespec __user *);
 
 struct compat_iovec {
         compat_uptr_t   iov_base;
@@ -113,7 +117,8 @@ struct compat_rusage {
         compat_long_t   ru_nivcsw;
 };
 
-extern int put_compat_rusage(const struct rusage *, struct compat_rusage __user *);
+extern int put_compat_rusage(const struct rusage *,
+                             struct compat_rusage __user *);
 
 struct compat_siginfo;
 
@@ -166,8 +171,7 @@ struct compat_ifmap {
         unsigned char port;
 };
 
-struct compat_if_settings
-{
+struct compat_if_settings {
         unsigned int type;      /* Type of physical device or protocol */
         unsigned int size;      /* Size of the data allocated by the caller */
         compat_uptr_t ifs_ifsu; /* union of pointers */
@@ -195,8 +199,8 @@ struct compat_ifreq {
 };
 
 struct compat_ifconf {
-        compat_int_t    ifc_len;                        /* size of buffer       */
-        compat_caddr_t  ifcbuf;
+        compat_int_t    ifc_len;                /* size of buffer */
+        compat_caddr_t  ifcbuf;
 };
 
 struct compat_robust_list {
@@ -209,6 +213,18 @@ struct compat_robust_list_head {
         compat_uptr_t                   list_op_pending;
 };
 
+struct compat_statfs;
+struct compat_statfs64;
+struct compat_old_linux_dirent;
+struct compat_linux_dirent;
+struct linux_dirent64;
+struct compat_msghdr;
+struct compat_mmsghdr;
+struct compat_sysinfo;
+struct compat_sysctl_args;
+struct compat_kexec_segment;
+struct compat_mq_attr;
+
 extern void compat_exit_robust_list(struct task_struct *curr);
 
 asmlinkage long
@@ -243,8 +259,8 @@ asmlinkage ssize_t compat_sys_pwritev(unsigned long fd,
                 const struct compat_iovec __user *vec,
                 unsigned long vlen, u32 pos_low, u32 pos_high);
 
-int compat_do_execve(char * filename, compat_uptr_t __user *argv,
-                compat_uptr_t __user *envp, struct pt_regs * regs);
+int compat_do_execve(char *filename, compat_uptr_t __user *argv,
+                     compat_uptr_t __user *envp, struct pt_regs *regs);
 
 asmlinkage long compat_sys_select(int n, compat_ulong_t __user *inp,
                 compat_ulong_t __user *outp, compat_ulong_t __user *exp,
@@ -331,12 +347,18 @@ asmlinkage long compat_sys_epoll_pwait(int epfd,
                         const compat_sigset_t __user *sigmask,
                         compat_size_t sigsetsize);
 
-asmlinkage long compat_sys_utimensat(unsigned int dfd, const char __user *filename,
-                                struct compat_timespec __user *t, int flags);
+asmlinkage long compat_sys_utime(const char __user *filename,
+                                 struct compat_utimbuf __user *t);
+asmlinkage long compat_sys_utimensat(unsigned int dfd,
+                                     const char __user *filename,
+                                     struct compat_timespec __user *t,
+                                     int flags);
 
+asmlinkage long compat_sys_time(compat_time_t __user *tloc);
+asmlinkage long compat_sys_stime(compat_time_t __user *tptr);
 asmlinkage long compat_sys_signalfd(int ufd,
-                                const compat_sigset_t __user *sigmask,
-                                compat_size_t sigsetsize);
+                                    const compat_sigset_t __user *sigmask,
+                                    compat_size_t sigsetsize);
 asmlinkage long compat_sys_timerfd_settime(int ufd, int flags,
                                    const struct compat_itimerspec __user *utmr,
                                    struct compat_itimerspec __user *otmr);
@@ -348,16 +370,190 @@ asmlinkage long compat_sys_move_pages(pid_t pid, unsigned long nr_page,
                                       const int __user *nodes,
                                       int __user *status,
                                       int flags);
-asmlinkage long compat_sys_futimesat(unsigned int dfd, const char __user *filename,
+asmlinkage long compat_sys_futimesat(unsigned int dfd,
+                                     const char __user *filename,
                                      struct compat_timeval __user *t);
-asmlinkage long compat_sys_newfstatat(unsigned int dfd, const char __user * filename,
+asmlinkage long compat_sys_utimes(const char __user *filename,
+                                  struct compat_timeval __user *t);
+asmlinkage long compat_sys_newstat(const char __user *filename,
+                                   struct compat_stat __user *statbuf);
+asmlinkage long compat_sys_newlstat(const char __user *filename,
+                                    struct compat_stat __user *statbuf);
+asmlinkage long compat_sys_newfstatat(unsigned int dfd,
+                                      const char __user *filename,
                                       struct compat_stat __user *statbuf,
                                       int flag);
+asmlinkage long compat_sys_newfstat(unsigned int fd,
+                                    struct compat_stat __user *statbuf);
+asmlinkage long compat_sys_statfs(const char __user *pathname,
+                                  struct compat_statfs __user *buf);
+asmlinkage long compat_sys_fstatfs(unsigned int fd,
+                                   struct compat_statfs __user *buf);
+asmlinkage long compat_sys_statfs64(const char __user *pathname,
+                                    compat_size_t sz,
+                                    struct compat_statfs64 __user *buf);
+asmlinkage long compat_sys_fstatfs64(unsigned int fd, compat_size_t sz,
+                                     struct compat_statfs64 __user *buf);
+asmlinkage long compat_sys_fcntl64(unsigned int fd, unsigned int cmd,
+                                   unsigned long arg);
+asmlinkage long compat_sys_fcntl(unsigned int fd, unsigned int cmd,
+                                 unsigned long arg);
+asmlinkage long compat_sys_io_setup(unsigned nr_reqs, u32 __user *ctx32p);
+asmlinkage long compat_sys_io_getevents(aio_context_t ctx_id,
+                                        unsigned long min_nr,
+                                        unsigned long nr,
+                                        struct io_event __user *events,
+                                        struct compat_timespec __user *timeout);
+asmlinkage long compat_sys_io_submit(aio_context_t ctx_id, int nr,
+                                     u32 __user *iocb);
+asmlinkage long compat_sys_mount(const char __user *dev_name,
+                                 const char __user *dir_name,
+                                 const char __user *type, unsigned long flags,
+                                 const void __user *data);
+asmlinkage long compat_sys_old_readdir(unsigned int fd,
+                                       struct compat_old_linux_dirent __user *,
+                                       unsigned int count);
+asmlinkage long compat_sys_getdents(unsigned int fd,
+                                    struct compat_linux_dirent __user *dirent,
+                                    unsigned int count);
+asmlinkage long compat_sys_getdents64(unsigned int fd,
+                                      struct linux_dirent64 __user *dirent,
+                                      unsigned int count);
+asmlinkage long compat_sys_vmsplice(int fd, const struct compat_iovec __user *,
+                                    unsigned int nr_segs, unsigned int flags);
+asmlinkage long compat_sys_open(const char __user *filename, int flags,
+                                int mode);
 asmlinkage long compat_sys_openat(unsigned int dfd, const char __user *filename,
                                   int flags, int mode);
+asmlinkage long compat_sys_open_by_handle_at(int mountdirfd,
+                                             struct file_handle __user *handle,
+                                             int flags);
+asmlinkage long compat_sys_pselect6(int n, compat_ulong_t __user *inp,
+                                    compat_ulong_t __user *outp,
+                                    compat_ulong_t __user *exp,
+                                    struct compat_timespec __user *tsp,
+                                    void __user *sig);
+asmlinkage long compat_sys_ppoll(struct pollfd __user *ufds,
+                                 unsigned int nfds,
+                                 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);
+asmlinkage long compat_sys_get_mempolicy(int __user *policy,
+                                         compat_ulong_t __user *nmask,
+                                         compat_ulong_t maxnode,
+                                         compat_ulong_t addr,
+                                         compat_ulong_t flags);
+asmlinkage long compat_sys_set_mempolicy(int mode, compat_ulong_t __user *nmask,
+                                         compat_ulong_t maxnode);
+asmlinkage long compat_sys_mbind(compat_ulong_t start, compat_ulong_t len,
+                                 compat_ulong_t mode,
+                                 compat_ulong_t __user *nmask,
+                                 compat_ulong_t maxnode, compat_ulong_t flags);
+
+asmlinkage long compat_sys_setsockopt(int fd, int level, int optname,
+                                      char __user *optval, unsigned int optlen);
+asmlinkage long compat_sys_sendmsg(int fd, struct compat_msghdr __user *msg,
+                                   unsigned flags);
+asmlinkage long compat_sys_recvmsg(int fd, struct compat_msghdr __user *msg,
+                                   unsigned int flags);
+asmlinkage long compat_sys_recv(int fd, void __user *buf, size_t len,
+                                unsigned flags);
+asmlinkage long compat_sys_recvfrom(int fd, void __user *buf, size_t len,
+                            unsigned flags, struct sockaddr __user *addr,
+                            int __user *addrlen);
+asmlinkage long compat_sys_recvmmsg(int fd, struct compat_mmsghdr __user *mmsg,
+                                    unsigned vlen, unsigned int flags,
+                                    struct compat_timespec __user *timeout);
+asmlinkage long compat_sys_nanosleep(struct compat_timespec __user *rqtp,
+                                     struct compat_timespec __user *rmtp);
+asmlinkage long compat_sys_getitimer(int which,
+                                     struct compat_itimerval __user *it);
+asmlinkage long compat_sys_setitimer(int which,
+                                     struct compat_itimerval __user *in,
+                                     struct compat_itimerval __user *out);
+asmlinkage long compat_sys_times(struct compat_tms __user *tbuf);
+asmlinkage long compat_sys_setrlimit(unsigned int resource,
+                                     struct compat_rlimit __user *rlim);
+asmlinkage long compat_sys_getrlimit(unsigned int resource,
+                                     struct compat_rlimit __user *rlim);
+asmlinkage long compat_sys_getrusage(int who, struct compat_rusage __user *ru);
+asmlinkage long compat_sys_sched_setaffinity(compat_pid_t pid,
+                                     unsigned int len,
+                                     compat_ulong_t __user *user_mask_ptr);
+asmlinkage long compat_sys_sched_getaffinity(compat_pid_t pid,
+                                     unsigned int len,
+                                     compat_ulong_t __user *user_mask_ptr);
+asmlinkage long compat_sys_timer_create(clockid_t which_clock,
+                        struct compat_sigevent __user *timer_event_spec,
+                        timer_t __user *created_timer_id);
+asmlinkage long compat_sys_timer_settime(timer_t timer_id, int flags,
+                                         struct compat_itimerspec __user *new,
+                                         struct compat_itimerspec __user *old);
+asmlinkage long compat_sys_timer_gettime(timer_t timer_id,
+                                 struct compat_itimerspec __user *setting);
+asmlinkage long compat_sys_clock_settime(clockid_t which_clock,
+                                         struct compat_timespec __user *tp);
+asmlinkage long compat_sys_clock_gettime(clockid_t which_clock,
+                                         struct compat_timespec __user *tp);
+asmlinkage long compat_sys_clock_adjtime(clockid_t which_clock,
+                                         struct compat_timex __user *tp);
+asmlinkage long compat_sys_clock_getres(clockid_t which_clock,
+                                        struct compat_timespec __user *tp);
+asmlinkage long compat_sys_clock_nanosleep(clockid_t which_clock, int flags,
+                                           struct compat_timespec __user *rqtp,
+                                           struct compat_timespec __user *rmtp);
+asmlinkage long compat_sys_rt_sigtimedwait(compat_sigset_t __user *uthese,
+                struct compat_siginfo __user *uinfo,
+                struct compat_timespec __user *uts, compat_size_t sigsetsize);
+asmlinkage long compat_sys_rt_sigsuspend(compat_sigset_t __user *unewset,
+                                         compat_size_t sigsetsize);
+asmlinkage long compat_sys_sysinfo(struct compat_sysinfo __user *info);
+asmlinkage long compat_sys_ioctl(unsigned int fd, unsigned int cmd,
+                                 unsigned long arg);
+asmlinkage long compat_sys_futex(u32 __user *uaddr, int op, u32 val,
+                struct compat_timespec __user *utime, u32 __user *uaddr2,
+                u32 val3);
+asmlinkage long compat_sys_getsockopt(int fd, int level, int optname,
+                                      char __user *optval, int __user *optlen);
+asmlinkage long compat_sys_kexec_load(unsigned long entry,
+                                      unsigned long nr_segments,
+                                      struct compat_kexec_segment __user *,
+                                      unsigned long flags);
+asmlinkage long compat_sys_mq_getsetattr(mqd_t mqdes,
+                        const struct compat_mq_attr __user *u_mqstat,
+                        struct compat_mq_attr __user *u_omqstat);
+asmlinkage long compat_sys_mq_notify(mqd_t mqdes,
+                        const struct compat_sigevent __user *u_notification);
+asmlinkage long compat_sys_mq_open(const char __user *u_name,
+                        int oflag, compat_mode_t mode,
+                        struct compat_mq_attr __user *u_attr);
+asmlinkage long compat_sys_mq_timedsend(mqd_t mqdes,
+                        const char __user *u_msg_ptr,
+                        size_t msg_len, unsigned int msg_prio,
+                        const struct compat_timespec __user *u_abs_timeout);
+asmlinkage ssize_t compat_sys_mq_timedreceive(mqd_t mqdes,
+                        char __user *u_msg_ptr,
+                        size_t msg_len, unsigned int __user *u_msg_prio,
+                        const struct compat_timespec __user *u_abs_timeout);
+asmlinkage long compat_sys_socketcall(int call, u32 __user *args);
+asmlinkage long compat_sys_sysctl(struct compat_sysctl_args __user *args);
 
 extern ssize_t compat_rw_copy_check_uvector(int type,
-                const struct compat_iovec __user *uvector, unsigned long nr_segs,
+                const struct compat_iovec __user *uvector,
+                unsigned long nr_segs,
                 unsigned long fast_segs, struct iovec *fast_pointer,
                 struct iovec **ret_pointer);
 
diff --git a/include/linux/compiler-gcc.h b/include/linux/compiler-gcc.h
index cb4c1eb7778e..59e4028e833d 100644
--- a/include/linux/compiler-gcc.h
+++ b/include/linux/compiler-gcc.h
@@ -34,8 +34,12 @@
     __asm__ ("" : "=r"(__ptr) : "0"(ptr));              \
     (typeof(ptr)) (__ptr + (off)); })
 
+#ifdef __CHECKER__
+#define __must_be_array(arr) 0
+#else
 /* &a[0] degrades to a pointer: a different type from an array */
 #define __must_be_array(a) BUILD_BUG_ON_ZERO(__same_type((a), &(a)[0]))
+#endif
 
 /*
  * Force always-inline if the user requests it so via the .config,
diff --git a/include/linux/compiler-gcc4.h b/include/linux/compiler-gcc4.h
index 64b7c003fd7a..dfadc96e9d63 100644
--- a/include/linux/compiler-gcc4.h
+++ b/include/linux/compiler-gcc4.h
@@ -51,7 +51,7 @@
 #if __GNUC_MINOR__ > 0
 #define __compiletime_object_size(obj) __builtin_object_size(obj, 0)
 #endif
-#if __GNUC_MINOR__ >= 4
+#if __GNUC_MINOR__ >= 4 && !defined(__CHECKER__)
 #define __compiletime_warning(message) __attribute__((warning(message)))
 #define __compiletime_error(message) __attribute__((error(message)))
 #endif
diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h
index 9343dd3de858..11be48e0d168 100644
--- a/include/linux/cpufreq.h
+++ b/include/linux/cpufreq.h
@@ -3,7 +3,7 @@
  *
  *  Copyright (C) 2001 Russell King
  *            (C) 2002 - 2003 Dominik Brodowski <linux@brodo.de>
- *            
+ *
  * 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.
@@ -56,9 +56,9 @@ static inline int cpufreq_unregister_notifier(struct notifier_block *nb,
 #define CPUFREQ_POLICY_POWERSAVE        (1)
 #define CPUFREQ_POLICY_PERFORMANCE      (2)
 
-/* Frequency values here are CPU kHz so that hardware which doesn't run 
- * with some frequencies can complain without having to guess what per 
- * cent / per mille means. 
+/* Frequency values here are CPU kHz so that hardware which doesn't run
+ * with some frequencies can complain without having to guess what per
+ * cent / per mille means.
  * Maximum transition latency is in nanoseconds - if it's unknown,
  * CPUFREQ_ETERNAL shall be used.
  */
@@ -72,13 +72,15 @@ extern struct kobject *cpufreq_global_kobject;
 struct cpufreq_cpuinfo {
         unsigned int            max_freq;
         unsigned int            min_freq;
-        unsigned int            transition_latency; /* in 10^(-9) s = nanoseconds */
+
+        /* in 10^(-9) s = nanoseconds */
+        unsigned int            transition_latency;
 };
 
 struct cpufreq_real_policy {
         unsigned int            min;    /* in kHz */
         unsigned int            max;    /* in kHz */
-        unsigned int            policy; /* see above */
+        unsigned int            policy; /* see above */
         struct cpufreq_governor *governor; /* see below */
 };
 
@@ -94,7 +96,7 @@ struct cpufreq_policy {
         unsigned int            max;    /* in kHz */
         unsigned int            cur;    /* in kHz, only needed if cpufreq
                                          * governors are used */
-        unsigned int            policy; /* see above */
+        unsigned int            policy; /* see above */
         struct cpufreq_governor *governor; /* see below */
 
         struct work_struct      update; /* if update_policy() needs to be
@@ -167,11 +169,11 @@ static inline unsigned long cpufreq_scale(unsigned long old, u_int div, u_int mu
 
 struct cpufreq_governor {
         char    name[CPUFREQ_NAME_LEN];
-        int     (*governor)     (struct cpufreq_policy *policy,
+        int     (*governor)     (struct cpufreq_policy *policy,
                                  unsigned int event);
         ssize_t (*show_setspeed)        (struct cpufreq_policy *policy,
                                          char *buf);
-        int     (*store_setspeed)       (struct cpufreq_policy *policy,
+        int     (*store_setspeed)       (struct cpufreq_policy *policy,
                                          unsigned int freq);
         unsigned int max_transition_latency; /* HW must be able to switch to
                         next freq faster than this value in nano secs or we
@@ -180,7 +182,8 @@ struct cpufreq_governor {
         struct module           *owner;
 };
 
-/* pass a target to the cpufreq driver 
+/*
+ * Pass a target to the cpufreq driver.
  */
 extern int cpufreq_driver_target(struct cpufreq_policy *policy,
                                  unsigned int target_freq,
@@ -237,9 +240,9 @@ struct cpufreq_driver {
 
 /* flags */
 
-#define CPUFREQ_STICKY          0x01    /* the driver isn't removed even if 
+#define CPUFREQ_STICKY          0x01    /* the driver isn't removed even if
                                          * all ->init() calls failed */
-#define CPUFREQ_CONST_LOOPS     0x02    /* loops_per_jiffy or other kernel
+#define CPUFREQ_CONST_LOOPS     0x02    /* loops_per_jiffy or other kernel
                                          * "constants" aren't affected by
                                          * frequency transitions */
 #define CPUFREQ_PM_NO_WARN      0x04    /* don't warn on suspend/resume speed
@@ -252,7 +255,7 @@ int cpufreq_unregister_driver(struct cpufreq_driver *driver_data);
 void cpufreq_notify_transition(struct cpufreq_freqs *freqs, unsigned int state);
 
 
-static inline void cpufreq_verify_within_limits(struct cpufreq_policy *policy, unsigned int min, unsigned int max) 
+static inline void cpufreq_verify_within_limits(struct cpufreq_policy *policy, unsigned int min, unsigned int max)
 {
         if (policy->min < min)
                 policy->min = min;
@@ -386,34 +389,15 @@ int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
 /* the following 3 funtions are for cpufreq core use only */
 struct cpufreq_frequency_table *cpufreq_frequency_get_table(unsigned int cpu);
 struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu);
-void   cpufreq_cpu_put (struct cpufreq_policy *data);
+void   cpufreq_cpu_put(struct cpufreq_policy *data);
 
 /* the following are really really optional */
 extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs;
 
-void cpufreq_frequency_table_get_attr(struct cpufreq_frequency_table *table, 
+void cpufreq_frequency_table_get_attr(struct cpufreq_frequency_table *table,
                                       unsigned int cpu);
 
 void cpufreq_frequency_table_put_attr(unsigned int cpu);
 
 
-/*********************************************************************
- *                     UNIFIED DEBUG HELPERS                         *
- *********************************************************************/
-
-#define CPUFREQ_DEBUG_CORE      1
-#define CPUFREQ_DEBUG_DRIVER    2
-#define CPUFREQ_DEBUG_GOVERNOR  4
-
-#ifdef CONFIG_CPU_FREQ_DEBUG
-
-extern void cpufreq_debug_printk(unsigned int type, const char *prefix, 
-                                 const char *fmt, ...);
-
-#else
-
-#define cpufreq_debug_printk(msg...) do { } while(0)
-
-#endif /* CONFIG_CPU_FREQ_DEBUG */
-
 #endif /* _LINUX_CPUFREQ_H */
diff --git a/include/linux/cpumask.h b/include/linux/cpumask.h
index bae6fe24d1f9..b24ac56477b4 100644
--- a/include/linux/cpumask.h
+++ b/include/linux/cpumask.h
@@ -547,6 +547,21 @@ static inline int cpumask_parse_user(const char __user *buf, int len,
 }
 
 /**
+ * cpumask_parselist_user - extract a cpumask from a user string
+ * @buf: the buffer to extract from
+ * @len: the length of the buffer
+ * @dstp: the cpumask to set.
+ *
+ * Returns -errno, or 0 for success.
+ */
+static inline int cpumask_parselist_user(const char __user *buf, int len,
+                                     struct cpumask *dstp)
+{
+        return bitmap_parselist_user(buf, len, cpumask_bits(dstp),
+                                                        nr_cpumask_bits);
+}
+
+/**
  * cpulist_scnprintf - print a cpumask into a string as comma-separated list
  * @buf: the buffer to sprintf into
  * @len: the length of the buffer
diff --git a/include/linux/cred.h b/include/linux/cred.h
index 9aeeb0ba2003..be16b61283cc 100644
--- a/include/linux/cred.h
+++ b/include/linux/cred.h
@@ -146,6 +146,7 @@ struct cred {
         void            *security;      /* subjective LSM security */
 #endif
         struct user_struct *user;       /* real user ID subscription */
+        struct user_namespace *user_ns; /* cached user->user_ns */
         struct group_info *group_info;  /* supplementary groups for euid/fsgid */
         struct rcu_head rcu;            /* RCU deletion hook */
 };
@@ -354,10 +355,15 @@ static inline void put_cred(const struct cred *_cred)
 #define current_fsgid()         (current_cred_xxx(fsgid))
 #define current_cap()           (current_cred_xxx(cap_effective))
 #define current_user()          (current_cred_xxx(user))
-#define _current_user_ns()      (current_cred_xxx(user)->user_ns)
 #define current_security()      (current_cred_xxx(security))
 
-extern struct user_namespace *current_user_ns(void);
+#ifdef CONFIG_USER_NS
+#define current_user_ns() (current_cred_xxx(user_ns))
+#else
+extern struct user_namespace init_user_ns;
+#define current_user_ns() (&init_user_ns)
+#endif
+
 
 #define current_uid_gid(_uid, _gid)             \
 do {                                            \
diff --git a/include/linux/device.h b/include/linux/device.h
index ab8dfc095709..c66111affca9 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -47,6 +47,38 @@ extern int __must_check bus_create_file(struct bus_type *,
                                         struct bus_attribute *);
 extern void bus_remove_file(struct bus_type *, struct bus_attribute *);
 
+/**
+ * struct bus_type - The bus type of the device
+ *
+ * @name:       The name of the bus.
+ * @bus_attrs:  Default attributes of the bus.
+ * @dev_attrs:  Default attributes of the devices on the bus.
+ * @drv_attrs:  Default attributes of the device drivers on the bus.
+ * @match:      Called, perhaps multiple times, whenever a new device or driver
+ *              is added for this bus. It should return a nonzero value if the
+ *              given device can be handled by the given driver.
+ * @uevent:     Called when a device is added, removed, or a few other things
+ *              that generate uevents to add the environment variables.
+ * @probe:      Called when a new device or driver add to this bus, and callback
+ *              the specific driver's probe to initial the matched device.
+ * @remove:     Called when a device removed from this bus.
+ * @shutdown:   Called at shut-down time to quiesce the device.
+ * @suspend:    Called when a device on this bus wants to go to sleep mode.
+ * @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.
+ * @p:          The private data of the driver core, only the driver core can
+ *              touch this.
+ *
+ * A bus is a channel between the processor and one or more devices. For the
+ * purposes of the device model, all devices are connected via a bus, even if
+ * it is an internal, virtual, "platform" bus. Buses can plug into each other.
+ * A USB controller is usually a PCI device, for example. The device model
+ * represents the actual connections between buses and the devices they control.
+ * A bus is represented by the bus_type structure. It contains the name, the
+ * default attributes, the bus' methods, PM operations, and the driver core's
+ * private data.
+ */
 struct bus_type {
         const char              *name;
         struct bus_attribute    *bus_attrs;
@@ -119,6 +151,37 @@ extern int bus_unregister_notifier(struct bus_type *bus,
 extern struct kset *bus_get_kset(struct bus_type *bus);
 extern struct klist *bus_get_device_klist(struct bus_type *bus);
 
+/**
+ * struct device_driver - The basic device driver structure
+ * @name:       Name of the device driver.
+ * @bus:        The bus which the device of this driver belongs to.
+ * @owner:      The module owner.
+ * @mod_name:   Used for built-in modules.
+ * @suppress_bind_attrs: Disables bind/unbind via sysfs.
+ * @of_match_table: The open firmware table.
+ * @probe:      Called to query the existence of a specific device,
+ *              whether this driver can work with it, and bind the driver
+ *              to a specific device.
+ * @remove:     Called when the device is removed from the system to
+ *              unbind a device from this driver.
+ * @shutdown:   Called at shut-down time to quiesce the device.
+ * @suspend:    Called to put the device to sleep mode. Usually to a
+ *              low power state.
+ * @resume:     Called to bring a device from sleep mode.
+ * @groups:     Default attributes that get created by the driver core
+ *              automatically.
+ * @pm:         Power management operations of the device which matched
+ *              this driver.
+ * @p:          Driver core's private data, no one other than the driver
+ *              core can touch this.
+ *
+ * The device driver-model tracks all of the drivers known to the system.
+ * The main reason for this tracking is to enable the driver core to match
+ * up drivers with new devices. Once drivers are known objects within the
+ * system, however, a number of other things become possible. Device drivers
+ * can export information and configuration variables that are independent
+ * of any specific device.
+ */
 struct device_driver {
         const char              *name;
         struct bus_type         *bus;
@@ -185,8 +248,34 @@ struct device *driver_find_device(struct device_driver *drv,
                                   struct device *start, void *data,
                                   int (*match)(struct device *dev, void *data));
 
-/*
- * device classes
+/**
+ * struct class - device classes
+ * @name:       Name of the class.
+ * @owner:      The module owner.
+ * @class_attrs: Default attributes of this class.
+ * @dev_attrs:  Default attributes of the devices belong to the class.
+ * @dev_bin_attrs: Default binary attributes of the devices belong to the class.
+ * @dev_kobj:   The kobject that represents this class and links it into the hierarchy.
+ * @dev_uevent: Called when a device is added, removed from this class, or a
+ *              few other things that generate uevents to add the environment
+ *              variables.
+ * @devnode:    Callback to provide the devtmpfs.
+ * @class_release: Called to release this class.
+ * @dev_release: Called to release the device.
+ * @suspend:    Used to put the device to sleep mode, usually to a low power
+ *              state.
+ * @resume:     Used to bring the device from the sleep mode.
+ * @ns_type:    Callbacks so sysfs can detemine namespaces.
+ * @namespace:  Namespace of the device belongs to this class.
+ * @pm:         The default device power management operations of this class.
+ * @p:          The private data of the driver core, no one other than the
+ *              driver core can touch this.
+ *
+ * A class is a higher-level view of a device that abstracts out low-level
+ * implementation details. Drivers may see a SCSI disk or an ATA disk, but,
+ * at the class level, they are all simply disks. Classes allow user space
+ * to work with devices based on what they do, rather than how they are
+ * connected or how they work.
  */
 struct class {
         const char              *name;
@@ -401,6 +490,65 @@ struct device_dma_parameters {
         unsigned long segment_boundary_mask;
 };
 
+/**
+ * struct device - The basic device structure
+ * @parent:     The device's "parent" device, the device to which it is attached.
+ *              In most cases, a parent device is some sort of bus or host
+ *              controller. If parent is NULL, the device, is a top-level device,
+ *              which is not usually what you want.
+ * @p:          Holds the private data of the driver core portions of the device.
+ *              See the comment of the struct device_private for detail.
+ * @kobj:       A top-level, abstract class from which other classes are derived.
+ * @init_name:  Initial name of the device.
+ * @type:       The type of device.
+ *              This identifies the device type and carries type-specific
+ *              information.
+ * @mutex:      Mutex to synchronize calls to its driver.
+ * @bus:        Type of bus device is on.
+ * @driver:     Which driver has allocated this
+ * @platform_data: Platform data specific to the device.
+ *              Example: For devices on custom boards, as typical of embedded
+ *              and SOC based hardware, Linux often uses platform_data to point
+ *              to board-specific structures describing devices and how they
+ *              are wired.  That can include what ports are available, chip
+ *              variants, which GPIO pins act in what additional roles, and so
+ *              on.  This shrinks the "Board Support Packages" (BSPs) and
+ *              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,
+ *              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.
+ * @dma_mask:   Dma mask (if dma'ble device).
+ * @coherent_dma_mask: Like dma_mask, but for alloc_coherent mapping as not all
+ *              hardware supports 64-bit addresses for consistent allocations
+ *              such descriptors.
+ * @dma_parms:  A low level driver may set these to teach IOMMU code about
+ *              segment limitations.
+ * @dma_pools:  Dma pools (if dma'ble device).
+ * @dma_mem:    Internal for coherent mem override.
+ * @archdata:   For arch-specific additions.
+ * @of_node:    Associated device tree node.
+ * @of_match:   Matching of_device_id from driver.
+ * @devt:       For creating the sysfs "dev".
+ * @devres_lock: Spinlock to protect the resource of the device.
+ * @devres_head: The resources list of the device.
+ * @knode_class: The node used to add the device to the class list.
+ * @class:      The class of the device.
+ * @groups:     Optional attribute groups.
+ * @release:    Callback to free the device after all references have
+ *              gone away. This should be set by the allocator of the
+ *              device (i.e. the bus driver that discovered the device).
+ *
+ * At the lowest level, every device in a Linux system is represented by an
+ * instance of struct device. The device structure contains the information
+ * that the device model core needs to model the system. Most subsystems,
+ * however, track additional information about the devices they host. As a
+ * result, it is rare for devices to be represented by bare device structures;
+ * instead, that structure, like kobject structures, is usually embedded within
+ * a higher-level representation of the device.
+ */
 struct device {
         struct device           *parent;
 
@@ -408,7 +556,7 @@ struct device {
 
         struct kobject kobj;
         const char              *init_name; /* initial name of the device */
-        struct device_type      *type;
+        const struct device_type *type;
 
         struct mutex            mutex;  /* mutex to synchronize calls to
                                          * its driver.
@@ -442,7 +590,6 @@ struct device {
         struct dev_archdata     archdata;
 
         struct device_node      *of_node; /* associated device tree node */
-        const struct of_device_id *of_match; /* matching of_device_id from driver */
 
         dev_t                   devt;   /* dev_t, creates the sysfs "dev" */
 
@@ -557,7 +704,7 @@ extern int device_move(struct device *dev, struct device *new_parent,
 extern const char *device_get_devnode(struct device *dev,
                                       mode_t *mode, const char **tmp);
 extern void *dev_get_drvdata(const struct device *dev);
-extern void dev_set_drvdata(struct device *dev, void *data);
+extern int dev_set_drvdata(struct device *dev, void *data);
 
 /*
  * Root device objects for grouping under /sys/devices
@@ -611,7 +758,7 @@ extern int (*platform_notify)(struct device *dev);
 extern int (*platform_notify_remove)(struct device *dev);
 
 
-/**
+/*
  * get_device - atomically increment the reference count for the device.
  *
  */
@@ -633,13 +780,6 @@ static inline int devtmpfs_mount(const char *mountpoint) { return 0; }
 /* drivers/base/power/shutdown.c */
 extern void device_shutdown(void);
 
-#ifndef CONFIG_ARCH_NO_SYSDEV_OPS
-/* drivers/base/sys.c */
-extern void sysdev_shutdown(void);
-#else
-static inline void sysdev_shutdown(void) { }
-#endif
-
 /* debugging and troubleshooting/diagnostic helpers. */
 extern const char *dev_driver_string(const struct device *dev);
 
@@ -742,13 +882,17 @@ do {						     \
 #endif
 
 /*
- * dev_WARN() acts like dev_printk(), but with the key difference
+ * dev_WARN*() acts like dev_printk(), but with the key difference
  * of using a WARN/WARN_ON to get the message out, including the
  * file/line information and a backtrace.
  */
 #define dev_WARN(dev, format, arg...) \
         WARN(1, "Device: %s\n" format, dev_driver_string(dev), ## arg);
 
+#define dev_WARN_ONCE(dev, condition, format, arg...) \
+        WARN_ONCE(condition, "Device %s\n" format, \
+                        dev_driver_string(dev), ## arg)
+
 /* Create alias, so I can be autoloaded. */
 #define MODULE_ALIAS_CHARDEV(major,minor) \
         MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor))
diff --git a/include/linux/dlm_plock.h b/include/linux/dlm_plock.h
index 2dd21243104f..3b1cc1be419f 100644
--- a/include/linux/dlm_plock.h
+++ b/include/linux/dlm_plock.h
@@ -14,7 +14,7 @@
 #define DLM_PLOCK_MISC_NAME             "dlm_plock"
 
 #define DLM_PLOCK_VERSION_MAJOR 1
-#define DLM_PLOCK_VERSION_MINOR 1
+#define DLM_PLOCK_VERSION_MINOR 2
 #define DLM_PLOCK_VERSION_PATCH 0
 
 enum {
@@ -23,12 +23,14 @@ enum {
         DLM_PLOCK_OP_GET,
 };
 
+#define DLM_PLOCK_FL_CLOSE 1
+
 struct dlm_plock_info {
         __u32 version[3];
         __u8 optype;
         __u8 ex;
         __u8 wait;
-        __u8 pad;
+        __u8 flags;
         __u32 pid;
         __s32 nodeid;
         __s32 rv;
diff --git a/include/linux/drbd.h b/include/linux/drbd.h
index cec467f5d676..9e5f5607eba3 100644
--- a/include/linux/drbd.h
+++ b/include/linux/drbd.h
@@ -38,7 +38,7 @@
 
 /* Although the Linux source code makes a difference between
    generic endianness and the bitfields' endianness, there is no
-   architecture as of Linux-2.6.24-rc4 where the bitfileds' endianness
+   architecture as of Linux-2.6.24-rc4 where the bitfields' endianness
    does not match the generic endianness. */
 
 #if __BYTE_ORDER == __LITTLE_ENDIAN
@@ -53,7 +53,7 @@
 
 
 extern const char *drbd_buildtag(void);
-#define REL_VERSION "8.3.10"
+#define REL_VERSION "8.3.11"
 #define API_VERSION 88
 #define PRO_VERSION_MIN 86
 #define PRO_VERSION_MAX 96
@@ -195,7 +195,7 @@ enum drbd_conns {
         C_WF_REPORT_PARAMS, /* we have a socket */
         C_CONNECTED,      /* we have introduced each other */
         C_STARTING_SYNC_S,  /* starting full sync by admin request. */
-        C_STARTING_SYNC_T,  /* stariing full sync by admin request. */
+        C_STARTING_SYNC_T,  /* starting full sync by admin request. */
         C_WF_BITMAP_S,
         C_WF_BITMAP_T,
         C_WF_SYNC_UUID,
@@ -236,7 +236,7 @@ union drbd_state {
  * pointed out by Maxim Uvarov q<muvarov@ru.mvista.com>
  * even though we transmit as "cpu_to_be32(state)",
  * the offsets of the bitfields still need to be swapped
- * on different endianess.
+ * on different endianness.
  */
         struct {
 #if defined(__LITTLE_ENDIAN_BITFIELD)
@@ -266,7 +266,7 @@ union drbd_state {
                 unsigned peer:2 ;   /* 3/4       primary/secondary/unknown */
                 unsigned role:2 ;   /* 3/4       primary/secondary/unknown */
 #else
-# error "this endianess is not supported"
+# error "this endianness is not supported"
 #endif
         };
         unsigned int i;
diff --git a/include/linux/drbd_tag_magic.h b/include/linux/drbd_tag_magic.h
index f14a165e82dc..069543190516 100644
--- a/include/linux/drbd_tag_magic.h
+++ b/include/linux/drbd_tag_magic.h
@@ -30,7 +30,7 @@ enum packet_types {
         int tag_and_len ## member;
 #include "linux/drbd_nl.h"
 
-/* declate tag-list-sizes */
+/* declare tag-list-sizes */
 static const int tag_list_sizes[] = {
 #define NL_PACKET(name, number, fields) 2 fields ,
 #define NL_INTEGER(pn, pr, member)      + 4 + 4
diff --git a/include/linux/dvb/frontend.h b/include/linux/dvb/frontend.h
index 493a2bf85f62..36a3ed63f571 100644
--- a/include/linux/dvb/frontend.h
+++ b/include/linux/dvb/frontend.h
@@ -175,14 +175,20 @@ typedef enum fe_transmit_mode {
         TRANSMISSION_MODE_2K,
         TRANSMISSION_MODE_8K,
         TRANSMISSION_MODE_AUTO,
-        TRANSMISSION_MODE_4K
+        TRANSMISSION_MODE_4K,
+        TRANSMISSION_MODE_1K,
+        TRANSMISSION_MODE_16K,
+        TRANSMISSION_MODE_32K,
 } fe_transmit_mode_t;
 
 typedef enum fe_bandwidth {
         BANDWIDTH_8_MHZ,
         BANDWIDTH_7_MHZ,
         BANDWIDTH_6_MHZ,
-        BANDWIDTH_AUTO
+        BANDWIDTH_AUTO,
+        BANDWIDTH_5_MHZ,
+        BANDWIDTH_10_MHZ,
+        BANDWIDTH_1_712_MHZ,
 } fe_bandwidth_t;
 
 
@@ -191,7 +197,10 @@ typedef enum fe_guard_interval {
         GUARD_INTERVAL_1_16,
         GUARD_INTERVAL_1_8,
         GUARD_INTERVAL_1_4,
-        GUARD_INTERVAL_AUTO
+        GUARD_INTERVAL_AUTO,
+        GUARD_INTERVAL_1_128,
+        GUARD_INTERVAL_19_128,
+        GUARD_INTERVAL_19_256,
 } fe_guard_interval_t;
 
 
@@ -305,7 +314,9 @@ struct dvb_frontend_event {
 
 #define DTV_ISDBS_TS_ID         42
 
-#define DTV_MAX_COMMAND                         DTV_ISDBS_TS_ID
+#define DTV_DVBT2_PLP_ID        43
+
+#define DTV_MAX_COMMAND                         DTV_DVBT2_PLP_ID
 
 typedef enum fe_pilot {
         PILOT_ON,
@@ -337,6 +348,7 @@ typedef enum fe_delivery_system {
         SYS_DMBTH,
         SYS_CMMB,
         SYS_DAB,
+        SYS_DVBT2,
 } fe_delivery_system_t;
 
 struct dtv_cmds_h {
diff --git a/include/linux/dvb/version.h b/include/linux/dvb/version.h
index 5a7546c12688..1421cc84afaa 100644
--- a/include/linux/dvb/version.h
+++ b/include/linux/dvb/version.h
@@ -24,6 +24,6 @@
 #define _DVBVERSION_H_
 
 #define DVB_API_VERSION 5
-#define DVB_API_VERSION_MINOR 2
+#define DVB_API_VERSION_MINOR 3
 
 #endif /*_DVBVERSION_H_*/
diff --git a/include/linux/dynamic_debug.h b/include/linux/dynamic_debug.h
index 0c9653f11c18..e747ecd48e1c 100644
--- a/include/linux/dynamic_debug.h
+++ b/include/linux/dynamic_debug.h
@@ -1,8 +1,6 @@
 #ifndef _DYNAMIC_DEBUG_H
 #define _DYNAMIC_DEBUG_H
 
-#include <linux/jump_label.h>
-
 /* dynamic_printk_enabled, and dynamic_printk_enabled2 are bitmasks in which
  * bit n is set to 1 if any modname hashes into the bucket n, 0 otherwise. They
  * use independent hash functions, to reduce the chance of false positives.
diff --git a/include/linux/elf.h b/include/linux/elf.h
index 4d608014753a..110821cb6ea5 100644
--- a/include/linux/elf.h
+++ b/include/linux/elf.h
@@ -395,6 +395,7 @@ typedef struct elf64_shdr {
 #define NT_S390_CTRS    0x304           /* s390 control registers */
 #define NT_S390_PREFIX  0x305           /* s390 prefix register */
 #define NT_S390_LAST_BREAK      0x306   /* s390 breaking event address */
+#define NT_ARM_VFP      0x400           /* ARM VFP/NEON registers */
 
 
 /* Note header in a PT_NOTE section */
diff --git a/include/linux/ethtool.h b/include/linux/ethtool.h
index dc80d8294247..c6a850ab2ec5 100644
--- a/include/linux/ethtool.h
+++ b/include/linux/ethtool.h
@@ -24,7 +24,10 @@ struct ethtool_cmd {
         __u32   cmd;
         __u32   supported;      /* Features this interface supports */
         __u32   advertising;    /* Features this interface advertises */
-        __u16   speed;          /* The forced speed, 10Mb, 100Mb, gigabit */
+        __u16   speed;          /* The forced speed (lower bits) in
+                                 * Mbps. Please use
+                                 * ethtool_cmd_speed()/_set() to
+                                 * access it */
         __u8    duplex;         /* Duplex, half or full */
         __u8    port;           /* Which connector port */
         __u8    phy_address;
@@ -33,7 +36,10 @@ struct ethtool_cmd {
         __u8    mdio_support;
         __u32   maxtxpkt;       /* Tx pkts before generating tx int */
         __u32   maxrxpkt;       /* Rx pkts before generating rx int */
-        __u16   speed_hi;
+        __u16   speed_hi;       /* The forced speed (upper
+                                 * bits) in Mbps. Please use
+                                 * ethtool_cmd_speed()/_set() to
+                                 * access it */
         __u8    eth_tp_mdix;
         __u8    reserved2;
         __u32   lp_advertising; /* Features the link partner advertises */
@@ -41,14 +47,14 @@ struct ethtool_cmd {
 };
 
 static inline void ethtool_cmd_speed_set(struct ethtool_cmd *ep,
-                                                __u32 speed)
+                                         __u32 speed)
 {
 
         ep->speed = (__u16)speed;
         ep->speed_hi = (__u16)(speed >> 16);
 }
 
-static inline __u32 ethtool_cmd_speed(struct ethtool_cmd *ep)
+static inline __u32 ethtool_cmd_speed(const struct ethtool_cmd *ep)
 {
         return (ep->speed_hi << 16) | ep->speed;
 }
@@ -229,6 +235,34 @@ struct ethtool_ringparam {
         __u32   tx_pending;
 };
 
+/**
+ * struct ethtool_channels - configuring number of network channel
+ * @cmd: ETHTOOL_{G,S}CHANNELS
+ * @max_rx: Read only. Maximum number of receive channel the driver support.
+ * @max_tx: Read only. Maximum number of transmit channel the driver support.
+ * @max_other: Read only. Maximum number of other channel the driver support.
+ * @max_combined: Read only. Maximum number of combined channel the driver
+ *      support. Set of queues RX, TX or other.
+ * @rx_count: Valid values are in the range 1 to the max_rx.
+ * @tx_count: Valid values are in the range 1 to the max_tx.
+ * @other_count: Valid values are in the range 1 to the max_other.
+ * @combined_count: Valid values are in the range 1 to the max_combined.
+ *
+ * This can be used to configure RX, TX and other channels.
+ */
+
+struct ethtool_channels {
+        __u32   cmd;
+        __u32   max_rx;
+        __u32   max_tx;
+        __u32   max_other;
+        __u32   max_combined;
+        __u32   rx_count;
+        __u32   tx_count;
+        __u32   other_count;
+        __u32   combined_count;
+};
+
 /* for configuring link flow control parameters */
 struct ethtool_pauseparam {
         __u32   cmd;    /* ETHTOOL_{G,S}PAUSEPARAM */
@@ -380,27 +414,42 @@ struct ethtool_usrip4_spec {
         __u8    proto;
 };
 
+union ethtool_flow_union {
+        struct ethtool_tcpip4_spec              tcp_ip4_spec;
+        struct ethtool_tcpip4_spec              udp_ip4_spec;
+        struct ethtool_tcpip4_spec              sctp_ip4_spec;
+        struct ethtool_ah_espip4_spec           ah_ip4_spec;
+        struct ethtool_ah_espip4_spec           esp_ip4_spec;
+        struct ethtool_usrip4_spec              usr_ip4_spec;
+        struct ethhdr                           ether_spec;
+        __u8                                    hdata[60];
+};
+
+struct ethtool_flow_ext {
+        __be16  vlan_etype;
+        __be16  vlan_tci;
+        __be32  data[2];
+};
+
 /**
  * struct ethtool_rx_flow_spec - specification for RX flow filter
  * @flow_type: Type of match to perform, e.g. %TCP_V4_FLOW
  * @h_u: Flow fields to match (dependent on @flow_type)
- * @m_u: Masks for flow field bits to be ignored
+ * @h_ext: Additional fields to match
+ * @m_u: Masks for flow field bits to be matched
+ * @m_ext: Masks for additional field bits to be matched
+ *      Note, all additional fields must be ignored unless @flow_type
+ *      includes the %FLOW_EXT flag.
  * @ring_cookie: RX ring/queue index to deliver to, or %RX_CLS_FLOW_DISC
  *      if packets should be discarded
  * @location: Index of filter in hardware table
  */
 struct ethtool_rx_flow_spec {
         __u32           flow_type;
-        union {
-                struct ethtool_tcpip4_spec              tcp_ip4_spec;
-                struct ethtool_tcpip4_spec              udp_ip4_spec;
-                struct ethtool_tcpip4_spec              sctp_ip4_spec;
-                struct ethtool_ah_espip4_spec           ah_ip4_spec;
-                struct ethtool_ah_espip4_spec           esp_ip4_spec;
-                struct ethtool_usrip4_spec              usr_ip4_spec;
-                struct ethhdr                           ether_spec;
-                __u8                                    hdata[72];
-        } h_u, m_u;
+        union ethtool_flow_union h_u;
+        struct ethtool_flow_ext h_ext;
+        union ethtool_flow_union m_u;
+        struct ethtool_flow_ext m_ext;
         __u64           ring_cookie;
         __u32           location;
 };
@@ -458,16 +507,10 @@ struct ethtool_rxnfc {
 
 struct compat_ethtool_rx_flow_spec {
         u32             flow_type;
-        union {
-                struct ethtool_tcpip4_spec              tcp_ip4_spec;
-                struct ethtool_tcpip4_spec              udp_ip4_spec;
-                struct ethtool_tcpip4_spec              sctp_ip4_spec;
-                struct ethtool_ah_espip4_spec           ah_ip4_spec;
-                struct ethtool_ah_espip4_spec           esp_ip4_spec;
-                struct ethtool_usrip4_spec              usr_ip4_spec;
-                struct ethhdr                           ether_spec;
-                u8                                      hdata[72];
-        } h_u, m_u;
+        union ethtool_flow_union h_u;
+        struct ethtool_flow_ext h_ext;
+        union ethtool_flow_union m_u;
+        struct ethtool_flow_ext m_ext;
         compat_u64      ring_cookie;
         u32             location;
 };
@@ -558,6 +601,26 @@ struct ethtool_flash {
         char    data[ETHTOOL_FLASH_MAX_FILENAME];
 };
 
+/**
+ * struct ethtool_dump - used for retrieving, setting device dump
+ * @cmd: Command number - %ETHTOOL_GET_DUMP_FLAG, %ETHTOOL_GET_DUMP_DATA, or
+ *      %ETHTOOL_SET_DUMP
+ * @version: FW version of the dump, filled in by driver
+ * @flag: driver dependent flag for dump setting, filled in by driver during
+ *        get and filled in by ethtool for set operation
+ * @len: length of dump data, used as the length of the user buffer on entry to
+ *       %ETHTOOL_GET_DUMP_DATA and this is returned as dump length by driver
+ *       for %ETHTOOL_GET_DUMP_FLAG command
+ * @data: data collected for get dump data operation
+ */
+struct ethtool_dump {
+        __u32   cmd;
+        __u32   version;
+        __u32   flag;
+        __u32   len;
+        __u8    data[0];
+};
+
 /* for returning and changing feature sets */
 
 /**
@@ -663,6 +726,22 @@ struct ethtool_rx_ntuple_list {
         unsigned int            count;
 };
 
+/**
+ * enum ethtool_phys_id_state - indicator state for physical identification
+ * @ETHTOOL_ID_INACTIVE: Physical ID indicator should be deactivated
+ * @ETHTOOL_ID_ACTIVE: Physical ID indicator should be activated
+ * @ETHTOOL_ID_ON: LED should be turned on (used iff %ETHTOOL_ID_ACTIVE
+ *      is not supported)
+ * @ETHTOOL_ID_OFF: LED should be turned off (used iff %ETHTOOL_ID_ACTIVE
+ *      is not supported)
+ */
+enum ethtool_phys_id_state {
+        ETHTOOL_ID_INACTIVE,
+        ETHTOOL_ID_ACTIVE,
+        ETHTOOL_ID_ON,
+        ETHTOOL_ID_OFF
+};
+
 struct net_device;
 
 /* Some generic methods drivers may use in their ethtool_ops */
@@ -683,63 +762,131 @@ void ethtool_ntuple_flush(struct net_device *dev);
 bool ethtool_invalid_flags(struct net_device *dev, u32 data, u32 supported);
 
 /**
- * &ethtool_ops - Alter and report network device settings
- * get_settings: Get device-specific settings
- * set_settings: Set device-specific settings
- * get_drvinfo: Report driver information
- * get_regs: Get device registers
- * get_wol: Report whether Wake-on-Lan is enabled
- * set_wol: Turn Wake-on-Lan on or off
- * get_msglevel: Report driver message level
- * set_msglevel: Set driver message level
- * nway_reset: Restart autonegotiation
- * get_link: Get link status
- * get_eeprom: Read data from the device EEPROM
- * set_eeprom: Write data to the device EEPROM
- * get_coalesce: Get interrupt coalescing parameters
- * set_coalesce: Set interrupt coalescing parameters
- * get_ringparam: Report ring sizes
- * set_ringparam: Set ring sizes
- * get_pauseparam: Report pause parameters
- * set_pauseparam: Set pause parameters
- * get_rx_csum: Report whether receive checksums are turned on or off
- * set_rx_csum: Turn receive checksum on or off
- * get_tx_csum: Report whether transmit checksums are turned on or off
- * set_tx_csum: Turn transmit checksums on or off
- * get_sg: Report whether scatter-gather is enabled
- * set_sg: Turn scatter-gather on or off
- * get_tso: Report whether TCP segmentation offload is enabled
- * set_tso: Turn TCP segmentation offload on or off
- * get_ufo: Report whether UDP fragmentation offload is enabled
- * set_ufo: Turn UDP fragmentation offload on or off
- * self_test: Run specified self-tests
- * get_strings: Return a set of strings that describe the requested objects
- * phys_id: Identify the device
- * get_stats: Return statistics about the device
- * get_flags: get 32-bit flags bitmap
- * set_flags: set 32-bit flags bitmap
- *
- * Description:
- *
- * get_settings:
- *      @get_settings is passed an &ethtool_cmd to fill in.  It returns
- *      an negative errno or zero.
- *
- * set_settings:
- *      @set_settings is passed an &ethtool_cmd and should attempt to set
- *      all the settings this device supports.  It may return an error value
- *      if something goes wrong (otherwise 0).
- *
- * get_eeprom:
+ * struct ethtool_ops - optional netdev operations
+ * @get_settings: Get various device settings including Ethernet link
+ *      settings. The @cmd parameter is expected to have been cleared
+ *      before get_settings is called. Returns a negative error code or
+ *      zero.
+ * @set_settings: Set various device settings including Ethernet link
+ *      settings.  Returns a negative error code or zero.
+ * @get_drvinfo: Report driver/device information.  Should only set the
+ *      @driver, @version, @fw_version and @bus_info fields.  If not
+ *      implemented, the @driver and @bus_info fields will be filled in
+ *      according to the netdev's parent device.
+ * @get_regs_len: Get buffer length required for @get_regs
+ * @get_regs: Get device registers
+ * @get_wol: Report whether Wake-on-Lan is enabled
+ * @set_wol: Turn Wake-on-Lan on or off.  Returns a negative error code
+ *      or zero.
+ * @get_msglevel: Report driver message level.  This should be the value
+ *      of the @msg_enable field used by netif logging functions.
+ * @set_msglevel: Set driver message level
+ * @nway_reset: Restart autonegotiation.  Returns a negative error code
+ *      or zero.
+ * @get_link: Report whether physical link is up.  Will only be called if
+ *      the netdev is up.  Should usually be set to ethtool_op_get_link(),
+ *      which uses netif_carrier_ok().
+ * @get_eeprom: Read data from the device EEPROM.
  *      Should fill in the magic field.  Don't need to check len for zero
  *      or wraparound.  Fill in the data argument with the eeprom values
  *      from offset to offset + len.  Update len to the amount read.
  *      Returns an error or zero.
- *
- * set_eeprom:
+ * @set_eeprom: Write data to the device EEPROM.
  *      Should validate the magic field.  Don't need to check len for zero
  *      or wraparound.  Update len to the amount written.  Returns an error
  *      or zero.
+ * @get_coalesce: Get interrupt coalescing parameters.  Returns a negative
+ *      error code or zero.
+ * @set_coalesce: Set interrupt coalescing parameters.  Returns a negative
+ *      error code or zero.
+ * @get_ringparam: Report ring sizes
+ * @set_ringparam: Set ring sizes.  Returns a negative error code or zero.
+ * @get_pauseparam: Report pause parameters
+ * @set_pauseparam: Set pause parameters.  Returns a negative error code
+ *      or zero.
+ * @get_rx_csum: Deprecated in favour of the netdev feature %NETIF_F_RXCSUM.
+ *      Report whether receive checksums are turned on or off.
+ * @set_rx_csum: Deprecated in favour of generic netdev features.  Turn
+ *      receive checksum on or off.  Returns a negative error code or zero.
+ * @get_tx_csum: Deprecated as redundant. Report whether transmit checksums
+ *      are turned on or off.
+ * @set_tx_csum: Deprecated in favour of generic netdev features.  Turn
+ *      transmit checksums on or off.  Returns a egative error code or zero.
+ * @get_sg: Deprecated as redundant.  Report whether scatter-gather is
+ *      enabled.  
+ * @set_sg: Deprecated in favour of generic netdev features.  Turn
+ *      scatter-gather on or off. Returns a negative error code or zero.
+ * @get_tso: Deprecated as redundant.  Report whether TCP segmentation
+ *      offload is enabled.
+ * @set_tso: Deprecated in favour of generic netdev features.  Turn TCP
+ *      segmentation offload on or off.  Returns a negative error code or zero.
+ * @self_test: Run specified self-tests
+ * @get_strings: Return a set of strings that describe the requested objects
+ * @set_phys_id: Identify the physical devices, e.g. by flashing an LED
+ *      attached to it.  The implementation may update the indicator
+ *      asynchronously or synchronously, but in either case it must return
+ *      quickly.  It is initially called with the argument %ETHTOOL_ID_ACTIVE,
+ *      and must either activate asynchronous updates and return zero, return
+ *      a negative error or return a positive frequency for synchronous
+ *      indication (e.g. 1 for one on/off cycle per second).  If it returns
+ *      a frequency then it will be called again at intervals with the
+ *      argument %ETHTOOL_ID_ON or %ETHTOOL_ID_OFF and should set the state of
+ *      the indicator accordingly.  Finally, it is called with the argument
+ *      %ETHTOOL_ID_INACTIVE and must deactivate the indicator.  Returns a
+ *      negative error code or zero.
+ * @get_ethtool_stats: Return extended statistics about the device.
+ *      This is only useful if the device maintains statistics not
+ *      included in &struct rtnl_link_stats64.
+ * @begin: Function to be called before any other operation.  Returns a
+ *      negative error code or zero.
+ * @complete: Function to be called after any other operation except
+ *      @begin.  Will be called even if the other operation failed.
+ * @get_ufo: Deprecated as redundant.  Report whether UDP fragmentation
+ *      offload is enabled.
+ * @set_ufo: Deprecated in favour of generic netdev features.  Turn UDP
+ *      fragmentation offload on or off.  Returns a negative error code or zero.
+ * @get_flags: Deprecated as redundant.  Report features included in
+ *      &enum ethtool_flags that are enabled.  
+ * @set_flags: Deprecated in favour of generic netdev features.  Turn
+ *      features included in &enum ethtool_flags on or off.  Returns a
+ *      negative error code or zero.
+ * @get_priv_flags: Report driver-specific feature flags.
+ * @set_priv_flags: Set driver-specific feature flags.  Returns a negative
+ *      error code or zero.
+ * @get_sset_count: Get number of strings that @get_strings will write.
+ * @get_rxnfc: Get RX flow classification rules.  Returns a negative
+ *      error code or zero.
+ * @set_rxnfc: Set RX flow classification rules.  Returns a negative
+ *      error code or zero.
+ * @flash_device: Write a firmware image to device's flash memory.
+ *      Returns a negative error code or zero.
+ * @reset: Reset (part of) the device, as specified by a bitmask of
+ *      flags from &enum ethtool_reset_flags.  Returns a negative
+ *      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.
+ *      Returns a negative error code or zero.
+ * @get_channels: Get number of channels.
+ * @set_channels: Set number of channels.  Returns a negative error code or
+ *      zero.
+ * @get_dump_flag: Get dump flag indicating current dump length, version,
+ *                 and flag of the device.
+ * @get_dump_data: Get dump data.
+ * @set_dump: Set dump specific flags to the device.
+ *
+ * All operations are optional (i.e. the function pointer may be set
+ * to %NULL) and callers must take this into account.  Callers must
+ * hold the RTNL, except that for @get_drvinfo the caller may or may
+ * not hold the RTNL.
+ *
+ * See the structures used by these operations for further documentation.
+ *
+ * See &struct net_device and &struct net_device_ops for documentation
+ * of the generic netdev features interface.
  */
 struct ethtool_ops {
         int     (*get_settings)(struct net_device *, struct ethtool_cmd *);
@@ -778,7 +925,7 @@ struct ethtool_ops {
         int     (*set_tso)(struct net_device *, u32);
         void    (*self_test)(struct net_device *, struct ethtool_test *, u64 *);
         void    (*get_strings)(struct net_device *, u32 stringset, u8 *);
-        int     (*phys_id)(struct net_device *, u32);
+        int     (*set_phys_id)(struct net_device *, enum ethtool_phys_id_state);
         void    (*get_ethtool_stats)(struct net_device *,
                                      struct ethtool_stats *, u64 *);
         int     (*begin)(struct net_device *);
@@ -802,6 +949,13 @@ struct ethtool_ops {
                                   struct ethtool_rxfh_indir *);
         int     (*set_rxfh_indir)(struct net_device *,
                                   const struct ethtool_rxfh_indir *);
+        void    (*get_channels)(struct net_device *, struct ethtool_channels *);
+        int     (*set_channels)(struct net_device *, struct ethtool_channels *);
+        int     (*get_dump_flag)(struct net_device *, struct ethtool_dump *);
+        int     (*get_dump_data)(struct net_device *,
+                                 struct ethtool_dump *, void *);
+        int     (*set_dump)(struct net_device *, struct ethtool_dump *);
+
 };
 #endif /* __KERNEL__ */
 
@@ -870,6 +1024,11 @@ struct ethtool_ops {
 
 #define ETHTOOL_GFEATURES       0x0000003a /* Get device offload settings */
 #define ETHTOOL_SFEATURES       0x0000003b /* Change device offload settings */
+#define ETHTOOL_GCHANNELS       0x0000003c /* Get no of channels */
+#define ETHTOOL_SCHANNELS       0x0000003d /* Set no of channels */
+#define ETHTOOL_SET_DUMP        0x0000003e /* Set dump settings */
+#define ETHTOOL_GET_DUMP_FLAG   0x0000003f /* Get dump settings */
+#define ETHTOOL_GET_DUMP_DATA   0x00000040 /* Get dump data */
 
 /* compatibility with older code */
 #define SPARC_ETH_GSET          ETHTOOL_GSET
@@ -897,6 +1056,8 @@ struct ethtool_ops {
 #define SUPPORTED_10000baseKX4_Full     (1 << 18)
 #define SUPPORTED_10000baseKR_Full      (1 << 19)
 #define SUPPORTED_10000baseR_FEC        (1 << 20)
+#define SUPPORTED_20000baseMLD2_Full    (1 << 21)
+#define SUPPORTED_20000baseKR2_Full     (1 << 22)
 
 /* Indicates what features are advertised by the interface. */
 #define ADVERTISED_10baseT_Half         (1 << 0)
@@ -920,6 +1081,8 @@ struct ethtool_ops {
 #define ADVERTISED_10000baseKX4_Full    (1 << 18)
 #define ADVERTISED_10000baseKR_Full     (1 << 19)
 #define ADVERTISED_10000baseR_FEC       (1 << 20)
+#define ADVERTISED_20000baseMLD2_Full   (1 << 21)
+#define ADVERTISED_20000baseKR2_Full    (1 << 22)
 
 /* The following are all involved in forcing a particular link
  * mode for the device for setting things.  When getting the
@@ -992,6 +1155,8 @@ struct ethtool_ops {
 #define IPV4_FLOW       0x10    /* hash only */
 #define IPV6_FLOW       0x11    /* hash only */
 #define ETHER_FLOW      0x12    /* spec only (ether_spec) */
+/* Flag to enable additional fields in struct ethtool_rx_flow_spec */
+#define FLOW_EXT        0x80000000
 
 /* L3-L4 network traffic flow hash options */
 #define RXH_L2DA        (1 << 1)
diff --git a/include/linux/fb.h b/include/linux/fb.h
index df728c1c29ed..6a8274877171 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -832,6 +832,7 @@ struct fb_tile_ops {
 #define FBINFO_CAN_FORCE_OUTPUT     0x200000
 
 struct fb_info {
+        atomic_t count;
         int node;
         int flags;
         struct mutex lock;              /* Lock for open/release/ioctl funcs */
diff --git a/include/linux/filter.h b/include/linux/filter.h
index 45266b75409a..9ee3f9fb0b4a 100644
--- a/include/linux/filter.h
+++ b/include/linux/filter.h
@@ -131,10 +131,16 @@ struct sock_fprog {	/* Required for SO_ATTACH_FILTER. */
 #define SKF_LL_OFF    (-0x200000)
 
 #ifdef __KERNEL__
+
+struct sk_buff;
+struct sock;
+
 struct sk_filter
 {
         atomic_t                refcnt;
         unsigned int            len;    /* Number of filter blocks */
+        unsigned int            (*bpf_func)(const struct sk_buff *skb,
+                                            const struct sock_filter *filter);
         struct rcu_head         rcu;
         struct sock_filter      insns[0];
 };
@@ -144,15 +150,86 @@ static inline unsigned int sk_filter_len(const struct sk_filter *fp)
         return fp->len * sizeof(struct sock_filter) + sizeof(*fp);
 }
 
-struct sk_buff;
-struct sock;
-
 extern int sk_filter(struct sock *sk, struct sk_buff *skb);
 extern unsigned int sk_run_filter(const struct sk_buff *skb,
                                   const struct sock_filter *filter);
 extern int sk_attach_filter(struct sock_fprog *fprog, struct sock *sk);
 extern int sk_detach_filter(struct sock *sk);
 extern int sk_chk_filter(struct sock_filter *filter, int flen);
+
+#ifdef CONFIG_BPF_JIT
+extern void bpf_jit_compile(struct sk_filter *fp);
+extern void bpf_jit_free(struct sk_filter *fp);
+#define SK_RUN_FILTER(FILTER, SKB) (*FILTER->bpf_func)(SKB, FILTER->insns)
+#else
+static inline void bpf_jit_compile(struct sk_filter *fp)
+{
+}
+static inline void bpf_jit_free(struct sk_filter *fp)
+{
+}
+#define SK_RUN_FILTER(FILTER, SKB) sk_run_filter(SKB, FILTER->insns)
+#endif
+
+enum {
+        BPF_S_RET_K = 1,
+        BPF_S_RET_A,
+        BPF_S_ALU_ADD_K,
+        BPF_S_ALU_ADD_X,
+        BPF_S_ALU_SUB_K,
+        BPF_S_ALU_SUB_X,
+        BPF_S_ALU_MUL_K,
+        BPF_S_ALU_MUL_X,
+        BPF_S_ALU_DIV_X,
+        BPF_S_ALU_AND_K,
+        BPF_S_ALU_AND_X,
+        BPF_S_ALU_OR_K,
+        BPF_S_ALU_OR_X,
+        BPF_S_ALU_LSH_K,
+        BPF_S_ALU_LSH_X,
+        BPF_S_ALU_RSH_K,
+        BPF_S_ALU_RSH_X,
+        BPF_S_ALU_NEG,
+        BPF_S_LD_W_ABS,
+        BPF_S_LD_H_ABS,
+        BPF_S_LD_B_ABS,
+        BPF_S_LD_W_LEN,
+        BPF_S_LD_W_IND,
+        BPF_S_LD_H_IND,
+        BPF_S_LD_B_IND,
+        BPF_S_LD_IMM,
+        BPF_S_LDX_W_LEN,
+        BPF_S_LDX_B_MSH,
+        BPF_S_LDX_IMM,
+        BPF_S_MISC_TAX,
+        BPF_S_MISC_TXA,
+        BPF_S_ALU_DIV_K,
+        BPF_S_LD_MEM,
+        BPF_S_LDX_MEM,
+        BPF_S_ST,
+        BPF_S_STX,
+        BPF_S_JMP_JA,
+        BPF_S_JMP_JEQ_K,
+        BPF_S_JMP_JEQ_X,
+        BPF_S_JMP_JGE_K,
+        BPF_S_JMP_JGE_X,
+        BPF_S_JMP_JGT_K,
+        BPF_S_JMP_JGT_X,
+        BPF_S_JMP_JSET_K,
+        BPF_S_JMP_JSET_X,
+        /* Ancillary data */
+        BPF_S_ANC_PROTOCOL,
+        BPF_S_ANC_PKTTYPE,
+        BPF_S_ANC_IFINDEX,
+        BPF_S_ANC_NLATTR,
+        BPF_S_ANC_NLATTR_NEST,
+        BPF_S_ANC_MARK,
+        BPF_S_ANC_QUEUE,
+        BPF_S_ANC_HATYPE,
+        BPF_S_ANC_RXHASH,
+        BPF_S_ANC_CPU,
+};
+
 #endif /* __KERNEL__ */
 
 #endif /* __LINUX_FILTER_H__ */
diff --git a/include/linux/firewire.h b/include/linux/firewire.h
index c64f3680d4f1..5e6f42789afe 100644
--- a/include/linux/firewire.h
+++ b/include/linux/firewire.h
@@ -125,7 +125,6 @@ struct fw_card {
         struct delayed_work bm_work; /* bus manager job */
         int bm_retries;
         int bm_generation;
-        __be32 bm_transaction_data[2];
         int bm_node_id;
         bool bm_abdicate;
 
@@ -441,12 +440,15 @@ int fw_iso_context_queue(struct fw_iso_context *ctx,
                          struct fw_iso_packet *packet,
                          struct fw_iso_buffer *buffer,
                          unsigned long payload);
+void fw_iso_context_queue_flush(struct fw_iso_context *ctx);
 int fw_iso_context_start(struct fw_iso_context *ctx,
                          int cycle, int sync, int tags);
 int fw_iso_context_stop(struct fw_iso_context *ctx);
 void fw_iso_context_destroy(struct fw_iso_context *ctx);
 void fw_iso_resource_manage(struct fw_card *card, int generation,
                             u64 channels_mask, int *channel, int *bandwidth,
-                            bool allocate, __be32 buffer[2]);
+                            bool allocate);
+
+extern struct workqueue_struct *fw_workqueue;
 
 #endif /* _LINUX_FIREWIRE_H */
diff --git a/include/linux/flex_array.h b/include/linux/flex_array.h
index 70e4efabe0fb..ebeb2f3ad068 100644
--- a/include/linux/flex_array.h
+++ b/include/linux/flex_array.h
@@ -61,7 +61,7 @@ struct flex_array {
 struct flex_array *flex_array_alloc(int element_size, unsigned int total,
                 gfp_t flags);
 int flex_array_prealloc(struct flex_array *fa, unsigned int start,
-                unsigned int end, gfp_t flags);
+                unsigned int nr_elements, gfp_t flags);
 void flex_array_free(struct flex_array *fa);
 void flex_array_free_parts(struct flex_array *fa);
 int flex_array_put(struct flex_array *fa, unsigned int element_nr, void *src,
diff --git a/include/linux/fs.h b/include/linux/fs.h
index dbd860af0804..3f9d3251790d 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -23,7 +23,8 @@
 
 /* Fixed constants first: */
 #undef NR_OPEN
-#define INR_OPEN 1024           /* Initial setting for nfile rlimits */
+#define INR_OPEN_CUR 1024       /* Initial setting for nfile rlimits */
+#define INR_OPEN_MAX 4096       /* Hard limit for nfile rlimits */
 
 #define BLOCK_SIZE_BITS 10
 #define BLOCK_SIZE (1<<BLOCK_SIZE_BITS)
@@ -358,7 +359,6 @@ struct inodes_stat_t {
 #define FS_EXTENT_FL                    0x00080000 /* Extents */
 #define FS_DIRECTIO_FL                  0x00100000 /* Use direct i/o */
 #define FS_NOCOW_FL                     0x00800000 /* Do not cow file */
-#define FS_COW_FL                       0x02000000 /* Cow file */
 #define FS_RESERVED_FL                  0x80000000 /* reserved for ext2 lib */
 
 #define FS_FL_USER_VISIBLE              0x0003DFFF /* User visible flags */
@@ -635,8 +635,7 @@ struct address_space {
         unsigned int            i_mmap_writable;/* count VM_SHARED mappings */
         struct prio_tree_root   i_mmap;         /* tree of private and shared mappings */
         struct list_head        i_mmap_nonlinear;/*list VM_NONLINEAR mappings */
-        spinlock_t              i_mmap_lock;    /* protect tree, count, list */
-        unsigned int            truncate_count; /* Cover race condition with truncate */
+        struct mutex            i_mmap_mutex;   /* protect tree, count, list */
         unsigned long           nrpages;        /* number of total pages */
         pgoff_t                 writeback_index;/* writeback starts here */
         const struct address_space_operations *a_ops;   /* methods */
@@ -645,7 +644,6 @@ struct address_space {
         spinlock_t              private_lock;   /* for use by the address_space */
         struct list_head        private_list;   /* ditto */
         struct address_space    *assoc_mapping; /* ditto */
-        struct mutex            unmap_mutex;    /* to protect unmapping */
 } __attribute__((aligned(sizeof(long))));
         /*
          * On most architectures that alignment is already the case; but
diff --git a/include/linux/fscache-cache.h b/include/linux/fscache-cache.h
index 76427e688d15..af095b54502e 100644
--- a/include/linux/fscache-cache.h
+++ b/include/linux/fscache-cache.h
@@ -100,17 +100,6 @@ struct fscache_operation {
 
         /* operation releaser */
         fscache_operation_release_t release;
-
-#ifdef CONFIG_WORKQUEUE_DEBUGFS
-        struct work_struct put_work;    /* work to delay operation put */
-        const char *name;               /* operation name */
-        const char *state;              /* operation state */
-#define fscache_set_op_name(OP, N)      do { (OP)->name  = (N); } while(0)
-#define fscache_set_op_state(OP, S)     do { (OP)->state = (S); } while(0)
-#else
-#define fscache_set_op_name(OP, N)      do { } while(0)
-#define fscache_set_op_state(OP, S)     do { } while(0)
-#endif
 };
 
 extern atomic_t fscache_op_debug_id;
@@ -137,7 +126,6 @@ static inline void fscache_operation_init(struct fscache_operation *op,
         op->processor = processor;
         op->release = release;
         INIT_LIST_HEAD(&op->pend_link);
-        fscache_set_op_state(op, "Init");
 }
 
 /*
diff --git a/include/linux/fsl_devices.h b/include/linux/fsl_devices.h
index 4eb56ed75fbc..fffdf00f87b9 100644
--- a/include/linux/fsl_devices.h
+++ b/include/linux/fsl_devices.h
@@ -72,6 +72,7 @@ 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 */
@@ -79,6 +80,21 @@ struct fsl_usb2_platform_data {
         unsigned        have_sysif_regs:1;
         unsigned        invert_drvvbus:1;
         unsigned        invert_pwr_fault:1;
+
+        unsigned        suspended:1;
+        unsigned        already_suspended:1;
+
+        /* register save area for suspend/resume */
+        u32             pm_command;
+        u32             pm_status;
+        u32             pm_intr_enable;
+        u32             pm_frame_index;
+        u32             pm_segment;
+        u32             pm_frame_list;
+        u32             pm_async_next;
+        u32             pm_configured_flag;
+        u32             pm_portsc;
+        u32             pm_usbgenctrl;
 };
 
 /* Flags in fsl_usb2_mph_platform_data */
diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h
index ca29e03c1fac..9d88e1cb5dbb 100644
--- a/include/linux/ftrace.h
+++ b/include/linux/ftrace.h
@@ -29,9 +29,22 @@ 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,
+        FTRACE_OPS_FL_DYNAMIC           = 1 << 2,
+};
+
 struct ftrace_ops {
-        ftrace_func_t     func;
-        struct ftrace_ops *next;
+        ftrace_func_t                   func;
+        struct ftrace_ops               *next;
+        unsigned long                   flags;
+#ifdef CONFIG_DYNAMIC_FTRACE
+        struct ftrace_hash              *notrace_hash;
+        struct ftrace_hash              *filter_hash;
+#endif
 };
 
 extern int function_trace_stop;
@@ -146,14 +159,13 @@ extern void unregister_ftrace_function_probe_all(char *glob);
 extern int ftrace_text_reserved(void *start, void *end);
 
 enum {
-        FTRACE_FL_FREE          = (1 << 0),
-        FTRACE_FL_FAILED        = (1 << 1),
-        FTRACE_FL_FILTER        = (1 << 2),
-        FTRACE_FL_ENABLED       = (1 << 3),
-        FTRACE_FL_NOTRACE       = (1 << 4),
-        FTRACE_FL_CONVERTED     = (1 << 5),
+        FTRACE_FL_ENABLED       = (1 << 30),
+        FTRACE_FL_FREE          = (1 << 31),
 };
 
+#define FTRACE_FL_MASK          (0x3UL << 30)
+#define FTRACE_REF_MAX          ((1 << 30) - 1)
+
 struct dyn_ftrace {
         union {
                 unsigned long           ip; /* address of mcount call-site */
@@ -167,7 +179,12 @@ struct dyn_ftrace {
 };
 
 int ftrace_force_update(void);
-void ftrace_set_filter(unsigned char *buf, int len, int reset);
+void ftrace_set_filter(struct ftrace_ops *ops, unsigned char *buf,
+                       int len, int reset);
+void ftrace_set_notrace(struct ftrace_ops *ops, unsigned char *buf,
+                        int len, int reset);
+void ftrace_set_global_filter(unsigned char *buf, int len, int reset);
+void ftrace_set_global_notrace(unsigned char *buf, int len, int reset);
 
 int register_ftrace_command(struct ftrace_func_command *cmd);
 int unregister_ftrace_command(struct ftrace_func_command *cmd);
diff --git a/include/linux/ftrace_event.h b/include/linux/ftrace_event.h
index 22b32af1b5ec..b5a550a39a70 100644
--- a/include/linux/ftrace_event.h
+++ b/include/linux/ftrace_event.h
@@ -37,6 +37,7 @@ struct trace_entry {
         unsigned char           flags;
         unsigned char           preempt_count;
         int                     pid;
+        int                     padding;
 };
 
 #define FTRACE_MAX_EVENT                                                \
diff --git a/include/linux/genalloc.h b/include/linux/genalloc.h
index 9869ef3674ac..5bbebda78b02 100644
--- a/include/linux/genalloc.h
+++ b/include/linux/genalloc.h
@@ -9,6 +9,8 @@
  */
 
 
+#ifndef __GENALLOC_H__
+#define __GENALLOC_H__
 /*
  *  General purpose special memory pool descriptor.
  */
@@ -24,13 +26,34 @@ struct gen_pool {
 struct gen_pool_chunk {
         spinlock_t lock;
         struct list_head next_chunk;    /* next chunk in pool */
+        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 */
         unsigned long bits[0];          /* bitmap for allocating memory chunk */
 };
 
 extern struct gen_pool *gen_pool_create(int, int);
-extern int gen_pool_add(struct gen_pool *, unsigned long, size_t, int);
+extern phys_addr_t gen_pool_virt_to_phys(struct gen_pool *pool, unsigned long);
+extern int gen_pool_add_virt(struct gen_pool *, unsigned long, phys_addr_t,
+                             size_t, int);
+/**
+ * gen_pool_add - add a new chunk of special memory to the pool
+ * @pool: pool to add new memory chunk to
+ * @addr: starting address of memory chunk to add to pool
+ * @size: size in bytes of the memory chunk to add to pool
+ * @nid: node id of the node the chunk structure and bitmap should be
+ *       allocated on, or -1
+ *
+ * Add a new chunk of special memory to the specified pool.
+ *
+ * Returns 0 on success or a -ve errno on failure.
+ */
+static inline int gen_pool_add(struct gen_pool *pool, unsigned long addr,
+                               size_t size, int nid)
+{
+        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 void gen_pool_free(struct gen_pool *, unsigned long, size_t);
+#endif /* __GENALLOC_H__ */
diff --git a/include/linux/genhd.h b/include/linux/genhd.h
index d764a426e9fd..b78956b3c2e7 100644
--- a/include/linux/genhd.h
+++ b/include/linux/genhd.h
@@ -100,7 +100,6 @@ struct hd_struct {
         sector_t start_sect;
         sector_t nr_sects;
         sector_t alignment_offset;
-        unsigned int discard_alignment;
         struct device __dev;
         struct kobject *holder_dir;
         int policy, partno;
@@ -127,6 +126,7 @@ struct hd_struct {
 #define GENHD_FL_SUPPRESS_PARTITION_INFO        32
 #define GENHD_FL_EXT_DEVT                       64 /* allow extended devt */
 #define GENHD_FL_NATIVE_CAPACITY                128
+#define GENHD_FL_BLOCK_EVENTS_ON_EXCL_WRITE     256
 
 enum {
         DISK_EVENT_MEDIA_CHANGE                 = 1 << 0, /* media changed */
diff --git a/include/linux/gfp.h b/include/linux/gfp.h
index bfb8f934521e..cb4089254f01 100644
--- a/include/linux/gfp.h
+++ b/include/linux/gfp.h
@@ -249,14 +249,7 @@ static inline enum zone_type gfp_zone(gfp_t flags)
 
         z = (GFP_ZONE_TABLE >> (bit * ZONES_SHIFT)) &
                                          ((1 << ZONES_SHIFT) - 1);
-
-        if (__builtin_constant_p(bit))
-                BUILD_BUG_ON((GFP_ZONE_BAD >> bit) & 1);
-        else {
-#ifdef CONFIG_DEBUG_VM
-                BUG_ON((GFP_ZONE_BAD >> bit) & 1);
-#endif
-        }
+        VM_BUG_ON((GFP_ZONE_BAD >> bit) & 1);
         return z;
 }
 
@@ -353,6 +346,8 @@ extern unsigned long get_zeroed_page(gfp_t gfp_mask);
 
 void *alloc_pages_exact(size_t size, gfp_t gfp_mask);
 void free_pages_exact(void *virt, size_t size);
+/* This is different from alloc_pages_exact_node !!! */
+void *alloc_pages_exact_nid(int nid, size_t size, gfp_t gfp_mask);
 
 #define __get_free_page(gfp_mask) \
                 __get_free_pages((gfp_mask), 0)
diff --git a/include/linux/gpio_keys.h b/include/linux/gpio_keys.h
index dd1a56fbe924..b5ca4b2c08ec 100644
--- a/include/linux/gpio_keys.h
+++ b/include/linux/gpio_keys.h
@@ -3,14 +3,15 @@
 
 struct gpio_keys_button {
         /* Configuration parameters */
-        int code;               /* input event code (KEY_*, SW_*) */
+        unsigned int code;      /* input event code (KEY_*, SW_*) */
         int gpio;
         int active_low;
-        char *desc;
-        int type;               /* input event type (EV_KEY, EV_SW) */
+        const char *desc;
+        unsigned int type;      /* input event type (EV_KEY, EV_SW, EV_ABS) */
         int wakeup;             /* configure the button as a wake-up source */
         int debounce_interval;  /* debounce ticks interval in msecs */
         bool can_disable;
+        int value;              /* axis value for EV_ABS */
 };
 
 struct gpio_keys_platform_data {
@@ -21,6 +22,7 @@ struct gpio_keys_platform_data {
         unsigned int rep:1;             /* enable input subsystem auto repeat */
         int (*enable)(struct device *dev);
         void (*disable)(struct device *dev);
+        const char *name;               /* input device name */
 };
 
 #endif
diff --git a/include/linux/hrtimer.h b/include/linux/hrtimer.h
index 62f500c724f9..51932e5acf7c 100644
--- a/include/linux/hrtimer.h
+++ b/include/linux/hrtimer.h
@@ -143,19 +143,18 @@ struct hrtimer_sleeper {
  */
 struct hrtimer_clock_base {
         struct hrtimer_cpu_base *cpu_base;
-        clockid_t               index;
+        int                     index;
+        clockid_t               clockid;
         struct timerqueue_head  active;
         ktime_t                 resolution;
         ktime_t                 (*get_time)(void);
         ktime_t                 softirq_time;
-#ifdef CONFIG_HIGH_RES_TIMERS
         ktime_t                 offset;
-#endif
 };
 
 enum  hrtimer_base_type {
-        HRTIMER_BASE_REALTIME,
         HRTIMER_BASE_MONOTONIC,
+        HRTIMER_BASE_REALTIME,
         HRTIMER_BASE_BOOTTIME,
         HRTIMER_MAX_CLOCK_BASES,
 };
@@ -164,7 +163,7 @@ enum  hrtimer_base_type {
  * struct hrtimer_cpu_base - the per cpu clock bases
  * @lock:               lock protecting the base and associated clock bases
  *                      and timers
- * @clock_base:         array of clock bases for this cpu
+ * @active_bases:       Bitfield to mark bases with active timers
  * @expires_next:       absolute time of the next event which was scheduled
  *                      via clock_set_next_event()
  * @hres_active:        State of high resolution mode
@@ -173,10 +172,11 @@ enum  hrtimer_base_type {
  * @nr_retries:         Total number of hrtimer interrupt retries
  * @nr_hangs:           Total number of hrtimer interrupt hangs
  * @max_hang_time:      Maximum time spent in hrtimer_interrupt
+ * @clock_base:         array of clock bases for this cpu
  */
 struct hrtimer_cpu_base {
         raw_spinlock_t                  lock;
-        struct hrtimer_clock_base       clock_base[HRTIMER_MAX_CLOCK_BASES];
+        unsigned long                   active_bases;
 #ifdef CONFIG_HIGH_RES_TIMERS
         ktime_t                         expires_next;
         int                             hres_active;
@@ -186,6 +186,7 @@ struct hrtimer_cpu_base {
         unsigned long                   nr_hangs;
         ktime_t                         max_hang_time;
 #endif
+        struct hrtimer_clock_base       clock_base[HRTIMER_MAX_CLOCK_BASES];
 };
 
 static inline void hrtimer_set_expires(struct hrtimer *timer, ktime_t time)
@@ -256,8 +257,6 @@ static inline ktime_t hrtimer_expires_remaining(const struct hrtimer *timer)
 #ifdef CONFIG_HIGH_RES_TIMERS
 struct clock_event_device;
 
-extern void clock_was_set(void);
-extern void hres_timers_resume(void);
 extern void hrtimer_interrupt(struct clock_event_device *dev);
 
 /*
@@ -291,16 +290,8 @@ extern void hrtimer_peek_ahead_timers(void);
 # define MONOTONIC_RES_NSEC     LOW_RES_NSEC
 # define KTIME_MONOTONIC_RES    KTIME_LOW_RES
 
-/*
- * clock_was_set() is a NOP for non- high-resolution systems. The
- * time-sorted order guarantees that a timer does not expire early and
- * is expired in the next softirq when the clock was advanced.
- */
-static inline void clock_was_set(void) { }
 static inline void hrtimer_peek_ahead_timers(void) { }
 
-static inline void hres_timers_resume(void) { }
-
 /*
  * In non high resolution mode the time reference is taken from
  * the base softirq time variable.
@@ -316,10 +307,18 @@ static inline int hrtimer_is_hres_active(struct hrtimer *timer)
 }
 #endif
 
+extern void clock_was_set(void);
+#ifdef CONFIG_TIMERFD
+extern void timerfd_clock_was_set(void);
+#else
+static inline void timerfd_clock_was_set(void) { }
+#endif
+extern void hrtimers_resume(void);
+
 extern ktime_t ktime_get(void);
 extern ktime_t ktime_get_real(void);
 extern ktime_t ktime_get_boottime(void);
-
+extern ktime_t ktime_get_monotonic_offset(void);
 
 DECLARE_PER_CPU(struct tick_device, tick_cpu_device);
 
diff --git a/include/linux/huge_mm.h b/include/linux/huge_mm.h
index 8847c8c29791..48c32ebf65a7 100644
--- a/include/linux/huge_mm.h
+++ b/include/linux/huge_mm.h
@@ -92,12 +92,8 @@ extern void __split_huge_page_pmd(struct mm_struct *mm, pmd_t *pmd);
 #define wait_split_huge_page(__anon_vma, __pmd)                         \
         do {                                                            \
                 pmd_t *____pmd = (__pmd);                               \
-                spin_unlock_wait(&(__anon_vma)->root->lock);            \
-                /*                                                      \
-                 * spin_unlock_wait() is just a loop in C and so the    \
-                 * CPU can reorder anything around it.                  \
-                 */                                                     \
-                smp_mb();                                               \
+                anon_vma_lock(__anon_vma);                              \
+                anon_vma_unlock(__anon_vma);                            \
                 BUG_ON(pmd_trans_splitting(*____pmd) ||                 \
                        pmd_trans_huge(*____pmd));                       \
         } while (0)
diff --git a/include/linux/i2c.h b/include/linux/i2c.h
index f1e3ff5880a9..a6c652ef516d 100644
--- a/include/linux/i2c.h
+++ b/include/linux/i2c.h
@@ -409,7 +409,7 @@ void i2c_unlock_adapter(struct i2c_adapter *);
 /* i2c adapter classes (bitmask) */
 #define I2C_CLASS_HWMON         (1<<0)  /* lm_sensors, ... */
 #define I2C_CLASS_DDC           (1<<3)  /* DDC bus on graphics adapters */
-#define I2C_CLASS_SPD           (1<<7)  /* SPD EEPROMs and similar */
+#define I2C_CLASS_SPD           (1<<7)  /* Memory modules */
 
 /* Internal numbers to terminate lists */
 #define I2C_CLIENT_END          0xfffeU
diff --git a/include/linux/i2c/i2c-sh_mobile.h b/include/linux/i2c/i2c-sh_mobile.h
new file mode 100644
index 000000000000..beda7081aead
--- /dev/null
+++ b/include/linux/i2c/i2c-sh_mobile.h
@@ -0,0 +1,10 @@
+#ifndef __I2C_SH_MOBILE_H__
+#define __I2C_SH_MOBILE_H__
+
+#include <linux/platform_device.h>
+
+struct i2c_sh_mobile_platform_data {
+        unsigned long bus_speed;
+};
+
+#endif /* __I2C_SH_MOBILE_H__ */
diff --git a/include/linux/i2c/mpr121_touchkey.h b/include/linux/i2c/mpr121_touchkey.h
new file mode 100644
index 000000000000..f0bcc38bbb97
--- /dev/null
+++ b/include/linux/i2c/mpr121_touchkey.h
@@ -0,0 +1,20 @@
+/* Header file for Freescale MPR121 Capacitive Touch Sensor */
+
+#ifndef _MPR121_TOUCHKEY_H
+#define _MPR121_TOUCHKEY_H
+
+/**
+ * struct mpr121_platform_data - platform data for mpr121 sensor
+ * @keymap: pointer to array of KEY_* values representing keymap
+ * @keymap_size: size of the keymap
+ * @wakeup: configure the button as a wake-up source
+ * @vdd_uv: VDD voltage in uV
+ */
+struct mpr121_platform_data {
+        const unsigned short *keymap;
+        unsigned int keymap_size;
+        bool wakeup;
+        int vdd_uv;
+};
+
+#endif /* _MPR121_TOUCHKEY_H */
diff --git a/include/linux/i2c/tsc2007.h b/include/linux/i2c/tsc2007.h
index c6361fbb7bf9..591427a63b06 100644
--- a/include/linux/i2c/tsc2007.h
+++ b/include/linux/i2c/tsc2007.h
@@ -6,6 +6,13 @@
 struct tsc2007_platform_data {
         u16     model;                          /* 2007. */
         u16     x_plate_ohms;
+        u16     max_rt; /* max. resistance above which samples are ignored */
+        unsigned long poll_delay; /* delay (in ms) after pen-down event
+                                     before polling starts */
+        unsigned long poll_period; /* time (in ms) between samples */
+        int     fuzzx; /* fuzz factor for X, Y and pressure axes */
+        int     fuzzy;
+        int     fuzzz;
 
         int     (*get_pendown_state)(void);
         void    (*clear_penirq)(void);          /* If needed, clear 2nd level
diff --git a/include/linux/ide.h b/include/linux/ide.h
index 072fe8c93e6f..42557851b12e 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -18,13 +18,13 @@
 #include <linux/pci.h>
 #include <linux/completion.h>
 #include <linux/pm.h>
+#include <linux/mutex.h>
 #ifdef CONFIG_BLK_DEV_IDEACPI
 #include <acpi/acpi.h>
 #endif
 #include <asm/byteorder.h>
 #include <asm/system.h>
 #include <asm/io.h>
-#include <asm/mutex.h>
 
 /* for request_sense */
 #include <linux/cdrom.h>
diff --git a/include/linux/ieee80211.h b/include/linux/ieee80211.h
index 2d1c6117d92c..b2eee5879883 100644
--- a/include/linux/ieee80211.h
+++ b/include/linux/ieee80211.h
@@ -884,6 +884,15 @@ struct ieee80211_ht_cap {
 #define IEEE80211_HT_CAP_40MHZ_INTOLERANT       0x4000
 #define IEEE80211_HT_CAP_LSIG_TXOP_PROT         0x8000
 
+/* 802.11n HT extended capabilities masks (for extended_ht_cap_info) */
+#define IEEE80211_HT_EXT_CAP_PCO                0x0001
+#define IEEE80211_HT_EXT_CAP_PCO_TIME           0x0006
+#define         IEEE80211_HT_EXT_CAP_PCO_TIME_SHIFT     1
+#define IEEE80211_HT_EXT_CAP_MCS_FB             0x0300
+#define         IEEE80211_HT_EXT_CAP_MCS_FB_SHIFT       8
+#define IEEE80211_HT_EXT_CAP_HTC_SUP            0x0400
+#define IEEE80211_HT_EXT_CAP_RD_RESPONDER       0x0800
+
 /* 802.11n HT capability AMPDU settings (for ampdu_params_info) */
 #define IEEE80211_HT_AMPDU_PARM_FACTOR          0x03
 #define IEEE80211_HT_AMPDU_PARM_DENSITY         0x1C
@@ -993,6 +1002,11 @@ struct ieee80211_ht_info {
 
 #define WLAN_CAPABILITY_ESS             (1<<0)
 #define WLAN_CAPABILITY_IBSS            (1<<1)
+
+/* A mesh STA sets the ESS and IBSS capability bits to zero */
+#define WLAN_CAPABILITY_IS_MBSS(cap)    \
+        (!((cap) & (WLAN_CAPABILITY_ESS | WLAN_CAPABILITY_IBSS)))
+
 #define WLAN_CAPABILITY_CF_POLLABLE     (1<<2)
 #define WLAN_CAPABILITY_CF_POLL_REQUEST (1<<3)
 #define WLAN_CAPABILITY_PRIVACY         (1<<4)
@@ -1252,9 +1266,8 @@ enum ieee80211_category {
         WLAN_CATEGORY_MULTIHOP_ACTION = 14,
         WLAN_CATEGORY_SELF_PROTECTED = 15,
         WLAN_CATEGORY_WMM = 17,
-        /* TODO: remove MESH_PLINK and MESH_PATH_SEL after */
-        /*       mesh is updated to current 802.11s draft  */
-        WLAN_CATEGORY_MESH_PLINK = 30,
+        /* TODO: remove MESH_PATH_SEL after mesh is updated
+         * to current 802.11s draft  */
         WLAN_CATEGORY_MESH_PATH_SEL = 32,
         WLAN_CATEGORY_VENDOR_SPECIFIC_PROTECTED = 126,
         WLAN_CATEGORY_VENDOR_SPECIFIC = 127,
@@ -1507,6 +1520,7 @@ static inline bool ieee80211_is_robust_mgmt_frame(struct ieee80211_hdr *hdr)
                 category = ((u8 *) hdr) + 24;
                 return *category != WLAN_CATEGORY_PUBLIC &&
                         *category != WLAN_CATEGORY_HT &&
+                        *category != WLAN_CATEGORY_SELF_PROTECTED &&
                         *category != WLAN_CATEGORY_VENDOR_SPECIFIC;
         }
 
diff --git a/include/linux/if_ether.h b/include/linux/if_ether.h
index be69043d2896..0f1325d98295 100644
--- a/include/linux/if_ether.h
+++ b/include/linux/if_ether.h
@@ -136,6 +136,7 @@ int eth_header_parse(const struct sk_buff *skb, unsigned char *haddr);
 extern struct ctl_table ether_table[];
 #endif
 
+int mac_pton(const char *s, u8 *mac);
 extern ssize_t sysfs_format_mac(char *buf, const unsigned char *addr, int len);
 
 #endif
diff --git a/include/linux/if_vlan.h b/include/linux/if_vlan.h
index 635e1faec412..dc01681fbb42 100644
--- a/include/linux/if_vlan.h
+++ b/include/linux/if_vlan.h
@@ -86,7 +86,6 @@ struct vlan_group {
                                             * the vlan is attached to.
                                             */
         unsigned int            nr_vlans;
-        int                     killall;
         struct hlist_node       hlist;  /* linked list */
         struct net_device **vlan_devices_arrays[VLAN_GROUP_ARRAY_SPLIT_PARTS];
         struct rcu_head         rcu;
@@ -111,6 +110,11 @@ static inline void vlan_group_set_device(struct vlan_group *vg,
         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;
+}
+
 #define vlan_tx_tag_present(__skb)      ((__skb)->vlan_tci & VLAN_TAG_PRESENT)
 #define vlan_tx_tag_get(__skb)          ((__skb)->vlan_tci & ~VLAN_TAG_PRESENT)
 
@@ -132,7 +136,8 @@ 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_hwaccel_do_receive(struct sk_buff **skb);
+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);
@@ -166,13 +171,18 @@ static inline int __vlan_hwaccel_rx(struct sk_buff *skb, struct vlan_group *grp,
         return NET_XMIT_SUCCESS;
 }
 
-static inline bool vlan_hwaccel_do_receive(struct sk_buff **skb)
+static inline bool vlan_do_receive(struct sk_buff **skb)
 {
         if ((*skb)->vlan_tci & VLAN_VID_MASK)
                 (*skb)->pkt_type = PACKET_OTHERHOST;
         return false;
 }
 
+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)
diff --git a/include/linux/init.h b/include/linux/init.h
index 577671c55153..9146f39cdddf 100644
--- a/include/linux/init.h
+++ b/include/linux/init.h
@@ -79,29 +79,29 @@
 #define __exitused  __used
 #endif
 
-#define __exit          __section(.exit.text) __exitused __cold
+#define __exit          __section(.exit.text) __exitused __cold notrace
 
 /* Used for HOTPLUG */
-#define __devinit        __section(.devinit.text) __cold
+#define __devinit        __section(.devinit.text) __cold notrace
 #define __devinitdata    __section(.devinit.data)
 #define __devinitconst   __section(.devinit.rodata)
-#define __devexit        __section(.devexit.text) __exitused __cold
+#define __devexit        __section(.devexit.text) __exitused __cold notrace
 #define __devexitdata    __section(.devexit.data)
 #define __devexitconst   __section(.devexit.rodata)
 
 /* Used for HOTPLUG_CPU */
-#define __cpuinit        __section(.cpuinit.text) __cold
+#define __cpuinit        __section(.cpuinit.text) __cold notrace
 #define __cpuinitdata    __section(.cpuinit.data)
 #define __cpuinitconst   __section(.cpuinit.rodata)
-#define __cpuexit        __section(.cpuexit.text) __exitused __cold
+#define __cpuexit        __section(.cpuexit.text) __exitused __cold notrace
 #define __cpuexitdata    __section(.cpuexit.data)
 #define __cpuexitconst   __section(.cpuexit.rodata)
 
 /* Used for MEMORY_HOTPLUG */
-#define __meminit        __section(.meminit.text) __cold
+#define __meminit        __section(.meminit.text) __cold notrace
 #define __meminitdata    __section(.meminit.data)
 #define __meminitconst   __section(.meminit.rodata)
-#define __memexit        __section(.memexit.text) __exitused __cold
+#define __memexit        __section(.memexit.text) __exitused __cold notrace
 #define __memexitdata    __section(.memexit.data)
 #define __memexitconst   __section(.memexit.rodata)
 
diff --git a/include/linux/init_task.h b/include/linux/init_task.h
index caa151fbebb7..bafc58c00fc3 100644
--- a/include/linux/init_task.h
+++ b/include/linux/init_task.h
@@ -83,13 +83,6 @@ extern struct group_info init_groups;
 #define INIT_IDS
 #endif
 
-/*
- * Because of the reduced scope of CAP_SETPCAP when filesystem
- * capabilities are in effect, it is safe to allow CAP_SETPCAP to
- * be available in the default configuration.
- */
-# define CAP_INIT_BSET  CAP_FULL_SET
-
 #ifdef CONFIG_RCU_BOOST
 #define INIT_TASK_RCU_BOOST()                                           \
         .rcu_boost_mutex = NULL,
@@ -134,7 +127,6 @@ extern struct cred init_cred;
         .stack          = &init_thread_info,                            \
         .usage          = ATOMIC_INIT(2),                               \
         .flags          = PF_KTHREAD,                                   \
-        .lock_depth     = -1,                                           \
         .prio           = MAX_PRIO-20,                                  \
         .static_prio    = MAX_PRIO-20,                                  \
         .normal_prio    = MAX_PRIO-20,                                  \
diff --git a/include/linux/input/ad714x.h b/include/linux/input/ad714x.h
index 0cbe5e81482e..d388d857bf14 100644
--- a/include/linux/input/ad714x.h
+++ b/include/linux/input/ad714x.h
@@ -6,7 +6,7 @@
  * The platform_data for the device's "struct device" holds this
  * information.
  *
- * Copyright 2009 Analog Devices Inc.
+ * Copyright 2009-2011 Analog Devices Inc.
  *
  * Licensed under the GPL-2 or later.
  */
@@ -58,6 +58,7 @@ struct ad714x_platform_data {
         struct ad714x_button_plat *button;
         unsigned short stage_cfg_reg[STAGE_NUM][STAGE_CFGREG_NUM];
         unsigned short sys_cfg_reg[SYS_CFGREG_NUM];
+        unsigned long irqflags;
 };
 
 #endif
diff --git a/include/linux/input/adp5589.h b/include/linux/input/adp5589.h
new file mode 100644
index 000000000000..ef792ecfaabf
--- /dev/null
+++ b/include/linux/input/adp5589.h
@@ -0,0 +1,213 @@
+/*
+ * Analog Devices ADP5589 I/O Expander and QWERTY Keypad Controller
+ *
+ * Copyright 2010-2011 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2.
+ */
+
+#ifndef _ADP5589_H
+#define _ADP5589_H
+
+#define ADP5589_ID                      0x00
+#define ADP5589_INT_STATUS              0x01
+#define ADP5589_STATUS                  0x02
+#define ADP5589_FIFO_1                  0x03
+#define ADP5589_FIFO_2                  0x04
+#define ADP5589_FIFO_3                  0x05
+#define ADP5589_FIFO_4                  0x06
+#define ADP5589_FIFO_5                  0x07
+#define ADP5589_FIFO_6                  0x08
+#define ADP5589_FIFO_7                  0x09
+#define ADP5589_FIFO_8                  0x0A
+#define ADP5589_FIFO_9                  0x0B
+#define ADP5589_FIFO_10                 0x0C
+#define ADP5589_FIFO_11                 0x0D
+#define ADP5589_FIFO_12                 0x0E
+#define ADP5589_FIFO_13                 0x0F
+#define ADP5589_FIFO_14                 0x10
+#define ADP5589_FIFO_15                 0x11
+#define ADP5589_FIFO_16                 0x12
+#define ADP5589_GPI_INT_STAT_A          0x13
+#define ADP5589_GPI_INT_STAT_B          0x14
+#define ADP5589_GPI_INT_STAT_C          0x15
+#define ADP5589_GPI_STATUS_A            0x16
+#define ADP5589_GPI_STATUS_B            0x17
+#define ADP5589_GPI_STATUS_C            0x18
+#define ADP5589_RPULL_CONFIG_A          0x19
+#define ADP5589_RPULL_CONFIG_B          0x1A
+#define ADP5589_RPULL_CONFIG_C          0x1B
+#define ADP5589_RPULL_CONFIG_D          0x1C
+#define ADP5589_RPULL_CONFIG_E          0x1D
+#define ADP5589_GPI_INT_LEVEL_A         0x1E
+#define ADP5589_GPI_INT_LEVEL_B         0x1F
+#define ADP5589_GPI_INT_LEVEL_C         0x20
+#define ADP5589_GPI_EVENT_EN_A          0x21
+#define ADP5589_GPI_EVENT_EN_B          0x22
+#define ADP5589_GPI_EVENT_EN_C          0x23
+#define ADP5589_GPI_INTERRUPT_EN_A      0x24
+#define ADP5589_GPI_INTERRUPT_EN_B      0x25
+#define ADP5589_GPI_INTERRUPT_EN_C      0x26
+#define ADP5589_DEBOUNCE_DIS_A          0x27
+#define ADP5589_DEBOUNCE_DIS_B          0x28
+#define ADP5589_DEBOUNCE_DIS_C          0x29
+#define ADP5589_GPO_DATA_OUT_A          0x2A
+#define ADP5589_GPO_DATA_OUT_B          0x2B
+#define ADP5589_GPO_DATA_OUT_C          0x2C
+#define ADP5589_GPO_OUT_MODE_A          0x2D
+#define ADP5589_GPO_OUT_MODE_B          0x2E
+#define ADP5589_GPO_OUT_MODE_C          0x2F
+#define ADP5589_GPIO_DIRECTION_A        0x30
+#define ADP5589_GPIO_DIRECTION_B        0x31
+#define ADP5589_GPIO_DIRECTION_C        0x32
+#define ADP5589_UNLOCK1                 0x33
+#define ADP5589_UNLOCK2                 0x34
+#define ADP5589_EXT_LOCK_EVENT          0x35
+#define ADP5589_UNLOCK_TIMERS           0x36
+#define ADP5589_LOCK_CFG                0x37
+#define ADP5589_RESET1_EVENT_A          0x38
+#define ADP5589_RESET1_EVENT_B          0x39
+#define ADP5589_RESET1_EVENT_C          0x3A
+#define ADP5589_RESET2_EVENT_A          0x3B
+#define ADP5589_RESET2_EVENT_B          0x3C
+#define ADP5589_RESET_CFG               0x3D
+#define ADP5589_PWM_OFFT_LOW            0x3E
+#define ADP5589_PWM_OFFT_HIGH           0x3F
+#define ADP5589_PWM_ONT_LOW             0x40
+#define ADP5589_PWM_ONT_HIGH            0x41
+#define ADP5589_PWM_CFG                 0x42
+#define ADP5589_CLOCK_DIV_CFG           0x43
+#define ADP5589_LOGIC_1_CFG             0x44
+#define ADP5589_LOGIC_2_CFG             0x45
+#define ADP5589_LOGIC_FF_CFG            0x46
+#define ADP5589_LOGIC_INT_EVENT_EN      0x47
+#define ADP5589_POLL_PTIME_CFG          0x48
+#define ADP5589_PIN_CONFIG_A            0x49
+#define ADP5589_PIN_CONFIG_B            0x4A
+#define ADP5589_PIN_CONFIG_C            0x4B
+#define ADP5589_PIN_CONFIG_D            0x4C
+#define ADP5589_GENERAL_CFG             0x4D
+#define ADP5589_INT_EN                  0x4E
+
+#define ADP5589_DEVICE_ID_MASK  0xF
+
+/* Put one of these structures in i2c_board_info platform_data */
+
+#define ADP5589_KEYMAPSIZE      88
+
+#define ADP5589_GPI_PIN_ROW0 97
+#define ADP5589_GPI_PIN_ROW1 98
+#define ADP5589_GPI_PIN_ROW2 99
+#define ADP5589_GPI_PIN_ROW3 100
+#define ADP5589_GPI_PIN_ROW4 101
+#define ADP5589_GPI_PIN_ROW5 102
+#define ADP5589_GPI_PIN_ROW6 103
+#define ADP5589_GPI_PIN_ROW7 104
+#define ADP5589_GPI_PIN_COL0 105
+#define ADP5589_GPI_PIN_COL1 106
+#define ADP5589_GPI_PIN_COL2 107
+#define ADP5589_GPI_PIN_COL3 108
+#define ADP5589_GPI_PIN_COL4 109
+#define ADP5589_GPI_PIN_COL5 110
+#define ADP5589_GPI_PIN_COL6 111
+#define ADP5589_GPI_PIN_COL7 112
+#define ADP5589_GPI_PIN_COL8 113
+#define ADP5589_GPI_PIN_COL9 114
+#define ADP5589_GPI_PIN_COL10 115
+#define GPI_LOGIC1 116
+#define GPI_LOGIC2 117
+
+#define ADP5589_GPI_PIN_ROW_BASE ADP5589_GPI_PIN_ROW0
+#define ADP5589_GPI_PIN_ROW_END ADP5589_GPI_PIN_ROW7
+#define ADP5589_GPI_PIN_COL_BASE ADP5589_GPI_PIN_COL0
+#define ADP5589_GPI_PIN_COL_END ADP5589_GPI_PIN_COL10
+
+#define ADP5589_GPI_PIN_BASE ADP5589_GPI_PIN_ROW_BASE
+#define ADP5589_GPI_PIN_END ADP5589_GPI_PIN_COL_END
+
+#define ADP5589_GPIMAPSIZE_MAX (ADP5589_GPI_PIN_END - ADP5589_GPI_PIN_BASE + 1)
+
+struct adp5589_gpi_map {
+        unsigned short pin;
+        unsigned short sw_evt;
+};
+
+/* scan_cycle_time */
+#define ADP5589_SCAN_CYCLE_10ms         0
+#define ADP5589_SCAN_CYCLE_20ms         1
+#define ADP5589_SCAN_CYCLE_30ms         2
+#define ADP5589_SCAN_CYCLE_40ms         3
+
+/* RESET_CFG */
+#define RESET_PULSE_WIDTH_500us         0
+#define RESET_PULSE_WIDTH_1ms           1
+#define RESET_PULSE_WIDTH_2ms           2
+#define RESET_PULSE_WIDTH_10ms          3
+
+#define RESET_TRIG_TIME_0ms             (0 << 2)
+#define RESET_TRIG_TIME_1000ms          (1 << 2)
+#define RESET_TRIG_TIME_1500ms          (2 << 2)
+#define RESET_TRIG_TIME_2000ms          (3 << 2)
+#define RESET_TRIG_TIME_2500ms          (4 << 2)
+#define RESET_TRIG_TIME_3000ms          (5 << 2)
+#define RESET_TRIG_TIME_3500ms          (6 << 2)
+#define RESET_TRIG_TIME_4000ms          (7 << 2)
+
+#define RESET_PASSTHRU_EN               (1 << 5)
+#define RESET1_POL_HIGH                 (1 << 6)
+#define RESET1_POL_LOW                  (0 << 6)
+#define RESET2_POL_HIGH                 (1 << 7)
+#define RESET2_POL_LOW                  (0 << 7)
+
+/* Mask Bits:
+ * C C C C C C C C C C C | R R R R R R R R
+ * 1 9 8 7 6 5 4 3 2 1 0 | 7 6 5 4 3 2 1 0
+ * 0
+ * ---------------- BIT ------------------
+ * 1 1 1 1 1 1 1 1 1 0 0 | 0 0 0 0 0 0 0 0
+ * 8 7 6 5 4 3 2 1 0 9 8 | 7 6 5 4 3 2 1 0
+ */
+
+#define ADP_ROW(x)                      (1 << (x))
+#define ADP_COL(x)                      (1 << (x + 8))
+
+struct adp5589_kpad_platform_data {
+        unsigned keypad_en_mask;        /* Keypad (Rows/Columns) enable mask */
+        const unsigned short *keymap;   /* Pointer to keymap */
+        unsigned short keymapsize;      /* Keymap size */
+        bool repeat;                    /* Enable key repeat */
+        bool en_keylock;                /* Enable key lock feature */
+        unsigned char unlock_key1;      /* Unlock Key 1 */
+        unsigned char unlock_key2;      /* Unlock Key 2 */
+        unsigned char unlock_timer;     /* Time in seconds [0..7] between the two unlock keys 0=disable */
+        unsigned char scan_cycle_time;  /* Time between consecutive scan cycles */
+        unsigned char reset_cfg;        /* Reset config */
+        unsigned short reset1_key_1;    /* Reset Key 1 */
+        unsigned short reset1_key_2;    /* Reset Key 2 */
+        unsigned short reset1_key_3;    /* Reset Key 3 */
+        unsigned short reset2_key_1;    /* Reset Key 1 */
+        unsigned short reset2_key_2;    /* Reset Key 2 */
+        unsigned debounce_dis_mask;     /* Disable debounce mask */
+        unsigned pull_dis_mask;         /* Disable all pull resistors mask */
+        unsigned pullup_en_100k;        /* Pull-Up 100k Enable Mask */
+        unsigned pullup_en_300k;        /* Pull-Up 300k Enable Mask */
+        unsigned pulldown_en_300k;      /* Pull-Down 300k Enable Mask */
+        const struct adp5589_gpi_map *gpimap;
+        unsigned short gpimapsize;
+        const struct adp5589_gpio_platform_data *gpio_data;
+};
+
+struct i2c_client; /* forward declaration */
+
+struct adp5589_gpio_platform_data {
+        int     gpio_start;     /* GPIO Chip base # */
+        int     (*setup)(struct i2c_client *client,
+                                int gpio, unsigned ngpio,
+                                void *context);
+        int     (*teardown)(struct i2c_client *client,
+                                int gpio, unsigned ngpio,
+                                void *context);
+        void    *context;
+};
+
+#endif
diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h
index bea0ac750712..6c12989839d9 100644
--- a/include/linux/interrupt.h
+++ b/include/linux/interrupt.h
@@ -414,7 +414,6 @@ enum
         TASKLET_SOFTIRQ,
         SCHED_SOFTIRQ,
         HRTIMER_SOFTIRQ,
-        RCU_SOFTIRQ,    /* Preferable RCU should always be the last softirq */
 
         NR_SOFTIRQS
 };
diff --git a/include/linux/irq.h b/include/linux/irq.h
index 09a308072f56..8b4538446636 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -53,12 +53,13 @@ typedef	void (*irq_preflow_handler_t)(struct irq_data *data);
  * Bits which can be modified via irq_set/clear/modify_status_flags()
  * IRQ_LEVEL                    - Interrupt is level type. Will be also
  *                                updated in the code when the above trigger
- *                                bits are modified via set_irq_type()
+ *                                bits are modified via irq_set_irq_type()
  * IRQ_PER_CPU                  - Mark an interrupt PER_CPU. Will protect
  *                                it from affinity setting
  * IRQ_NOPROBE                  - Interrupt cannot be probed by autoprobing
  * IRQ_NOREQUEST                - Interrupt cannot be requested via
  *                                request_irq()
+ * IRQ_NOTHREAD                 - Interrupt cannot be threaded
  * IRQ_NOAUTOEN                 - Interrupt is not automatically enabled in
  *                                request/setup_irq()
  * IRQ_NO_BALANCING             - Interrupt cannot be balanced (affinity set)
@@ -85,6 +86,7 @@ enum {
         IRQ_NO_BALANCING        = (1 << 13),
         IRQ_MOVE_PCNTXT         = (1 << 14),
         IRQ_NESTED_THREAD       = (1 << 15),
+        IRQ_NOTHREAD            = (1 << 16),
 };
 
 #define IRQF_MODIFY_MASK        \
@@ -261,23 +263,6 @@ static inline void irqd_clr_chained_irq_inprogress(struct irq_data *d)
  * struct irq_chip - hardware interrupt chip descriptor
  *
  * @name:               name for /proc/interrupts
- * @startup:            deprecated, replaced by irq_startup
- * @shutdown:           deprecated, replaced by irq_shutdown
- * @enable:             deprecated, replaced by irq_enable
- * @disable:            deprecated, replaced by irq_disable
- * @ack:                deprecated, replaced by irq_ack
- * @mask:               deprecated, replaced by irq_mask
- * @mask_ack:           deprecated, replaced by irq_mask_ack
- * @unmask:             deprecated, replaced by irq_unmask
- * @eoi:                deprecated, replaced by irq_eoi
- * @end:                deprecated, will go away with __do_IRQ()
- * @set_affinity:       deprecated, replaced by irq_set_affinity
- * @retrigger:          deprecated, replaced by irq_retrigger
- * @set_type:           deprecated, replaced by irq_set_type
- * @set_wake:           deprecated, replaced by irq_wake
- * @bus_lock:           deprecated, replaced by irq_bus_lock
- * @bus_sync_unlock:    deprecated, replaced by irq_bus_sync_unlock
- *
  * @irq_startup:        start up the interrupt (defaults to ->enable if NULL)
  * @irq_shutdown:       shut down the interrupt (defaults to ->disable if NULL)
  * @irq_enable:         enable the interrupt (defaults to chip->unmask if NULL)
@@ -295,6 +280,9 @@ static inline void irqd_clr_chained_irq_inprogress(struct irq_data *d)
  * @irq_bus_sync_unlock:function to sync and unlock slow bus (i2c) chips
  * @irq_cpu_online:     configure an interrupt source for a secondary CPU
  * @irq_cpu_offline:    un-configure an interrupt source for a secondary CPU
+ * @irq_suspend:        function called from core code on suspend once per chip
+ * @irq_resume:         function called from core code on resume once per chip
+ * @irq_pm_shutdown:    function called from core code on shutdown once per chip
  * @irq_print_chip:     optional to print special chip info in show_interrupts
  * @flags:              chip specific flags
  *
@@ -324,6 +312,10 @@ struct irq_chip {
         void            (*irq_cpu_online)(struct irq_data *data);
         void            (*irq_cpu_offline)(struct irq_data *data);
 
+        void            (*irq_suspend)(struct irq_data *data);
+        void            (*irq_resume)(struct irq_data *data);
+        void            (*irq_pm_shutdown)(struct irq_data *data);
+
         void            (*irq_print_chip)(struct irq_data *data, struct seq_file *p);
 
         unsigned long   flags;
@@ -439,7 +431,7 @@ irq_set_handler(unsigned int irq, irq_flow_handler_t handle)
 /*
  * Set a highlevel chained flow handler for a given IRQ.
  * (a chained handler is automatically enabled and set to
- *  IRQ_NOREQUEST and IRQ_NOPROBE)
+ *  IRQ_NOREQUEST, IRQ_NOPROBE, and IRQ_NOTHREAD)
  */
 static inline void
 irq_set_chained_handler(unsigned int irq, irq_flow_handler_t handle)
@@ -469,6 +461,16 @@ static inline void irq_set_probe(unsigned int irq)
         irq_modify_status(irq, IRQ_NOPROBE, 0);
 }
 
+static inline void irq_set_nothread(unsigned int irq)
+{
+        irq_modify_status(irq, 0, IRQ_NOTHREAD);
+}
+
+static inline void irq_set_thread(unsigned int irq)
+{
+        irq_modify_status(irq, IRQ_NOTHREAD, 0);
+}
+
 static inline void irq_set_nested_thread(unsigned int irq, bool nest)
 {
         if (nest)
@@ -573,6 +575,145 @@ static inline int irq_reserve_irq(unsigned int irq)
         return irq_reserve_irqs(irq, 1);
 }
 
+#ifndef irq_reg_writel
+# define irq_reg_writel(val, addr)      writel(val, addr)
+#endif
+#ifndef irq_reg_readl
+# define irq_reg_readl(addr)            readl(addr)
+#endif
+
+/**
+ * struct irq_chip_regs - register offsets for struct irq_gci
+ * @enable:     Enable register offset to reg_base
+ * @disable:    Disable register offset to reg_base
+ * @mask:       Mask register offset to reg_base
+ * @ack:        Ack register offset to reg_base
+ * @eoi:        Eoi register offset to reg_base
+ * @type:       Type configuration register offset to reg_base
+ * @polarity:   Polarity configuration register offset to reg_base
+ */
+struct irq_chip_regs {
+        unsigned long           enable;
+        unsigned long           disable;
+        unsigned long           mask;
+        unsigned long           ack;
+        unsigned long           eoi;
+        unsigned long           type;
+        unsigned long           polarity;
+};
+
+/**
+ * struct irq_chip_type - Generic interrupt chip instance for a flow type
+ * @chip:               The real interrupt chip which provides the callbacks
+ * @regs:               Register offsets for this chip
+ * @handler:            Flow handler associated with this chip
+ * @type:               Chip can handle these flow types
+ *
+ * A irq_generic_chip can have several instances of irq_chip_type when
+ * it requires different functions and register offsets for different
+ * flow types.
+ */
+struct irq_chip_type {
+        struct irq_chip         chip;
+        struct irq_chip_regs    regs;
+        irq_flow_handler_t      handler;
+        u32                     type;
+};
+
+/**
+ * struct irq_chip_generic - Generic irq chip data structure
+ * @lock:               Lock to protect register and cache data access
+ * @reg_base:           Register base address (virtual)
+ * @irq_base:           Interrupt base nr for this chip
+ * @irq_cnt:            Number of interrupts handled by this chip
+ * @mask_cache:         Cached mask register
+ * @type_cache:         Cached type register
+ * @polarity_cache:     Cached polarity register
+ * @wake_enabled:       Interrupt can wakeup from suspend
+ * @wake_active:        Interrupt is marked as an wakeup from suspend source
+ * @num_ct:             Number of available irq_chip_type instances (usually 1)
+ * @private:            Private data for non generic chip callbacks
+ * @list:               List head for keeping track of instances
+ * @chip_types:         Array of interrupt irq_chip_types
+ *
+ * Note, that irq_chip_generic can have multiple irq_chip_type
+ * implementations which can be associated to a particular irq line of
+ * an irq_chip_generic instance. That allows to share and protect
+ * state in an irq_chip_generic instance when we need to implement
+ * different flow mechanisms (level/edge) for it.
+ */
+struct irq_chip_generic {
+        raw_spinlock_t          lock;
+        void __iomem            *reg_base;
+        unsigned int            irq_base;
+        unsigned int            irq_cnt;
+        u32                     mask_cache;
+        u32                     type_cache;
+        u32                     polarity_cache;
+        u32                     wake_enabled;
+        u32                     wake_active;
+        unsigned int            num_ct;
+        void                    *private;
+        struct list_head        list;
+        struct irq_chip_type    chip_types[0];
+};
+
+/**
+ * enum irq_gc_flags - Initialization flags for generic irq chips
+ * @IRQ_GC_INIT_MASK_CACHE:     Initialize the mask_cache by reading mask reg
+ * @IRQ_GC_INIT_NESTED_LOCK:    Set the lock class of the irqs to nested for
+ *                              irq chips which need to call irq_set_wake() on
+ *                              the parent irq. Usually GPIO implementations
+ */
+enum irq_gc_flags {
+        IRQ_GC_INIT_MASK_CACHE          = 1 << 0,
+        IRQ_GC_INIT_NESTED_LOCK         = 1 << 1,
+};
+
+/* Generic chip callback functions */
+void irq_gc_noop(struct irq_data *d);
+void irq_gc_mask_disable_reg(struct irq_data *d);
+void irq_gc_mask_set_bit(struct irq_data *d);
+void irq_gc_mask_clr_bit(struct irq_data *d);
+void irq_gc_unmask_enable_reg(struct irq_data *d);
+void irq_gc_ack(struct irq_data *d);
+void irq_gc_mask_disable_reg_and_ack(struct irq_data *d);
+void irq_gc_eoi(struct irq_data *d);
+int irq_gc_set_wake(struct irq_data *d, unsigned int on);
+
+/* Setup functions for irq_chip_generic */
+struct irq_chip_generic *
+irq_alloc_generic_chip(const char *name, int nr_ct, unsigned int irq_base,
+                       void __iomem *reg_base, irq_flow_handler_t handler);
+void irq_setup_generic_chip(struct irq_chip_generic *gc, u32 msk,
+                            enum irq_gc_flags flags, unsigned int clr,
+                            unsigned int set);
+int irq_setup_alt_chip(struct irq_data *d, unsigned int type);
+void irq_remove_generic_chip(struct irq_chip_generic *gc, u32 msk,
+                             unsigned int clr, unsigned int set);
+
+static inline struct irq_chip_type *irq_data_get_chip_type(struct irq_data *d)
+{
+        return container_of(d->chip, struct irq_chip_type, chip);
+}
+
+#define IRQ_MSK(n) (u32)((n) < 32 ? ((1 << (n)) - 1) : UINT_MAX)
+
+#ifdef CONFIG_SMP
+static inline void irq_gc_lock(struct irq_chip_generic *gc)
+{
+        raw_spin_lock(&gc->lock);
+}
+
+static inline void irq_gc_unlock(struct irq_chip_generic *gc)
+{
+        raw_spin_unlock(&gc->lock);
+}
+#else
+static inline void irq_gc_lock(struct irq_chip_generic *gc) { }
+static inline void irq_gc_unlock(struct irq_chip_generic *gc) { }
+#endif
+
 #endif /* CONFIG_GENERIC_HARDIRQS */
 
 #endif /* !CONFIG_S390 */
diff --git a/include/linux/irqdesc.h b/include/linux/irqdesc.h
index a082905b5ebe..2d921b35212c 100644
--- a/include/linux/irqdesc.h
+++ b/include/linux/irqdesc.h
@@ -16,16 +16,18 @@ struct timer_rand_state;
  * @irq_data:           per irq and chip data passed down to chip functions
  * @timer_rand_state:   pointer to timer rand state struct
  * @kstat_irqs:         irq stats per cpu
- * @handle_irq:         highlevel irq-events handler [if NULL, __do_IRQ()]
+ * @handle_irq:         highlevel irq-events handler
+ * @preflow_handler:    handler called before the flow handler (currently used by sparc)
  * @action:             the irq action chain
  * @status:             status information
  * @core_internal_state__do_not_mess_with_it: core internal status information
  * @depth:              disable-depth, for nested irq_disable() calls
- * @wake_depth:         enable depth, for multiple set_irq_wake() callers
+ * @wake_depth:         enable depth, for multiple irq_set_irq_wake() callers
  * @irq_count:          stats field to detect stalled irqs
  * @last_unhandled:     aging timer for unhandled count
  * @irqs_unhandled:     stats field for spurious unhandled interrupts
  * @lock:               locking for SMP
+ * @affinity_hint:      hint to user space for preferred irq affinity
  * @affinity_notify:    context for notification of affinity changes
  * @pending_mask:       pending rebalanced interrupts
  * @threads_oneshot:    bitfield to handle shared oneshot threads
@@ -109,10 +111,7 @@ static inline void generic_handle_irq_desc(unsigned int irq, struct irq_desc *de
         desc->handle_irq(irq, desc);
 }
 
-static inline void generic_handle_irq(unsigned int irq)
-{
-        generic_handle_irq_desc(irq, irq_to_desc(irq));
-}
+int generic_handle_irq(unsigned int irq);
 
 /* Test to see if a driver has successfully requested an irq */
 static inline int irq_has_action(unsigned int irq)
diff --git a/include/linux/jump_label.h b/include/linux/jump_label.h
index 7880f18e4b86..83e745f3ead7 100644
--- a/include/linux/jump_label.h
+++ b/include/linux/jump_label.h
@@ -1,20 +1,43 @@
 #ifndef _LINUX_JUMP_LABEL_H
 #define _LINUX_JUMP_LABEL_H
 
+#include <linux/types.h>
+#include <linux/compiler.h>
+
 #if defined(CC_HAVE_ASM_GOTO) && defined(CONFIG_JUMP_LABEL)
+
+struct jump_label_key {
+        atomic_t enabled;
+        struct jump_entry *entries;
+#ifdef CONFIG_MODULES
+        struct jump_label_mod *next;
+#endif
+};
+
 # include <asm/jump_label.h>
 # define HAVE_JUMP_LABEL
 #endif
 
 enum jump_label_type {
+        JUMP_LABEL_DISABLE = 0,
         JUMP_LABEL_ENABLE,
-        JUMP_LABEL_DISABLE
 };
 
 struct module;
 
 #ifdef HAVE_JUMP_LABEL
 
+#ifdef CONFIG_MODULES
+#define JUMP_LABEL_INIT {{ 0 }, NULL, NULL}
+#else
+#define JUMP_LABEL_INIT {{ 0 }, NULL}
+#endif
+
+static __always_inline bool static_branch(struct jump_label_key *key)
+{
+        return arch_static_branch(key);
+}
+
 extern struct jump_entry __start___jump_table[];
 extern struct jump_entry __stop___jump_table[];
 
@@ -23,37 +46,37 @@ extern void jump_label_unlock(void);
 extern void arch_jump_label_transform(struct jump_entry *entry,
                                  enum jump_label_type type);
 extern void arch_jump_label_text_poke_early(jump_label_t addr);
-extern void jump_label_update(unsigned long key, enum jump_label_type type);
-extern void jump_label_apply_nops(struct module *mod);
 extern int jump_label_text_reserved(void *start, void *end);
+extern void jump_label_inc(struct jump_label_key *key);
+extern void jump_label_dec(struct jump_label_key *key);
+extern bool jump_label_enabled(struct jump_label_key *key);
+extern void jump_label_apply_nops(struct module *mod);
 
-#define jump_label_enable(key) \
-        jump_label_update((unsigned long)key, JUMP_LABEL_ENABLE);
+#else
 
-#define jump_label_disable(key) \
-        jump_label_update((unsigned long)key, JUMP_LABEL_DISABLE);
+#include <asm/atomic.h>
 
-#else
+#define JUMP_LABEL_INIT {ATOMIC_INIT(0)}
 
-#define JUMP_LABEL(key, label)                  \
-do {                                            \
-        if (unlikely(*key))                     \
-                goto label;                     \
-} while (0)
+struct jump_label_key {
+        atomic_t enabled;
+};
 
-#define jump_label_enable(cond_var)     \
-do {                                    \
-       *(cond_var) = 1;                 \
-} while (0)
+static __always_inline bool static_branch(struct jump_label_key *key)
+{
+        if (unlikely(atomic_read(&key->enabled)))
+                return true;
+        return false;
+}
 
-#define jump_label_disable(cond_var)    \
-do {                                    \
-       *(cond_var) = 0;                 \
-} while (0)
+static inline void jump_label_inc(struct jump_label_key *key)
+{
+        atomic_inc(&key->enabled);
+}
 
-static inline int jump_label_apply_nops(struct module *mod)
+static inline void jump_label_dec(struct jump_label_key *key)
 {
-        return 0;
+        atomic_dec(&key->enabled);
 }
 
 static inline int jump_label_text_reserved(void *start, void *end)
@@ -64,16 +87,16 @@ static inline int jump_label_text_reserved(void *start, void *end)
 static inline void jump_label_lock(void) {}
 static inline void jump_label_unlock(void) {}
 
-#endif
+static inline bool jump_label_enabled(struct jump_label_key *key)
+{
+        return !!atomic_read(&key->enabled);
+}
 
-#define COND_STMT(key, stmt)                                    \
-do {                                                            \
-        __label__ jl_enabled;                                   \
-        JUMP_LABEL(key, jl_enabled);                            \
-        if (0) {                                                \
-jl_enabled:                                                     \
-                stmt;                                           \
-        }                                                       \
-} while (0)
+static inline int jump_label_apply_nops(struct module *mod)
+{
+        return 0;
+}
+
+#endif
 
 #endif
diff --git a/include/linux/jump_label_ref.h b/include/linux/jump_label_ref.h
deleted file mode 100644
index e5d012ad92c6..000000000000
--- a/include/linux/jump_label_ref.h
+++ /dev/null
@@ -1,44 +0,0 @@
-#ifndef _LINUX_JUMP_LABEL_REF_H
-#define _LINUX_JUMP_LABEL_REF_H
-
-#include <linux/jump_label.h>
-#include <asm/atomic.h>
-
-#ifdef HAVE_JUMP_LABEL
-
-static inline void jump_label_inc(atomic_t *key)
-{
-        if (atomic_add_return(1, key) == 1)
-                jump_label_enable(key);
-}
-
-static inline void jump_label_dec(atomic_t *key)
-{
-        if (atomic_dec_and_test(key))
-                jump_label_disable(key);
-}
-
-#else /* !HAVE_JUMP_LABEL */
-
-static inline void jump_label_inc(atomic_t *key)
-{
-        atomic_inc(key);
-}
-
-static inline void jump_label_dec(atomic_t *key)
-{
-        atomic_dec(key);
-}
-
-#undef JUMP_LABEL
-#define JUMP_LABEL(key, label)                                          \
-do {                                                                    \
-        if (unlikely(__builtin_choose_expr(                             \
-              __builtin_types_compatible_p(typeof(key), atomic_t *),    \
-              atomic_read((atomic_t *)(key)), *(key))))                 \
-                goto label;                                             \
-} while (0)
-
-#endif /* HAVE_JUMP_LABEL */
-
-#endif /* _LINUX_JUMP_LABEL_REF_H */
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 00cec4dc0ae2..fb0e7329fee1 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -248,6 +248,37 @@ int __must_check kstrtos16(const char *s, unsigned int base, s16 *res);
 int __must_check kstrtou8(const char *s, unsigned int base, u8 *res);
 int __must_check kstrtos8(const char *s, unsigned int base, s8 *res);
 
+int __must_check kstrtoull_from_user(const char __user *s, size_t count, unsigned int base, unsigned long long *res);
+int __must_check kstrtoll_from_user(const char __user *s, size_t count, unsigned int base, long long *res);
+int __must_check kstrtoul_from_user(const char __user *s, size_t count, unsigned int base, unsigned long *res);
+int __must_check kstrtol_from_user(const char __user *s, size_t count, unsigned int base, long *res);
+int __must_check kstrtouint_from_user(const char __user *s, size_t count, unsigned int base, unsigned int *res);
+int __must_check kstrtoint_from_user(const char __user *s, size_t count, unsigned int base, int *res);
+int __must_check kstrtou16_from_user(const char __user *s, size_t count, unsigned int base, u16 *res);
+int __must_check kstrtos16_from_user(const char __user *s, size_t count, unsigned int base, s16 *res);
+int __must_check kstrtou8_from_user(const char __user *s, size_t count, unsigned int base, u8 *res);
+int __must_check kstrtos8_from_user(const char __user *s, size_t count, unsigned int base, s8 *res);
+
+static inline int __must_check kstrtou64_from_user(const char __user *s, size_t count, unsigned int base, u64 *res)
+{
+        return kstrtoull_from_user(s, count, base, res);
+}
+
+static inline int __must_check kstrtos64_from_user(const char __user *s, size_t count, unsigned int base, s64 *res)
+{
+        return kstrtoll_from_user(s, count, base, res);
+}
+
+static inline int __must_check kstrtou32_from_user(const char __user *s, size_t count, unsigned int base, u32 *res)
+{
+        return kstrtouint_from_user(s, count, base, res);
+}
+
+static inline int __must_check kstrtos32_from_user(const char __user *s, size_t count, unsigned int base, s32 *res)
+{
+        return kstrtoint_from_user(s, count, base, res);
+}
+
 extern unsigned long simple_strtoul(const char *,char **,unsigned int);
 extern long simple_strtol(const char *,char **,unsigned int);
 extern unsigned long long simple_strtoull(const char *,char **,unsigned int);
@@ -283,6 +314,7 @@ extern char *get_options(const char *str, int nints, int *ints);
 extern unsigned long long memparse(const char *ptr, char **retptr);
 
 extern int core_kernel_text(unsigned long addr);
+extern int core_kernel_data(unsigned long addr);
 extern int __kernel_text_address(unsigned long addr);
 extern int kernel_text_address(unsigned long addr);
 extern int func_ptr_is_kernel_text(void *ptr);
@@ -637,6 +669,13 @@ struct sysinfo {
         char _f[20-2*sizeof(long)-sizeof(int)]; /* Padding: libc5 uses this.. */
 };
 
+#ifdef __CHECKER__
+#define BUILD_BUG_ON_NOT_POWER_OF_2(n)
+#define BUILD_BUG_ON_ZERO(e)
+#define BUILD_BUG_ON_NULL(e)
+#define BUILD_BUG_ON(condition)
+#else /* __CHECKER__ */
+
 /* Force a compilation error if a constant expression is not a power of 2 */
 #define BUILD_BUG_ON_NOT_POWER_OF_2(n)                  \
         BUILD_BUG_ON((n) == 0 || (((n) & ((n) - 1)) != 0))
@@ -673,6 +712,7 @@ extern int __build_bug_on_failed;
                 if (condition) __build_bug_on_failed = 1;       \
         } while(0)
 #endif
+#endif  /* __CHECKER__ */
 
 /* Trap pasters of __FUNCTION__ at compile-time */
 #define __FUNCTION__ (__func__)
diff --git a/include/linux/key.h b/include/linux/key.h
index b2bb01719561..ef19b99aff98 100644
--- a/include/linux/key.h
+++ b/include/linux/key.h
@@ -276,6 +276,19 @@ static inline key_serial_t key_serial(struct key *key)
         return key ? key->serial : 0;
 }
 
+/**
+ * key_is_instantiated - Determine if a key has been positively instantiated
+ * @key: The key to check.
+ *
+ * Return true if the specified key has been positively instantiated, false
+ * otherwise.
+ */
+static inline bool key_is_instantiated(const struct key *key)
+{
+        return test_bit(KEY_FLAG_INSTANTIATED, &key->flags) &&
+                !test_bit(KEY_FLAG_NEGATIVE, &key->flags);
+}
+
 #define rcu_dereference_key(KEY)                                        \
         (rcu_dereference_protected((KEY)->payload.rcudata,              \
                                    rwsem_is_locked(&((struct key *)(KEY))->sem)))
diff --git a/include/linux/kmod.h b/include/linux/kmod.h
index 6efd7a78de6a..d4a5c84c503d 100644
--- a/include/linux/kmod.h
+++ b/include/linux/kmod.h
@@ -24,6 +24,7 @@
 #include <linux/errno.h>
 #include <linux/compiler.h>
 #include <linux/workqueue.h>
+#include <linux/sysctl.h>
 
 #define KMOD_PATH_LEN 256
 
@@ -109,9 +110,12 @@ call_usermodehelper(char *path, char **argv, char **envp, enum umh_wait wait)
                                        NULL, NULL, NULL);
 }
 
+extern struct ctl_table usermodehelper_table[];
+
 extern void usermodehelper_init(void);
 
 extern int usermodehelper_disable(void);
 extern void usermodehelper_enable(void);
+extern bool usermodehelper_is_disabled(void);
 
 #endif /* __LINUX_KMOD_H__ */
diff --git a/include/linux/kvm.h b/include/linux/kvm.h
index ea2dc1a2e13d..55ef181521ff 100644
--- a/include/linux/kvm.h
+++ b/include/linux/kvm.h
@@ -541,6 +541,9 @@ struct kvm_ppc_pvinfo {
 #define KVM_CAP_PPC_GET_PVINFO 57
 #define KVM_CAP_PPC_IRQ_LEVEL 58
 #define KVM_CAP_ASYNC_PF 59
+#define KVM_CAP_TSC_CONTROL 60
+#define KVM_CAP_GET_TSC_KHZ 61
+#define KVM_CAP_PPC_BOOKE_SREGS 62
 
 #ifdef KVM_CAP_IRQ_ROUTING
 
@@ -677,6 +680,9 @@ struct kvm_clock_data {
 #define KVM_SET_PIT2              _IOW(KVMIO,  0xa0, struct kvm_pit_state2)
 /* Available with KVM_CAP_PPC_GET_PVINFO */
 #define KVM_PPC_GET_PVINFO        _IOW(KVMIO,  0xa1, struct kvm_ppc_pvinfo)
+/* Available with KVM_CAP_TSC_CONTROL */
+#define KVM_SET_TSC_KHZ           _IO(KVMIO,  0xa2)
+#define KVM_GET_TSC_KHZ           _IO(KVMIO,  0xa3)
 
 /*
  * ioctls for vcpu fds
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
index ab428552af8e..31ebb59cbd2f 100644
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@ -27,6 +27,10 @@
 
 #include <asm/kvm_host.h>
 
+#ifndef KVM_MMIO_SIZE
+#define KVM_MMIO_SIZE 8
+#endif
+
 /*
  * vcpu->requests bit members
  */
@@ -43,7 +47,6 @@
 #define KVM_REQ_DEACTIVATE_FPU    10
 #define KVM_REQ_EVENT             11
 #define KVM_REQ_APF_HALT          12
-#define KVM_REQ_NMI               13
 
 #define KVM_USERSPACE_IRQ_SOURCE_ID     0
 
@@ -133,7 +136,8 @@ struct kvm_vcpu {
         int mmio_read_completed;
         int mmio_is_write;
         int mmio_size;
-        unsigned char mmio_data[8];
+        int mmio_index;
+        unsigned char mmio_data[KVM_MMIO_SIZE];
         gpa_t mmio_phys_addr;
 #endif
 
@@ -292,9 +296,10 @@ static inline struct kvm_vcpu *kvm_get_vcpu(struct kvm *kvm, int i)
 }
 
 #define kvm_for_each_vcpu(idx, vcpup, kvm) \
-        for (idx = 0, vcpup = kvm_get_vcpu(kvm, idx); \
-             idx < atomic_read(&kvm->online_vcpus) && vcpup; \
-             vcpup = kvm_get_vcpu(kvm, ++idx))
+        for (idx = 0; \
+             idx < atomic_read(&kvm->online_vcpus) && \
+             (vcpup = kvm_get_vcpu(kvm, idx)) != NULL; \
+             idx++)
 
 int kvm_vcpu_init(struct kvm_vcpu *vcpu, struct kvm *kvm, unsigned id);
 void kvm_vcpu_uninit(struct kvm_vcpu *vcpu);
@@ -365,7 +370,6 @@ pfn_t gfn_to_pfn_prot(struct kvm *kvm, gfn_t gfn, bool write_fault,
                       bool *writable);
 pfn_t gfn_to_pfn_memslot(struct kvm *kvm,
                          struct kvm_memory_slot *slot, gfn_t gfn);
-int memslot_id(struct kvm *kvm, gfn_t gfn);
 void kvm_release_pfn_dirty(pfn_t);
 void kvm_release_pfn_clean(pfn_t pfn);
 void kvm_set_pfn_dirty(pfn_t pfn);
@@ -513,6 +517,7 @@ struct kvm_assigned_dev_kernel {
         struct kvm *kvm;
         spinlock_t intx_lock;
         char irq_name[32];
+        struct pci_saved_state *pci_saved_state;
 };
 
 struct kvm_irq_mask_notifier {
@@ -587,8 +592,17 @@ static inline int kvm_deassign_device(struct kvm *kvm,
 
 static inline void kvm_guest_enter(void)
 {
+        BUG_ON(preemptible());
         account_system_vtime(current);
         current->flags |= PF_VCPU;
+        /* KVM does not hold any references to rcu protected data when it
+         * switches CPU into a guest mode. In fact switching to a guest mode
+         * is very similar to exiting to userspase from rcu point of view. In
+         * addition CPU may stay in a guest mode for quite a long time (up to
+         * one time slice). Lets treat guest mode as quiescent state, just like
+         * we do with user-mode execution.
+         */
+        rcu_virt_note_context_switch(smp_processor_id());
 }
 
 static inline void kvm_guest_exit(void)
@@ -597,6 +611,11 @@ static inline void kvm_guest_exit(void)
         current->flags &= ~PF_VCPU;
 }
 
+static inline int memslot_id(struct kvm *kvm, gfn_t gfn)
+{
+        return gfn_to_memslot(kvm, gfn)->id;
+}
+
 static inline unsigned long gfn_to_hva_memslot(struct kvm_memory_slot *slot,
                                                gfn_t gfn)
 {
diff --git a/include/linux/leds-pca9532.h b/include/linux/leds-pca9532.h
index f158eb1149aa..b8d6fffed4d8 100644
--- a/include/linux/leds-pca9532.h
+++ b/include/linux/leds-pca9532.h
@@ -25,7 +25,7 @@ enum pca9532_state {
 };
 
 enum pca9532_type { PCA9532_TYPE_NONE, PCA9532_TYPE_LED,
-        PCA9532_TYPE_N2100_BEEP };
+        PCA9532_TYPE_N2100_BEEP, PCA9532_TYPE_GPIO };
 
 struct pca9532_led {
         u8 id;
@@ -41,6 +41,7 @@ struct pca9532_platform_data {
         struct pca9532_led leds[16];
         u8 pwm[2];
         u8 psc[2];
+        int gpio_base;
 };
 
 #endif /* __LINUX_PCA9532_H */
diff --git a/include/linux/leds-regulator.h b/include/linux/leds-regulator.h
index 5a8eb389aab8..e2337a8c90b0 100644
--- a/include/linux/leds-regulator.h
+++ b/include/linux/leds-regulator.h
@@ -16,7 +16,7 @@
  * Use "vled" as supply id when declaring the regulator consumer:
  *
  * static struct regulator_consumer_supply pcap_regulator_VVIB_consumers [] = {
- *      { .dev_name = "leds-regulator.0", supply = "vled" },
+ *      { .dev_name = "leds-regulator.0", .supply = "vled" },
  * };
  *
  * If you have several regulator driven LEDs, you can append a numerical id to
diff --git a/include/linux/leds.h b/include/linux/leds.h
index 61e0340a4b77..5884def15a24 100644
--- a/include/linux/leds.h
+++ b/include/linux/leds.h
@@ -207,5 +207,7 @@ struct gpio_led_platform_data {
                                         unsigned long *delay_off);
 };
 
+struct platform_device *gpio_led_register_device(
+                int id, const struct gpio_led_platform_data *pdata);
 
 #endif          /* __LINUX_LEDS_H_INCLUDED */
diff --git a/include/linux/libata.h b/include/linux/libata.h
index 04f32a3eb26b..5a9926b34072 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -1151,6 +1151,7 @@ extern void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
                       ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
                       ata_postreset_fn_t postreset);
 extern void ata_std_error_handler(struct ata_port *ap);
+extern int ata_link_nr_enabled(struct ata_link *link);
 
 /*
  * Base operations to inherit from and initializers for sht
diff --git a/include/linux/linkage.h b/include/linux/linkage.h
index 7135ebc8428c..3f46aedea42f 100644
--- a/include/linux/linkage.h
+++ b/include/linux/linkage.h
@@ -14,10 +14,6 @@
 #define asmlinkage CPP_ASMLINKAGE
 #endif
 
-#ifndef asmregparm
-# define asmregparm
-#endif
-
 #define __page_aligned_data     __section(.data..page_aligned) __aligned(PAGE_SIZE)
 #define __page_aligned_bss      __section(.bss..page_aligned) __aligned(PAGE_SIZE)
 
diff --git a/include/linux/list.h b/include/linux/list.h
index 3a54266a1e85..cc6d2aa6b415 100644
--- a/include/linux/list.h
+++ b/include/linux/list.h
@@ -4,7 +4,7 @@
 #include <linux/types.h>
 #include <linux/stddef.h>
 #include <linux/poison.h>
-#include <linux/prefetch.h>
+#include <linux/const.h>
 
 /*
  * Simple doubly linked list implementation.
@@ -367,18 +367,15 @@ static inline void list_splice_tail_init(struct list_head *list,
  * @head:       the head for your list.
  */
 #define list_for_each(pos, head) \
-        for (pos = (head)->next; prefetch(pos->next), pos != (head); \
-                pos = pos->next)
+        for (pos = (head)->next; pos != (head); pos = pos->next)
 
 /**
  * __list_for_each      -       iterate over a list
  * @pos:        the &struct list_head to use as a loop cursor.
  * @head:       the head for your list.
  *
- * This variant differs from list_for_each() in that it's the
- * simplest possible list iteration code, no prefetching is done.
- * Use this for code that knows the list to be very short (empty
- * or 1 entry) most of the time.
+ * This variant doesn't differ from list_for_each() any more.
+ * We don't do prefetching in either case.
  */
 #define __list_for_each(pos, head) \
         for (pos = (head)->next; pos != (head); pos = pos->next)
@@ -389,8 +386,7 @@ static inline void list_splice_tail_init(struct list_head *list,
  * @head:       the head for your list.
  */
 #define list_for_each_prev(pos, head) \
-        for (pos = (head)->prev; prefetch(pos->prev), pos != (head); \
-                pos = pos->prev)
+        for (pos = (head)->prev; pos != (head); pos = pos->prev)
 
 /**
  * list_for_each_safe - iterate over a list safe against removal of list entry
@@ -410,7 +406,7 @@ static inline void list_splice_tail_init(struct list_head *list,
  */
 #define list_for_each_prev_safe(pos, n, head) \
         for (pos = (head)->prev, n = pos->prev; \
-             prefetch(pos->prev), pos != (head); \
+             pos != (head); \
              pos = n, n = pos->prev)
 
 /**
@@ -421,7 +417,7 @@ static inline void list_splice_tail_init(struct list_head *list,
  */
 #define list_for_each_entry(pos, head, member)                          \
         for (pos = list_entry((head)->next, typeof(*pos), member);      \
-             prefetch(pos->member.next), &pos->member != (head);        \
+             &pos->member != (head);    \
              pos = list_entry(pos->member.next, typeof(*pos), member))
 
 /**
@@ -432,7 +428,7 @@ static inline void list_splice_tail_init(struct list_head *list,
  */
 #define list_for_each_entry_reverse(pos, head, member)                  \
         for (pos = list_entry((head)->prev, typeof(*pos), member);      \
-             prefetch(pos->member.prev), &pos->member != (head);        \
+             &pos->member != (head);    \
              pos = list_entry(pos->member.prev, typeof(*pos), member))
 
 /**
@@ -457,7 +453,7 @@ static inline void list_splice_tail_init(struct list_head *list,
  */
 #define list_for_each_entry_continue(pos, head, member)                 \
         for (pos = list_entry(pos->member.next, typeof(*pos), member);  \
-             prefetch(pos->member.next), &pos->member != (head);        \
+             &pos->member != (head);    \
              pos = list_entry(pos->member.next, typeof(*pos), member))
 
 /**
@@ -471,7 +467,7 @@ static inline void list_splice_tail_init(struct list_head *list,
  */
 #define list_for_each_entry_continue_reverse(pos, head, member)         \
         for (pos = list_entry(pos->member.prev, typeof(*pos), member);  \
-             prefetch(pos->member.prev), &pos->member != (head);        \
+             &pos->member != (head);    \
              pos = list_entry(pos->member.prev, typeof(*pos), member))
 
 /**
@@ -483,7 +479,7 @@ static inline void list_splice_tail_init(struct list_head *list,
  * Iterate over list of given type, continuing from current position.
  */
 #define list_for_each_entry_from(pos, head, member)                     \
-        for (; prefetch(pos->member.next), &pos->member != (head);      \
+        for (; &pos->member != (head);  \
              pos = list_entry(pos->member.next, typeof(*pos), member))
 
 /**
@@ -664,8 +660,7 @@ static inline void hlist_move_list(struct hlist_head *old,
 #define hlist_entry(ptr, type, member) container_of(ptr,type,member)
 
 #define hlist_for_each(pos, head) \
-        for (pos = (head)->first; pos && ({ prefetch(pos->next); 1; }); \
-             pos = pos->next)
+        for (pos = (head)->first; pos ; pos = pos->next)
 
 #define hlist_for_each_safe(pos, n, head) \
         for (pos = (head)->first; pos && ({ n = pos->next; 1; }); \
@@ -680,7 +675,7 @@ static inline void hlist_move_list(struct hlist_head *old,
  */
 #define hlist_for_each_entry(tpos, pos, head, member)                    \
         for (pos = (head)->first;                                        \
-             pos && ({ prefetch(pos->next); 1;}) &&                      \
+             pos &&                                                      \
                 ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
              pos = pos->next)
 
@@ -692,7 +687,7 @@ static inline void hlist_move_list(struct hlist_head *old,
  */
 #define hlist_for_each_entry_continue(tpos, pos, member)                 \
         for (pos = (pos)->next;                                          \
-             pos && ({ prefetch(pos->next); 1;}) &&                      \
+             pos &&                                                      \
                 ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
              pos = pos->next)
 
@@ -703,7 +698,7 @@ static inline void hlist_move_list(struct hlist_head *old,
  * @member:     the name of the hlist_node within the struct.
  */
 #define hlist_for_each_entry_from(tpos, pos, member)                     \
-        for (; pos && ({ prefetch(pos->next); 1;}) &&                    \
+        for (; pos &&                                                    \
                 ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
              pos = pos->next)
 
diff --git a/include/linux/lockdep.h b/include/linux/lockdep.h
index 4aef1dda6406..ef820a3c378b 100644
--- a/include/linux/lockdep.h
+++ b/include/linux/lockdep.h
@@ -487,12 +487,15 @@ static inline void print_irqtrace_events(struct task_struct *curr)
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 # ifdef CONFIG_PROVE_LOCKING
 #  define mutex_acquire(l, s, t, i)             lock_acquire(l, s, t, 0, 2, NULL, i)
+#  define mutex_acquire_nest(l, s, t, n, i)     lock_acquire(l, s, t, 0, 2, n, i)
 # else
 #  define mutex_acquire(l, s, t, i)             lock_acquire(l, s, t, 0, 1, NULL, i)
+#  define mutex_acquire_nest(l, s, t, n, i)     lock_acquire(l, s, t, 0, 1, n, i)
 # endif
 # define mutex_release(l, n, i)                 lock_release(l, n, i)
 #else
 # define mutex_acquire(l, s, t, i)              do { } while (0)
+# define mutex_acquire_nest(l, s, t, n, i)      do { } while (0)
 # define mutex_release(l, n, i)                 do { } while (0)
 #endif
 
diff --git a/include/linux/lru_cache.h b/include/linux/lru_cache.h
index 6a4fab7c6e09..7a71ffad037c 100644
--- a/include/linux/lru_cache.h
+++ b/include/linux/lru_cache.h
@@ -139,9 +139,9 @@ write intent log information, three of which are mentioned here.
  * .list is on one of three lists:
  *  in_use: currently in use (refcnt > 0, lc_number != LC_FREE)
  *     lru: unused but ready to be reused or recycled
- *          (ts_refcnt == 0, lc_number != LC_FREE),
+ *          (lc_refcnt == 0, lc_number != LC_FREE),
  *    free: unused but ready to be recycled
- *          (ts_refcnt == 0, lc_number == LC_FREE),
+ *          (lc_refcnt == 0, lc_number == LC_FREE),
  *
  * an element is said to be "in the active set",
  * if either on "in_use" or "lru", i.e. lc_number != LC_FREE.
@@ -160,8 +160,8 @@ struct lc_element {
         struct hlist_node colision;
         struct list_head list;           /* LRU list or free list */
         unsigned refcnt;
-        /* back "pointer" into ts_cache->element[index],
-         * for paranoia, and for "ts_element_to_index" */
+        /* back "pointer" into lc_cache->element[index],
+         * for paranoia, and for "lc_element_to_index" */
         unsigned lc_index;
         /* if we want to track a larger set of objects,
          * it needs to become arch independend u64 */
@@ -190,8 +190,8 @@ struct lru_cache {
         /* Arbitrary limit on maximum tracked objects. Practical limit is much
          * lower due to allocation failures, probably. For typical use cases,
          * nr_elements should be a few thousand at most.
-         * This also limits the maximum value of ts_element.ts_index, allowing the
-         * 8 high bits of .ts_index to be overloaded with flags in the future. */
+         * This also limits the maximum value of lc_element.lc_index, allowing the
+         * 8 high bits of .lc_index to be overloaded with flags in the future. */
 #define LC_MAX_ACTIVE   (1<<24)
 
         /* statistics */
diff --git a/include/linux/lsm_audit.h b/include/linux/lsm_audit.h
index 112a55033352..88e78dedc2e8 100644
--- a/include/linux/lsm_audit.h
+++ b/include/linux/lsm_audit.h
@@ -27,7 +27,7 @@
 /* Auxiliary data to use in generating the audit record. */
 struct common_audit_data {
         char type;
-#define LSM_AUDIT_DATA_FS       1
+#define LSM_AUDIT_DATA_PATH     1
 #define LSM_AUDIT_DATA_NET      2
 #define LSM_AUDIT_DATA_CAP      3
 #define LSM_AUDIT_DATA_IPC      4
@@ -35,12 +35,13 @@ struct common_audit_data {
 #define LSM_AUDIT_DATA_KEY      6
 #define LSM_AUDIT_DATA_NONE     7
 #define LSM_AUDIT_DATA_KMOD     8
+#define LSM_AUDIT_DATA_INODE    9
+#define LSM_AUDIT_DATA_DENTRY   10
         struct task_struct *tsk;
         union   {
-                struct {
-                        struct path path;
-                        struct inode *inode;
-                } fs;
+                struct path path;
+                struct dentry *dentry;
+                struct inode *inode;
                 struct {
                         int netif;
                         struct sock *sk;
diff --git a/include/linux/memblock.h b/include/linux/memblock.h
index 62a10c2a11f2..7525e38c434d 100644
--- a/include/linux/memblock.h
+++ b/include/linux/memblock.h
@@ -2,6 +2,8 @@
 #define _LINUX_MEMBLOCK_H
 #ifdef __KERNEL__
 
+#define MEMBLOCK_ERROR  0
+
 #ifdef CONFIG_HAVE_MEMBLOCK
 /*
  * Logical memory blocks.
@@ -20,7 +22,6 @@
 #include <asm/memblock.h>
 
 #define INIT_MEMBLOCK_REGIONS   128
-#define MEMBLOCK_ERROR          0
 
 struct memblock_region {
         phys_addr_t base;
@@ -160,6 +161,12 @@ static inline unsigned long memblock_region_reserved_end_pfn(const struct memblo
 #define __initdata_memblock
 #endif
 
+#else
+static inline phys_addr_t memblock_alloc(phys_addr_t size, phys_addr_t align)
+{
+        return MEMBLOCK_ERROR;
+}
+
 #endif /* CONFIG_HAVE_MEMBLOCK */
 
 #endif /* __KERNEL__ */
diff --git a/include/linux/mempolicy.h b/include/linux/mempolicy.h
index 31ac26ca4acf..7978eec1b7d9 100644
--- a/include/linux/mempolicy.h
+++ b/include/linux/mempolicy.h
@@ -199,6 +199,9 @@ void mpol_free_shared_policy(struct shared_policy *p);
 struct mempolicy *mpol_shared_policy_lookup(struct shared_policy *sp,
                                             unsigned long idx);
 
+struct mempolicy *get_vma_policy(struct task_struct *tsk,
+                struct vm_area_struct *vma, unsigned long addr);
+
 extern void numa_default_policy(void);
 extern void numa_policy_init(void);
 extern void mpol_rebind_task(struct task_struct *tsk, const nodemask_t *new,
@@ -228,10 +231,10 @@ int do_migrate_pages(struct mm_struct *mm,
 
 #ifdef CONFIG_TMPFS
 extern int mpol_parse_str(char *str, struct mempolicy **mpol, int no_context);
+#endif
 
 extern int mpol_to_str(char *buffer, int maxlen, struct mempolicy *pol,
                         int no_context);
-#endif
 
 /* Check if a vma is migratable */
 static inline int vma_migratable(struct vm_area_struct *vma)
@@ -368,13 +371,13 @@ static inline int mpol_parse_str(char *str, struct mempolicy **mpol,
 {
         return 1;       /* error */
 }
+#endif
 
 static inline int mpol_to_str(char *buffer, int maxlen, struct mempolicy *pol,
                                 int no_context)
 {
         return 0;
 }
-#endif
 
 #endif /* CONFIG_NUMA */
 #endif /* __KERNEL__ */
diff --git a/include/linux/mfd/db5500-prcmu.h b/include/linux/mfd/db5500-prcmu.h
new file mode 100644
index 000000000000..f0977986402c
--- /dev/null
+++ b/include/linux/mfd/db5500-prcmu.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) ST-Ericsson SA 2010
+ *
+ * License Terms: GNU General Public License v2
+ *
+ * U5500 PRCMU API.
+ */
+#ifndef __MACH_PRCMU_U5500_H
+#define __MACH_PRCMU_U5500_H
+
+#ifdef CONFIG_UX500_SOC_DB5500
+
+void db5500_prcmu_early_init(void);
+
+int db5500_prcmu_abb_read(u8 slave, u8 reg, u8 *value, u8 size);
+int db5500_prcmu_abb_write(u8 slave, u8 reg, u8 *value, u8 size);
+
+#else /* !CONFIG_UX500_SOC_DB5500 */
+
+static inline void db5500_prcmu_early_init(void)
+{
+}
+
+static inline int db5500_prcmu_abb_read(u8 slave, u8 reg, u8 *value, u8 size)
+{
+        return -ENOSYS;
+}
+
+static inline int db5500_prcmu_abb_write(u8 slave, u8 reg, u8 *value, u8 size)
+{
+        return -ENOSYS;
+}
+
+#endif /* CONFIG_UX500_SOC_DB5500 */
+
+static inline int db5500_prcmu_config_abb_event_readout(u32 abb_events)
+{
+#ifdef CONFIG_MACH_U5500_SIMULATOR
+        return 0;
+#else
+        return -1;
+#endif
+}
+
+#endif /* __MACH_PRCMU_U5500_H */
diff --git a/include/linux/mfd/db8500-prcmu.h b/include/linux/mfd/db8500-prcmu.h
new file mode 100644
index 000000000000..917dbcab701c
--- /dev/null
+++ b/include/linux/mfd/db8500-prcmu.h
@@ -0,0 +1,978 @@
+/*
+ * Copyright (C) STMicroelectronics 2009
+ * Copyright (C) ST-Ericsson SA 2010
+ *
+ * License Terms: GNU General Public License v2
+ * Author: Kumar Sanghvi <kumar.sanghvi@stericsson.com>
+ *
+ * PRCMU f/w APIs
+ */
+#ifndef __MFD_DB8500_PRCMU_H
+#define __MFD_DB8500_PRCMU_H
+
+#include <linux/interrupt.h>
+#include <linux/notifier.h>
+
+/* This portion previously known as <mach/prcmu-fw-defs_v1.h> */
+
+/**
+ * enum state - ON/OFF state definition
+ * @OFF: State is ON
+ * @ON: State is OFF
+ *
+ */
+enum state {
+        OFF = 0x0,
+        ON  = 0x1,
+};
+
+/**
+ * enum ret_state - general purpose On/Off/Retention states
+ *
+ */
+enum ret_state {
+        OFFST = 0,
+        ONST  = 1,
+        RETST = 2
+};
+
+/**
+ * enum clk_arm - ARM Cortex A9 clock schemes
+ * @A9_OFF:
+ * @A9_BOOT:
+ * @A9_OPPT1:
+ * @A9_OPPT2:
+ * @A9_EXTCLK:
+ */
+enum clk_arm {
+        A9_OFF,
+        A9_BOOT,
+        A9_OPPT1,
+        A9_OPPT2,
+        A9_EXTCLK
+};
+
+/**
+ * enum clk_gen - GEN#0/GEN#1 clock schemes
+ * @GEN_OFF:
+ * @GEN_BOOT:
+ * @GEN_OPPT1:
+ */
+enum clk_gen {
+        GEN_OFF,
+        GEN_BOOT,
+        GEN_OPPT1,
+};
+
+/* some information between arm and xp70 */
+
+/**
+ * enum romcode_write - Romcode message written by A9 AND read by XP70
+ * @RDY_2_DS: Value set when ApDeepSleep state can be executed by XP70
+ * @RDY_2_XP70_RST: Value set when 0x0F has been successfully polled by the
+ *                 romcode. The xp70 will go into self-reset
+ */
+enum romcode_write {
+        RDY_2_DS = 0x09,
+        RDY_2_XP70_RST = 0x10
+};
+
+/**
+ * enum romcode_read - Romcode message written by XP70 and read by A9
+ * @INIT: Init value when romcode field is not used
+ * @FS_2_DS: Value set when power state is going from ApExecute to
+ *          ApDeepSleep
+ * @END_DS: Value set when ApDeepSleep power state is reached coming from
+ *         ApExecute state
+ * @DS_TO_FS: Value set when power state is going from ApDeepSleep to
+ *           ApExecute
+ * @END_FS: Value set when ApExecute power state is reached coming from
+ *         ApDeepSleep state
+ * @SWR: Value set when power state is going to ApReset
+ * @END_SWR: Value set when the xp70 finished executing ApReset actions and
+ *          waits for romcode acknowledgment to go to self-reset
+ */
+enum romcode_read {
+        INIT = 0x00,
+        FS_2_DS = 0x0A,
+        END_DS = 0x0B,
+        DS_TO_FS = 0x0C,
+        END_FS = 0x0D,
+        SWR = 0x0E,
+        END_SWR = 0x0F
+};
+
+/**
+ * enum ap_pwrst - current power states defined in PRCMU firmware
+ * @NO_PWRST: Current power state init
+ * @AP_BOOT: Current power state is apBoot
+ * @AP_EXECUTE: Current power state is apExecute
+ * @AP_DEEP_SLEEP: Current power state is apDeepSleep
+ * @AP_SLEEP: Current power state is apSleep
+ * @AP_IDLE: Current power state is apIdle
+ * @AP_RESET: Current power state is apReset
+ */
+enum ap_pwrst {
+        NO_PWRST = 0x00,
+        AP_BOOT = 0x01,
+        AP_EXECUTE = 0x02,
+        AP_DEEP_SLEEP = 0x03,
+        AP_SLEEP = 0x04,
+        AP_IDLE = 0x05,
+        AP_RESET = 0x06
+};
+
+/**
+ * enum ap_pwrst_trans - Transition states defined in PRCMU firmware
+ * @NO_TRANSITION: No power state transition
+ * @APEXECUTE_TO_APSLEEP: Power state transition from ApExecute to ApSleep
+ * @APIDLE_TO_APSLEEP: Power state transition from ApIdle to ApSleep
+ * @APBOOT_TO_APEXECUTE: Power state transition from ApBoot to ApExecute
+ * @APEXECUTE_TO_APDEEPSLEEP: Power state transition from ApExecute to
+ *                          ApDeepSleep
+ * @APEXECUTE_TO_APIDLE: Power state transition from ApExecute to ApIdle
+ */
+enum ap_pwrst_trans {
+        NO_TRANSITION                   = 0x00,
+        APEXECUTE_TO_APSLEEP            = 0x01,
+        APIDLE_TO_APSLEEP               = 0x02, /* To be removed */
+        PRCMU_AP_SLEEP                  = 0x01,
+        APBOOT_TO_APEXECUTE             = 0x03,
+        APEXECUTE_TO_APDEEPSLEEP        = 0x04, /* To be removed */
+        PRCMU_AP_DEEP_SLEEP             = 0x04,
+        APEXECUTE_TO_APIDLE             = 0x05, /* To be removed */
+        PRCMU_AP_IDLE                   = 0x05,
+        PRCMU_AP_DEEP_IDLE              = 0x07,
+};
+
+/**
+ * enum ddr_pwrst - DDR power states definition
+ * @DDR_PWR_STATE_UNCHANGED: SDRAM and DDR controller state is unchanged
+ * @DDR_PWR_STATE_ON:
+ * @DDR_PWR_STATE_OFFLOWLAT:
+ * @DDR_PWR_STATE_OFFHIGHLAT:
+ */
+enum ddr_pwrst {
+        DDR_PWR_STATE_UNCHANGED     = 0x00,
+        DDR_PWR_STATE_ON            = 0x01,
+        DDR_PWR_STATE_OFFLOWLAT     = 0x02,
+        DDR_PWR_STATE_OFFHIGHLAT    = 0x03
+};
+
+/**
+ * enum arm_opp - ARM OPP states definition
+ * @ARM_OPP_INIT:
+ * @ARM_NO_CHANGE: The ARM operating point is unchanged
+ * @ARM_100_OPP: The new ARM operating point is arm100opp
+ * @ARM_50_OPP: The new ARM operating point is arm50opp
+ * @ARM_MAX_OPP: Operating point is "max" (more than 100)
+ * @ARM_MAX_FREQ100OPP: Set max opp if available, else 100
+ * @ARM_EXTCLK: The new ARM operating point is armExtClk
+ */
+enum arm_opp {
+        ARM_OPP_INIT = 0x00,
+        ARM_NO_CHANGE = 0x01,
+        ARM_100_OPP = 0x02,
+        ARM_50_OPP = 0x03,
+        ARM_MAX_OPP = 0x04,
+        ARM_MAX_FREQ100OPP = 0x05,
+        ARM_EXTCLK = 0x07
+};
+
+/**
+ * enum ape_opp - APE OPP states definition
+ * @APE_OPP_INIT:
+ * @APE_NO_CHANGE: The APE operating point is unchanged
+ * @APE_100_OPP: The new APE operating point is ape100opp
+ * @APE_50_OPP: 50%
+ */
+enum ape_opp {
+        APE_OPP_INIT = 0x00,
+        APE_NO_CHANGE = 0x01,
+        APE_100_OPP = 0x02,
+        APE_50_OPP = 0x03
+};
+
+/**
+ * enum hw_acc_state - State definition for hardware accelerator
+ * @HW_NO_CHANGE: The hardware accelerator state must remain unchanged
+ * @HW_OFF: The hardware accelerator must be switched off
+ * @HW_OFF_RAMRET: The hardware accelerator must be switched off with its
+ *               internal RAM in retention
+ * @HW_ON: The hwa hardware accelerator hwa must be switched on
+ *
+ * NOTE! Deprecated, to be removed when all users switched over to use the
+ * regulator API.
+ */
+enum hw_acc_state {
+        HW_NO_CHANGE = 0x00,
+        HW_OFF = 0x01,
+        HW_OFF_RAMRET = 0x02,
+        HW_ON = 0x04
+};
+
+/**
+ * enum  mbox_2_arm_stat - Status messages definition for mbox_arm
+ * @BOOT_TO_EXECUTEOK: The apBoot to apExecute state transition has been
+ *                    completed
+ * @DEEPSLEEPOK: The apExecute to apDeepSleep state transition has been
+ *              completed
+ * @SLEEPOK: The apExecute to apSleep state transition has been completed
+ * @IDLEOK: The apExecute to apIdle state transition has been completed
+ * @SOFTRESETOK: The A9 watchdog/ SoftReset state has been completed
+ * @SOFTRESETGO : The A9 watchdog/SoftReset state is on going
+ * @BOOT_TO_EXECUTE: The apBoot to apExecute state transition is on going
+ * @EXECUTE_TO_DEEPSLEEP: The apExecute to apDeepSleep state transition is on
+ *                       going
+ * @DEEPSLEEP_TO_EXECUTE: The apDeepSleep to apExecute state transition is on
+ *                       going
+ * @DEEPSLEEP_TO_EXECUTEOK: The apDeepSleep to apExecute state transition has
+ *                         been completed
+ * @EXECUTE_TO_SLEEP: The apExecute to apSleep state transition is on going
+ * @SLEEP_TO_EXECUTE: The apSleep to apExecute state transition is on going
+ * @SLEEP_TO_EXECUTEOK: The apSleep to apExecute state transition has been
+ *                     completed
+ * @EXECUTE_TO_IDLE: The apExecute to apIdle state transition is on going
+ * @IDLE_TO_EXECUTE: The apIdle to apExecute state transition is on going
+ * @IDLE_TO_EXECUTEOK: The apIdle to apExecute state transition has been
+ *                    completed
+ * @INIT_STATUS: Status init
+ */
+enum ap_pwrsttr_status {
+        BOOT_TO_EXECUTEOK = 0xFF,
+        DEEPSLEEPOK = 0xFE,
+        SLEEPOK = 0xFD,
+        IDLEOK = 0xFC,
+        SOFTRESETOK = 0xFB,
+        SOFTRESETGO = 0xFA,
+        BOOT_TO_EXECUTE = 0xF9,
+        EXECUTE_TO_DEEPSLEEP = 0xF8,
+        DEEPSLEEP_TO_EXECUTE = 0xF7,
+        DEEPSLEEP_TO_EXECUTEOK = 0xF6,
+        EXECUTE_TO_SLEEP = 0xF5,
+        SLEEP_TO_EXECUTE = 0xF4,
+        SLEEP_TO_EXECUTEOK = 0xF3,
+        EXECUTE_TO_IDLE = 0xF2,
+        IDLE_TO_EXECUTE = 0xF1,
+        IDLE_TO_EXECUTEOK = 0xF0,
+        RDYTODS_RETURNTOEXE    = 0xEF,
+        NORDYTODS_RETURNTOEXE  = 0xEE,
+        EXETOSLEEP_RETURNTOEXE = 0xED,
+        EXETOIDLE_RETURNTOEXE  = 0xEC,
+        INIT_STATUS = 0xEB,
+
+        /*error messages */
+        INITERROR                     = 0x00,
+        PLLARMLOCKP_ER                = 0x01,
+        PLLDDRLOCKP_ER                = 0x02,
+        PLLSOCLOCKP_ER                = 0x03,
+        PLLSOCK1LOCKP_ER              = 0x04,
+        ARMWFI_ER                     = 0x05,
+        SYSCLKOK_ER                   = 0x06,
+        I2C_NACK_DATA_ER              = 0x07,
+        BOOT_ER                       = 0x08,
+        I2C_STATUS_ALWAYS_1           = 0x0A,
+        I2C_NACK_REG_ADDR_ER          = 0x0B,
+        I2C_NACK_DATA0123_ER          = 0x1B,
+        I2C_NACK_ADDR_ER              = 0x1F,
+        CURAPPWRSTISNOT_BOOT          = 0x20,
+        CURAPPWRSTISNOT_EXECUTE       = 0x21,
+        CURAPPWRSTISNOT_SLEEPMODE     = 0x22,
+        CURAPPWRSTISNOT_CORRECTFORIT10 = 0x23,
+        FIFO4500WUISNOT_WUPEVENT      = 0x24,
+        PLL32KLOCKP_ER                = 0x29,
+        DDRDEEPSLEEPOK_ER             = 0x2A,
+        ROMCODEREADY_ER               = 0x50,
+        WUPBEFOREDS                   = 0x51,
+        DDRCONFIG_ER                  = 0x52,
+        WUPBEFORESLEEP                = 0x53,
+        WUPBEFOREIDLE                 = 0x54
+};  /* earlier called as  mbox_2_arm_stat */
+
+/**
+ * enum dvfs_stat - DVFS status messages definition
+ * @DVFS_GO: A state transition DVFS is on going
+ * @DVFS_ARM100OPPOK: The state transition DVFS has been completed for 100OPP
+ * @DVFS_ARM50OPPOK: The state transition DVFS has been completed for 50OPP
+ * @DVFS_ARMEXTCLKOK: The state transition DVFS has been completed for EXTCLK
+ * @DVFS_NOCHGTCLKOK: The state transition DVFS has been completed for
+ *                   NOCHGCLK
+ * @DVFS_INITSTATUS: Value init
+ */
+enum dvfs_stat {
+        DVFS_GO = 0xFF,
+        DVFS_ARM100OPPOK = 0xFE,
+        DVFS_ARM50OPPOK = 0xFD,
+        DVFS_ARMEXTCLKOK = 0xFC,
+        DVFS_NOCHGTCLKOK = 0xFB,
+        DVFS_INITSTATUS = 0x00
+};
+
+/**
+ * enum sva_mmdsp_stat - SVA MMDSP status messages
+ * @SVA_MMDSP_GO: SVAMMDSP interrupt has happened
+ * @SVA_MMDSP_INIT: Status init
+ */
+enum sva_mmdsp_stat {
+        SVA_MMDSP_GO = 0xFF,
+        SVA_MMDSP_INIT = 0x00
+};
+
+/**
+ * enum sia_mmdsp_stat - SIA MMDSP status messages
+ * @SIA_MMDSP_GO: SIAMMDSP interrupt has happened
+ * @SIA_MMDSP_INIT: Status init
+ */
+enum sia_mmdsp_stat {
+        SIA_MMDSP_GO = 0xFF,
+        SIA_MMDSP_INIT = 0x00
+};
+
+/**
+ * enum  mbox_to_arm_err - Error messages definition
+ * @INIT_ERR: Init value
+ * @PLLARMLOCKP_ERR: PLLARM has not been correctly locked in given time
+ * @PLLDDRLOCKP_ERR: PLLDDR has not been correctly locked in the given time
+ * @PLLSOC0LOCKP_ERR: PLLSOC0 has not been correctly locked in the given time
+ * @PLLSOC1LOCKP_ERR: PLLSOC1 has not been correctly locked in the given time
+ * @ARMWFI_ERR: The ARM WFI has not been correctly executed in the given time
+ * @SYSCLKOK_ERR: The SYSCLK is not available in the given time
+ * @BOOT_ERR: Romcode has not validated the XP70 self reset in the given time
+ * @ROMCODESAVECONTEXT: The Romcode didn.t correctly save it secure context
+ * @VARMHIGHSPEEDVALTO_ERR: The ARM high speed supply value transfered
+ *          through I2C has not been correctly executed in the given time
+ * @VARMHIGHSPEEDACCESS_ERR: The command value of VarmHighSpeedVal transfered
+ *             through I2C has not been correctly executed in the given time
+ * @VARMLOWSPEEDVALTO_ERR:The ARM low speed supply value transfered through
+ *                     I2C has not been correctly executed in the given time
+ * @VARMLOWSPEEDACCESS_ERR: The command value of VarmLowSpeedVal transfered
+ *             through I2C has not been correctly executed in the given time
+ * @VARMRETENTIONVALTO_ERR: The ARM retention supply value transfered through
+ *                     I2C has not been correctly executed in the given time
+ * @VARMRETENTIONACCESS_ERR: The command value of VarmRetentionVal transfered
+ *             through I2C has not been correctly executed in the given time
+ * @VAPEHIGHSPEEDVALTO_ERR: The APE highspeed supply value transfered through
+ *                     I2C has not been correctly executed in the given time
+ * @VSAFEHPVALTO_ERR: The SAFE high power supply value transfered through I2C
+ *                         has not been correctly executed in the given time
+ * @VMODSEL1VALTO_ERR: The MODEM sel1 supply value transfered through I2C has
+ *                             not been correctly executed in the given time
+ * @VMODSEL2VALTO_ERR: The MODEM sel2 supply value transfered through I2C has
+ *                             not been correctly executed in the given time
+ * @VARMOFFACCESS_ERR: The command value of Varm ON/OFF transfered through
+ *                     I2C has not been correctly executed in the given time
+ * @VAPEOFFACCESS_ERR: The command value of Vape ON/OFF transfered through
+ *                     I2C has not been correctly executed in the given time
+ * @VARMRETACCES_ERR: The command value of Varm retention ON/OFF transfered
+ *             through I2C has not been correctly executed in the given time
+ * @CURAPPWRSTISNOTBOOT:Generated when Arm want to do power state transition
+ *             ApBoot to ApExecute but the power current state is not Apboot
+ * @CURAPPWRSTISNOTEXECUTE: Generated when Arm want to do power state
+ *              transition from ApExecute to others power state but the
+ *              power current state is not ApExecute
+ * @CURAPPWRSTISNOTSLEEPMODE: Generated when wake up events are transmitted
+ *             but the power current state is not ApDeepSleep/ApSleep/ApIdle
+ * @CURAPPWRSTISNOTCORRECTDBG:  Generated when wake up events are transmitted
+ *              but the power current state is not correct
+ * @ARMREGU1VALTO_ERR:The ArmRegu1 value transferred through I2C has not
+ *                    been correctly executed in the given time
+ * @ARMREGU2VALTO_ERR: The ArmRegu2 value transferred through I2C has not
+ *                    been correctly executed in the given time
+ * @VAPEREGUVALTO_ERR: The VApeRegu value transfered through I2C has not
+ *                    been correctly executed in the given time
+ * @VSMPS3REGUVALTO_ERR: The VSmps3Regu value transfered through I2C has not
+ *                      been correctly executed in the given time
+ * @VMODREGUVALTO_ERR: The VModemRegu value transfered through I2C has not
+ *                    been correctly executed in the given time
+ */
+enum mbox_to_arm_err {
+        INIT_ERR = 0x00,
+        PLLARMLOCKP_ERR = 0x01,
+        PLLDDRLOCKP_ERR = 0x02,
+        PLLSOC0LOCKP_ERR = 0x03,
+        PLLSOC1LOCKP_ERR = 0x04,
+        ARMWFI_ERR = 0x05,
+        SYSCLKOK_ERR = 0x06,
+        BOOT_ERR = 0x07,
+        ROMCODESAVECONTEXT = 0x08,
+        VARMHIGHSPEEDVALTO_ERR = 0x10,
+        VARMHIGHSPEEDACCESS_ERR = 0x11,
+        VARMLOWSPEEDVALTO_ERR = 0x12,
+        VARMLOWSPEEDACCESS_ERR = 0x13,
+        VARMRETENTIONVALTO_ERR = 0x14,
+        VARMRETENTIONACCESS_ERR = 0x15,
+        VAPEHIGHSPEEDVALTO_ERR = 0x16,
+        VSAFEHPVALTO_ERR = 0x17,
+        VMODSEL1VALTO_ERR = 0x18,
+        VMODSEL2VALTO_ERR = 0x19,
+        VARMOFFACCESS_ERR = 0x1A,
+        VAPEOFFACCESS_ERR = 0x1B,
+        VARMRETACCES_ERR = 0x1C,
+        CURAPPWRSTISNOTBOOT = 0x20,
+        CURAPPWRSTISNOTEXECUTE = 0x21,
+        CURAPPWRSTISNOTSLEEPMODE = 0x22,
+        CURAPPWRSTISNOTCORRECTDBG = 0x23,
+        ARMREGU1VALTO_ERR = 0x24,
+        ARMREGU2VALTO_ERR = 0x25,
+        VAPEREGUVALTO_ERR = 0x26,
+        VSMPS3REGUVALTO_ERR = 0x27,
+        VMODREGUVALTO_ERR = 0x28
+};
+
+enum hw_acc {
+        SVAMMDSP = 0,
+        SVAPIPE = 1,
+        SIAMMDSP = 2,
+        SIAPIPE = 3,
+        SGA = 4,
+        B2R2MCDE = 5,
+        ESRAM12 = 6,
+        ESRAM34 = 7,
+};
+
+enum cs_pwrmgt {
+        PWRDNCS0  = 0,
+        WKUPCS0   = 1,
+        PWRDNCS1  = 2,
+        WKUPCS1   = 3
+};
+
+/* Defs related to autonomous power management */
+
+/**
+ * enum sia_sva_pwr_policy - Power policy
+ * @NO_CHGT:    No change
+ * @DSPOFF_HWPOFF:
+ * @DSPOFFRAMRET_HWPOFF:
+ * @DSPCLKOFF_HWPOFF:
+ * @DSPCLKOFF_HWPCLKOFF:
+ *
+ */
+enum sia_sva_pwr_policy {
+        NO_CHGT                 = 0x0,
+        DSPOFF_HWPOFF           = 0x1,
+        DSPOFFRAMRET_HWPOFF     = 0x2,
+        DSPCLKOFF_HWPOFF        = 0x3,
+        DSPCLKOFF_HWPCLKOFF     = 0x4,
+};
+
+/**
+ * enum auto_enable - Auto Power enable
+ * @AUTO_OFF:
+ * @AUTO_ON:
+ *
+ */
+enum auto_enable {
+        AUTO_OFF        = 0x0,
+        AUTO_ON         = 0x1,
+};
+
+/* End of file previously known as prcmu-fw-defs_v1.h */
+
+/* PRCMU Wakeup defines */
+enum prcmu_wakeup_index {
+        PRCMU_WAKEUP_INDEX_RTC,
+        PRCMU_WAKEUP_INDEX_RTT0,
+        PRCMU_WAKEUP_INDEX_RTT1,
+        PRCMU_WAKEUP_INDEX_HSI0,
+        PRCMU_WAKEUP_INDEX_HSI1,
+        PRCMU_WAKEUP_INDEX_USB,
+        PRCMU_WAKEUP_INDEX_ABB,
+        PRCMU_WAKEUP_INDEX_ABB_FIFO,
+        PRCMU_WAKEUP_INDEX_ARM,
+        NUM_PRCMU_WAKEUP_INDICES
+};
+#define PRCMU_WAKEUP(_name) (BIT(PRCMU_WAKEUP_INDEX_##_name))
+
+/* PRCMU QoS APE OPP class */
+#define PRCMU_QOS_APE_OPP 1
+#define PRCMU_QOS_DDR_OPP 2
+#define PRCMU_QOS_DEFAULT_VALUE -1
+
+/**
+ * enum hw_acc_dev - enum for hw accelerators
+ * @HW_ACC_SVAMMDSP: for SVAMMDSP
+ * @HW_ACC_SVAPIPE:  for SVAPIPE
+ * @HW_ACC_SIAMMDSP: for SIAMMDSP
+ * @HW_ACC_SIAPIPE: for SIAPIPE
+ * @HW_ACC_SGA: for SGA
+ * @HW_ACC_B2R2: for B2R2
+ * @HW_ACC_MCDE: for MCDE
+ * @HW_ACC_ESRAM1: for ESRAM1
+ * @HW_ACC_ESRAM2: for ESRAM2
+ * @HW_ACC_ESRAM3: for ESRAM3
+ * @HW_ACC_ESRAM4: for ESRAM4
+ * @NUM_HW_ACC: number of hardware accelerators
+ *
+ * Different hw accelerators which can be turned ON/
+ * OFF or put into retention (MMDSPs and ESRAMs).
+ * Used with EPOD API.
+ *
+ * NOTE! Deprecated, to be removed when all users switched over to use the
+ * regulator API.
+ */
+enum hw_acc_dev {
+        HW_ACC_SVAMMDSP,
+        HW_ACC_SVAPIPE,
+        HW_ACC_SIAMMDSP,
+        HW_ACC_SIAPIPE,
+        HW_ACC_SGA,
+        HW_ACC_B2R2,
+        HW_ACC_MCDE,
+        HW_ACC_ESRAM1,
+        HW_ACC_ESRAM2,
+        HW_ACC_ESRAM3,
+        HW_ACC_ESRAM4,
+        NUM_HW_ACC
+};
+
+/*
+ * Ids for all EPODs (power domains)
+ * - EPOD_ID_SVAMMDSP: power domain for SVA MMDSP
+ * - EPOD_ID_SVAPIPE: power domain for SVA pipe
+ * - EPOD_ID_SIAMMDSP: power domain for SIA MMDSP
+ * - EPOD_ID_SIAPIPE: power domain for SIA pipe
+ * - EPOD_ID_SGA: power domain for SGA
+ * - EPOD_ID_B2R2_MCDE: power domain for B2R2 and MCDE
+ * - EPOD_ID_ESRAM12: power domain for ESRAM 1 and 2
+ * - EPOD_ID_ESRAM34: power domain for ESRAM 3 and 4
+ * - NUM_EPOD_ID: number of power domains
+ */
+#define EPOD_ID_SVAMMDSP        0
+#define EPOD_ID_SVAPIPE         1
+#define EPOD_ID_SIAMMDSP        2
+#define EPOD_ID_SIAPIPE         3
+#define EPOD_ID_SGA             4
+#define EPOD_ID_B2R2_MCDE       5
+#define EPOD_ID_ESRAM12         6
+#define EPOD_ID_ESRAM34         7
+#define NUM_EPOD_ID             8
+
+/*
+ * state definition for EPOD (power domain)
+ * - EPOD_STATE_NO_CHANGE: The EPOD should remain unchanged
+ * - EPOD_STATE_OFF: The EPOD is switched off
+ * - EPOD_STATE_RAMRET: The EPOD is switched off with its internal RAM in
+ *                         retention
+ * - EPOD_STATE_ON_CLK_OFF: The EPOD is switched on, clock is still off
+ * - EPOD_STATE_ON: Same as above, but with clock enabled
+ */
+#define EPOD_STATE_NO_CHANGE    0x00
+#define EPOD_STATE_OFF          0x01
+#define EPOD_STATE_RAMRET       0x02
+#define EPOD_STATE_ON_CLK_OFF   0x03
+#define EPOD_STATE_ON           0x04
+
+/*
+ * CLKOUT sources
+ */
+#define PRCMU_CLKSRC_CLK38M             0x00
+#define PRCMU_CLKSRC_ACLK               0x01
+#define PRCMU_CLKSRC_SYSCLK             0x02
+#define PRCMU_CLKSRC_LCDCLK             0x03
+#define PRCMU_CLKSRC_SDMMCCLK           0x04
+#define PRCMU_CLKSRC_TVCLK              0x05
+#define PRCMU_CLKSRC_TIMCLK             0x06
+#define PRCMU_CLKSRC_CLK009             0x07
+/* These are only valid for CLKOUT1: */
+#define PRCMU_CLKSRC_SIAMMDSPCLK        0x40
+#define PRCMU_CLKSRC_I2CCLK             0x41
+#define PRCMU_CLKSRC_MSP02CLK           0x42
+#define PRCMU_CLKSRC_ARMPLL_OBSCLK      0x43
+#define PRCMU_CLKSRC_HSIRXCLK           0x44
+#define PRCMU_CLKSRC_HSITXCLK           0x45
+#define PRCMU_CLKSRC_ARMCLKFIX          0x46
+#define PRCMU_CLKSRC_HDMICLK            0x47
+
+/*
+ * Definitions for autonomous power management configuration.
+ */
+
+#define PRCMU_AUTO_PM_OFF 0
+#define PRCMU_AUTO_PM_ON 1
+
+#define PRCMU_AUTO_PM_POWER_ON_HSEM BIT(0)
+#define PRCMU_AUTO_PM_POWER_ON_ABB_FIFO_IT BIT(1)
+
+enum prcmu_auto_pm_policy {
+        PRCMU_AUTO_PM_POLICY_NO_CHANGE,
+        PRCMU_AUTO_PM_POLICY_DSP_OFF_HWP_OFF,
+        PRCMU_AUTO_PM_POLICY_DSP_OFF_RAMRET_HWP_OFF,
+        PRCMU_AUTO_PM_POLICY_DSP_CLK_OFF_HWP_OFF,
+        PRCMU_AUTO_PM_POLICY_DSP_CLK_OFF_HWP_CLK_OFF,
+};
+
+/**
+ * struct prcmu_auto_pm_config - Autonomous power management configuration.
+ * @sia_auto_pm_enable: SIA autonomous pm enable. (PRCMU_AUTO_PM_{OFF,ON})
+ * @sia_power_on:       SIA power ON enable. (PRCMU_AUTO_PM_POWER_ON_* bitmask)
+ * @sia_policy:         SIA power policy. (enum prcmu_auto_pm_policy)
+ * @sva_auto_pm_enable: SVA autonomous pm enable. (PRCMU_AUTO_PM_{OFF,ON})
+ * @sva_power_on:       SVA power ON enable. (PRCMU_AUTO_PM_POWER_ON_* bitmask)
+ * @sva_policy:         SVA power policy. (enum prcmu_auto_pm_policy)
+ */
+struct prcmu_auto_pm_config {
+        u8 sia_auto_pm_enable;
+        u8 sia_power_on;
+        u8 sia_policy;
+        u8 sva_auto_pm_enable;
+        u8 sva_power_on;
+        u8 sva_policy;
+};
+
+/**
+ * enum ddr_opp - DDR OPP states definition
+ * @DDR_100_OPP: The new DDR operating point is ddr100opp
+ * @DDR_50_OPP: The new DDR operating point is ddr50opp
+ * @DDR_25_OPP: The new DDR operating point is ddr25opp
+ */
+enum ddr_opp {
+        DDR_100_OPP = 0x00,
+        DDR_50_OPP = 0x01,
+        DDR_25_OPP = 0x02,
+};
+
+/*
+ * Clock identifiers.
+ */
+enum prcmu_clock {
+        PRCMU_SGACLK,
+        PRCMU_UARTCLK,
+        PRCMU_MSP02CLK,
+        PRCMU_MSP1CLK,
+        PRCMU_I2CCLK,
+        PRCMU_SDMMCCLK,
+        PRCMU_SLIMCLK,
+        PRCMU_PER1CLK,
+        PRCMU_PER2CLK,
+        PRCMU_PER3CLK,
+        PRCMU_PER5CLK,
+        PRCMU_PER6CLK,
+        PRCMU_PER7CLK,
+        PRCMU_LCDCLK,
+        PRCMU_BMLCLK,
+        PRCMU_HSITXCLK,
+        PRCMU_HSIRXCLK,
+        PRCMU_HDMICLK,
+        PRCMU_APEATCLK,
+        PRCMU_APETRACECLK,
+        PRCMU_MCDECLK,
+        PRCMU_IPI2CCLK,
+        PRCMU_DSIALTCLK,
+        PRCMU_DMACLK,
+        PRCMU_B2R2CLK,
+        PRCMU_TVCLK,
+        PRCMU_SSPCLK,
+        PRCMU_RNGCLK,
+        PRCMU_UICCCLK,
+        PRCMU_NUM_REG_CLOCKS,
+        PRCMU_SYSCLK = PRCMU_NUM_REG_CLOCKS,
+        PRCMU_TIMCLK,
+};
+
+/*
+ * Definitions for controlling ESRAM0 in deep sleep.
+ */
+#define ESRAM0_DEEP_SLEEP_STATE_OFF 1
+#define ESRAM0_DEEP_SLEEP_STATE_RET 2
+
+#ifdef CONFIG_MFD_DB8500_PRCMU
+void __init prcmu_early_init(void);
+int prcmu_set_display_clocks(void);
+int prcmu_disable_dsipll(void);
+int prcmu_enable_dsipll(void);
+#else
+static inline void __init prcmu_early_init(void) {}
+#endif
+
+#ifdef CONFIG_MFD_DB8500_PRCMU
+
+int prcmu_set_rc_a2p(enum romcode_write);
+enum romcode_read prcmu_get_rc_p2a(void);
+enum ap_pwrst prcmu_get_xp70_current_state(void);
+int prcmu_set_power_state(u8 state, bool keep_ulp_clk, bool keep_ap_pll);
+
+void prcmu_enable_wakeups(u32 wakeups);
+static inline void prcmu_disable_wakeups(void)
+{
+        prcmu_enable_wakeups(0);
+}
+
+void prcmu_config_abb_event_readout(u32 abb_events);
+void prcmu_get_abb_event_buffer(void __iomem **buf);
+int prcmu_set_arm_opp(u8 opp);
+int prcmu_get_arm_opp(void);
+bool prcmu_has_arm_maxopp(void);
+bool prcmu_is_u8400(void);
+int prcmu_set_ape_opp(u8 opp);
+int prcmu_get_ape_opp(void);
+int prcmu_request_ape_opp_100_voltage(bool enable);
+int prcmu_release_usb_wakeup_state(void);
+int prcmu_set_ddr_opp(u8 opp);
+int prcmu_get_ddr_opp(void);
+unsigned long prcmu_qos_get_cpufreq_opp_delay(void);
+void prcmu_qos_set_cpufreq_opp_delay(unsigned long);
+/* NOTE! Use regulator framework instead */
+int prcmu_set_hwacc(u16 hw_acc_dev, u8 state);
+int prcmu_set_epod(u16 epod_id, u8 epod_state);
+void prcmu_configure_auto_pm(struct prcmu_auto_pm_config *sleep,
+        struct prcmu_auto_pm_config *idle);
+bool prcmu_is_auto_pm_enabled(void);
+
+int prcmu_config_clkout(u8 clkout, u8 source, u8 div);
+int prcmu_request_clock(u8 clock, bool enable);
+int prcmu_set_clock_divider(u8 clock, u8 divider);
+int prcmu_config_esram0_deep_sleep(u8 state);
+int prcmu_config_hotdog(u8 threshold);
+int prcmu_config_hotmon(u8 low, u8 high);
+int prcmu_start_temp_sense(u16 cycles32k);
+int prcmu_stop_temp_sense(void);
+int prcmu_abb_read(u8 slave, u8 reg, u8 *value, u8 size);
+int prcmu_abb_write(u8 slave, u8 reg, u8 *value, u8 size);
+
+void prcmu_ac_wake_req(void);
+void prcmu_ac_sleep_req(void);
+void prcmu_system_reset(u16 reset_code);
+void prcmu_modem_reset(void);
+bool prcmu_is_ac_wake_requested(void);
+void prcmu_enable_spi2(void);
+void prcmu_disable_spi2(void);
+
+#else /* !CONFIG_MFD_DB8500_PRCMU */
+
+static inline int prcmu_set_rc_a2p(enum romcode_write code)
+{
+        return 0;
+}
+
+static inline enum romcode_read prcmu_get_rc_p2a(void)
+{
+        return INIT;
+}
+
+static inline enum ap_pwrst prcmu_get_xp70_current_state(void)
+{
+        return AP_EXECUTE;
+}
+
+static inline int prcmu_set_power_state(u8 state, bool keep_ulp_clk,
+        bool keep_ap_pll)
+{
+        return 0;
+}
+
+static inline void prcmu_enable_wakeups(u32 wakeups) {}
+
+static inline void prcmu_disable_wakeups(void) {}
+
+static inline void prcmu_config_abb_event_readout(u32 abb_events) {}
+
+static inline int prcmu_set_arm_opp(u8 opp)
+{
+        return 0;
+}
+
+static inline int prcmu_get_arm_opp(void)
+{
+        return ARM_100_OPP;
+}
+
+static bool prcmu_has_arm_maxopp(void)
+{
+        return false;
+}
+
+static bool prcmu_is_u8400(void)
+{
+        return false;
+}
+
+static inline int prcmu_set_ape_opp(u8 opp)
+{
+        return 0;
+}
+
+static inline int prcmu_get_ape_opp(void)
+{
+        return APE_100_OPP;
+}
+
+static inline int prcmu_request_ape_opp_100_voltage(bool enable)
+{
+        return 0;
+}
+
+static inline int prcmu_release_usb_wakeup_state(void)
+{
+        return 0;
+}
+
+static inline int prcmu_set_ddr_opp(u8 opp)
+{
+        return 0;
+}
+
+static inline int prcmu_get_ddr_opp(void)
+{
+        return DDR_100_OPP;
+}
+
+static inline unsigned long prcmu_qos_get_cpufreq_opp_delay(void)
+{
+        return 0;
+}
+
+static inline void prcmu_qos_set_cpufreq_opp_delay(unsigned long n) {}
+
+static inline int prcmu_set_hwacc(u16 hw_acc_dev, u8 state)
+{
+        return 0;
+}
+
+static inline void prcmu_configure_auto_pm(struct prcmu_auto_pm_config *sleep,
+        struct prcmu_auto_pm_config *idle)
+{
+}
+
+static inline bool prcmu_is_auto_pm_enabled(void)
+{
+        return false;
+}
+
+static inline int prcmu_config_clkout(u8 clkout, u8 source, u8 div)
+{
+        return 0;
+}
+
+static inline int prcmu_request_clock(u8 clock, bool enable)
+{
+        return 0;
+}
+
+static inline int prcmu_set_clock_divider(u8 clock, u8 divider)
+{
+        return 0;
+}
+
+int prcmu_config_esram0_deep_sleep(u8 state)
+{
+        return 0;
+}
+
+static inline int prcmu_config_hotdog(u8 threshold)
+{
+        return 0;
+}
+
+static inline int prcmu_config_hotmon(u8 low, u8 high)
+{
+        return 0;
+}
+
+static inline int prcmu_start_temp_sense(u16 cycles32k)
+{
+        return 0;
+}
+
+static inline int prcmu_stop_temp_sense(void)
+{
+        return 0;
+}
+
+static inline int prcmu_abb_read(u8 slave, u8 reg, u8 *value, u8 size)
+{
+        return -ENOSYS;
+}
+
+static inline int prcmu_abb_write(u8 slave, u8 reg, u8 *value, u8 size)
+{
+        return -ENOSYS;
+}
+
+static inline void prcmu_ac_wake_req(void) {}
+
+static inline void prcmu_ac_sleep_req(void) {}
+
+static inline void prcmu_system_reset(u16 reset_code) {}
+
+static inline void prcmu_modem_reset(void) {}
+
+static inline bool prcmu_is_ac_wake_requested(void)
+{
+        return false;
+}
+
+#ifndef CONFIG_UX500_SOC_DB5500
+static inline int prcmu_set_display_clocks(void)
+{
+        return 0;
+}
+
+static inline int prcmu_disable_dsipll(void)
+{
+        return 0;
+}
+
+static inline int prcmu_enable_dsipll(void)
+{
+        return 0;
+}
+#endif
+
+static inline int prcmu_enable_spi2(void)
+{
+        return 0;
+}
+
+static inline int prcmu_disable_spi2(void)
+{
+        return 0;
+}
+
+#endif /* !CONFIG_MFD_DB8500_PRCMU */
+
+#ifdef CONFIG_UX500_PRCMU_QOS_POWER
+int prcmu_qos_requirement(int pm_qos_class);
+int prcmu_qos_add_requirement(int pm_qos_class, char *name, s32 value);
+int prcmu_qos_update_requirement(int pm_qos_class, char *name, s32 new_value);
+void prcmu_qos_remove_requirement(int pm_qos_class, char *name);
+int prcmu_qos_add_notifier(int prcmu_qos_class,
+                           struct notifier_block *notifier);
+int prcmu_qos_remove_notifier(int prcmu_qos_class,
+                              struct notifier_block *notifier);
+#else
+static inline int prcmu_qos_requirement(int prcmu_qos_class)
+{
+        return 0;
+}
+
+static inline int prcmu_qos_add_requirement(int prcmu_qos_class,
+                                            char *name, s32 value)
+{
+        return 0;
+}
+
+static inline int prcmu_qos_update_requirement(int prcmu_qos_class,
+                                               char *name, s32 new_value)
+{
+        return 0;
+}
+
+static inline void prcmu_qos_remove_requirement(int prcmu_qos_class, char *name)
+{
+}
+
+static inline int prcmu_qos_add_notifier(int prcmu_qos_class,
+                                         struct notifier_block *notifier)
+{
+        return 0;
+}
+static inline int prcmu_qos_remove_notifier(int prcmu_qos_class,
+                                            struct notifier_block *notifier)
+{
+        return 0;
+}
+
+#endif
+
+#endif /* __MFD_DB8500_PRCMU_H */
diff --git a/include/linux/mfd/tmio.h b/include/linux/mfd/tmio.h
index 8e70310ee945..5a90266c3a5a 100644
--- a/include/linux/mfd/tmio.h
+++ b/include/linux/mfd/tmio.h
@@ -4,6 +4,7 @@
 #include <linux/fb.h>
 #include <linux/io.h>
 #include <linux/platform_device.h>
+#include <linux/pm_runtime.h>
 
 #define tmio_ioread8(addr) readb(addr)
 #define tmio_ioread16(addr) readw(addr)
@@ -61,6 +62,12 @@
  * Some controllers can support SDIO IRQ signalling.
  */
 #define TMIO_MMC_SDIO_IRQ               (1 << 2)
+/*
+ * Some platforms can detect card insertion events with controller powered
+ * down, in which case they have to call tmio_mmc_cd_wakeup() to power up the
+ * controller and report the event to the driver.
+ */
+#define TMIO_MMC_HAS_COLD_CD            (1 << 3)
 
 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);
@@ -82,11 +89,21 @@ struct tmio_mmc_data {
         unsigned long                   flags;
         u32                             ocr_mask;       /* available voltages */
         struct tmio_mmc_dma             *dma;
+        struct device                   *dev;
+        bool                            power;
         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);
 };
 
+static inline void tmio_mmc_cd_wakeup(struct tmio_mmc_data *pdata)
+{
+        if (pdata && !pdata->power) {
+                pdata->power = true;
+                pm_runtime_get(pdata->dev);
+        }
+}
+
 /*
  * data for the NAND controller
  */
diff --git a/include/linux/mfd/wm8994/pdata.h b/include/linux/mfd/wm8994/pdata.h
index 466b1c777aff..d12f8d635a81 100644
--- a/include/linux/mfd/wm8994/pdata.h
+++ b/include/linux/mfd/wm8994/pdata.h
@@ -32,6 +32,10 @@ struct wm8994_ldo_pdata {
 #define WM8994_EQ_REGS  20
 #define WM8958_MBC_CUTOFF_REGS 20
 #define WM8958_MBC_COEFF_REGS  48
+#define WM8958_MBC_COMBINED_REGS 56
+#define WM8958_VSS_HPF_REGS 2
+#define WM8958_VSS_REGS 148
+#define WM8958_ENH_EQ_REGS 32
 
 /**
  * DRC configurations are specified with a label and a set of register
@@ -71,6 +75,42 @@ struct wm8958_mbc_cfg {
         const char *name;
         u16 cutoff_regs[WM8958_MBC_CUTOFF_REGS];
         u16 coeff_regs[WM8958_MBC_COEFF_REGS];
+
+        /* Coefficient layout when using MBC+VSS firmware */
+        u16 combined_regs[WM8958_MBC_COMBINED_REGS];
+};
+
+/**
+ * VSS HPF configurations are specified with a label and two values to
+ * write.  Configurations are expected to be generated using the
+ * multiband compressor configuration panel in WISCE - see
+ * http://www.wolfsonmicro.com/wisce/
+ */
+struct wm8958_vss_hpf_cfg {
+        const char *name;
+        u16 regs[WM8958_VSS_HPF_REGS];
+};
+
+/**
+ * VSS configurations are specified with a label and array of values
+ * to write.  Configurations are expected to be generated using the
+ * multiband compressor configuration panel in WISCE - see
+ * http://www.wolfsonmicro.com/wisce/
+ */
+struct wm8958_vss_cfg {
+        const char *name;
+        u16 regs[WM8958_VSS_REGS];
+};
+
+/**
+ * Enhanced EQ configurations are specified with a label and array of
+ * values to write.  Configurations are expected to be generated using
+ * the multiband compressor configuration panel in WISCE - see
+ * http://www.wolfsonmicro.com/wisce/
+ */
+struct wm8958_enh_eq_cfg {
+        const char *name;
+        u16 regs[WM8958_ENH_EQ_REGS];
 };
 
 struct wm8994_pdata {
@@ -95,6 +135,15 @@ struct wm8994_pdata {
         int num_mbc_cfgs;
         struct wm8958_mbc_cfg *mbc_cfgs;
 
+        int num_vss_cfgs;
+        struct wm8958_vss_cfg *vss_cfgs;
+
+        int num_vss_hpf_cfgs;
+        struct wm8958_vss_hpf_cfg *vss_hpf_cfgs;
+
+        int num_enh_eq_cfgs;
+        struct wm8958_enh_eq_cfg *enh_eq_cfgs;
+
         /* LINEOUT can be differential or single ended */
         unsigned int lineout1_diff:1;
         unsigned int lineout2_diff:1;
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 2348db26bc3d..8eb969ebf904 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -153,6 +153,7 @@ extern pgprot_t protection_map[16];
 #define FAULT_FLAG_MKWRITE      0x04    /* Fault was mkwrite of existing pte */
 #define FAULT_FLAG_ALLOW_RETRY  0x08    /* Retry fault if blocking */
 #define FAULT_FLAG_RETRY_NOWAIT 0x10    /* Don't drop mmap_sem and wait when retrying */
+#define FAULT_FLAG_KILLABLE     0x20    /* The fault task is in SIGKILL killable region */
 
 /*
  * This interface is used by x86 PAT code to identify a pfn mapping that is
@@ -604,10 +605,6 @@ static inline pte_t maybe_mkwrite(pte_t pte, struct vm_area_struct *vma)
 #define NODE_NOT_IN_PAGE_FLAGS
 #endif
 
-#ifndef PFN_SECTION_SHIFT
-#define PFN_SECTION_SHIFT 0
-#endif
-
 /*
  * Define the bit shifts to access each section.  For non-existent
  * sections we define the shift as 0; that plus a 0 mask ensures
@@ -681,6 +678,12 @@ static inline struct zone *page_zone(struct page *page)
 }
 
 #if defined(CONFIG_SPARSEMEM) && !defined(CONFIG_SPARSEMEM_VMEMMAP)
+static inline void set_page_section(struct page *page, unsigned long section)
+{
+        page->flags &= ~(SECTIONS_MASK << SECTIONS_PGSHIFT);
+        page->flags |= (section & SECTIONS_MASK) << SECTIONS_PGSHIFT;
+}
+
 static inline unsigned long page_to_section(struct page *page)
 {
         return (page->flags >> SECTIONS_PGSHIFT) & SECTIONS_MASK;
@@ -699,18 +702,14 @@ static inline void set_page_node(struct page *page, unsigned long node)
         page->flags |= (node & NODES_MASK) << NODES_PGSHIFT;
 }
 
-static inline void set_page_section(struct page *page, unsigned long section)
-{
-        page->flags &= ~(SECTIONS_MASK << SECTIONS_PGSHIFT);
-        page->flags |= (section & SECTIONS_MASK) << SECTIONS_PGSHIFT;
-}
-
 static inline void set_page_links(struct page *page, enum zone_type zone,
         unsigned long node, unsigned long pfn)
 {
         set_page_zone(page, zone);
         set_page_node(page, node);
+#if defined(CONFIG_SPARSEMEM) && !defined(CONFIG_SPARSEMEM_VMEMMAP)
         set_page_section(page, pfn_to_section_nr(pfn));
+#endif
 }
 
 /*
@@ -862,26 +861,18 @@ extern void pagefault_out_of_memory(void);
 #define offset_in_page(p)       ((unsigned long)(p) & ~PAGE_MASK)
 
 /*
- * Flags passed to show_mem() and __show_free_areas() to suppress output in
+ * Flags passed to show_mem() and show_free_areas() to suppress output in
  * various contexts.
  */
 #define SHOW_MEM_FILTER_NODES   (0x0001u)       /* filter disallowed nodes */
 
-extern void show_free_areas(void);
-extern void __show_free_areas(unsigned int flags);
+extern void show_free_areas(unsigned int flags);
+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);
 int shmem_zero_setup(struct vm_area_struct *);
 
-#ifndef CONFIG_MMU
-extern unsigned long shmem_get_unmapped_area(struct file *file,
-                                             unsigned long addr,
-                                             unsigned long len,
-                                             unsigned long pgoff,
-                                             unsigned long flags);
-#endif
-
 extern int can_do_mlock(void);
 extern int user_shm_lock(size_t, struct user_struct *);
 extern void user_shm_unlock(size_t, struct user_struct *);
@@ -894,8 +885,6 @@ struct zap_details {
         struct address_space *check_mapping;    /* Check page->mapping if set */
         pgoff_t first_index;                    /* Lowest page->index to unmap */
         pgoff_t last_index;                     /* Highest page->index to unmap */
-        spinlock_t *i_mmap_lock;                /* For unmap_mapping_range: */
-        unsigned long truncate_count;           /* Compare vm_truncate_count */
 };
 
 struct page *vm_normal_page(struct vm_area_struct *vma, unsigned long addr,
@@ -905,7 +894,7 @@ int zap_vma_ptes(struct vm_area_struct *vma, unsigned long address,
                 unsigned long size);
 unsigned long zap_page_range(struct vm_area_struct *vma, unsigned long address,
                 unsigned long size, struct zap_details *);
-unsigned long unmap_vmas(struct mmu_gather **tlb,
+unsigned long unmap_vmas(struct mmu_gather *tlb,
                 struct vm_area_struct *start_vma, unsigned long start_addr,
                 unsigned long end_addr, unsigned long *nr_accounted,
                 struct zap_details *);
@@ -1011,11 +1000,33 @@ int set_page_dirty_lock(struct page *page);
 int clear_page_dirty_for_io(struct page *page);
 
 /* Is the vma a continuation of the stack vma above it? */
-static inline int vma_stack_continue(struct vm_area_struct *vma, unsigned long addr)
+static inline int vma_growsdown(struct vm_area_struct *vma, unsigned long addr)
 {
         return vma && (vma->vm_end == addr) && (vma->vm_flags & VM_GROWSDOWN);
 }
 
+static inline int stack_guard_page_start(struct vm_area_struct *vma,
+                                             unsigned long addr)
+{
+        return (vma->vm_flags & VM_GROWSDOWN) &&
+                (vma->vm_start == addr) &&
+                !vma_growsdown(vma->vm_prev, addr);
+}
+
+/* Is the vma a continuation of the stack vma below it? */
+static inline int vma_growsup(struct vm_area_struct *vma, unsigned long addr)
+{
+        return vma && (vma->vm_start == addr) && (vma->vm_flags & VM_GROWSUP);
+}
+
+static inline int stack_guard_page_end(struct vm_area_struct *vma,
+                                           unsigned long addr)
+{
+        return (vma->vm_flags & VM_GROWSUP) &&
+                (vma->vm_end == addr) &&
+                !vma_growsup(vma->vm_next, addr);
+}
+
 extern unsigned long move_page_tables(struct vm_area_struct *vma,
                 unsigned long old_addr, struct vm_area_struct *new_vma,
                 unsigned long new_addr, unsigned long len);
@@ -1034,65 +1045,35 @@ int __get_user_pages_fast(unsigned long start, int nr_pages, int write,
 /*
  * per-process(per-mm_struct) statistics.
  */
-#if defined(SPLIT_RSS_COUNTING)
-/*
- * The mm counters are not protected by its page_table_lock,
- * so must be incremented atomically.
- */
 static inline void set_mm_counter(struct mm_struct *mm, int member, long value)
 {
         atomic_long_set(&mm->rss_stat.count[member], value);
 }
 
+#if defined(SPLIT_RSS_COUNTING)
 unsigned long get_mm_counter(struct mm_struct *mm, int member);
-
-static inline void add_mm_counter(struct mm_struct *mm, int member, long value)
-{
-        atomic_long_add(value, &mm->rss_stat.count[member]);
-}
-
-static inline void inc_mm_counter(struct mm_struct *mm, int member)
-{
-        atomic_long_inc(&mm->rss_stat.count[member]);
-}
-
-static inline void dec_mm_counter(struct mm_struct *mm, int member)
-{
-        atomic_long_dec(&mm->rss_stat.count[member]);
-}
-
-#else  /* !USE_SPLIT_PTLOCKS */
-/*
- * The mm counters are protected by its page_table_lock,
- * so can be incremented directly.
- */
-static inline void set_mm_counter(struct mm_struct *mm, int member, long value)
-{
-        mm->rss_stat.count[member] = value;
-}
-
+#else
 static inline unsigned long get_mm_counter(struct mm_struct *mm, int member)
 {
-        return mm->rss_stat.count[member];
+        return atomic_long_read(&mm->rss_stat.count[member]);
 }
+#endif
 
 static inline void add_mm_counter(struct mm_struct *mm, int member, long value)
 {
-        mm->rss_stat.count[member] += value;
+        atomic_long_add(value, &mm->rss_stat.count[member]);
 }
 
 static inline void inc_mm_counter(struct mm_struct *mm, int member)
 {
-        mm->rss_stat.count[member]++;
+        atomic_long_inc(&mm->rss_stat.count[member]);
 }
 
 static inline void dec_mm_counter(struct mm_struct *mm, int member)
 {
-        mm->rss_stat.count[member]--;
+        atomic_long_dec(&mm->rss_stat.count[member]);
 }
 
-#endif /* !USE_SPLIT_PTLOCKS */
-
 static inline unsigned long get_mm_rss(struct mm_struct *mm)
 {
         return get_mm_counter(mm, MM_FILEPAGES) +
@@ -1141,13 +1122,24 @@ 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.
  *
- * 'shrink' is passed 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).
+ * '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.
@@ -1156,7 +1148,7 @@ static inline void sync_mm_rss(struct task_struct *task, struct mm_struct *mm)
  * querying the cache size, so a fastpath for that case is appropriate.
  */
 struct shrinker {
-        int (*shrink)(struct shrinker *, int nr_to_scan, gfp_t gfp_mask);
+        int (*shrink)(struct shrinker *, struct shrink_control *sc);
         int seeks;      /* seeks to recreate an obj */
 
         /* These are for internal use */
@@ -1358,7 +1350,7 @@ extern void set_dma_reserve(unsigned long new_dma_reserve);
 extern void memmap_init_zone(unsigned long, int, unsigned long,
                                 unsigned long, enum memmap_context);
 extern void setup_per_zone_wmarks(void);
-extern void calculate_zone_inactive_ratio(struct zone *zone);
+extern int __meminit init_per_zone_wmark_min(void);
 extern void mem_init(void);
 extern void __init mmap_init(void);
 extern void show_mem(unsigned int flags);
@@ -1366,6 +1358,8 @@ extern void si_meminfo(struct sysinfo * val);
 extern void si_meminfo_node(struct sysinfo *val, int nid);
 extern int after_bootmem;
 
+extern void warn_alloc_failed(gfp_t gfp_mask, int order, const char *fmt, ...);
+
 extern void setup_per_cpu_pageset(void);
 
 extern void zone_pcp_update(struct zone *zone);
@@ -1495,15 +1489,17 @@ unsigned long ra_submit(struct file_ra_state *ra,
                         struct address_space *mapping,
                         struct file *filp);
 
-/* Do stack extension */
+/* Generic expand stack which grows the stack according to GROWS{UP,DOWN} */
 extern int expand_stack(struct vm_area_struct *vma, unsigned long address);
+
+/* CONFIG_STACK_GROWSUP still needs to to grow downwards at some places */
+extern int expand_downwards(struct vm_area_struct *vma,
+                unsigned long address);
 #if VM_GROWSUP
 extern int expand_upwards(struct vm_area_struct *vma, unsigned long address);
 #else
   #define expand_upwards(vma, address) do { } while (0)
 #endif
-extern int expand_stack_downwards(struct vm_area_struct *vma,
-                                  unsigned long address);
 
 /* Look up the first VMA which satisfies  addr < vm_end,  NULL if none. */
 extern struct vm_area_struct * find_vma(struct mm_struct * mm, unsigned long addr);
@@ -1605,8 +1601,9 @@ int in_gate_area_no_mm(unsigned long addr);
 
 int drop_caches_sysctl_handler(struct ctl_table *, int,
                                         void __user *, size_t *, loff_t *);
-unsigned long shrink_slab(unsigned long scanned, gfp_t gfp_mask,
-                        unsigned long lru_pages);
+unsigned long shrink_slab(struct shrink_control *shrink,
+                          unsigned long nr_pages_scanned,
+                          unsigned long lru_pages);
 
 #ifndef CONFIG_MMU
 #define randomize_va_space 0
diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
index 02aa5619709b..071d459e866b 100644
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -175,7 +175,6 @@ struct vm_area_struct {
                                            units, *not* PAGE_CACHE_SIZE */
         struct file * vm_file;          /* File we map to (can be NULL). */
         void * vm_private_data;         /* was vm_pte (shared mem) */
-        unsigned long vm_truncate_count;/* truncate_count or restart_addr */
 
 #ifndef CONFIG_MMU
         struct vm_region *vm_region;    /* NOMMU mapping region */
@@ -205,19 +204,16 @@ enum {
 
 #if USE_SPLIT_PTLOCKS && defined(CONFIG_MMU)
 #define SPLIT_RSS_COUNTING
-struct mm_rss_stat {
-        atomic_long_t count[NR_MM_COUNTERS];
-};
 /* per-thread cached information, */
 struct task_rss_stat {
         int events;     /* for synchronization threshold */
         int count[NR_MM_COUNTERS];
 };
-#else  /* !USE_SPLIT_PTLOCKS */
+#endif /* USE_SPLIT_PTLOCKS */
+
 struct mm_rss_stat {
-        unsigned long count[NR_MM_COUNTERS];
+        atomic_long_t count[NR_MM_COUNTERS];
 };
-#endif /* !USE_SPLIT_PTLOCKS */
 
 struct mm_struct {
         struct vm_area_struct * mmap;           /* list of VMAs */
@@ -266,8 +262,6 @@ struct mm_struct {
 
         struct linux_binfmt *binfmt;
 
-        cpumask_t cpu_vm_mask;
-
         /* Architecture-specific MM context */
         mm_context_t context;
 
@@ -317,9 +311,14 @@ struct mm_struct {
 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
         pgtable_t pmd_huge_pte; /* protected by page_table_lock */
 #endif
+
+        cpumask_var_t cpu_vm_mask_var;
 };
 
 /* Future-safe accessor for struct mm_struct's cpu_vm_mask. */
-#define mm_cpumask(mm) (&(mm)->cpu_vm_mask)
+static inline cpumask_t *mm_cpumask(struct mm_struct *mm)
+{
+        return mm->cpu_vm_mask_var;
+}
 
 #endif /* _LINUX_MM_TYPES_H */
diff --git a/include/linux/mmc/Kbuild b/include/linux/mmc/Kbuild
new file mode 100644
index 000000000000..1fb26448faa9
--- /dev/null
+++ b/include/linux/mmc/Kbuild
@@ -0,0 +1 @@
+header-y += ioctl.h
diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
index adb4888248be..c6927a4d157f 100644
--- a/include/linux/mmc/card.h
+++ b/include/linux/mmc/card.h
@@ -11,6 +11,7 @@
 #define LINUX_MMC_CARD_H
 
 #include <linux/mmc/core.h>
+#include <linux/mod_devicetable.h>
 
 struct mmc_cid {
         unsigned int            manfid;
@@ -29,6 +30,7 @@ struct mmc_csd {
         unsigned short          cmdclass;
         unsigned short          tacc_clks;
         unsigned int            tacc_ns;
+        unsigned int            c_size;
         unsigned int            r2w_factor;
         unsigned int            max_dtr;
         unsigned int            erase_size;             /* In sectors */
@@ -45,6 +47,10 @@ struct mmc_ext_csd {
         u8                      rev;
         u8                      erase_group_def;
         u8                      sec_feature_support;
+        u8                      rel_sectors;
+        u8                      rel_param;
+        u8                      part_config;
+        unsigned int            part_time;              /* Units: ms */
         unsigned int            sa_timeout;             /* Units: 100ns */
         unsigned int            hs_max_dtr;
         unsigned int            sectors;
@@ -57,13 +63,18 @@ struct mmc_ext_csd {
         bool                    enhanced_area_en;       /* enable bit */
         unsigned long long      enhanced_area_offset;   /* Units: Byte */
         unsigned int            enhanced_area_size;     /* Units: KB */
+        unsigned int            boot_size;              /* in bytes */
 };
 
 struct sd_scr {
         unsigned char           sda_vsn;
+        unsigned char           sda_spec3;
         unsigned char           bus_widths;
 #define SD_SCR_BUS_WIDTH_1      (1<<0)
 #define SD_SCR_BUS_WIDTH_4      (1<<2)
+        unsigned char           cmds;
+#define SD_SCR_CMD20_SUPPORT   (1<<0)
+#define SD_SCR_CMD23_SUPPORT   (1<<1)
 };
 
 struct sd_ssr {
@@ -74,6 +85,39 @@ struct sd_ssr {
 
 struct sd_switch_caps {
         unsigned int            hs_max_dtr;
+        unsigned int            uhs_max_dtr;
+#define UHS_SDR104_MAX_DTR      208000000
+#define UHS_SDR50_MAX_DTR       100000000
+#define UHS_DDR50_MAX_DTR       50000000
+#define UHS_SDR25_MAX_DTR       UHS_DDR50_MAX_DTR
+#define UHS_SDR12_MAX_DTR       25000000
+        unsigned int            sd3_bus_mode;
+#define UHS_SDR12_BUS_SPEED     0
+#define UHS_SDR25_BUS_SPEED     1
+#define UHS_SDR50_BUS_SPEED     2
+#define UHS_SDR104_BUS_SPEED    3
+#define UHS_DDR50_BUS_SPEED     4
+
+#define SD_MODE_UHS_SDR12       (1 << UHS_SDR12_BUS_SPEED)
+#define SD_MODE_UHS_SDR25       (1 << UHS_SDR25_BUS_SPEED)
+#define SD_MODE_UHS_SDR50       (1 << UHS_SDR50_BUS_SPEED)
+#define SD_MODE_UHS_SDR104      (1 << UHS_SDR104_BUS_SPEED)
+#define SD_MODE_UHS_DDR50       (1 << UHS_DDR50_BUS_SPEED)
+        unsigned int            sd3_drv_type;
+#define SD_DRIVER_TYPE_B        0x01
+#define SD_DRIVER_TYPE_A        0x02
+#define SD_DRIVER_TYPE_C        0x04
+#define SD_DRIVER_TYPE_D        0x08
+        unsigned int            sd3_curr_limit;
+#define SD_SET_CURRENT_LIMIT_200        0
+#define SD_SET_CURRENT_LIMIT_400        1
+#define SD_SET_CURRENT_LIMIT_600        2
+#define SD_SET_CURRENT_LIMIT_800        3
+
+#define SD_MAX_CURRENT_200      (1 << SD_SET_CURRENT_LIMIT_200)
+#define SD_MAX_CURRENT_400      (1 << SD_SET_CURRENT_LIMIT_400)
+#define SD_MAX_CURRENT_600      (1 << SD_SET_CURRENT_LIMIT_600)
+#define SD_MAX_CURRENT_800      (1 << SD_SET_CURRENT_LIMIT_800)
 };
 
 struct sdio_cccr {
@@ -118,6 +162,8 @@ struct mmc_card {
 #define MMC_STATE_HIGHSPEED     (1<<2)          /* card is in high speed mode */
 #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_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 */
 #define MMC_QUIRK_BLKSZ_FOR_BYTE_MODE (1<<1)    /* use func->cur_blksize */
@@ -125,6 +171,10 @@ struct mmc_card {
 #define MMC_QUIRK_NONSTD_SDIO   (1<<2)          /* non-standard SDIO card attached */
                                                 /* (missing CIA registers) */
 #define MMC_QUIRK_BROKEN_CLK_GATING (1<<3)      /* clock gating the sdio bus will make card fail */
+#define MMC_QUIRK_NONSTD_FUNC_IF (1<<4)         /* SDIO card has nonstd function interfaces */
+#define MMC_QUIRK_DISABLE_CD    (1<<5)          /* disconnect CD/DAT[3] resistor */
+#define MMC_QUIRK_INAND_CMD38   (1<<6)          /* iNAND devices have broken CMD38 */
+#define MMC_QUIRK_BLK_NO_CMD23  (1<<7)          /* Avoid CMD23 for regular multiblock */
 
         unsigned int            erase_size;     /* erase size in sectors */
         unsigned int            erase_shift;    /* if erase unit is power 2 */
@@ -145,14 +195,100 @@ struct mmc_card {
         struct sdio_cccr        cccr;           /* common card info */
         struct sdio_cis         cis;            /* common tuple info */
         struct sdio_func        *sdio_func[SDIO_MAX_FUNCS]; /* SDIO functions (devices) */
+        struct sdio_func        *sdio_single_irq; /* SDIO function when only one IRQ active */
         unsigned                num_info;       /* number of info strings */
         const char              **info;         /* info strings */
         struct sdio_func_tuple  *tuples;        /* unknown common tuples */
 
+        unsigned int            sd_bus_speed;   /* Bus Speed Mode set for the card */
+
         struct dentry           *debugfs_root;
 };
 
-void mmc_fixup_device(struct mmc_card *dev);
+/*
+ *  The world is not perfect and supplies us with broken mmc/sdio devices.
+ *  For at least some of these bugs we need a work-around.
+ */
+
+struct mmc_fixup {
+        /* CID-specific fields. */
+        const char *name;
+
+        /* Valid revision range */
+        u64 rev_start, rev_end;
+
+        unsigned int manfid;
+        unsigned short oemid;
+
+        /* SDIO-specfic fields. You can use SDIO_ANY_ID here of course */
+        u16 cis_vendor, cis_device;
+
+        void (*vendor_fixup)(struct mmc_card *card, int data);
+        int data;
+};
+
+#define CID_MANFID_ANY (-1u)
+#define CID_OEMID_ANY ((unsigned short) -1)
+#define CID_NAME_ANY (NULL)
+
+#define END_FIXUP { 0 }
+
+#define _FIXUP_EXT(_name, _manfid, _oemid, _rev_start, _rev_end,        \
+                   _cis_vendor, _cis_device,                            \
+                   _fixup, _data)                                       \
+        {                                                  \
+                .name = (_name),                           \
+                .manfid = (_manfid),                       \
+                .oemid = (_oemid),                         \
+                .rev_start = (_rev_start),                 \
+                .rev_end = (_rev_end),                     \
+                .cis_vendor = (_cis_vendor),               \
+                .cis_device = (_cis_device),               \
+                .vendor_fixup = (_fixup),                  \
+                .data = (_data),                           \
+         }
+
+#define MMC_FIXUP_REV(_name, _manfid, _oemid, _rev_start, _rev_end,     \
+                      _fixup, _data)                                    \
+        _FIXUP_EXT(_name, _manfid,                                      \
+                   _oemid, _rev_start, _rev_end,                        \
+                   SDIO_ANY_ID, SDIO_ANY_ID,                            \
+                   _fixup, _data)                                       \
+
+#define MMC_FIXUP(_name, _manfid, _oemid, _fixup, _data) \
+        MMC_FIXUP_REV(_name, _manfid, _oemid, 0, -1ull, _fixup, _data)
+
+#define SDIO_FIXUP(_vendor, _device, _fixup, _data)                     \
+        _FIXUP_EXT(CID_NAME_ANY, CID_MANFID_ANY,                        \
+                    CID_OEMID_ANY, 0, -1ull,                            \
+                   _vendor, _device,                                    \
+                   _fixup, _data)                                       \
+
+#define cid_rev(hwrev, fwrev, year, month)      \
+        (((u64) hwrev) << 40 |                  \
+         ((u64) fwrev) << 32 |                  \
+         ((u64) year) << 16 |                   \
+         ((u64) month))
+
+#define cid_rev_card(card)                \
+        cid_rev(card->cid.hwrev,          \
+                    card->cid.fwrev,      \
+                    card->cid.year,       \
+                    card->cid.month)
+
+/*
+ * Unconditionally quirk add/remove.
+ */
+
+static inline void __maybe_unused add_quirk(struct mmc_card *card, int data)
+{
+        card->quirks |= data;
+}
+
+static inline void __maybe_unused remove_quirk(struct mmc_card *card, int data)
+{
+        card->quirks &= ~data;
+}
 
 #define mmc_card_mmc(c)         ((c)->type == MMC_TYPE_MMC)
 #define mmc_card_sd(c)          ((c)->type == MMC_TYPE_SD)
@@ -163,12 +299,50 @@ void mmc_fixup_device(struct mmc_card *dev);
 #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_card_ext_capacity(c) ((c)->state & MMC_CARD_SDXC)
 
 #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)
 #define mmc_card_set_blockaddr(c) ((c)->state |= MMC_STATE_BLOCKADDR)
 #define mmc_card_set_ddr_mode(c) ((c)->state |= MMC_STATE_HIGHSPEED_DDR)
+#define mmc_sd_card_set_uhs(c) ((c)->state |= MMC_STATE_ULTRAHIGHSPEED)
+#define mmc_card_set_ext_capacity(c) ((c)->state |= MMC_CARD_SDXC)
+
+/*
+ * Quirk add/remove for MMC products.
+ */
+
+static inline void __maybe_unused add_quirk_mmc(struct mmc_card *card, int data)
+{
+        if (mmc_card_mmc(card))
+                card->quirks |= data;
+}
+
+static inline void __maybe_unused remove_quirk_mmc(struct mmc_card *card,
+                                                   int data)
+{
+        if (mmc_card_mmc(card))
+                card->quirks &= ~data;
+}
+
+/*
+ * Quirk add/remove for SD products.
+ */
+
+static inline void __maybe_unused add_quirk_sd(struct mmc_card *card, int data)
+{
+        if (mmc_card_sd(card))
+                card->quirks |= data;
+}
+
+static inline void __maybe_unused remove_quirk_sd(struct mmc_card *card,
+                                                   int data)
+{
+        if (mmc_card_sd(card))
+                card->quirks &= ~data;
+}
 
 static inline int mmc_card_lenient_fn0(const struct mmc_card *c)
 {
@@ -180,6 +354,16 @@ static inline int mmc_blksz_for_byte_mode(const struct mmc_card *c)
         return c->quirks & MMC_QUIRK_BLKSZ_FOR_BYTE_MODE;
 }
 
+static inline int mmc_card_disable_cd(const struct mmc_card *c)
+{
+        return c->quirks & MMC_QUIRK_DISABLE_CD;
+}
+
+static inline int mmc_card_nonstd_func_interface(const struct mmc_card *c)
+{
+        return c->quirks & MMC_QUIRK_NONSTD_FUNC_IF;
+}
+
 #define mmc_card_name(c)        ((c)->cid.prod_name)
 #define mmc_card_id(c)          (dev_name(&(c)->dev))
 
@@ -203,4 +387,7 @@ struct mmc_driver {
 extern int mmc_register_driver(struct mmc_driver *);
 extern void mmc_unregister_driver(struct mmc_driver *);
 
+extern void mmc_fixup_device(struct mmc_card *card,
+                             const struct mmc_fixup *table);
+
 #endif
diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
index 07f27af4dba5..b6718e549a51 100644
--- a/include/linux/mmc/core.h
+++ b/include/linux/mmc/core.h
@@ -92,7 +92,7 @@ struct mmc_command {
  *              actively failing requests
  */
 
-        unsigned int            erase_timeout;  /* in milliseconds */
+        unsigned int            cmd_timeout_ms; /* in milliseconds */
 
         struct mmc_data         *data;          /* data segment associated with cmd */
         struct mmc_request      *mrq;           /* associated request */
@@ -120,6 +120,7 @@ struct mmc_data {
 };
 
 struct mmc_request {
+        struct mmc_command      *sbc;           /* SET_BLOCK_COUNT for multiblock */
         struct mmc_command      *cmd;
         struct mmc_data         *data;
         struct mmc_command      *stop;
@@ -133,8 +134,10 @@ struct mmc_card;
 
 extern void mmc_wait_for_req(struct mmc_host *, struct mmc_request *);
 extern int mmc_wait_for_cmd(struct mmc_host *, struct mmc_command *, int);
+extern int mmc_app_cmd(struct mmc_host *, struct mmc_card *);
 extern int mmc_wait_for_app_cmd(struct mmc_host *, struct mmc_card *,
         struct mmc_command *, int);
+extern int mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int);
 
 #define MMC_ERASE_ARG           0x00000000
 #define MMC_SECURE_ERASE_ARG    0x80000000
diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h
index eb792cb6d745..1ee4424462eb 100644
--- a/include/linux/mmc/host.h
+++ b/include/linux/mmc/host.h
@@ -50,12 +50,30 @@ struct mmc_ios {
 #define MMC_TIMING_LEGACY       0
 #define MMC_TIMING_MMC_HS       1
 #define MMC_TIMING_SD_HS        2
+#define MMC_TIMING_UHS_SDR12    MMC_TIMING_LEGACY
+#define MMC_TIMING_UHS_SDR25    MMC_TIMING_SD_HS
+#define MMC_TIMING_UHS_SDR50    3
+#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
+
+        unsigned char   signal_voltage;         /* signalling voltage (1.8V or 3.3V) */
+
+#define MMC_SIGNAL_VOLTAGE_330  0
+#define MMC_SIGNAL_VOLTAGE_180  1
+#define MMC_SIGNAL_VOLTAGE_120  2
+
+        unsigned char   drv_type;               /* driver type (A, B, C, D) */
+
+#define MMC_SET_DRIVER_TYPE_B   0
+#define MMC_SET_DRIVER_TYPE_A   1
+#define MMC_SET_DRIVER_TYPE_C   2
+#define MMC_SET_DRIVER_TYPE_D   3
 };
 
 struct mmc_host_ops {
@@ -117,6 +135,10 @@ struct mmc_host_ops {
 
         /* optional callback for HC quirks */
         void    (*init_card)(struct mmc_host *host, struct mmc_card *card);
+
+        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);
 };
 
 struct mmc_card;
@@ -173,6 +195,22 @@ struct mmc_host {
                                                 /* DDR mode at 1.2V */
 #define MMC_CAP_POWER_OFF_CARD  (1 << 13)       /* Can power off after boot */
 #define MMC_CAP_BUS_WIDTH_TEST  (1 << 14)       /* CMD14/CMD19 bus width ok */
+#define MMC_CAP_UHS_SDR12       (1 << 15)       /* Host supports UHS SDR12 mode */
+#define MMC_CAP_UHS_SDR25       (1 << 16)       /* Host supports UHS SDR25 mode */
+#define MMC_CAP_UHS_SDR50       (1 << 17)       /* Host supports UHS SDR50 mode */
+#define MMC_CAP_UHS_SDR104      (1 << 18)       /* Host supports UHS SDR104 mode */
+#define MMC_CAP_UHS_DDR50       (1 << 19)       /* Host supports UHS DDR50 mode */
+#define MMC_CAP_SET_XPC_330     (1 << 20)       /* Host supports >150mA current at 3.3V */
+#define MMC_CAP_SET_XPC_300     (1 << 21)       /* Host supports >150mA current at 3.0V */
+#define MMC_CAP_SET_XPC_180     (1 << 22)       /* Host supports >150mA current at 1.8V */
+#define MMC_CAP_DRIVER_TYPE_A   (1 << 23)       /* Host supports Driver Type A */
+#define MMC_CAP_DRIVER_TYPE_C   (1 << 24)       /* Host supports Driver Type C */
+#define MMC_CAP_DRIVER_TYPE_D   (1 << 25)       /* Host supports Driver Type D */
+#define MMC_CAP_MAX_CURRENT_200 (1 << 26)       /* Host max current limit is 200mA */
+#define MMC_CAP_MAX_CURRENT_400 (1 << 27)       /* Host max current limit is 400mA */
+#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. */
 
         mmc_pm_flag_t           pm_caps;        /* supported pm features */
 
@@ -183,6 +221,7 @@ struct mmc_host {
         struct work_struct      clk_gate_work; /* delayed clock gate */
         unsigned int            clk_old;        /* old clock value cache */
         spinlock_t              clk_lock;       /* lock for clk fields */
+        struct mutex            clk_gate_mutex; /* mutex for clock gating */
 #endif
 
         /* host specific block data */
@@ -320,10 +359,19 @@ static inline int mmc_card_is_removable(struct mmc_host *host)
         return !(host->caps & MMC_CAP_NONREMOVABLE) && mmc_assume_removable;
 }
 
-static inline int mmc_card_is_powered_resumed(struct mmc_host *host)
+static inline int mmc_card_keep_power(struct mmc_host *host)
 {
         return host->pm_flags & MMC_PM_KEEP_POWER;
 }
 
+static inline int mmc_card_wake_sdio_irq(struct mmc_host *host)
+{
+        return host->pm_flags & MMC_PM_WAKE_SDIO_IRQ;
+}
+
+static inline int mmc_host_cmd23(struct mmc_host *host)
+{
+        return host->caps & MMC_CAP_CMD23;
+}
 #endif
 
diff --git a/include/linux/mmc/ioctl.h b/include/linux/mmc/ioctl.h
new file mode 100644
index 000000000000..5baf2983a12f
--- /dev/null
+++ b/include/linux/mmc/ioctl.h
@@ -0,0 +1,54 @@
+#ifndef LINUX_MMC_IOCTL_H
+#define LINUX_MMC_IOCTL_H
+struct mmc_ioc_cmd {
+        /* Implies direction of data.  true = write, false = read */
+        int write_flag;
+
+        /* Application-specific command.  true = precede with CMD55 */
+        int is_acmd;
+
+        __u32 opcode;
+        __u32 arg;
+        __u32 response[4];  /* CMD response */
+        unsigned int flags;
+        unsigned int blksz;
+        unsigned int blocks;
+
+        /*
+         * Sleep at least postsleep_min_us useconds, and at most
+         * postsleep_max_us useconds *after* issuing command.  Needed for
+         * some read commands for which cards have no other way of indicating
+         * they're ready for the next command (i.e. there is no equivalent of
+         * a "busy" indicator for read operations).
+         */
+        unsigned int postsleep_min_us;
+        unsigned int postsleep_max_us;
+
+        /*
+         * Override driver-computed timeouts.  Note the difference in units!
+         */
+        unsigned int data_timeout_ns;
+        unsigned int cmd_timeout_ms;
+
+        /*
+         * For 64-bit machines, the next member, ``__u64 data_ptr``, wants to
+         * be 8-byte aligned.  Make sure this struct is the same size when
+         * built for 32-bit.
+         */
+        __u32 __pad;
+
+        /* DAT buffer */
+        __u64 data_ptr;
+};
+#define mmc_ioc_cmd_set_data(ic, ptr) ic.data_ptr = (__u64)(unsigned long) ptr
+
+#define MMC_IOC_CMD _IOWR(MMC_BLOCK_MAJOR, 0, struct mmc_ioc_cmd)
+
+/*
+ * Since this ioctl is only meant to enhance (and not replace) normal access
+ * to the mmc bus device, an upper data transfer limit of MMC_IOC_MAX_BYTES
+ * is enforced per ioctl call.  For larger data transfers, use the normal
+ * block device operations.
+ */
+#define MMC_IOC_MAX_BYTES  (512L * 256)
+#endif  /* LINUX_MMC_IOCTL_H */
diff --git a/include/linux/mmc/mmc.h b/include/linux/mmc/mmc.h
index 264ba5451e3b..ac26a685cca8 100644
--- a/include/linux/mmc/mmc.h
+++ b/include/linux/mmc/mmc.h
@@ -50,6 +50,7 @@
 #define MMC_SET_BLOCKLEN         16   /* ac   [31:0] block len   R1  */
 #define MMC_READ_SINGLE_BLOCK    17   /* adtc [31:0] data addr   R1  */
 #define MMC_READ_MULTIPLE_BLOCK  18   /* adtc [31:0] data addr   R1  */
+#define MMC_SEND_TUNING_BLOCK    19   /* adtc                    R1  */
 
   /* class 3 */
 #define MMC_WRITE_DAT_UNTIL_STOP 20   /* adtc [31:0] data addr   R1  */
@@ -82,6 +83,12 @@
 #define MMC_APP_CMD              55   /* ac   [31:16] RCA        R1  */
 #define MMC_GEN_CMD              56   /* adtc [0] RD/WR          R1  */
 
+static inline bool mmc_op_multi(u32 opcode)
+{
+        return opcode == MMC_WRITE_MULTIPLE_BLOCK ||
+               opcode == MMC_READ_MULTIPLE_BLOCK;
+}
+
 /*
  * MMC_SWITCH argument format:
  *
@@ -255,18 +262,23 @@ struct _mmc_csd {
 
 #define EXT_CSD_PARTITION_ATTRIBUTE     156     /* R/W */
 #define EXT_CSD_PARTITION_SUPPORT       160     /* RO */
+#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 */
 #define EXT_CSD_ERASED_MEM_CONT         181     /* RO */
 #define EXT_CSD_BUS_WIDTH               183     /* R/W */
 #define EXT_CSD_HS_TIMING               185     /* R/W */
 #define EXT_CSD_REV                     192     /* RO */
 #define EXT_CSD_STRUCTURE               194     /* RO */
 #define EXT_CSD_CARD_TYPE               196     /* 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 */
+#define EXT_CSD_REL_WR_SEC_C            222     /* RO */
 #define EXT_CSD_HC_WP_GRP_SIZE          221     /* RO */
 #define EXT_CSD_ERASE_TIMEOUT_MULT      223     /* RO */
 #define EXT_CSD_HC_ERASE_GRP_SIZE       224     /* RO */
+#define EXT_CSD_BOOT_MULT               226     /* RO */
 #define EXT_CSD_SEC_TRIM_MULT           229     /* RO */
 #define EXT_CSD_SEC_ERASE_MULT          230     /* RO */
 #define EXT_CSD_SEC_FEATURE_SUPPORT     231     /* RO */
@@ -276,6 +288,12 @@ struct _mmc_csd {
  * EXT_CSD field definitions
  */
 
+#define EXT_CSD_WR_REL_PARAM_EN         (1<<2)
+
+#define EXT_CSD_PART_CONFIG_ACC_MASK    (0x7)
+#define EXT_CSD_PART_CONFIG_ACC_BOOT0   (0x1)
+#define EXT_CSD_PART_CONFIG_ACC_BOOT1   (0x2)
+
 #define EXT_CSD_CMD_SET_NORMAL          (1<<0)
 #define EXT_CSD_CMD_SET_SECURE          (1<<1)
 #define EXT_CSD_CMD_SET_CPSECURE        (1<<2)
diff --git a/include/linux/mmc/sd.h b/include/linux/mmc/sd.h
index 3fd85e088cc3..7d35d52c3df3 100644
--- a/include/linux/mmc/sd.h
+++ b/include/linux/mmc/sd.h
@@ -17,6 +17,7 @@
 /* This is basically the same command as for MMC with some quirks. */
 #define SD_SEND_RELATIVE_ADDR     3   /* bcr                     R6  */
 #define SD_SEND_IF_COND           8   /* bcr  [11:0] See below   R7  */
+#define SD_SWITCH_VOLTAGE         11  /* ac                      R1  */
 
   /* class 10 */
 #define SD_SWITCH                 6   /* adtc [31:0] See below   R1  */
@@ -32,6 +33,12 @@
 #define SD_APP_OP_COND           41   /* bcr  [31:0] OCR         R3  */
 #define SD_APP_SEND_SCR          51   /* adtc                    R1  */
 
+/* OCR bit definitions */
+#define SD_OCR_S18R             (1 << 24)    /* 1.8V switching request */
+#define SD_ROCR_S18A            SD_OCR_S18R  /* 1.8V switching accepted by card */
+#define SD_OCR_XPC              (1 << 28)    /* SDXC power control */
+#define SD_OCR_CCS              (1 << 30)    /* Card Capacity Status */
+
 /*
  * SD_SWITCH argument format:
  *
@@ -59,7 +66,7 @@
 
 #define SCR_SPEC_VER_0          0       /* Implements system specification 1.0 - 1.01 */
 #define SCR_SPEC_VER_1          1       /* Implements system specification 1.10 */
-#define SCR_SPEC_VER_2          2       /* Implements system specification 2.00 */
+#define SCR_SPEC_VER_2          2       /* Implements system specification 2.00-3.0X */
 
 /*
  * SD bus widths
diff --git a/include/linux/mmc/sdhci.h b/include/linux/mmc/sdhci.h
index 83bd9f76709a..6a68c4eb4e44 100644
--- a/include/linux/mmc/sdhci.h
+++ b/include/linux/mmc/sdhci.h
@@ -85,6 +85,8 @@ struct sdhci_host {
 #define SDHCI_QUIRK_NO_HISPD_BIT                        (1<<29)
 /* Controller treats ADMA descriptors with length 0000h incorrectly */
 #define SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC            (1<<30)
+/* The read-only detection via SDHCI_PRESENT_STATE register is unstable */
+#define SDHCI_QUIRK_UNSTABLE_RO_DETECT                  (1<<31)
 
         int irq;                /* Device IRQ */
         void __iomem *ioaddr;   /* Mapped address */
@@ -109,11 +111,16 @@ struct sdhci_host {
 #define SDHCI_USE_ADMA          (1<<1)  /* Host is ADMA capable */
 #define SDHCI_REQ_USE_DMA       (1<<2)  /* Use DMA for this req. */
 #define SDHCI_DEVICE_DEAD       (1<<3)  /* Device unresponsive */
+#define SDHCI_SDR50_NEEDS_TUNING (1<<4) /* SDR50 needs tuning */
+#define SDHCI_NEEDS_RETUNING    (1<<5)  /* Host needs retuning */
+#define SDHCI_AUTO_CMD12        (1<<6)  /* Auto CMD12 support */
+#define SDHCI_AUTO_CMD23        (1<<7)  /* Auto CMD23 support */
 
         unsigned int version;   /* SDHCI spec. version */
 
         unsigned int max_clk;   /* Max possible freq (MHz) */
         unsigned int timeout_clk;       /* Timeout freq (KHz) */
+        unsigned int clk_mul;   /* Clock Muliplier value */
 
         unsigned int clock;     /* Current clock (MHz) */
         u8 pwr;                 /* Current voltage */
@@ -145,6 +152,14 @@ struct sdhci_host {
         unsigned int            ocr_avail_sd;
         unsigned int            ocr_avail_mmc;
 
+        wait_queue_head_t       buf_ready_int;  /* Waitqueue for Buffer Read Ready interrupt */
+        unsigned int            tuning_done;    /* Condition flag set when CMD19 succeeds */
+
+        unsigned int            tuning_count;   /* Timer count for re-tuning */
+        unsigned int            tuning_mode;    /* Re-tuning mode supported by host */
+#define SDHCI_TUNING_MODE_1     0
+        struct timer_list       tuning_timer;   /* Timer for tuning */
+
         unsigned long private[0] ____cacheline_aligned;
 };
 #endif /* __SDHCI_H */
diff --git a/include/linux/mmc/sh_mobile_sdhi.h b/include/linux/mmc/sh_mobile_sdhi.h
index c981b959760f..faf32b6ec185 100644
--- a/include/linux/mmc/sh_mobile_sdhi.h
+++ b/include/linux/mmc/sh_mobile_sdhi.h
@@ -3,12 +3,16 @@
 
 #include <linux/types.h>
 
+struct platform_device;
+struct tmio_mmc_data;
+
 struct sh_mobile_sdhi_info {
         int dma_slave_tx;
         int dma_slave_rx;
         unsigned long tmio_flags;
         unsigned long tmio_caps;
         u32 tmio_ocr_mask;      /* available MMC voltages */
+        struct tmio_mmc_data *pdata;
         void (*set_pwr)(struct platform_device *pdev, int state);
         int (*get_cd)(struct platform_device *pdev);
 };
diff --git a/include/linux/mmu_notifier.h b/include/linux/mmu_notifier.h
index cc2e7dfea9d7..1d1b1e13f79f 100644
--- a/include/linux/mmu_notifier.h
+++ b/include/linux/mmu_notifier.h
@@ -150,7 +150,7 @@ struct mmu_notifier_ops {
  * Therefore notifier chains can only be traversed when either
  *
  * 1. mmap_sem is held.
- * 2. One of the reverse map locks is held (i_mmap_lock or anon_vma->lock).
+ * 2. One of the reverse map locks is held (i_mmap_mutex or anon_vma->mutex).
  * 3. No other concurrent thread can access the list (release)
  */
 struct mmu_notifier {
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index e56f835274c9..217bcf6bca77 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -928,9 +928,6 @@ static inline unsigned long early_pfn_to_nid(unsigned long pfn)
 #define pfn_to_nid(pfn)         (0)
 #endif
 
-#define pfn_to_section_nr(pfn) ((pfn) >> PFN_SECTION_SHIFT)
-#define section_nr_to_pfn(sec) ((sec) << PFN_SECTION_SHIFT)
-
 #ifdef CONFIG_SPARSEMEM
 
 /*
@@ -956,6 +953,12 @@ static inline unsigned long early_pfn_to_nid(unsigned long pfn)
 #error Allocator MAX_ORDER exceeds SECTION_SIZE
 #endif
 
+#define pfn_to_section_nr(pfn) ((pfn) >> PFN_SECTION_SHIFT)
+#define section_nr_to_pfn(sec) ((sec) << PFN_SECTION_SHIFT)
+
+#define SECTION_ALIGN_UP(pfn)   (((pfn) + PAGES_PER_SECTION - 1) & PAGE_SECTION_MASK)
+#define SECTION_ALIGN_DOWN(pfn) ((pfn) & PAGE_SECTION_MASK)
+
 struct page;
 struct page_cgroup;
 struct mem_section {
diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetable.h
index 48c007dae476..ae28e93fd072 100644
--- a/include/linux/mod_devicetable.h
+++ b/include/linux/mod_devicetable.h
@@ -382,6 +382,23 @@ struct ssb_device_id {
 #define SSB_ANY_ID              0xFFFF
 #define SSB_ANY_REV             0xFF
 
+/* Broadcom's specific AMBA core, see drivers/bcma/ */
+struct bcma_device_id {
+        __u16   manuf;
+        __u16   id;
+        __u8    rev;
+        __u8    class;
+};
+#define BCMA_CORE(_manuf, _id, _rev, _class)  \
+        { .manuf = _manuf, .id = _id, .rev = _rev, .class = _class, }
+#define BCMA_CORETABLE_END  \
+        { 0, },
+
+#define BCMA_ANY_MANUF          0xFFFF
+#define BCMA_ANY_ID             0xFFFF
+#define BCMA_ANY_REV            0xFF
+#define BCMA_ANY_CLASS          0xFF
+
 struct virtio_device_id {
         __u32 device;
         __u32 vendor;
diff --git a/include/linux/module.h b/include/linux/module.h
index 5de42043dff0..d9ca2d5dc6d0 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -64,6 +64,9 @@ struct module_version_attribute {
         const char *version;
 } __attribute__ ((__aligned__(sizeof(void *))));
 
+extern ssize_t __modver_version_show(struct module_attribute *,
+                                     struct module *, char *);
+
 struct module_kobject
 {
         struct kobject kobj;
@@ -172,12 +175,7 @@ extern struct module __this_module;
 #define MODULE_VERSION(_version) MODULE_INFO(version, _version)
 #else
 #define MODULE_VERSION(_version)                                        \
-        extern ssize_t __modver_version_show(struct module_attribute *, \
-                                             struct module *, char *);  \
-        static struct module_version_attribute __modver_version_attr    \
-        __used                                                          \
-    __attribute__ ((__section__ ("__modver"),aligned(sizeof(void *)))) \
-        = {                                                             \
+        static struct module_version_attribute ___modver_attr = {       \
                 .mattr  = {                                             \
                         .attr   = {                                     \
                                 .name   = "version",                    \
@@ -187,7 +185,10 @@ extern struct module __this_module;
                 },                                                      \
                 .module_name    = KBUILD_MODNAME,                       \
                 .version        = _version,                             \
-        }
+        };                                                              \
+        static const struct module_version_attribute                    \
+        __used __attribute__ ((__section__ ("__modver")))               \
+        * __moduleparam_const __modver_attr = &___modver_attr
 #endif
 
 /* Optional firmware file (or files) needed by the module
@@ -223,7 +224,7 @@ struct module_use {
         extern void *__crc_##sym __attribute__((weak));         \
         static const unsigned long __kcrctab_##sym              \
         __used                                                  \
-        __attribute__((section("__kcrctab" sec), unused))       \
+        __attribute__((section("___kcrctab" sec "+" #sym), unused))     \
         = (unsigned long) &__crc_##sym;
 #else
 #define __CRC_SYMBOL(sym, sec)
@@ -238,7 +239,7 @@ struct module_use {
         = MODULE_SYMBOL_PREFIX #sym;                            \
         static const struct kernel_symbol __ksymtab_##sym       \
         __used                                                  \
-        __attribute__((section("__ksymtab" sec), unused))       \
+        __attribute__((section("___ksymtab" sec "+" #sym), unused))     \
         = { (unsigned long)&sym, __kstrtab_##sym }
 
 #define EXPORT_SYMBOL(sym)                                      \
@@ -367,34 +368,35 @@ struct module
         struct module_notes_attrs *notes_attrs;
 #endif
 
+        /* The command line arguments (may be mangled).  People like
+           keeping pointers to this stuff */
+        char *args;
+
 #ifdef CONFIG_SMP
         /* Per-cpu data. */
         void __percpu *percpu;
         unsigned int percpu_size;
 #endif
 
-        /* The command line arguments (may be mangled).  People like
-           keeping pointers to this stuff */
-        char *args;
 #ifdef CONFIG_TRACEPOINTS
-        struct tracepoint * const *tracepoints_ptrs;
         unsigned int num_tracepoints;
+        struct tracepoint * const *tracepoints_ptrs;
 #endif
 #ifdef HAVE_JUMP_LABEL
         struct jump_entry *jump_entries;
         unsigned int num_jump_entries;
 #endif
 #ifdef CONFIG_TRACING
-        const char **trace_bprintk_fmt_start;
         unsigned int num_trace_bprintk_fmt;
+        const char **trace_bprintk_fmt_start;
 #endif
 #ifdef CONFIG_EVENT_TRACING
         struct ftrace_event_call **trace_events;
         unsigned int num_trace_events;
 #endif
 #ifdef CONFIG_FTRACE_MCOUNT_RECORD
-        unsigned long *ftrace_callsites;
         unsigned int num_ftrace_callsites;
+        unsigned long *ftrace_callsites;
 #endif
 
 #ifdef CONFIG_MODULE_UNLOAD
@@ -475,8 +477,9 @@ const struct kernel_symbol *find_symbol(const char *name,
                                         bool warn);
 
 /* Walk the exported symbol table */
-bool each_symbol(bool (*fn)(const struct symsearch *arr, struct module *owner,
-                            unsigned int symnum, void *data), void *data);
+bool each_symbol_section(bool (*fn)(const struct symsearch *arr,
+                                    struct module *owner,
+                                    void *data), void *data);
 
 /* Returns 0 and fills in value, defined and namebuf, or -ERANGE if
    symnum out of range. */
diff --git a/include/linux/moduleparam.h b/include/linux/moduleparam.h
index 07b41951e3fa..ddaae98c53f9 100644
--- a/include/linux/moduleparam.h
+++ b/include/linux/moduleparam.h
@@ -67,9 +67,9 @@ struct kparam_string {
 struct kparam_array
 {
         unsigned int max;
+        unsigned int elemsize;
         unsigned int *num;
         const struct kernel_param_ops *ops;
-        unsigned int elemsize;
         void *elem;
 };
 
@@ -371,8 +371,9 @@ extern int param_get_invbool(char *buffer, const struct kernel_param *kp);
  */
 #define module_param_array_named(name, array, type, nump, perm)         \
         static const struct kparam_array __param_arr_##name             \
-        = { ARRAY_SIZE(array), nump, &param_ops_##type,                 \
-            sizeof(array[0]), array };                                  \
+        = { .max = ARRAY_SIZE(array), .num = nump,                      \
+            .ops = &param_ops_##type,                                   \
+            .elemsize = sizeof(array[0]), .elem = array };              \
         __module_param_call(MODULE_PARAM_PREFIX, name,                  \
                             &param_array_ops,                           \
                             .arr = &__param_arr_##name,                 \
diff --git a/include/linux/mroute.h b/include/linux/mroute.h
index b21d567692b2..46caaf44339d 100644
--- a/include/linux/mroute.h
+++ b/include/linux/mroute.h
@@ -244,6 +244,7 @@ struct mfc_cache {
 #ifdef __KERNEL__
 struct rtmsg;
 extern int ipmr_get_route(struct net *net, struct sk_buff *skb,
+                          __be32 saddr, __be32 daddr,
                           struct rtmsg *rtm, int nowait);
 #endif
 
diff --git a/include/linux/mtd/physmap.h b/include/linux/mtd/physmap.h
index bcfd9f777454..49b959029417 100644
--- a/include/linux/mtd/physmap.h
+++ b/include/linux/mtd/physmap.h
@@ -22,7 +22,9 @@ struct map_info;
 
 struct physmap_flash_data {
         unsigned int            width;
-        void                    (*set_vpp)(struct map_info *, int);
+        int                     (*init)(struct platform_device *);
+        void                    (*exit)(struct platform_device *);
+        void                    (*set_vpp)(struct platform_device *, int);
         unsigned int            nr_parts;
         unsigned int            pfow_base;
         char                    *probe_type;
diff --git a/include/linux/mtd/ubi.h b/include/linux/mtd/ubi.h
index 84854edf4436..15da0e99f48a 100644
--- a/include/linux/mtd/ubi.h
+++ b/include/linux/mtd/ubi.h
@@ -21,7 +21,7 @@
 #ifndef __LINUX_UBI_H__
 #define __LINUX_UBI_H__
 
-#include <asm/ioctl.h>
+#include <linux/ioctl.h>
 #include <linux/types.h>
 #include <mtd/ubi-user.h>
 
@@ -87,7 +87,7 @@ enum {
  * physical eraseblock size and on how much bytes UBI headers consume. But
  * because of the volume alignment (@alignment), the usable size of logical
  * eraseblocks if a volume may be less. The following equation is true:
- *      @usable_leb_size = LEB size - (LEB size mod @alignment),
+ *      @usable_leb_size = LEB size - (LEB size mod @alignment),
  * where LEB size is the logical eraseblock size defined by the UBI device.
  *
  * The alignment is multiple to the minimal flash input/output unit size or %1
diff --git a/include/linux/mutex.h b/include/linux/mutex.h
index 94b48bd40dd7..a940fe435aca 100644
--- a/include/linux/mutex.h
+++ b/include/linux/mutex.h
@@ -51,7 +51,7 @@ struct mutex {
         spinlock_t              wait_lock;
         struct list_head        wait_list;
 #if defined(CONFIG_DEBUG_MUTEXES) || defined(CONFIG_SMP)
-        struct thread_info      *owner;
+        struct task_struct      *owner;
 #endif
 #ifdef CONFIG_DEBUG_MUTEXES
         const char              *name;
@@ -132,6 +132,7 @@ static inline int mutex_is_locked(struct mutex *lock)
  */
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 extern void mutex_lock_nested(struct mutex *lock, unsigned int subclass);
+extern void _mutex_lock_nest_lock(struct mutex *lock, struct lockdep_map *nest_lock);
 extern int __must_check mutex_lock_interruptible_nested(struct mutex *lock,
                                         unsigned int subclass);
 extern int __must_check mutex_lock_killable_nested(struct mutex *lock,
@@ -140,6 +141,13 @@ extern int __must_check mutex_lock_killable_nested(struct mutex *lock,
 #define mutex_lock(lock) mutex_lock_nested(lock, 0)
 #define mutex_lock_interruptible(lock) mutex_lock_interruptible_nested(lock, 0)
 #define mutex_lock_killable(lock) mutex_lock_killable_nested(lock, 0)
+
+#define mutex_lock_nest_lock(lock, nest_lock)                           \
+do {                                                                    \
+        typecheck(struct lockdep_map *, &(nest_lock)->dep_map);         \
+        _mutex_lock_nest_lock(lock, &(nest_lock)->dep_map);             \
+} while (0)
+
 #else
 extern void mutex_lock(struct mutex *lock);
 extern int __must_check mutex_lock_interruptible(struct mutex *lock);
@@ -148,6 +156,7 @@ extern int __must_check mutex_lock_killable(struct mutex *lock);
 # define mutex_lock_nested(lock, subclass) mutex_lock(lock)
 # define mutex_lock_interruptible_nested(lock, subclass) mutex_lock_interruptible(lock)
 # define mutex_lock_killable_nested(lock, subclass) mutex_lock_killable(lock)
+# define mutex_lock_nest_lock(lock, nest_lock) mutex_lock(lock)
 #endif
 
 /*
diff --git a/include/linux/mxm-wmi.h b/include/linux/mxm-wmi.h
new file mode 100644
index 000000000000..617a2950523c
--- /dev/null
+++ b/include/linux/mxm-wmi.h
@@ -0,0 +1,33 @@
+/*
+ * MXM WMI driver
+ *
+ * Copyright(C) 2010 Red Hat.
+ *
+ *  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 MXM_WMI_H
+#define MXM_WMI_H
+
+/* discrete adapters */
+#define MXM_MXDS_ADAPTER_0 0x0
+#define MXM_MXDS_ADAPTER_1 0x0
+/* integrated adapter */
+#define MXM_MXDS_ADAPTER_IGD 0x10
+int mxm_wmi_call_mxds(int adapter);
+int mxm_wmi_call_mxmx(int adapter);
+bool mxm_wmi_supported(void);
+
+#endif
diff --git a/include/linux/net.h b/include/linux/net.h
index 94de83c0f877..1da55e9b6f01 100644
--- a/include/linux/net.h
+++ b/include/linux/net.h
@@ -42,6 +42,7 @@
 #define SYS_RECVMSG     17              /* sys_recvmsg(2)               */
 #define SYS_ACCEPT4     18              /* sys_accept4(2)               */
 #define SYS_RECVMMSG    19              /* sys_recvmmsg(2)              */
+#define SYS_SENDMMSG    20              /* sys_sendmmsg(2)              */
 
 typedef enum {
         SS_FREE = 0,                    /* not allocated                */
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index 0249fe7e3872..ca333e79e10f 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -1020,9 +1020,6 @@ struct net_device {
          *      part of the usual set specified in Space.c.
          */
 
-        unsigned char           if_port;        /* Selectable AUI, TP,..*/
-        unsigned char           dma;            /* DMA channel          */
-
         unsigned long           state;
 
         struct list_head        dev_list;
@@ -1035,7 +1032,7 @@ struct net_device {
         u32                     hw_features;
         /* user-requested features */
         u32                     wanted_features;
-        /* VLAN feature mask */
+        /* mask of features inheritable by VLAN devices */
         u32                     vlan_features;
 
         /* Net device feature bits; if you change something,
@@ -1066,6 +1063,8 @@ struct net_device {
 #define NETIF_F_NTUPLE          (1 << 27) /* N-tuple filters supported */
 #define NETIF_F_RXHASH          (1 << 28) /* Receive hashing offload */
 #define NETIF_F_RXCSUM          (1 << 29) /* Receive checksumming offload */
+#define NETIF_F_NOCACHE_COPY    (1 << 30) /* Use no-cache copyfromuser */
+#define NETIF_F_LOOPBACK        (1 << 31) /* Enable loopback */
 
         /* Segmentation offload features */
 #define NETIF_F_GSO_SHIFT       16
@@ -1079,9 +1078,9 @@ struct net_device {
 
         /* Features valid for ethtool to change */
         /* = all defined minus driver/device-class-related */
-#define NETIF_F_NEVER_CHANGE    (NETIF_F_HIGHDMA | NETIF_F_VLAN_CHALLENGED | \
+#define NETIF_F_NEVER_CHANGE    (NETIF_F_VLAN_CHALLENGED | \
                                   NETIF_F_LLTX | NETIF_F_NETNS_LOCAL)
-#define NETIF_F_ETHTOOL_BITS    (0x3f3fffff & ~NETIF_F_NEVER_CHANGE)
+#define NETIF_F_ETHTOOL_BITS    (0xff3fffff & ~NETIF_F_NEVER_CHANGE)
 
         /* List of features with software fallbacks. */
 #define NETIF_F_GSO_SOFTWARE    (NETIF_F_TSO | NETIF_F_TSO_ECN | \
@@ -1095,9 +1094,14 @@ struct net_device {
 
 #define NETIF_F_ALL_TSO         (NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_TSO_ECN)
 
+#define NETIF_F_ALL_FCOE        (NETIF_F_FCOE_CRC | NETIF_F_FCOE_MTU | \
+                                 NETIF_F_FSO)
+
 #define NETIF_F_ALL_TX_OFFLOADS (NETIF_F_ALL_CSUM | NETIF_F_SG | \
                                  NETIF_F_FRAGLIST | NETIF_F_ALL_TSO | \
-                                 NETIF_F_SCTP_CSUM | NETIF_F_FCOE_CRC)
+                                 NETIF_F_HIGHDMA | \
+                                 NETIF_F_SCTP_CSUM | \
+                                 NETIF_F_ALL_FCOE)
 
         /*
          * If one device supports one of these features, then enable them
@@ -1105,7 +1109,12 @@ struct net_device {
          */
 #define NETIF_F_ONE_FOR_ALL     (NETIF_F_GSO_SOFTWARE | NETIF_F_GSO_ROBUST | \
                                  NETIF_F_SG | NETIF_F_HIGHDMA |         \
-                                 NETIF_F_FRAGLIST)
+                                 NETIF_F_FRAGLIST | NETIF_F_VLAN_CHALLENGED)
+        /*
+         * If one device doesn't support one of these features, then disable it
+         * for all in netdev_increment_features.
+         */
+#define NETIF_F_ALL_FOR_ALL     (NETIF_F_NOCACHE_COPY | NETIF_F_FSO)
 
         /* changeable features with no special hardware requirements */
 #define NETIF_F_SOFT_FEATURES   (NETIF_F_GSO | NETIF_F_GRO)
@@ -1134,13 +1143,16 @@ struct net_device {
         const struct header_ops *header_ops;
 
         unsigned int            flags;  /* interface flags (a la BSD)   */
+        unsigned int            priv_flags; /* Like 'flags' but invisible to userspace. */
         unsigned short          gflags;
-        unsigned int            priv_flags; /* Like 'flags' but invisible to userspace. */
         unsigned short          padded; /* How much padding added by alloc_netdev() */
 
         unsigned char           operstate; /* RFC2863 operstate */
         unsigned char           link_mode; /* mapping policy to operstate */
 
+        unsigned char           if_port;        /* Selectable AUI, TP,..*/
+        unsigned char           dma;            /* DMA channel          */
+
         unsigned int            mtu;    /* interface MTU value          */
         unsigned short          type;   /* interface hardware type      */
         unsigned short          hard_header_len;        /* hardware hdr length  */
@@ -1281,7 +1293,9 @@ struct net_device {
                NETREG_UNREGISTERED,     /* completed unregister todo */
                NETREG_RELEASED,         /* called free_netdev */
                NETREG_DUMMY,            /* dummy device for NAPI poll */
-        } reg_state:16;
+        } reg_state:8;
+
+        bool dismantle; /* device is going do be freed */
 
         enum {
                 RTNL_LINK_INITIALIZED,
@@ -2513,6 +2527,7 @@ extern struct rtnl_link_stats64 *dev_get_stats(struct net_device *dev,
 extern int              netdev_max_backlog;
 extern int              netdev_tstamp_prequeue;
 extern int              weight_p;
+extern int              bpf_jit_enable;
 extern int              netdev_set_master(struct net_device *dev, struct net_device *master);
 extern int netdev_set_bond_master(struct net_device *dev,
                                   struct net_device *master);
@@ -2550,7 +2565,9 @@ static inline u32 netdev_get_wanted_features(struct net_device *dev)
 }
 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);
 
 void netif_stacked_transfer_operstate(const struct net_device *rootdev,
                                         struct net_device *dev);
@@ -2588,13 +2605,8 @@ static inline int netif_is_bond_slave(struct net_device *dev)
 
 extern struct pernet_operations __net_initdata loopback_net_ops;
 
-static inline int dev_ethtool_get_settings(struct net_device *dev,
-                                           struct ethtool_cmd *cmd)
-{
-        if (!dev->ethtool_ops || !dev->ethtool_ops->get_settings)
-                return -EOPNOTSUPP;
-        return dev->ethtool_ops->get_settings(dev, cmd);
-}
+int dev_ethtool_get_settings(struct net_device *dev,
+                             struct ethtool_cmd *cmd);
 
 static inline u32 dev_ethtool_get_rx_csum(struct net_device *dev)
 {
diff --git a/include/linux/netfilter/ipset/ip_set_getport.h b/include/linux/netfilter/ipset/ip_set_getport.h
index 5aebd170f899..90d09300e954 100644
--- a/include/linux/netfilter/ipset/ip_set_getport.h
+++ b/include/linux/netfilter/ipset/ip_set_getport.h
@@ -22,7 +22,9 @@ static inline bool ip_set_proto_with_ports(u8 proto)
 {
         switch (proto) {
         case IPPROTO_TCP:
+        case IPPROTO_SCTP:
         case IPPROTO_UDP:
+        case IPPROTO_UDPLITE:
                 return true;
         }
         return false;
diff --git a/include/linux/netfilter/x_tables.h b/include/linux/netfilter/x_tables.h
index 37219525ff6f..32cddf78b13e 100644
--- a/include/linux/netfilter/x_tables.h
+++ b/include/linux/netfilter/x_tables.h
@@ -456,72 +456,60 @@ extern void xt_proto_fini(struct net *net, u_int8_t af);
 extern struct xt_table_info *xt_alloc_table_info(unsigned int size);
 extern void xt_free_table_info(struct xt_table_info *info);
 
-/*
- * Per-CPU spinlock associated with per-cpu table entries, and
- * with a counter for the "reading" side that allows a recursive
- * reader to avoid taking the lock and deadlocking.
- *
- * "reading" is used by ip/arp/ip6 tables rule processing which runs per-cpu.
- * It needs to ensure that the rules are not being changed while the packet
- * is being processed. In some cases, the read lock will be acquired
- * twice on the same CPU; this is okay because of the count.
- *
- * "writing" is used when reading counters.
- *  During replace any readers that are using the old tables have to complete
- *  before freeing the old table. This is handled by the write locking
- *  necessary for reading the counters.
+/**
+ * xt_recseq - recursive seqcount for netfilter use
+ * 
+ * Packet processing changes the seqcount only if no recursion happened
+ * get_counters() can use read_seqcount_begin()/read_seqcount_retry(),
+ * because we use the normal seqcount convention :
+ * Low order bit set to 1 if a writer is active.
  */
-struct xt_info_lock {
-        seqlock_t lock;
-        unsigned char readers;
-};
-DECLARE_PER_CPU(struct xt_info_lock, xt_info_locks);
+DECLARE_PER_CPU(seqcount_t, xt_recseq);
 
-/*
- * Note: we need to ensure that preemption is disabled before acquiring
- * the per-cpu-variable, so we do it as a two step process rather than
- * using "spin_lock_bh()".
- *
- * We _also_ need to disable bottom half processing before updating our
- * nesting count, to make sure that the only kind of re-entrancy is this
- * code being called by itself: since the count+lock is not an atomic
- * operation, we can allow no races.
+/**
+ * xt_write_recseq_begin - start of a write section
  *
- * _Only_ that special combination of being per-cpu and never getting
- * re-entered asynchronously means that the count is safe.
+ * Begin packet processing : all readers must wait the end
+ * 1) Must be called with preemption disabled
+ * 2) softirqs must be disabled too (or we should use irqsafe_cpu_add())
+ * Returns :
+ *  1 if no recursion on this cpu
+ *  0 if recursion detected
  */
-static inline void xt_info_rdlock_bh(void)
+static inline unsigned int xt_write_recseq_begin(void)
 {
-        struct xt_info_lock *lock;
+        unsigned int addend;
 
-        local_bh_disable();
-        lock = &__get_cpu_var(xt_info_locks);
-        if (likely(!lock->readers++))
-                write_seqlock(&lock->lock);
-}
+        /*
+         * Low order bit of sequence is set if we already
+         * called xt_write_recseq_begin().
+         */
+        addend = (__this_cpu_read(xt_recseq.sequence) + 1) & 1;
 
-static inline void xt_info_rdunlock_bh(void)
-{
-        struct xt_info_lock *lock = &__get_cpu_var(xt_info_locks);
+        /*
+         * This is kind of a write_seqcount_begin(), but addend is 0 or 1
+         * We dont check addend value to avoid a test and conditional jump,
+         * since addend is most likely 1
+         */
+        __this_cpu_add(xt_recseq.sequence, addend);
+        smp_wmb();
 
-        if (likely(!--lock->readers))
-                write_sequnlock(&lock->lock);
-        local_bh_enable();
+        return addend;
 }
 
-/*
- * The "writer" side needs to get exclusive access to the lock,
- * regardless of readers.  This must be called with bottom half
- * processing (and thus also preemption) disabled.
+/**
+ * xt_write_recseq_end - end of a write section
+ * @addend: return value from previous xt_write_recseq_begin()
+ *
+ * End packet processing : all readers can proceed
+ * 1) Must be called with preemption disabled
+ * 2) softirqs must be disabled too (or we should use irqsafe_cpu_add())
  */
-static inline void xt_info_wrlock(unsigned int cpu)
-{
-        write_seqlock(&per_cpu(xt_info_locks, cpu).lock);
-}
-
-static inline void xt_info_wrunlock(unsigned int cpu)
+static inline void xt_write_recseq_end(unsigned int addend)
 {
-        write_sequnlock(&per_cpu(xt_info_locks, cpu).lock);
+        /* this is kind of a write_seqcount_end(), but addend is 0 or 1 */
+        smp_wmb();
+        __this_cpu_add(xt_recseq.sequence, addend);
 }
 
 /*
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index 890dce242639..7e371f7df9c4 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -233,6 +233,7 @@ struct nfs4_layoutget {
         struct nfs4_layoutget_args args;
         struct nfs4_layoutget_res res;
         struct pnfs_layout_segment **lsegpp;
+        gfp_t gfp_flags;
 };
 
 struct nfs4_getdeviceinfo_args {
diff --git a/include/linux/nilfs2_fs.h b/include/linux/nilfs2_fs.h
index 8768c469e93e..7454ad7451b4 100644
--- a/include/linux/nilfs2_fs.h
+++ b/include/linux/nilfs2_fs.h
@@ -107,7 +107,7 @@ struct nilfs_super_root {
 #define NILFS_SR_DAT_OFFSET(inode_size)     NILFS_SR_MDT_OFFSET(inode_size, 0)
 #define NILFS_SR_CPFILE_OFFSET(inode_size)  NILFS_SR_MDT_OFFSET(inode_size, 1)
 #define NILFS_SR_SUFILE_OFFSET(inode_size)  NILFS_SR_MDT_OFFSET(inode_size, 2)
-#define NILFS_SR_BYTES                  (sizeof(struct nilfs_super_root))
+#define NILFS_SR_BYTES(inode_size)          NILFS_SR_MDT_OFFSET(inode_size, 3)
 
 /*
  * Maximal mount counts
@@ -845,5 +845,7 @@ struct nilfs_bdesc {
         _IOR(NILFS_IOCTL_IDENT, 0x8A, __u64)
 #define NILFS_IOCTL_RESIZE  \
         _IOW(NILFS_IOCTL_IDENT, 0x8B, __u64)
+#define NILFS_IOCTL_SET_ALLOC_RANGE  \
+        _IOW(NILFS_IOCTL_IDENT, 0x8C, __u64[2])
 
 #endif  /* _LINUX_NILFS_FS_H */
diff --git a/include/linux/nl80211.h b/include/linux/nl80211.h
index bbfa1093f606..c7ccaae15af6 100644
--- a/include/linux/nl80211.h
+++ b/include/linux/nl80211.h
@@ -77,6 +77,39 @@
  */
 
 /**
+ * DOC: Virtual interface / concurrency capabilities
+ *
+ * Some devices are able to operate with virtual MACs, they can have
+ * more than one virtual interface. The capability handling for this
+ * is a bit complex though, as there may be a number of restrictions
+ * on the types of concurrency that are supported.
+ *
+ * To start with, each device supports the interface types listed in
+ * the %NL80211_ATTR_SUPPORTED_IFTYPES attribute, but by listing the
+ * types there no concurrency is implied.
+ *
+ * Once concurrency is desired, more attributes must be observed:
+ * To start with, since some interface types are purely managed in
+ * software, like the AP-VLAN type in mac80211 for example, there's
+ * an additional list of these, they can be added at any time and
+ * are only restricted by some semantic restrictions (e.g. AP-VLAN
+ * cannot be added without a corresponding AP interface). This list
+ * is exported in the %NL80211_ATTR_SOFTWARE_IFTYPES attribute.
+ *
+ * Further, the list of supported combinations is exported. This is
+ * in the %NL80211_ATTR_INTERFACE_COMBINATIONS attribute. Basically,
+ * it exports a list of "groups", and at any point in time the
+ * interfaces that are currently active must fall into any one of
+ * the advertised groups. Within each group, there are restrictions
+ * on the number of interfaces of different types that are supported
+ * and also the number of different channels, along with potentially
+ * some other restrictions. See &enum nl80211_if_combination_attrs.
+ *
+ * All together, these attributes define the concurrency of virtual
+ * interfaces that a given device supports.
+ */
+
+/**
  * enum nl80211_commands - supported nl80211 commands
  *
  * @NL80211_CMD_UNSPEC: unspecified command to catch errors
@@ -203,6 +236,28 @@
  * @NL80211_CMD_SCAN_ABORTED: scan was aborted, for unspecified reasons,
  *      partial scan results may be available
  *
+ * @NL80211_CMD_START_SCHED_SCAN: start a scheduled scan at certain
+ *      intervals, as specified by %NL80211_ATTR_SCHED_SCAN_INTERVAL.
+ *      Like with normal scans, if SSIDs (%NL80211_ATTR_SCAN_SSIDS)
+ *      are passed, they are used in the probe requests.  For
+ *      broadcast, a broadcast SSID must be passed (ie. an empty
+ *      string).  If no SSID is passed, no probe requests are sent and
+ *      a passive scan is performed.  %NL80211_ATTR_SCAN_FREQUENCIES,
+ *      if passed, define which channels should be scanned; if not
+ *      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_SCHED_SCAN_RESULTS: indicates that there are scheduled scan
+ *      results available.
+ * @NL80211_CMD_SCHED_SCAN_STOPPED: indicates that the scheduled scan has
+ *      stopped.  The driver may issue this event at any time during a
+ *      scheduled scan.  One reason for stopping the scan is if the hardware
+ *      does not support starting an association or a normal scan while running
+ *      a scheduled scan.  This event is also sent when the
+ *      %NL80211_CMD_STOP_SCHED_SCAN command is received or when the interface
+ *      is brought down while a scheduled scan was running.
+ *
  * @NL80211_CMD_GET_SURVEY: get survey resuls, e.g. channel occupation
  *      or noise level
  * @NL80211_CMD_NEW_SURVEY_RESULTS: survey data notification (as a reply to
@@ -410,6 +465,24 @@
  *      notification. This event is used to indicate that an unprotected
  *      disassociation frame was dropped when MFP is in use.
  *
+ * @NL80211_CMD_NEW_PEER_CANDIDATE: Notification on the reception of a
+ *      beacon or probe response from a compatible mesh peer.  This is only
+ *      sent while no station information (sta_info) exists for the new peer
+ *      candidate and when @NL80211_MESH_SETUP_USERSPACE_AUTH is set.  On
+ *      reception of this notification, userspace may decide to create a new
+ *      station (@NL80211_CMD_NEW_STATION).  To stop this notification from
+ *      reoccurring, the userspace authentication daemon may want to create the
+ *      new station with the AUTHENTICATED flag unset and maybe change it later
+ *      depending on the authentication result.
+ *
+ * @NL80211_CMD_GET_WOWLAN: get Wake-on-Wireless-LAN (WoWLAN) settings.
+ * @NL80211_CMD_SET_WOWLAN: set Wake-on-Wireless-LAN (WoWLAN) settings.
+ *      Since wireless is more complex than wired ethernet, it supports
+ *      various triggers. These triggers can be configured through this
+ *      command with the %NL80211_ATTR_WOWLAN_TRIGGERS attribute. For
+ *      more background information, see
+ *      http://wireless.kernel.org/en/users/Documentation/WoWLAN.
+ *
  * @NL80211_CMD_MAX: highest used command number
  * @__NL80211_CMD_AFTER_LAST: internal use
  */
@@ -522,6 +595,16 @@ enum nl80211_commands {
         NL80211_CMD_UNPROT_DEAUTHENTICATE,
         NL80211_CMD_UNPROT_DISASSOCIATE,
 
+        NL80211_CMD_NEW_PEER_CANDIDATE,
+
+        NL80211_CMD_GET_WOWLAN,
+        NL80211_CMD_SET_WOWLAN,
+
+        NL80211_CMD_START_SCHED_SCAN,
+        NL80211_CMD_STOP_SCHED_SCAN,
+        NL80211_CMD_SCHED_SCAN_RESULTS,
+        NL80211_CMD_SCHED_SCAN_STOPPED,
+
         /* add new commands above here */
 
         /* used to define NL80211_CMD_MAX below */
@@ -545,6 +628,7 @@ enum nl80211_commands {
 /* source-level API compatibility */
 #define NL80211_CMD_GET_MESH_PARAMS NL80211_CMD_GET_MESH_CONFIG
 #define NL80211_CMD_SET_MESH_PARAMS NL80211_CMD_SET_MESH_CONFIG
+#define NL80211_MESH_SETUP_VENDOR_PATH_SEL_IE NL80211_MESH_SETUP_IE
 
 /**
  * enum nl80211_attrs - nl80211 netlink attributes
@@ -886,6 +970,31 @@ enum nl80211_commands {
  *      changed once the mesh is active.
  * @NL80211_ATTR_MESH_CONFIG: Mesh configuration parameters, a nested attribute
  *      containing attributes from &enum nl80211_meshconf_params.
+ * @NL80211_ATTR_SUPPORT_MESH_AUTH: Currently, this means the underlying driver
+ *      allows auth frames in a mesh to be passed to userspace for processing via
+ *      the @NL80211_MESH_SETUP_USERSPACE_AUTH flag.
+ * @NL80211_ATTR_STA_PLINK_STATE: The state of a mesh peer link as
+ *      defined in &enum nl80211_plink_state. Used when userspace is
+ *      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: 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
+ *      triggers.
+
+ * @NL80211_ATTR_SCHED_SCAN_INTERVAL: Interval between scheduled scan
+ *      cycles, in msecs.
+ *
+ * @NL80211_ATTR_INTERFACE_COMBINATIONS: Nested attribute listing the supported
+ *      interface combinations. In each nested item, it contains attributes
+ *      defined in &enum nl80211_if_combination_attrs.
+ * @NL80211_ATTR_SOFTWARE_IFTYPES: Nested attribute (just like
+ *      %NL80211_ATTR_SUPPORTED_IFTYPES) containing the interface types that
+ *      are managed in software: interfaces of these types aren't subject to
+ *      any restrictions in their number or combinations.
  *
  * @NL80211_ATTR_MAX: highest attribute number currently defined
  * @__NL80211_ATTR_AFTER_LAST: internal use
@@ -1074,6 +1183,17 @@ enum nl80211_attrs {
         NL80211_ATTR_WIPHY_ANTENNA_AVAIL_TX,
         NL80211_ATTR_WIPHY_ANTENNA_AVAIL_RX,
 
+        NL80211_ATTR_SUPPORT_MESH_AUTH,
+        NL80211_ATTR_STA_PLINK_STATE,
+
+        NL80211_ATTR_WOWLAN_TRIGGERS,
+        NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED,
+
+        NL80211_ATTR_SCHED_SCAN_INTERVAL,
+
+        NL80211_ATTR_INTERFACE_COMBINATIONS,
+        NL80211_ATTR_SOFTWARE_IFTYPES,
+
         /* add attributes here, update the policy in nl80211.c */
 
         __NL80211_ATTR_AFTER_LAST,
@@ -1126,7 +1246,9 @@ enum nl80211_attrs {
  * @NL80211_IFTYPE_ADHOC: independent BSS member
  * @NL80211_IFTYPE_STATION: managed BSS member
  * @NL80211_IFTYPE_AP: access point
- * @NL80211_IFTYPE_AP_VLAN: VLAN interface for access points
+ * @NL80211_IFTYPE_AP_VLAN: VLAN interface for access points; VLAN interfaces
+ *      are a bit special in that they must always be tied to a pre-existing
+ *      AP type interface.
  * @NL80211_IFTYPE_WDS: wireless distribution interface
  * @NL80211_IFTYPE_MONITOR: monitor interface receiving all frames
  * @NL80211_IFTYPE_MESH_POINT: mesh point
@@ -1168,6 +1290,7 @@ enum nl80211_iftype {
  *      with short barker preamble
  * @NL80211_STA_FLAG_WME: station is WME/QoS capable
  * @NL80211_STA_FLAG_MFP: station uses management frame protection
+ * @NL80211_STA_FLAG_AUTHENTICATED: station is authenticated
  * @NL80211_STA_FLAG_MAX: highest station flag number currently defined
  * @__NL80211_STA_FLAG_AFTER_LAST: internal use
  */
@@ -1177,6 +1300,7 @@ enum nl80211_sta_flags {
         NL80211_STA_FLAG_SHORT_PREAMBLE,
         NL80211_STA_FLAG_WME,
         NL80211_STA_FLAG_MFP,
+        NL80211_STA_FLAG_AUTHENTICATED,
 
         /* keep last */
         __NL80211_STA_FLAG_AFTER_LAST,
@@ -1222,6 +1346,36 @@ enum nl80211_rate_info {
 };
 
 /**
+ * enum nl80211_sta_bss_param - BSS information collected by STA
+ *
+ * These attribute types are used with %NL80211_STA_INFO_BSS_PARAM
+ * when getting information about the bitrate of a station.
+ *
+ * @__NL80211_STA_BSS_PARAM_INVALID: attribute number 0 is reserved
+ * @NL80211_STA_BSS_PARAM_CTS_PROT: whether CTS protection is enabled (flag)
+ * @NL80211_STA_BSS_PARAM_SHORT_PREAMBLE:  whether short preamble is enabled
+ *      (flag)
+ * @NL80211_STA_BSS_PARAM_SHORT_SLOT_TIME:  whether short slot time is enabled
+ *      (flag)
+ * @NL80211_STA_BSS_PARAM_DTIM_PERIOD: DTIM period for beaconing (u8)
+ * @NL80211_STA_BSS_PARAM_BEACON_INTERVAL: Beacon interval (u16)
+ * @NL80211_STA_BSS_PARAM_MAX: highest sta_bss_param number currently defined
+ * @__NL80211_STA_BSS_PARAM_AFTER_LAST: internal use
+ */
+enum nl80211_sta_bss_param {
+        __NL80211_STA_BSS_PARAM_INVALID,
+        NL80211_STA_BSS_PARAM_CTS_PROT,
+        NL80211_STA_BSS_PARAM_SHORT_PREAMBLE,
+        NL80211_STA_BSS_PARAM_SHORT_SLOT_TIME,
+        NL80211_STA_BSS_PARAM_DTIM_PERIOD,
+        NL80211_STA_BSS_PARAM_BEACON_INTERVAL,
+
+        /* keep last */
+        __NL80211_STA_BSS_PARAM_AFTER_LAST,
+        NL80211_STA_BSS_PARAM_MAX = __NL80211_STA_BSS_PARAM_AFTER_LAST - 1
+};
+
+/**
  * enum nl80211_sta_info - station information
  *
  * These attribute types are used with %NL80211_ATTR_STA_INFO
@@ -1233,7 +1387,7 @@ enum nl80211_rate_info {
  * @NL80211_STA_INFO_TX_BYTES: total transmitted bytes (u32, to this station)
  * @NL80211_STA_INFO_SIGNAL: signal strength of last received PPDU (u8, dBm)
  * @NL80211_STA_INFO_TX_BITRATE: current unicast tx rate, nested attribute
- *      containing info as possible, see &enum nl80211_sta_info_txrate.
+ *      containing info as possible, see &enum nl80211_rate_info
  * @NL80211_STA_INFO_RX_PACKETS: total received packet (u32, from this station)
  * @NL80211_STA_INFO_TX_PACKETS: total transmitted packets (u32, to this
  *      station)
@@ -1243,8 +1397,12 @@ enum nl80211_rate_info {
  * @NL80211_STA_INFO_LLID: the station's mesh LLID
  * @NL80211_STA_INFO_PLID: the station's mesh PLID
  * @NL80211_STA_INFO_PLINK_STATE: peer link state for the station
+ *      (see %enum nl80211_plink_state)
  * @NL80211_STA_INFO_RX_BITRATE: last unicast data frame rx rate, nested
  *      attribute, like NL80211_STA_INFO_TX_BITRATE.
+ * @NL80211_STA_INFO_BSS_PARAM: current station's view of BSS, nested attribute
+ *     containing info as possible, see &enum nl80211_sta_bss_param
+ * @NL80211_STA_INFO_CONNECTED_TIME: time since the station is last connected
  * @__NL80211_STA_INFO_AFTER_LAST: internal
  * @NL80211_STA_INFO_MAX: highest possible station info attribute
  */
@@ -1264,6 +1422,8 @@ enum nl80211_sta_info {
         NL80211_STA_INFO_TX_FAILED,
         NL80211_STA_INFO_SIGNAL_AVG,
         NL80211_STA_INFO_RX_BITRATE,
+        NL80211_STA_INFO_BSS_PARAM,
+        NL80211_STA_INFO_CONNECTED_TIME,
 
         /* keep last */
         __NL80211_STA_INFO_AFTER_LAST,
@@ -1686,9 +1846,21 @@ enum nl80211_meshconf_params {
  * vendor specific path metric or disable it to use the default Airtime
  * metric.
  *
- * @NL80211_MESH_SETUP_VENDOR_PATH_SEL_IE: A vendor specific information
- * element that vendors will use to identify the path selection methods and
- * metrics in use.
+ * @NL80211_MESH_SETUP_IE: Information elements for this mesh, for instance, a
+ * robust security network ie, or a vendor specific information element that
+ * vendors will use to identify the path selection methods and metrics in use.
+ *
+ * @NL80211_MESH_SETUP_USERSPACE_AUTH: Enable this option if an authentication
+ * daemon will be authenticating mesh candidates.
+ *
+ * @NL80211_MESH_SETUP_USERSPACE_AMPE: Enable this option if an authentication
+ * daemon will be securing peer link frames.  AMPE is a secured version of Mesh
+ * Peering Management (MPM) and is implemented with the assistance of a
+ * userspace daemon.  When this flag is set, the kernel will send peer
+ * management frames to a userspace daemon that will implement AMPE
+ * functionality (security capabilities selection, key confirmation, and key
+ * management).  When the flag is unset (default), the kernel can autonomously
+ * complete (unsecured) mesh peering without the need of a userspace daemon.
  *
  * @NL80211_MESH_SETUP_ATTR_MAX: highest possible mesh setup attribute number
  * @__NL80211_MESH_SETUP_ATTR_AFTER_LAST: Internal use
@@ -1697,7 +1869,9 @@ enum nl80211_mesh_setup_params {
         __NL80211_MESH_SETUP_INVALID,
         NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL,
         NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC,
-        NL80211_MESH_SETUP_VENDOR_PATH_SEL_IE,
+        NL80211_MESH_SETUP_IE,
+        NL80211_MESH_SETUP_USERSPACE_AUTH,
+        NL80211_MESH_SETUP_USERSPACE_AMPE,
 
         /* keep last */
         __NL80211_MESH_SETUP_ATTR_AFTER_LAST,
@@ -2002,4 +2176,189 @@ enum nl80211_tx_power_setting {
         NL80211_TX_POWER_FIXED,
 };
 
+/**
+ * enum nl80211_wowlan_packet_pattern_attr - WoWLAN packet pattern attribute
+ * @__NL80211_WOWLAN_PKTPAT_INVALID: invalid number for nested attribute
+ * @NL80211_WOWLAN_PKTPAT_PATTERN: the pattern, values where the mask has
+ *      a zero bit are ignored
+ * @NL80211_WOWLAN_PKTPAT_MASK: pattern mask, must be long enough to have
+ *      a bit for each byte in the pattern. The lowest-order bit corresponds
+ *      to the first byte of the pattern, but the bytes of the pattern are
+ *      in a little-endian-like format, i.e. the 9th byte of the pattern
+ *      corresponds to the lowest-order bit in the second byte of the mask.
+ *      For example: The match 00:xx:00:00:xx:00:00:00:00:xx:xx:xx (where
+ *      xx indicates "don't care") would be represented by a pattern of
+ *      twelve zero bytes, and a mask of "0xed,0x07".
+ *      Note that the pattern matching is done as though frames were not
+ *      802.11 frames but 802.3 frames, i.e. the frame is fully unpacked
+ *      first (including SNAP header unpacking) and then matched.
+ * @NUM_NL80211_WOWLAN_PKTPAT: number of attributes
+ * @MAX_NL80211_WOWLAN_PKTPAT: max attribute number
+ */
+enum nl80211_wowlan_packet_pattern_attr {
+        __NL80211_WOWLAN_PKTPAT_INVALID,
+        NL80211_WOWLAN_PKTPAT_MASK,
+        NL80211_WOWLAN_PKTPAT_PATTERN,
+
+        NUM_NL80211_WOWLAN_PKTPAT,
+        MAX_NL80211_WOWLAN_PKTPAT = NUM_NL80211_WOWLAN_PKTPAT - 1,
+};
+
+/**
+ * struct nl80211_wowlan_pattern_support - pattern support information
+ * @max_patterns: maximum number of patterns supported
+ * @min_pattern_len: minimum length of each pattern
+ * @max_pattern_len: maximum length of each pattern
+ *
+ * This struct is carried in %NL80211_WOWLAN_TRIG_PKT_PATTERN when
+ * that is part of %NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED in the
+ * capability information given by the kernel to userspace.
+ */
+struct nl80211_wowlan_pattern_support {
+        __u32 max_patterns;
+        __u32 min_pattern_len;
+        __u32 max_pattern_len;
+} __attribute__((packed));
+
+/**
+ * enum nl80211_wowlan_triggers - WoWLAN trigger definitions
+ * @__NL80211_WOWLAN_TRIG_INVALID: invalid number for nested attributes
+ * @NL80211_WOWLAN_TRIG_ANY: wake up on any activity, do not really put
+ *      the chip into a special state -- works best with chips that have
+ *      support for low-power operation already (flag)
+ * @NL80211_WOWLAN_TRIG_DISCONNECT: wake up on disconnect, the way disconnect
+ *      is detected is implementation-specific (flag)
+ * @NL80211_WOWLAN_TRIG_MAGIC_PKT: wake up on magic packet (6x 0xff, followed
+ *      by 16 repetitions of MAC addr, anywhere in payload) (flag)
+ * @NL80211_WOWLAN_TRIG_PKT_PATTERN: wake up on the specified packet patterns
+ *      which are passed in an array of nested attributes, each nested attribute
+ *      defining a with attributes from &struct nl80211_wowlan_trig_pkt_pattern.
+ *      Each pattern defines a wakeup packet. The matching is done on the MSDU,
+ *      i.e. as though the packet was an 802.3 packet, so the pattern matching
+ *      is done after the packet is converted to the MSDU.
+ *
+ *      In %NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED, it is a binary attribute
+ *      carrying a &struct nl80211_wowlan_pattern_support.
+ * @NUM_NL80211_WOWLAN_TRIG: number of wake on wireless triggers
+ * @MAX_NL80211_WOWLAN_TRIG: highest wowlan trigger attribute number
+ */
+enum nl80211_wowlan_triggers {
+        __NL80211_WOWLAN_TRIG_INVALID,
+        NL80211_WOWLAN_TRIG_ANY,
+        NL80211_WOWLAN_TRIG_DISCONNECT,
+        NL80211_WOWLAN_TRIG_MAGIC_PKT,
+        NL80211_WOWLAN_TRIG_PKT_PATTERN,
+
+        /* keep last */
+        NUM_NL80211_WOWLAN_TRIG,
+        MAX_NL80211_WOWLAN_TRIG = NUM_NL80211_WOWLAN_TRIG - 1
+};
+
+/**
+ * enum nl80211_iface_limit_attrs - limit attributes
+ * @NL80211_IFACE_LIMIT_UNSPEC: (reserved)
+ * @NL80211_IFACE_LIMIT_MAX: maximum number of interfaces that
+ *      can be chosen from this set of interface types (u32)
+ * @NL80211_IFACE_LIMIT_TYPES: nested attribute containing a
+ *      flag attribute for each interface type in this set
+ * @NUM_NL80211_IFACE_LIMIT: number of attributes
+ * @MAX_NL80211_IFACE_LIMIT: highest attribute number
+ */
+enum nl80211_iface_limit_attrs {
+        NL80211_IFACE_LIMIT_UNSPEC,
+        NL80211_IFACE_LIMIT_MAX,
+        NL80211_IFACE_LIMIT_TYPES,
+
+        /* keep last */
+        NUM_NL80211_IFACE_LIMIT,
+        MAX_NL80211_IFACE_LIMIT = NUM_NL80211_IFACE_LIMIT - 1
+};
+
+/**
+ * enum nl80211_if_combination_attrs -- interface combination attributes
+ *
+ * @NL80211_IFACE_COMB_UNSPEC: (reserved)
+ * @NL80211_IFACE_COMB_LIMITS: Nested attributes containing the limits
+ *      for given interface types, see &enum nl80211_iface_limit_attrs.
+ * @NL80211_IFACE_COMB_MAXNUM: u32 attribute giving the total number of
+ *      interfaces that can be created in this group. This number doesn't
+ *      apply to interfaces purely managed in software, which are listed
+ *      in a separate attribute %NL80211_ATTR_INTERFACES_SOFTWARE.
+ * @NL80211_IFACE_COMB_STA_AP_BI_MATCH: flag attribute specifying that
+ *      beacon intervals within this group must be all the same even for
+ *      infrastructure and AP/GO combinations, i.e. the GO(s) must adopt
+ *      the infrastructure network's beacon interval.
+ * @NL80211_IFACE_COMB_NUM_CHANNELS: u32 attribute specifying how many
+ *      different channels may be used within this group.
+ * @NUM_NL80211_IFACE_COMB: number of attributes
+ * @MAX_NL80211_IFACE_COMB: highest attribute number
+ *
+ * Examples:
+ *      limits = [ #{STA} <= 1, #{AP} <= 1 ], matching BI, channels = 1, max = 2
+ *      => allows an AP and a STA that must match BIs
+ *
+ *      numbers = [ #{AP, P2P-GO} <= 8 ], channels = 1, max = 8
+ *      => allows 8 of AP/GO
+ *
+ *      numbers = [ #{STA} <= 2 ], channels = 2, max = 2
+ *      => allows two STAs on different channels
+ *
+ *      numbers = [ #{STA} <= 1, #{P2P-client,P2P-GO} <= 3 ], max = 4
+ *      => allows a STA plus three P2P interfaces
+ *
+ * The list of these four possiblities could completely be contained
+ * within the %NL80211_ATTR_INTERFACE_COMBINATIONS attribute to indicate
+ * that any of these groups must match.
+ *
+ * "Combinations" of just a single interface will not be listed here,
+ * a single interface of any valid interface type is assumed to always
+ * be possible by itself. This means that implicitly, for each valid
+ * interface type, the following group always exists:
+ *      numbers = [ #{<type>} <= 1 ], channels = 1, max = 1
+ */
+enum nl80211_if_combination_attrs {
+        NL80211_IFACE_COMB_UNSPEC,
+        NL80211_IFACE_COMB_LIMITS,
+        NL80211_IFACE_COMB_MAXNUM,
+        NL80211_IFACE_COMB_STA_AP_BI_MATCH,
+        NL80211_IFACE_COMB_NUM_CHANNELS,
+
+        /* keep last */
+        NUM_NL80211_IFACE_COMB,
+        MAX_NL80211_IFACE_COMB = NUM_NL80211_IFACE_COMB - 1
+};
+
+
+/**
+ * enum nl80211_plink_state - state of a mesh peer link finite state machine
+ *
+ * @NL80211_PLINK_LISTEN: initial state, considered the implicit
+ *      state of non existant mesh peer links
+ * @NL80211_PLINK_OPN_SNT: mesh plink open frame has been sent to
+ *      this mesh peer
+ * @NL80211_PLINK_OPN_RCVD: mesh plink open frame has been received
+ *      from this mesh peer
+ * @NL80211_PLINK_CNF_RCVD: mesh plink confirm frame has been
+ *      received from this mesh peer
+ * @NL80211_PLINK_ESTAB: mesh peer link is established
+ * @NL80211_PLINK_HOLDING: mesh peer link is being closed or cancelled
+ * @NL80211_PLINK_BLOCKED: all frames transmitted from this mesh
+ *      plink are discarded
+ * @NUM_NL80211_PLINK_STATES: number of peer link states
+ * @MAX_NL80211_PLINK_STATES: highest numerical value of plink states
+ */
+enum nl80211_plink_state {
+        NL80211_PLINK_LISTEN,
+        NL80211_PLINK_OPN_SNT,
+        NL80211_PLINK_OPN_RCVD,
+        NL80211_PLINK_CNF_RCVD,
+        NL80211_PLINK_ESTAB,
+        NL80211_PLINK_HOLDING,
+        NL80211_PLINK_BLOCKED,
+
+        /* keep last */
+        NUM_NL80211_PLINK_STATES,
+        MAX_NL80211_PLINK_STATES = NUM_NL80211_PLINK_STATES - 1
+};
+
 #endif /* __LINUX_NL80211_H */
diff --git a/include/linux/nmi.h b/include/linux/nmi.h
index c536f8545f74..2d304efc89df 100644
--- a/include/linux/nmi.h
+++ b/include/linux/nmi.h
@@ -45,11 +45,12 @@ static inline bool trigger_all_cpu_backtrace(void)
 
 #ifdef CONFIG_LOCKUP_DETECTOR
 int hw_nmi_is_cpu_stuck(struct pt_regs *);
-u64 hw_nmi_get_sample_period(void);
+u64 hw_nmi_get_sample_period(int watchdog_thresh);
 extern int watchdog_enabled;
+extern int watchdog_thresh;
 struct ctl_table;
-extern int proc_dowatchdog_enabled(struct ctl_table *, int ,
-                        void __user *, size_t *, loff_t *);
+extern int proc_dowatchdog(struct ctl_table *, int ,
+                           void __user *, size_t *, loff_t *);
 #endif
 
 #endif
diff --git a/include/linux/notifier.h b/include/linux/notifier.h
index 621dfa16acc0..c0688b0168b3 100644
--- a/include/linux/notifier.h
+++ b/include/linux/notifier.h
@@ -209,8 +209,9 @@ static inline int notifier_to_errno(int ret)
 #define NETDEV_POST_TYPE_CHANGE 0x000F
 #define NETDEV_POST_INIT        0x0010
 #define NETDEV_UNREGISTER_BATCH 0x0011
-#define NETDEV_BONDING_DESLAVE  0x0012
+#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
diff --git a/include/linux/of_device.h b/include/linux/of_device.h
index 8bfe6c1d4365..ae5638480ef2 100644
--- a/include/linux/of_device.h
+++ b/include/linux/of_device.h
@@ -21,8 +21,7 @@ extern void of_device_make_bus_id(struct device *dev);
 static inline int of_driver_match_device(struct device *dev,
                                          const struct device_driver *drv)
 {
-        dev->of_match = of_match_device(drv->of_match_table, dev);
-        return dev->of_match != NULL;
+        return of_match_device(drv->of_match_table, dev) != NULL;
 }
 
 extern struct platform_device *of_dev_get(struct platform_device *dev);
@@ -58,6 +57,11 @@ static inline int of_device_uevent(struct device *dev,
 
 static inline void of_device_node_put(struct device *dev) { }
 
+static inline const struct of_device_id *of_match_device(
+                const struct of_device_id *matches, const struct device *dev)
+{
+        return NULL;
+}
 #endif /* CONFIG_OF_DEVICE */
 
 #endif /* _LINUX_OF_DEVICE_H */
diff --git a/include/linux/of_irq.h b/include/linux/of_irq.h
index 109e013b1772..e6955f5d1f08 100644
--- a/include/linux/of_irq.h
+++ b/include/linux/of_irq.h
@@ -68,6 +68,7 @@ extern int of_irq_to_resource(struct device_node *dev, int index,
 extern int of_irq_count(struct device_node *dev);
 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 */
diff --git a/include/linux/oom.h b/include/linux/oom.h
index 5e3aa8311c5e..4952fb874ad3 100644
--- a/include/linux/oom.h
+++ b/include/linux/oom.h
@@ -40,6 +40,8 @@ enum oom_constraint {
         CONSTRAINT_MEMCG,
 };
 
+extern int test_set_oom_score_adj(int new_val);
+
 extern unsigned int oom_badness(struct task_struct *p, struct mem_cgroup *mem,
                         const nodemask_t *nodemask, unsigned long totalpages);
 extern int try_set_zonelist_oom(struct zonelist *zonelist, gfp_t gfp_flags);
diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h
index 811183de1ef5..79a6700b7162 100644
--- a/include/linux/page-flags.h
+++ b/include/linux/page-flags.h
@@ -308,7 +308,7 @@ static inline void SetPageUptodate(struct page *page)
 {
 #ifdef CONFIG_S390
         if (!test_and_set_bit(PG_uptodate, &page->flags))
-                page_clear_dirty(page, 0);
+                page_set_storage_key(page_to_pfn(page), PAGE_DEFAULT_KEY, 0);
 #else
         /*
          * Memory barrier must be issued before setting the PG_uptodate bit,
diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
index c11950652646..716875e53520 100644
--- a/include/linux/pagemap.h
+++ b/include/linux/pagemap.h
@@ -219,6 +219,12 @@ static inline struct page *page_cache_alloc_cold(struct address_space *x)
         return __page_cache_alloc(mapping_gfp_mask(x)|__GFP_COLD);
 }
 
+static inline struct page *page_cache_alloc_readahead(struct address_space *x)
+{
+        return __page_cache_alloc(mapping_gfp_mask(x) |
+                                  __GFP_COLD | __GFP_NORETRY | __GFP_NOWARN);
+}
+
 typedef int filler_t(void *, struct page *);
 
 extern struct page * find_get_page(struct address_space *mapping,
@@ -357,6 +363,15 @@ static inline int lock_page_or_retry(struct page *page, struct mm_struct *mm,
  */
 extern void wait_on_page_bit(struct page *page, int bit_nr);
 
+extern int wait_on_page_bit_killable(struct page *page, int bit_nr);
+
+static inline int wait_on_page_locked_killable(struct page *page)
+{
+        if (PageLocked(page))
+                return wait_on_page_bit_killable(page, PG_locked);
+        return 0;
+}
+
 /* 
  * Wait for a page to be unlocked.
  *
diff --git a/include/linux/pci-aspm.h b/include/linux/pci-aspm.h
index 67cb3ae38016..7cea7b6c1413 100644
--- a/include/linux/pci-aspm.h
+++ b/include/linux/pci-aspm.h
@@ -28,6 +28,7 @@ extern void pcie_aspm_exit_link_state(struct pci_dev *pdev);
 extern void pcie_aspm_pm_state_change(struct pci_dev *pdev);
 extern void pcie_aspm_powersave_config_link(struct pci_dev *pdev);
 extern void pci_disable_link_state(struct pci_dev *pdev, int state);
+extern void pci_disable_link_state_locked(struct pci_dev *pdev, int state);
 extern void pcie_clear_aspm(void);
 extern void pcie_no_aspm(void);
 #else
diff --git a/include/linux/pci-ats.h b/include/linux/pci-ats.h
new file mode 100644
index 000000000000..655824fa4c76
--- /dev/null
+++ b/include/linux/pci-ats.h
@@ -0,0 +1,52 @@
+#ifndef LINUX_PCI_ATS_H
+#define LINUX_PCI_ATS_H
+
+/* Address Translation Service */
+struct pci_ats {
+        int pos;        /* capability position */
+        int stu;        /* Smallest Translation Unit */
+        int qdep;       /* Invalidate Queue Depth */
+        int ref_cnt;    /* Physical Function reference count */
+        unsigned int is_enabled:1;      /* Enable bit is set */
+};
+
+#ifdef CONFIG_PCI_IOV
+
+extern int pci_enable_ats(struct pci_dev *dev, int ps);
+extern void pci_disable_ats(struct pci_dev *dev);
+extern int pci_ats_queue_depth(struct pci_dev *dev);
+/**
+ * pci_ats_enabled - query the ATS status
+ * @dev: the PCI device
+ *
+ * Returns 1 if ATS capability is enabled, or 0 if not.
+ */
+static inline int pci_ats_enabled(struct pci_dev *dev)
+{
+        return dev->ats && dev->ats->is_enabled;
+}
+
+#else /* CONFIG_PCI_IOV */
+
+static inline int pci_enable_ats(struct pci_dev *dev, int ps)
+{
+        return -ENODEV;
+}
+
+static inline void pci_disable_ats(struct pci_dev *dev)
+{
+}
+
+static inline int pci_ats_queue_depth(struct pci_dev *dev)
+{
+        return -ENODEV;
+}
+
+static inline int pci_ats_enabled(struct pci_dev *dev)
+{
+        return 0;
+}
+
+#endif /* CONFIG_PCI_IOV */
+
+#endif /* LINUX_PCI_ATS_H*/
diff --git a/include/linux/pci.h b/include/linux/pci.h
index 96f70d7e058d..c446b5ca2d38 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -214,12 +214,17 @@ enum pci_bus_speed {
         PCI_SPEED_UNKNOWN               = 0xff,
 };
 
-struct pci_cap_saved_state {
-        struct hlist_node next;
+struct pci_cap_saved_data {
         char cap_nr;
+        unsigned int size;
         u32 data[0];
 };
 
+struct pci_cap_saved_state {
+        struct hlist_node next;
+        struct pci_cap_saved_data cap;
+};
+
 struct pcie_link_state;
 struct pci_vpd;
 struct pci_sriov;
@@ -366,7 +371,7 @@ static inline struct pci_cap_saved_state *pci_find_saved_cap(
         struct hlist_node *pos;
 
         hlist_for_each_entry(tmp, pos, &pci_dev->saved_cap_space, next) {
-                if (tmp->cap_nr == cap)
+                if (tmp->cap.cap_nr == cap)
                         return tmp;
         }
         return NULL;
@@ -807,6 +812,10 @@ size_t pci_get_rom_size(struct pci_dev *pdev, void __iomem *rom, size_t size);
 /* Power management related routines */
 int pci_save_state(struct pci_dev *dev);
 void pci_restore_state(struct pci_dev *dev);
+struct pci_saved_state *pci_store_saved_state(struct pci_dev *dev);
+int pci_load_saved_state(struct pci_dev *dev, struct pci_saved_state *state);
+int pci_load_and_free_saved_state(struct pci_dev *dev,
+                                  struct pci_saved_state **state);
 int __pci_complete_power_transition(struct pci_dev *dev, pci_power_t state);
 int pci_set_power_state(struct pci_dev *dev, pci_power_t state);
 pci_power_t pci_choose_state(struct pci_dev *dev, pm_message_t state);
@@ -828,6 +837,23 @@ static inline int pci_enable_wake(struct pci_dev *dev, pci_power_t state,
         return __pci_enable_wake(dev, state, false, enable);
 }
 
+#define PCI_EXP_IDO_REQUEST     (1<<0)
+#define PCI_EXP_IDO_COMPLETION  (1<<1)
+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,
+};
+int pci_enable_obff(struct pci_dev *dev, enum pci_obff_signal_type);
+void pci_disable_obff(struct pci_dev *dev);
+
+bool pci_ltr_supported(struct pci_dev *dev);
+int pci_enable_ltr(struct pci_dev *dev);
+void pci_disable_ltr(struct pci_dev *dev);
+int pci_set_ltr(struct pci_dev *dev, int snoop_lat_ns, int nosnoop_lat_ns);
+
 /* For use by arch with custom probe code */
 void set_pcie_port_type(struct pci_dev *pdev);
 void set_pcie_hotplug_bridge(struct pci_dev *pdev);
@@ -915,8 +941,11 @@ int pci_cfg_space_size_ext(struct pci_dev *dev);
 int pci_cfg_space_size(struct pci_dev *dev);
 unsigned char pci_bus_max_busnr(struct pci_bus *bus);
 
+#define PCI_VGA_STATE_CHANGE_BRIDGE (1 << 0)
+#define PCI_VGA_STATE_CHANGE_DECODES (1 << 1)
+
 int pci_set_vga_state(struct pci_dev *pdev, bool decode,
-                      unsigned int command_bits, bool change_bridge);
+                      unsigned int command_bits, u32 flags);
 /* kmem_cache style wrapper around pci_alloc_consistent() */
 
 #include <linux/pci-dma.h>
@@ -1061,7 +1090,7 @@ static inline int pci_proc_domain(struct pci_bus *bus)
 
 /* some architectures require additional setup to direct VGA traffic */
 typedef int (*arch_set_vga_state_t)(struct pci_dev *pdev, bool decode,
-                      unsigned int command_bits, bool change_bridge);
+                      unsigned int command_bits, u32 flags);
 extern void pci_register_set_vga_state(arch_set_vga_state_t func);
 
 #else /* CONFIG_PCI is not enabled */
@@ -1207,6 +1236,23 @@ static inline int pci_enable_wake(struct pci_dev *dev, pci_power_t state,
         return 0;
 }
 
+static inline void pci_enable_ido(struct pci_dev *dev, unsigned long type)
+{
+}
+
+static inline void pci_disable_ido(struct pci_dev *dev, unsigned long type)
+{
+}
+
+static inline int pci_enable_obff(struct pci_dev *dev, unsigned long type)
+{
+        return 0;
+}
+
+static inline void pci_disable_obff(struct pci_dev *dev)
+{
+}
+
 static inline int pci_request_regions(struct pci_dev *dev, const char *res_name)
 {
         return -EIO;
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 8abe8d78c4bf..24787b751286 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -608,6 +608,8 @@
 #define PCI_DEVICE_ID_MATROX_G550       0x2527
 #define PCI_DEVICE_ID_MATROX_VIA        0x4536
 
+#define PCI_VENDOR_ID_MOBILITY_ELECTRONICS      0x14f2
+
 #define PCI_VENDOR_ID_CT                0x102c
 #define PCI_DEVICE_ID_CT_69000          0x00c0
 #define PCI_DEVICE_ID_CT_65545          0x00d8
@@ -2481,6 +2483,8 @@
 #define PCI_DEVICE_ID_INTEL_COUGARPOINT_LPC_MAX 0x1c5f
 #define PCI_DEVICE_ID_INTEL_PATSBURG_LPC_0      0x1d40
 #define PCI_DEVICE_ID_INTEL_PATSBURG_LPC_1      0x1d41
+#define PCI_DEVICE_ID_INTEL_PANTHERPOINT_LPC_MIN        0x1e40
+#define PCI_DEVICE_ID_INTEL_PANTHERPOINT_LPC_MAX        0x1e5f
 #define PCI_DEVICE_ID_INTEL_DH89XXCC_LPC_MIN    0x2310
 #define PCI_DEVICE_ID_INTEL_DH89XXCC_LPC_MAX    0x231f
 #define PCI_DEVICE_ID_INTEL_82801AA_0   0x2410
diff --git a/include/linux/pci_regs.h b/include/linux/pci_regs.h
index be01380f798a..e8840964aca1 100644
--- a/include/linux/pci_regs.h
+++ b/include/linux/pci_regs.h
@@ -508,8 +508,18 @@
 #define PCI_EXP_RTSTA_PENDING   0x20000 /* PME pending */
 #define PCI_EXP_DEVCAP2         36      /* Device Capabilities 2 */
 #define  PCI_EXP_DEVCAP2_ARI    0x20    /* Alternative Routing-ID */
+#define  PCI_EXP_DEVCAP2_LTR    0x800   /* Latency tolerance reporting */
+#define  PCI_EXP_OBFF_MASK      0xc0000 /* OBFF support mechanism */
+#define  PCI_EXP_OBFF_MSG       0x40000 /* New message signaling */
+#define  PCI_EXP_OBFF_WAKE      0x80000 /* Re-use WAKE# for OBFF */
 #define PCI_EXP_DEVCTL2         40      /* Device Control 2 */
 #define  PCI_EXP_DEVCTL2_ARI    0x20    /* Alternative Routing-ID */
+#define  PCI_EXP_IDO_REQ_EN     0x100   /* ID-based ordering request enable */
+#define  PCI_EXP_IDO_CMP_EN     0x200   /* ID-based ordering completion enable */
+#define  PCI_EXP_LTR_EN         0x400   /* Latency tolerance reporting */
+#define  PCI_EXP_OBFF_MSGA_EN   0x2000  /* OBFF enable with Message type A */
+#define  PCI_EXP_OBFF_MSGB_EN   0x4000  /* OBFF enable with Message type B */
+#define  PCI_EXP_OBFF_WAKE_EN   0x6000  /* OBFF using WAKE# signaling */
 #define PCI_EXP_LNKCTL2         48      /* Link Control 2 */
 #define PCI_EXP_SLTCTL2         56      /* Slot Control 2 */
 
@@ -527,6 +537,7 @@
 #define PCI_EXT_CAP_ID_ARI      14
 #define PCI_EXT_CAP_ID_ATS      15
 #define PCI_EXT_CAP_ID_SRIOV    16
+#define PCI_EXT_CAP_ID_LTR      24
 
 /* Advanced Error Reporting */
 #define PCI_ERR_UNCOR_STATUS    4       /* Uncorrectable Error Status */
@@ -683,6 +694,12 @@
 #define  PCI_SRIOV_VFM_MO       0x2     /* Active.MigrateOut */
 #define  PCI_SRIOV_VFM_AV       0x3     /* Active.Available */
 
+#define PCI_LTR_MAX_SNOOP_LAT   0x4
+#define PCI_LTR_MAX_NOSNOOP_LAT 0x6
+#define  PCI_LTR_VALUE_MASK     0x000003ff
+#define  PCI_LTR_SCALE_MASK     0x00001c00
+#define  PCI_LTR_SCALE_SHIFT    10
+
 /* Access Control Service */
 #define PCI_ACS_CAP             0x04    /* ACS Capability Register */
 #define  PCI_ACS_SV             0x01    /* Source Validation */
diff --git a/include/linux/percpu.h b/include/linux/percpu.h
index 3a5c4449fd36..8b97308e65df 100644
--- a/include/linux/percpu.h
+++ b/include/linux/percpu.h
@@ -948,7 +948,7 @@ do {									\
         irqsafe_generic_cpu_cmpxchg_double(pcp1, pcp2, oval1, oval2, nval1, nval2)
 # endif
 # define irqsafe_cpu_cmpxchg_double(pcp1, pcp2, oval1, oval2, nval1, nval2)     \
-        __pcpu_double_call_return_int(irqsafe_cpu_cmpxchg_double_, (pcp1), (pcp2), (oval1), (oval2), (nval1), (nval2))
+        __pcpu_double_call_return_bool(irqsafe_cpu_cmpxchg_double_, (pcp1), (pcp2), (oval1), (oval2), (nval1), (nval2))
 #endif
 
 #endif /* __LINUX_PERCPU_H */
diff --git a/include/linux/percpu_counter.h b/include/linux/percpu_counter.h
index 46f6ba56fa91..5edc9014263a 100644
--- a/include/linux/percpu_counter.h
+++ b/include/linux/percpu_counter.h
@@ -75,7 +75,7 @@ static inline s64 percpu_counter_read_positive(struct percpu_counter *fbc)
         barrier();              /* Prevent reloads of fbc->count */
         if (ret >= 0)
                 return ret;
-        return 1;
+        return 0;
 }
 
 static inline int percpu_counter_initialized(struct percpu_counter *fbc)
@@ -133,6 +133,10 @@ static inline s64 percpu_counter_read(struct percpu_counter *fbc)
         return fbc->count;
 }
 
+/*
+ * percpu_counter is intended to track positive numbers. In the UP case the
+ * number should never be negative.
+ */
 static inline s64 percpu_counter_read_positive(struct percpu_counter *fbc)
 {
         return fbc->count;
diff --git a/include/linux/perf_event.h b/include/linux/perf_event.h
index ee9f1e782800..3412684ce5d5 100644
--- a/include/linux/perf_event.h
+++ b/include/linux/perf_event.h
@@ -2,8 +2,8 @@
  * Performance events:
  *
  *    Copyright (C) 2008-2009, Thomas Gleixner <tglx@linutronix.de>
- *    Copyright (C) 2008-2009, Red Hat, Inc., Ingo Molnar
- *    Copyright (C) 2008-2009, Red Hat, Inc., Peter Zijlstra
+ *    Copyright (C) 2008-2011, Red Hat, Inc., Ingo Molnar
+ *    Copyright (C) 2008-2011, Red Hat, Inc., Peter Zijlstra
  *
  * Data type definitions, declarations, prototypes.
  *
@@ -52,6 +52,8 @@ enum perf_hw_id {
         PERF_COUNT_HW_BRANCH_INSTRUCTIONS       = 4,
         PERF_COUNT_HW_BRANCH_MISSES             = 5,
         PERF_COUNT_HW_BUS_CYCLES                = 6,
+        PERF_COUNT_HW_STALLED_CYCLES_FRONTEND   = 7,
+        PERF_COUNT_HW_STALLED_CYCLES_BACKEND    = 8,
 
         PERF_COUNT_HW_MAX,                      /* non-ABI */
 };
@@ -468,9 +470,9 @@ enum perf_callchain_context {
         PERF_CONTEXT_MAX                = (__u64)-4095,
 };
 
-#define PERF_FLAG_FD_NO_GROUP   (1U << 0)
-#define PERF_FLAG_FD_OUTPUT     (1U << 1)
-#define PERF_FLAG_PID_CGROUP    (1U << 2) /* pid=cgroup id, per-cpu mode only */
+#define PERF_FLAG_FD_NO_GROUP           (1U << 0)
+#define PERF_FLAG_FD_OUTPUT             (1U << 1)
+#define PERF_FLAG_PID_CGROUP            (1U << 2) /* pid=cgroup id, per-cpu mode only */
 
 #ifdef __KERNEL__
 /*
@@ -484,9 +486,9 @@ enum perf_callchain_context {
 #endif
 
 struct perf_guest_info_callbacks {
-        int (*is_in_guest) (void);
-        int (*is_user_mode) (void);
-        unsigned long (*get_guest_ip) (void);
+        int                             (*is_in_guest)(void);
+        int                             (*is_user_mode)(void);
+        unsigned long                   (*get_guest_ip)(void);
 };
 
 #ifdef CONFIG_HAVE_HW_BREAKPOINT
@@ -505,7 +507,7 @@ struct perf_guest_info_callbacks {
 #include <linux/ftrace.h>
 #include <linux/cpu.h>
 #include <linux/irq_work.h>
-#include <linux/jump_label_ref.h>
+#include <linux/jump_label.h>
 #include <asm/atomic.h>
 #include <asm/local.h>
 
@@ -652,19 +654,19 @@ struct pmu {
          * Start the transaction, after this ->add() doesn't need to
          * do schedulability tests.
          */
-        void (*start_txn)       (struct pmu *pmu); /* optional */
+        void (*start_txn)               (struct pmu *pmu); /* optional */
         /*
          * If ->start_txn() disabled the ->add() schedulability test
          * then ->commit_txn() is required to perform one. On success
          * the transaction is closed. On error the transaction is kept
          * open until ->cancel_txn() is called.
          */
-        int  (*commit_txn)      (struct pmu *pmu); /* optional */
+        int  (*commit_txn)              (struct pmu *pmu); /* optional */
         /*
          * Will cancel the transaction, assumes ->del() is called
          * for each successful ->add() during the transaction.
          */
-        void (*cancel_txn)      (struct pmu *pmu); /* optional */
+        void (*cancel_txn)              (struct pmu *pmu); /* optional */
 };
 
 /**
@@ -712,15 +714,15 @@ typedef void (*perf_overflow_handler_t)(struct perf_event *, int,
                                         struct pt_regs *regs);
 
 enum perf_group_flag {
-        PERF_GROUP_SOFTWARE = 0x1,
+        PERF_GROUP_SOFTWARE             = 0x1,
 };
 
-#define SWEVENT_HLIST_BITS      8
-#define SWEVENT_HLIST_SIZE      (1 << SWEVENT_HLIST_BITS)
+#define SWEVENT_HLIST_BITS              8
+#define SWEVENT_HLIST_SIZE              (1 << SWEVENT_HLIST_BITS)
 
 struct swevent_hlist {
-        struct hlist_head       heads[SWEVENT_HLIST_SIZE];
-        struct rcu_head         rcu_head;
+        struct hlist_head               heads[SWEVENT_HLIST_SIZE];
+        struct rcu_head                 rcu_head;
 };
 
 #define PERF_ATTACH_CONTEXT     0x01
@@ -733,13 +735,13 @@ struct swevent_hlist {
  * This is a per-cpu dynamically allocated data structure.
  */
 struct perf_cgroup_info {
-        u64 time;
-        u64 timestamp;
+        u64                             time;
+        u64                             timestamp;
 };
 
 struct perf_cgroup {
-        struct cgroup_subsys_state css;
-        struct perf_cgroup_info *info;  /* timing info, one per cpu */
+        struct                          cgroup_subsys_state css;
+        struct                          perf_cgroup_info *info; /* timing info, one per cpu */
 };
 #endif
 
@@ -923,7 +925,7 @@ struct perf_event_context {
 
 /*
  * Number of contexts where an event can trigger:
- *      task, softirq, hardirq, nmi.
+ *      task, softirq, hardirq, nmi.
  */
 #define PERF_NR_CONTEXTS        4
 
@@ -1001,8 +1003,7 @@ struct perf_sample_data {
         struct perf_raw_record          *raw;
 };
 
-static inline
-void perf_sample_data_init(struct perf_sample_data *data, u64 addr)
+static inline void perf_sample_data_init(struct perf_sample_data *data, u64 addr)
 {
         data->addr = addr;
         data->raw  = NULL;
@@ -1034,13 +1035,12 @@ static inline int is_software_event(struct perf_event *event)
         return event->pmu->task_ctx_nr == perf_sw_context;
 }
 
-extern atomic_t perf_swevent_enabled[PERF_COUNT_SW_MAX];
+extern struct jump_label_key perf_swevent_enabled[PERF_COUNT_SW_MAX];
 
 extern void __perf_sw_event(u32, u64, int, 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) { }
+static inline void perf_arch_fetch_caller_regs(struct pt_regs *regs, unsigned long ip) { }
 #endif
 
 /*
@@ -1063,26 +1063,24 @@ perf_sw_event(u32 event_id, u64 nr, int nmi, struct pt_regs *regs, u64 addr)
 {
         struct pt_regs hot_regs;
 
-        JUMP_LABEL(&perf_swevent_enabled[event_id], have_event);
-        return;
-
-have_event:
-        if (!regs) {
-                perf_fetch_caller_regs(&hot_regs);
-                regs = &hot_regs;
+        if (static_branch(&perf_swevent_enabled[event_id])) {
+                if (!regs) {
+                        perf_fetch_caller_regs(&hot_regs);
+                        regs = &hot_regs;
+                }
+                __perf_sw_event(event_id, nr, nmi, regs, addr);
         }
-        __perf_sw_event(event_id, nr, nmi, regs, addr);
 }
 
-extern atomic_t perf_sched_events;
+extern struct jump_label_key perf_sched_events;
 
 static inline void perf_event_task_sched_in(struct task_struct *task)
 {
-        COND_STMT(&perf_sched_events, __perf_event_task_sched_in(task));
+        if (static_branch(&perf_sched_events))
+                __perf_event_task_sched_in(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 *task, struct task_struct *next)
 {
         perf_sw_event(PERF_COUNT_SW_CONTEXT_SWITCHES, 1, 1, NULL, 0);
 
@@ -1100,14 +1098,10 @@ extern void perf_event_fork(struct task_struct *tsk);
 /* Callchains */
 DECLARE_PER_CPU(struct perf_callchain_entry, perf_callchain_entry);
 
-extern void perf_callchain_user(struct perf_callchain_entry *entry,
-                                struct pt_regs *regs);
-extern void perf_callchain_kernel(struct perf_callchain_entry *entry,
-                                  struct pt_regs *regs);
-
+extern void perf_callchain_user(struct perf_callchain_entry *entry, struct pt_regs *regs);
+extern void perf_callchain_kernel(struct perf_callchain_entry *entry, struct pt_regs *regs);
 
-static inline void
-perf_callchain_store(struct perf_callchain_entry *entry, u64 ip)
+static inline void perf_callchain_store(struct perf_callchain_entry *entry, u64 ip)
 {
         if (entry->nr < PERF_MAX_STACK_DEPTH)
                 entry->ip[entry->nr++] = ip;
@@ -1143,9 +1137,9 @@ extern void perf_tp_event(u64 addr, u64 count, void *record,
 extern void perf_bp_event(struct perf_event *event, void *data);
 
 #ifndef perf_misc_flags
-#define perf_misc_flags(regs)   (user_mode(regs) ? PERF_RECORD_MISC_USER : \
-                                 PERF_RECORD_MISC_KERNEL)
-#define perf_instruction_pointer(regs)  instruction_pointer(regs)
+# define perf_misc_flags(regs) \
+                (user_mode(regs) ? PERF_RECORD_MISC_USER : PERF_RECORD_MISC_KERNEL)
+# define perf_instruction_pointer(regs) instruction_pointer(regs)
 #endif
 
 extern int perf_output_begin(struct perf_output_handle *handle,
@@ -1180,9 +1174,9 @@ static inline void
 perf_bp_event(struct perf_event *event, void *data)                     { }
 
 static inline int perf_register_guest_info_callbacks
-(struct perf_guest_info_callbacks *callbacks) { return 0; }
+(struct perf_guest_info_callbacks *callbacks)                           { return 0; }
 static inline int perf_unregister_guest_info_callbacks
-(struct perf_guest_info_callbacks *callbacks) { return 0; }
+(struct perf_guest_info_callbacks *callbacks)                           { return 0; }
 
 static inline void perf_event_mmap(struct vm_area_struct *vma)          { }
 static inline void perf_event_comm(struct task_struct *tsk)             { }
@@ -1195,23 +1189,22 @@ static inline void perf_event_disable(struct perf_event *event)		{ }
 static inline void perf_event_task_tick(void)                           { }
 #endif
 
-#define perf_output_put(handle, x) \
-        perf_output_copy((handle), &(x), sizeof(x))
+#define perf_output_put(handle, x) perf_output_copy((handle), &(x), sizeof(x))
 
 /*
  * This has to have a higher priority than migration_notifier in sched.c.
  */
-#define perf_cpu_notifier(fn)                                   \
-do {                                                            \
-        static struct notifier_block fn##_nb __cpuinitdata =    \
-                { .notifier_call = fn, .priority = CPU_PRI_PERF }; \
-        fn(&fn##_nb, (unsigned long)CPU_UP_PREPARE,             \
-                (void *)(unsigned long)smp_processor_id());     \
-        fn(&fn##_nb, (unsigned long)CPU_STARTING,               \
-                (void *)(unsigned long)smp_processor_id());     \
-        fn(&fn##_nb, (unsigned long)CPU_ONLINE,                 \
-                (void *)(unsigned long)smp_processor_id());     \
-        register_cpu_notifier(&fn##_nb);                        \
+#define perf_cpu_notifier(fn)                                           \
+do {                                                                    \
+        static struct notifier_block fn##_nb __cpuinitdata =            \
+                { .notifier_call = fn, .priority = CPU_PRI_PERF };      \
+        fn(&fn##_nb, (unsigned long)CPU_UP_PREPARE,                     \
+                (void *)(unsigned long)smp_processor_id());             \
+        fn(&fn##_nb, (unsigned long)CPU_STARTING,                       \
+                (void *)(unsigned long)smp_processor_id());             \
+        fn(&fn##_nb, (unsigned long)CPU_ONLINE,                         \
+                (void *)(unsigned long)smp_processor_id());             \
+        register_cpu_notifier(&fn##_nb);                                \
 } while (0)
 
 #endif /* __KERNEL__ */
diff --git a/include/linux/pkt_sched.h b/include/linux/pkt_sched.h
index 3a02e0208575..c5336705921f 100644
--- a/include/linux/pkt_sched.h
+++ b/include/linux/pkt_sched.h
@@ -588,4 +588,19 @@ struct tc_sfb_xstats {
 
 #define SFB_MAX_PROB 0xFFFF
 
+/* QFQ */
+enum {
+        TCA_QFQ_UNSPEC,
+        TCA_QFQ_WEIGHT,
+        TCA_QFQ_LMAX,
+        __TCA_QFQ_MAX
+};
+
+#define TCA_QFQ_MAX     (__TCA_QFQ_MAX - 1)
+
+struct tc_qfq_stats {
+        __u32 weight;
+        __u32 lmax;
+};
+
 #endif
diff --git a/include/linux/platform_device.h b/include/linux/platform_device.h
index 744942c95fec..ede1a80e3358 100644
--- a/include/linux/platform_device.h
+++ b/include/linux/platform_device.h
@@ -150,9 +150,6 @@ extern struct platform_device *platform_create_bundle(struct platform_driver *dr
                                         struct resource *res, unsigned int n_res,
                                         const void *data, size_t size);
 
-extern const struct dev_pm_ops * platform_bus_get_pm_ops(void);
-extern void platform_bus_set_pm_ops(const struct dev_pm_ops *pm);
-
 /* early platform driver interface */
 struct early_platform_driver {
         const char *class_str;
@@ -205,4 +202,64 @@ static inline char *early_platform_driver_setup_func(void)		\
 }
 #endif /* MODULE */
 
+#ifdef CONFIG_PM_SLEEP
+extern int platform_pm_prepare(struct device *dev);
+extern void platform_pm_complete(struct device *dev);
+#else
+#define platform_pm_prepare     NULL
+#define platform_pm_complete    NULL
+#endif
+
+#ifdef CONFIG_SUSPEND
+extern int platform_pm_suspend(struct device *dev);
+extern int platform_pm_suspend_noirq(struct device *dev);
+extern int platform_pm_resume(struct device *dev);
+extern int platform_pm_resume_noirq(struct device *dev);
+#else
+#define platform_pm_suspend             NULL
+#define platform_pm_resume              NULL
+#define platform_pm_suspend_noirq       NULL
+#define platform_pm_resume_noirq        NULL
+#endif
+
+#ifdef CONFIG_HIBERNATE_CALLBACKS
+extern int platform_pm_freeze(struct device *dev);
+extern int platform_pm_freeze_noirq(struct device *dev);
+extern int platform_pm_thaw(struct device *dev);
+extern int platform_pm_thaw_noirq(struct device *dev);
+extern int platform_pm_poweroff(struct device *dev);
+extern int platform_pm_poweroff_noirq(struct device *dev);
+extern int platform_pm_restore(struct device *dev);
+extern int platform_pm_restore_noirq(struct device *dev);
+#else
+#define platform_pm_freeze              NULL
+#define platform_pm_thaw                NULL
+#define platform_pm_poweroff            NULL
+#define platform_pm_restore             NULL
+#define platform_pm_freeze_noirq        NULL
+#define platform_pm_thaw_noirq          NULL
+#define platform_pm_poweroff_noirq      NULL
+#define platform_pm_restore_noirq       NULL
+#endif
+
+#ifdef CONFIG_PM_SLEEP
+#define USE_PLATFORM_PM_SLEEP_OPS \
+        .prepare = platform_pm_prepare, \
+        .complete = platform_pm_complete, \
+        .suspend = platform_pm_suspend, \
+        .resume = platform_pm_resume, \
+        .freeze = platform_pm_freeze, \
+        .thaw = platform_pm_thaw, \
+        .poweroff = platform_pm_poweroff, \
+        .restore = platform_pm_restore, \
+        .suspend_noirq = platform_pm_suspend_noirq, \
+        .resume_noirq = platform_pm_resume_noirq, \
+        .freeze_noirq = platform_pm_freeze_noirq, \
+        .thaw_noirq = platform_pm_thaw_noirq, \
+        .poweroff_noirq = platform_pm_poweroff_noirq, \
+        .restore_noirq = platform_pm_restore_noirq,
+#else
+#define USE_PLATFORM_PM_SLEEP_OPS
+#endif
+
 #endif /* _PLATFORM_DEVICE_H_ */
diff --git a/include/linux/pm.h b/include/linux/pm.h
index 512e09177e57..3160648ccdda 100644
--- a/include/linux/pm.h
+++ b/include/linux/pm.h
@@ -460,6 +460,7 @@ struct dev_pm_info {
         unsigned long           active_jiffies;
         unsigned long           suspended_jiffies;
         unsigned long           accounting_timestamp;
+        void                    *subsys_data;  /* Owned by the subsystem. */
 #endif
 };
 
@@ -529,21 +530,17 @@ struct dev_power_domain {
  */
 
 #ifdef CONFIG_PM_SLEEP
-#ifndef CONFIG_ARCH_NO_SYSDEV_OPS
-extern int sysdev_suspend(pm_message_t state);
-extern int sysdev_resume(void);
-#else
-static inline int sysdev_suspend(pm_message_t state) { return 0; }
-static inline int sysdev_resume(void) { return 0; }
-#endif
-
 extern void device_pm_lock(void);
 extern void dpm_resume_noirq(pm_message_t state);
 extern void dpm_resume_end(pm_message_t state);
+extern void dpm_resume(pm_message_t state);
+extern void dpm_complete(pm_message_t state);
 
 extern void device_pm_unlock(void);
 extern int dpm_suspend_noirq(pm_message_t state);
 extern int dpm_suspend_start(pm_message_t state);
+extern int dpm_suspend(pm_message_t state);
+extern int dpm_prepare(pm_message_t state);
 
 extern void __suspend_report_result(const char *function, void *fn, int ret);
 
@@ -553,6 +550,16 @@ extern void __suspend_report_result(const char *function, void *fn, int ret);
         } while (0)
 
 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(struct device *dev);
+extern int pm_generic_resume(struct device *dev);
+extern int pm_generic_freeze(struct device *dev);
+extern int pm_generic_thaw(struct device *dev);
+extern int pm_generic_restore(struct device *dev);
+extern int pm_generic_poweroff(struct device *dev);
+extern void pm_generic_complete(struct device *dev);
+
 #else /* !CONFIG_PM_SLEEP */
 
 #define device_pm_lock() do {} while (0)
@@ -569,6 +576,15 @@ static inline int device_pm_wait_for_dev(struct device *a, struct device *b)
 {
         return 0;
 }
+
+#define pm_generic_prepare      NULL
+#define pm_generic_suspend      NULL
+#define pm_generic_resume       NULL
+#define pm_generic_freeze       NULL
+#define pm_generic_thaw         NULL
+#define pm_generic_restore      NULL
+#define pm_generic_poweroff     NULL
+#define pm_generic_complete     NULL
 #endif /* !CONFIG_PM_SLEEP */
 
 /* How to reorder dpm_list after device_move() */
@@ -579,11 +595,4 @@ enum dpm_order {
         DPM_ORDER_DEV_LAST,
 };
 
-extern int pm_generic_suspend(struct device *dev);
-extern int pm_generic_resume(struct device *dev);
-extern int pm_generic_freeze(struct device *dev);
-extern int pm_generic_thaw(struct device *dev);
-extern int pm_generic_restore(struct device *dev);
-extern int pm_generic_poweroff(struct device *dev);
-
 #endif /* _LINUX_PM_H */
diff --git a/include/linux/pm_runtime.h b/include/linux/pm_runtime.h
index 8de9aa6e7def..878cf84baeb1 100644
--- a/include/linux/pm_runtime.h
+++ b/include/linux/pm_runtime.h
@@ -245,4 +245,46 @@ static inline void pm_runtime_dont_use_autosuspend(struct device *dev)
         __pm_runtime_use_autosuspend(dev, false);
 }
 
+struct pm_clk_notifier_block {
+        struct notifier_block nb;
+        struct dev_power_domain *pwr_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);
+#else
+static inline int pm_runtime_clk_init(struct device *dev)
+{
+        return -EINVAL;
+}
+static inline void pm_runtime_clk_destroy(struct device *dev)
+{
+}
+static inline int pm_runtime_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)
+{
+}
+#define pm_runtime_clock_suspend        NULL
+#define pm_runtime_clock_resume         NULL
+#endif
+
+#ifdef CONFIG_HAVE_CLK
+extern void pm_runtime_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,
+                                        struct pm_clk_notifier_block *clknb)
+{
+}
+#endif
+
 #endif
diff --git a/include/linux/posix-clock.h b/include/linux/posix-clock.h
index 7f1183dcd119..34c4498b800f 100644
--- a/include/linux/posix-clock.h
+++ b/include/linux/posix-clock.h
@@ -45,7 +45,7 @@ struct posix_clock;
  * @timer_create:   Create a new timer
  * @timer_delete:   Remove a previously created timer
  * @timer_gettime:  Get remaining time and interval of a timer
- * @timer_setttime: Set a timer's initial expiration and interval
+ * @timer_settime: Set a timer's initial expiration and interval
  * @fasync:         Optional character device fasync method
  * @mmap:           Optional character device mmap method
  * @open:           Optional character device open method
diff --git a/include/linux/posix-timers.h b/include/linux/posix-timers.h
index d51243ae0726..959c14132f46 100644
--- a/include/linux/posix-timers.h
+++ b/include/linux/posix-timers.h
@@ -5,6 +5,7 @@
 #include <linux/list.h>
 #include <linux/sched.h>
 #include <linux/timex.h>
+#include <linux/alarmtimer.h>
 
 union cpu_time_count {
         cputime_t cpu;
@@ -80,6 +81,8 @@ struct k_itimer {
                         unsigned long incr;
                         unsigned long expires;
                 } mmtimer;
+                struct alarm alarmtimer;
+                struct rcu_head rcu;
         } it;
 };
 
diff --git a/include/linux/printk.h b/include/linux/printk.h
index ee048e77e1ae..0101d55d9651 100644
--- a/include/linux/printk.h
+++ b/include/linux/printk.h
@@ -1,6 +1,8 @@
 #ifndef __KERNEL_PRINTK__
 #define __KERNEL_PRINTK__
 
+#include <linux/init.h>
+
 extern const char linux_banner[];
 extern const char linux_proc_banner[];
 
@@ -113,6 +115,7 @@ extern int dmesg_restrict;
 extern int kptr_restrict;
 
 void log_buf_kexec_setup(void);
+void __init setup_log_buf(int early);
 #else
 static inline __attribute__ ((format (printf, 1, 0)))
 int vprintk(const char *s, va_list args)
@@ -137,6 +140,10 @@ static inline bool printk_timed_ratelimit(unsigned long *caller_jiffies,
 static inline void log_buf_kexec_setup(void)
 {
 }
+
+static inline void setup_log_buf(int early)
+{
+}
 #endif
 
 extern void dump_stack(void) __cold;
diff --git a/include/linux/proc_fs.h b/include/linux/proc_fs.h
index a23f0b72a023..648c9c58add7 100644
--- a/include/linux/proc_fs.h
+++ b/include/linux/proc_fs.h
@@ -210,6 +210,8 @@ static inline struct proc_dir_entry *proc_symlink(const char *name,
                 struct proc_dir_entry *parent,const char *dest) {return NULL;}
 static inline struct proc_dir_entry *proc_mkdir(const char *name,
         struct proc_dir_entry *parent) {return NULL;}
+static inline struct proc_dir_entry *proc_mkdir_mode(const char *name,
+        mode_t mode, struct proc_dir_entry *parent) { return NULL; }
 
 static inline struct proc_dir_entry *create_proc_read_entry(const char *name,
         mode_t mode, struct proc_dir_entry *base, 
@@ -307,12 +309,4 @@ static inline struct net *PDE_NET(struct proc_dir_entry *pde)
         return pde->parent->data;
 }
 
-struct proc_maps_private {
-        struct pid *pid;
-        struct task_struct *task;
-#ifdef CONFIG_MMU
-        struct vm_area_struct *tail_vma;
-#endif
-};
-
 #endif /* _LINUX_PROC_FS_H */
diff --git a/include/linux/pstore.h b/include/linux/pstore.h
index 41977737bb7d..2455ef2683f0 100644
--- a/include/linux/pstore.h
+++ b/include/linux/pstore.h
@@ -35,7 +35,9 @@ struct pstore_info {
         struct mutex    buf_mutex;      /* serialize access to 'buf' */
         char            *buf;
         size_t          bufsize;
-        size_t          (*read)(u64 *id, enum pstore_type_id *type,
+        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);
diff --git a/include/linux/pti.h b/include/linux/pti.h
new file mode 100644
index 000000000000..81af667bb2d5
--- /dev/null
+++ b/include/linux/pti.h
@@ -0,0 +1,42 @@
+/*
+ *  Copyright (C) Intel 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.
+ *
+ * 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.
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * The PTI (Parallel Trace Interface) driver directs trace data routed from
+ * various parts in the system out through the Intel Penwell PTI port and
+ * out of the mobile device for analysis with a debugging tool
+ * (Lauterbach, Fido). This is part of a solution for the MIPI P1149.7,
+ * compact JTAG, standard.
+ *
+ * This header file will allow other parts of the OS to use the
+ * interface to write out it's contents for debugging a mobile system.
+ */
+
+#ifndef PTI_H_
+#define PTI_H_
+
+/* offset for last dword of any PTI message. Part of MIPI P1149.7 */
+#define PTI_LASTDWORD_DTS       0x30
+
+/* basic structure used as a write address to the PTI HW */
+struct pti_masterchannel {
+        u8 master;
+        u8 channel;
+};
+
+/* 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);
+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 943a85ab0020..e07e2742a865 100644
--- a/include/linux/ptp_classify.h
+++ b/include/linux/ptp_classify.h
@@ -25,6 +25,7 @@
 
 #include <linux/if_ether.h>
 #include <linux/if_vlan.h>
+#include <linux/ip.h>
 #include <linux/filter.h>
 #ifdef __KERNEL__
 #include <linux/in.h>
@@ -58,6 +59,12 @@
 #define OFF_NEXT        6
 #define OFF_UDP_DST     2
 
+#define OFF_PTP_SOURCE_UUID     22 /* PTPv1 only */
+#define OFF_PTP_SEQUENCE_ID     30
+#define OFF_PTP_CONTROL         32 /* PTPv1 only */
+
+#define IPV4_HLEN(data) (((struct iphdr *)(data + OFF_IHL))->ihl << 2)
+
 #define IP6_HLEN        40
 #define UDP_HLEN        8
 
diff --git a/include/linux/ptp_clock.h b/include/linux/ptp_clock.h
new file mode 100644
index 000000000000..94e981f810a2
--- /dev/null
+++ b/include/linux/ptp_clock.h
@@ -0,0 +1,84 @@
+/*
+ * PTP 1588 clock support - user space interface
+ *
+ * Copyright (C) 2010 OMICRON electronics GmbH
+ *
+ *  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 _PTP_CLOCK_H_
+#define _PTP_CLOCK_H_
+
+#include <linux/ioctl.h>
+#include <linux/types.h>
+
+/* PTP_xxx bits, for the flags field within the request structures. */
+#define PTP_ENABLE_FEATURE (1<<0)
+#define PTP_RISING_EDGE    (1<<1)
+#define PTP_FALLING_EDGE   (1<<2)
+
+/*
+ * struct ptp_clock_time - represents a time value
+ *
+ * The sign of the seconds field applies to the whole value. The
+ * nanoseconds field is always unsigned. The reserved field is
+ * included for sub-nanosecond resolution, should the demand for
+ * this ever appear.
+ *
+ */
+struct ptp_clock_time {
+        __s64 sec;  /* seconds */
+        __u32 nsec; /* nanoseconds */
+        __u32 reserved;
+};
+
+struct ptp_clock_caps {
+        int max_adj;   /* Maximum frequency adjustment in parts per billon. */
+        int n_alarm;   /* Number of programmable alarms. */
+        int n_ext_ts;  /* Number of external time stamp channels. */
+        int n_per_out; /* Number of programmable periodic signals. */
+        int pps;       /* Whether the clock supports a PPS callback. */
+        int rsv[15];   /* Reserved for future use. */
+};
+
+struct ptp_extts_request {
+        unsigned int index;  /* Which channel to configure. */
+        unsigned int flags;  /* Bit field for PTP_xxx flags. */
+        unsigned int rsv[2]; /* Reserved for future use. */
+};
+
+struct ptp_perout_request {
+        struct ptp_clock_time start;  /* Absolute start time. */
+        struct ptp_clock_time period; /* Desired period, zero means disable. */
+        unsigned int index;           /* Which channel to configure. */
+        unsigned int flags;           /* Reserved for future use. */
+        unsigned int rsv[4];          /* Reserved for future use. */
+};
+
+#define PTP_CLK_MAGIC '='
+
+#define PTP_CLOCK_GETCAPS  _IOR(PTP_CLK_MAGIC, 1, struct ptp_clock_caps)
+#define PTP_EXTTS_REQUEST  _IOW(PTP_CLK_MAGIC, 2, struct ptp_extts_request)
+#define PTP_PEROUT_REQUEST _IOW(PTP_CLK_MAGIC, 3, struct ptp_perout_request)
+#define PTP_ENABLE_PPS     _IOW(PTP_CLK_MAGIC, 4, int)
+
+struct ptp_extts_event {
+        struct ptp_clock_time t; /* Time event occured. */
+        unsigned int index;      /* Which channel produced the event. */
+        unsigned int flags;      /* Reserved for future use. */
+        unsigned int rsv[2];     /* Reserved for future use. */
+};
+
+#endif
diff --git a/include/linux/ptp_clock_kernel.h b/include/linux/ptp_clock_kernel.h
new file mode 100644
index 000000000000..dd2e44fba63e
--- /dev/null
+++ b/include/linux/ptp_clock_kernel.h
@@ -0,0 +1,139 @@
+/*
+ * PTP 1588 clock support
+ *
+ * Copyright (C) 2010 OMICRON electronics GmbH
+ *
+ *  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 _PTP_CLOCK_KERNEL_H_
+#define _PTP_CLOCK_KERNEL_H_
+
+#include <linux/ptp_clock.h>
+
+
+struct ptp_clock_request {
+        enum {
+                PTP_CLK_REQ_EXTTS,
+                PTP_CLK_REQ_PEROUT,
+                PTP_CLK_REQ_PPS,
+        } type;
+        union {
+                struct ptp_extts_request extts;
+                struct ptp_perout_request perout;
+        };
+};
+
+/**
+ * struct ptp_clock_info - decribes a PTP hardware clock
+ *
+ * @owner:     The clock driver should set to THIS_MODULE.
+ * @name:      A short name to identify the clock.
+ * @max_adj:   The maximum possible frequency adjustment, in parts per billon.
+ * @n_alarm:   The number of programmable alarms.
+ * @n_ext_ts:  The number of external time stamp channels.
+ * @n_per_out: The number of programmable periodic signals.
+ * @pps:       Indicates whether the clock supports a PPS callback.
+ *
+ * clock operations
+ *
+ * @adjfreq:  Adjusts the frequency of the hardware clock.
+ *            parameter delta: Desired period change in parts per billion.
+ *
+ * @adjtime:  Shifts the time of the hardware clock.
+ *            parameter delta: Desired change in nanoseconds.
+ *
+ * @gettime:  Reads the current time from the hardware clock.
+ *            parameter ts: Holds the result.
+ *
+ * @settime:  Set the current time on the hardware clock.
+ *            parameter ts: Time value to set.
+ *
+ * @enable:   Request driver to enable or disable an ancillary feature.
+ *            parameter request: Desired resource to enable or disable.
+ *            parameter on: Caller passes one to enable or zero to disable.
+ *
+ * Drivers should embed their ptp_clock_info within a private
+ * structure, obtaining a reference to it using container_of().
+ *
+ * The callbacks must all return zero on success, non-zero otherwise.
+ */
+
+struct ptp_clock_info {
+        struct module *owner;
+        char name[16];
+        s32 max_adj;
+        int n_alarm;
+        int n_ext_ts;
+        int n_per_out;
+        int pps;
+        int (*adjfreq)(struct ptp_clock_info *ptp, s32 delta);
+        int (*adjtime)(struct ptp_clock_info *ptp, s64 delta);
+        int (*gettime)(struct ptp_clock_info *ptp, struct timespec *ts);
+        int (*settime)(struct ptp_clock_info *ptp, const struct timespec *ts);
+        int (*enable)(struct ptp_clock_info *ptp,
+                      struct ptp_clock_request *request, int on);
+};
+
+struct ptp_clock;
+
+/**
+ * ptp_clock_register() - register a PTP hardware clock driver
+ *
+ * @info:  Structure describing the new clock.
+ */
+
+extern struct ptp_clock *ptp_clock_register(struct ptp_clock_info *info);
+
+/**
+ * ptp_clock_unregister() - unregister a PTP hardware clock driver
+ *
+ * @ptp:  The clock to remove from service.
+ */
+
+extern int ptp_clock_unregister(struct ptp_clock *ptp);
+
+
+enum ptp_clock_events {
+        PTP_CLOCK_ALARM,
+        PTP_CLOCK_EXTTS,
+        PTP_CLOCK_PPS,
+};
+
+/**
+ * struct ptp_clock_event - decribes a PTP hardware clock event
+ *
+ * @type:  One of the ptp_clock_events enumeration values.
+ * @index: Identifies the source of the event.
+ * @timestamp: When the event occured.
+ */
+
+struct ptp_clock_event {
+        int type;
+        int index;
+        u64 timestamp;
+};
+
+/**
+ * ptp_clock_event() - notify the PTP layer about an event
+ *
+ * @ptp:    The clock obtained from ptp_clock_register().
+ * @event:  Message structure describing the event.
+ */
+
+extern void ptp_clock_event(struct ptp_clock *ptp,
+                            struct ptp_clock_event *event);
+
+#endif
diff --git a/include/linux/ptrace.h b/include/linux/ptrace.h
index a1147e5dd245..9178d5cc0b01 100644
--- a/include/linux/ptrace.h
+++ b/include/linux/ptrace.h
@@ -189,6 +189,10 @@ static inline void ptrace_init_task(struct task_struct *child, bool ptrace)
                 child->ptrace = current->ptrace;
                 __ptrace_link(child, current->parent);
         }
+
+#ifdef CONFIG_HAVE_HW_BREAKPOINT
+        atomic_set(&child->ptrace_bp_refcnt, 1);
+#endif
 }
 
 /**
@@ -350,6 +354,13 @@ extern int task_current_syscall(struct task_struct *target, long *callno,
                                 unsigned long args[6], unsigned int maxargs,
                                 unsigned long *sp, unsigned long *pc);
 
-#endif
+#ifdef CONFIG_HAVE_HW_BREAKPOINT
+extern int ptrace_get_breakpoints(struct task_struct *tsk);
+extern void ptrace_put_breakpoints(struct task_struct *tsk);
+#else
+static inline void ptrace_put_breakpoints(struct task_struct *tsk) { }
+#endif /* CONFIG_HAVE_HW_BREAKPOINT */
+
+#endif /* __KERNEL */
 
 #endif
diff --git a/include/linux/rbtree.h b/include/linux/rbtree.h
index 7066acb2c530..033b507b33b1 100644
--- a/include/linux/rbtree.h
+++ b/include/linux/rbtree.h
@@ -136,6 +136,14 @@ static inline void rb_set_color(struct rb_node *rb, int color)
 #define RB_EMPTY_NODE(node)     (rb_parent(node) == node)
 #define RB_CLEAR_NODE(node)     (rb_set_parent(node, node))
 
+static inline void rb_init_node(struct rb_node *rb)
+{
+        rb->rb_parent_color = 0;
+        rb->rb_right = NULL;
+        rb->rb_left = NULL;
+        RB_CLEAR_NODE(rb);
+}
+
 extern void rb_insert_color(struct rb_node *, struct rb_root *);
 extern void rb_erase(struct rb_node *, struct rb_root *);
 
diff --git a/include/linux/rculist.h b/include/linux/rculist.h
index 2dea94fc4402..e3beb315517a 100644
--- a/include/linux/rculist.h
+++ b/include/linux/rculist.h
@@ -253,7 +253,7 @@ static inline void list_splice_init_rcu(struct list_head *list,
  */
 #define list_for_each_entry_rcu(pos, head, member) \
         for (pos = list_entry_rcu((head)->next, typeof(*pos), member); \
-                prefetch(pos->member.next), &pos->member != (head); \
+                &pos->member != (head); \
                 pos = list_entry_rcu(pos->member.next, typeof(*pos), member))
 
 
@@ -270,7 +270,7 @@ static inline void list_splice_init_rcu(struct list_head *list,
  */
 #define list_for_each_continue_rcu(pos, head) \
         for ((pos) = rcu_dereference_raw(list_next_rcu(pos)); \
-                prefetch((pos)->next), (pos) != (head); \
+                (pos) != (head); \
                 (pos) = rcu_dereference_raw(list_next_rcu(pos)))
 
 /**
@@ -284,7 +284,7 @@ static inline void list_splice_init_rcu(struct list_head *list,
  */
 #define list_for_each_entry_continue_rcu(pos, head, member)             \
         for (pos = list_entry_rcu(pos->member.next, typeof(*pos), member); \
-             prefetch(pos->member.next), &pos->member != (head);        \
+             &pos->member != (head);    \
              pos = list_entry_rcu(pos->member.next, typeof(*pos), member))
 
 /**
@@ -427,7 +427,7 @@ static inline void hlist_add_after_rcu(struct hlist_node *prev,
 
 #define __hlist_for_each_rcu(pos, head)                         \
         for (pos = rcu_dereference(hlist_first_rcu(head));      \
-             pos && ({ prefetch(pos->next); 1; });              \
+             pos;                                               \
              pos = rcu_dereference(hlist_next_rcu(pos)))
 
 /**
@@ -443,7 +443,7 @@ static inline void hlist_add_after_rcu(struct hlist_node *prev,
  */
 #define hlist_for_each_entry_rcu(tpos, pos, head, member)               \
         for (pos = rcu_dereference_raw(hlist_first_rcu(head));          \
-                pos && ({ prefetch(pos->next); 1; }) &&                  \
+                pos &&                                                   \
                 ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1; }); \
                 pos = rcu_dereference_raw(hlist_next_rcu(pos)))
 
@@ -460,7 +460,7 @@ static inline void hlist_add_after_rcu(struct hlist_node *prev,
  */
 #define hlist_for_each_entry_rcu_bh(tpos, pos, head, member)             \
         for (pos = rcu_dereference_bh((head)->first);                    \
-                pos && ({ prefetch(pos->next); 1; }) &&                  \
+                pos &&                                                   \
                 ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1; }); \
                 pos = rcu_dereference_bh(pos->next))
 
@@ -472,7 +472,7 @@ static inline void hlist_add_after_rcu(struct hlist_node *prev,
  */
 #define hlist_for_each_entry_continue_rcu(tpos, pos, member)            \
         for (pos = rcu_dereference((pos)->next);                        \
-             pos && ({ prefetch(pos->next); 1; }) &&                    \
+             pos &&                                                     \
              ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1; });  \
              pos = rcu_dereference(pos->next))
 
@@ -484,7 +484,7 @@ static inline void hlist_add_after_rcu(struct hlist_node *prev,
  */
 #define hlist_for_each_entry_continue_rcu_bh(tpos, pos, member)         \
         for (pos = rcu_dereference_bh((pos)->next);                     \
-             pos && ({ prefetch(pos->next); 1; }) &&                    \
+             pos &&                                                     \
              ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1; });  \
              pos = rcu_dereference_bh(pos->next))
 
diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
index ff422d2b7f90..99f9aa7c2804 100644
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -47,6 +47,18 @@
 extern int rcutorture_runnable; /* for sysctl */
 #endif /* #ifdef CONFIG_RCU_TORTURE_TEST */
 
+#if defined(CONFIG_TREE_RCU) || defined(CONFIG_TREE_PREEMPT_RCU)
+extern void rcutorture_record_test_transition(void);
+extern void rcutorture_record_progress(unsigned long vernum);
+#else
+static inline void rcutorture_record_test_transition(void)
+{
+}
+static inline void rcutorture_record_progress(unsigned long vernum)
+{
+}
+#endif
+
 #define UINT_CMP_GE(a, b)       (UINT_MAX / 2 >= (a) - (b))
 #define UINT_CMP_LT(a, b)       (UINT_MAX / 2 < (a) - (b))
 #define ULONG_CMP_GE(a, b)      (ULONG_MAX / 2 >= (a) - (b))
@@ -68,7 +80,6 @@ extern void call_rcu_sched(struct rcu_head *head,
 extern void synchronize_sched(void);
 extern void rcu_barrier_bh(void);
 extern void rcu_barrier_sched(void);
-extern int sched_expedited_torture_stats(char *page);
 
 static inline void __rcu_read_lock_bh(void)
 {
@@ -774,6 +785,7 @@ extern struct debug_obj_descr rcuhead_debug_descr;
 
 static inline void debug_rcu_head_queue(struct rcu_head *head)
 {
+        WARN_ON_ONCE((unsigned long)head & 0x3);
         debug_object_activate(head, &rcuhead_debug_descr);
         debug_object_active_state(head, &rcuhead_debug_descr,
                                   STATE_RCU_HEAD_READY,
@@ -797,4 +809,60 @@ static inline void debug_rcu_head_unqueue(struct rcu_head *head)
 }
 #endif  /* #else !CONFIG_DEBUG_OBJECTS_RCU_HEAD */
 
+static __always_inline bool __is_kfree_rcu_offset(unsigned long offset)
+{
+        return offset < 4096;
+}
+
+static __always_inline
+void __kfree_rcu(struct rcu_head *head, unsigned long offset)
+{
+        typedef void (*rcu_callback)(struct rcu_head *);
+
+        BUILD_BUG_ON(!__builtin_constant_p(offset));
+
+        /* See the kfree_rcu() header comment. */
+        BUILD_BUG_ON(!__is_kfree_rcu_offset(offset));
+
+        call_rcu(head, (rcu_callback)offset);
+}
+
+extern void kfree(const void *);
+
+static inline void __rcu_reclaim(struct rcu_head *head)
+{
+        unsigned long offset = (unsigned long)head->func;
+
+        if (__is_kfree_rcu_offset(offset))
+                kfree((void *)head - offset);
+        else
+                head->func(head);
+}
+
+/**
+ * kfree_rcu() - kfree an object after a grace period.
+ * @ptr:        pointer to kfree
+ * @rcu_head:   the name of the struct rcu_head within the type of @ptr.
+ *
+ * Many rcu callbacks functions just call kfree() on the base structure.
+ * These functions are trivial, but their size adds up, and furthermore
+ * when they are used in a kernel module, that module must invoke the
+ * high-latency rcu_barrier() function at module-unload time.
+ *
+ * The kfree_rcu() function handles this issue.  Rather than encoding a
+ * function address in the embedded rcu_head structure, kfree_rcu() instead
+ * encodes the offset of the rcu_head structure within the base structure.
+ * Because the functions are not allowed in the low-order 4096 bytes of
+ * kernel virtual memory, offsets up to 4095 bytes can be accommodated.
+ * If the offset is larger than 4095 bytes, a compile-time error will
+ * be generated in __kfree_rcu().  If this error is triggered, you can
+ * either fall back to use of call_rcu() or rearrange the structure to
+ * position the rcu_head structure into the first 4096 bytes.
+ *
+ * Note that the allowable offset might decrease in the future, for example,
+ * to allow something like kmem_cache_free_rcu().
+ */
+#define kfree_rcu(ptr, rcu_head)                                        \
+        __kfree_rcu(&((ptr)->rcu_head), offsetof(typeof(*(ptr)), rcu_head))
+
 #endif /* __LINUX_RCUPDATE_H */
diff --git a/include/linux/rcutiny.h b/include/linux/rcutiny.h
index 30ebd7c8d874..52b3e0281fd0 100644
--- a/include/linux/rcutiny.h
+++ b/include/linux/rcutiny.h
@@ -100,6 +100,14 @@ static inline void rcu_note_context_switch(int cpu)
 }
 
 /*
+ * Take advantage of the fact that there is only one CPU, which
+ * allows us to ignore virtualization-based context switches.
+ */
+static inline void rcu_virt_note_context_switch(int cpu)
+{
+}
+
+/*
  * Return the number of grace periods.
  */
 static inline long rcu_batches_completed(void)
diff --git a/include/linux/rcutree.h b/include/linux/rcutree.h
index 3a933482734a..e65d06634dd8 100644
--- a/include/linux/rcutree.h
+++ b/include/linux/rcutree.h
@@ -35,6 +35,16 @@ extern void rcu_note_context_switch(int cpu);
 extern int rcu_needs_cpu(int cpu);
 extern void rcu_cpu_stall_reset(void);
 
+/*
+ * Note a virtualization-based context switch.  This is simply a
+ * wrapper around rcu_note_context_switch(), which allows TINY_RCU
+ * to save a few bytes.
+ */
+static inline void rcu_virt_note_context_switch(int cpu)
+{
+        rcu_note_context_switch(cpu);
+}
+
 #ifdef CONFIG_TREE_PREEMPT_RCU
 
 extern void exit_rcu(void);
@@ -58,9 +68,12 @@ static inline void synchronize_rcu_bh_expedited(void)
 
 extern void rcu_barrier(void);
 
+extern unsigned long rcutorture_testseq;
+extern unsigned long rcutorture_vernum;
 extern long rcu_batches_completed(void);
 extern long rcu_batches_completed_bh(void);
 extern long rcu_batches_completed_sched(void);
+
 extern void rcu_force_quiescent_state(void);
 extern void rcu_bh_force_quiescent_state(void);
 extern void rcu_sched_force_quiescent_state(void);
diff --git a/include/linux/regulator/db8500-prcmu.h b/include/linux/regulator/db8500-prcmu.h
new file mode 100644
index 000000000000..612062313b68
--- /dev/null
+++ b/include/linux/regulator/db8500-prcmu.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) ST-Ericsson SA 2010
+ *
+ * License Terms: GNU General Public License v2
+ *
+ * Author: Bengt Jonsson <bengt.g.jonsson@stericsson.com> for ST-Ericsson
+ *
+ * Interface to power domain regulators on DB8500
+ */
+
+#ifndef __REGULATOR_H__
+#define __REGULATOR_H__
+
+/* Number of DB8500 regulators and regulator enumeration */
+enum db8500_regulator_id {
+        DB8500_REGULATOR_VAPE,
+        DB8500_REGULATOR_VARM,
+        DB8500_REGULATOR_VMODEM,
+        DB8500_REGULATOR_VPLL,
+        DB8500_REGULATOR_VSMPS1,
+        DB8500_REGULATOR_VSMPS2,
+        DB8500_REGULATOR_VSMPS3,
+        DB8500_REGULATOR_VRF1,
+        DB8500_REGULATOR_SWITCH_SVAMMDSP,
+        DB8500_REGULATOR_SWITCH_SVAMMDSPRET,
+        DB8500_REGULATOR_SWITCH_SVAPIPE,
+        DB8500_REGULATOR_SWITCH_SIAMMDSP,
+        DB8500_REGULATOR_SWITCH_SIAMMDSPRET,
+        DB8500_REGULATOR_SWITCH_SIAPIPE,
+        DB8500_REGULATOR_SWITCH_SGA,
+        DB8500_REGULATOR_SWITCH_B2R2_MCDE,
+        DB8500_REGULATOR_SWITCH_ESRAM12,
+        DB8500_REGULATOR_SWITCH_ESRAM12RET,
+        DB8500_REGULATOR_SWITCH_ESRAM34,
+        DB8500_REGULATOR_SWITCH_ESRAM34RET,
+        DB8500_NUM_REGULATORS
+};
+
+/*
+ * Exported interface for CPUIdle only. This function is called with all
+ * interrupts turned off.
+ */
+int power_state_active_is_enabled(void);
+
+#endif
diff --git a/include/linux/rfkill-gpio.h b/include/linux/rfkill-gpio.h
new file mode 100644
index 000000000000..a175d0598033
--- /dev/null
+++ b/include/linux/rfkill-gpio.h
@@ -0,0 +1,43 @@
+/*
+ * 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 __RFKILL_GPIO_H
+#define __RFKILL_GPIO_H
+
+#include <linux/types.h>
+#include <linux/rfkill.h>
+
+/**
+ * struct rfkill_gpio_platform_data - platform data for rfkill gpio device.
+ * for unused gpio's, the expected value is -1.
+ * @name:               name for the gpio rf kill instance
+ * @reset_gpio:         GPIO which is used for reseting rfkill switch
+ * @shutdown_gpio:      GPIO which is used for shutdown of rfkill switch
+ * @power_clk_name:     [optional] name of clk to turn off while blocked
+ */
+
+struct rfkill_gpio_platform_data {
+        char                    *name;
+        int                     reset_gpio;
+        int                     shutdown_gpio;
+        const char              *power_clk_name;
+        enum rfkill_type        type;
+};
+
+#endif /* __RFKILL_GPIO_H */
diff --git a/include/linux/rfkill-regulator.h b/include/linux/rfkill-regulator.h
new file mode 100644
index 000000000000..aca36bc83315
--- /dev/null
+++ b/include/linux/rfkill-regulator.h
@@ -0,0 +1,48 @@
+/*
+ * rfkill-regulator.c - Regulator consumer driver for rfkill
+ *
+ * Copyright (C) 2009  Guiming Zhuo <gmzhuo@gmail.com>
+ * Copyright (C) 2011  Antonio Ospite <ospite@studenti.unina.it>
+ *
+ * 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_RFKILL_REGULATOR_H
+#define __LINUX_RFKILL_REGULATOR_H
+
+/*
+ * Use "vrfkill" as supply id when declaring the regulator consumer:
+ *
+ * static struct regulator_consumer_supply pcap_regulator_V6_consumers [] = {
+ *      { .dev_name = "rfkill-regulator.0", .supply = "vrfkill" },
+ * };
+ *
+ * If you have several regulator driven rfkill, you can append a numerical id to
+ * .dev_name as done above, and use the same id when declaring the platform
+ * device:
+ *
+ * static struct rfkill_regulator_platform_data ezx_rfkill_bt_data = {
+ *      .name  = "ezx-bluetooth",
+ *      .type  = RFKILL_TYPE_BLUETOOTH,
+ * };
+ *
+ * static struct platform_device a910_rfkill = {
+ *      .name  = "rfkill-regulator",
+ *      .id    = 0,
+ *      .dev   = {
+ *              .platform_data = &ezx_rfkill_bt_data,
+ *      },
+ * };
+ */
+
+#include <linux/rfkill.h>
+
+struct rfkill_regulator_platform_data {
+        char *name;             /* the name for the rfkill switch */
+        enum rfkill_type type;  /* the type as specified in rfkill.h */
+};
+
+#endif /* __LINUX_RFKILL_REGULATOR_H */
diff --git a/include/linux/rmap.h b/include/linux/rmap.h
index 830e65dc01ee..2148b122779b 100644
--- a/include/linux/rmap.h
+++ b/include/linux/rmap.h
@@ -7,7 +7,7 @@
 #include <linux/list.h>
 #include <linux/slab.h>
 #include <linux/mm.h>
-#include <linux/spinlock.h>
+#include <linux/mutex.h>
 #include <linux/memcontrol.h>
 
 /*
@@ -26,7 +26,7 @@
  */
 struct anon_vma {
         struct anon_vma *root;  /* Root of this anon_vma tree */
-        spinlock_t lock;        /* Serialize access to vma list */
+        struct mutex mutex;     /* Serialize access to vma list */
         /*
          * The refcount is taken on an anon_vma when there is no
          * guarantee that the vma of page tables will exist for
@@ -64,7 +64,7 @@ struct anon_vma_chain {
         struct vm_area_struct *vma;
         struct anon_vma *anon_vma;
         struct list_head same_vma;   /* locked by mmap_sem & page_table_lock */
-        struct list_head same_anon_vma; /* locked by anon_vma->lock */
+        struct list_head same_anon_vma; /* locked by anon_vma->mutex */
 };
 
 #ifdef CONFIG_MMU
@@ -93,24 +93,24 @@ static inline void vma_lock_anon_vma(struct vm_area_struct *vma)
 {
         struct anon_vma *anon_vma = vma->anon_vma;
         if (anon_vma)
-                spin_lock(&anon_vma->root->lock);
+                mutex_lock(&anon_vma->root->mutex);
 }
 
 static inline void vma_unlock_anon_vma(struct vm_area_struct *vma)
 {
         struct anon_vma *anon_vma = vma->anon_vma;
         if (anon_vma)
-                spin_unlock(&anon_vma->root->lock);
+                mutex_unlock(&anon_vma->root->mutex);
 }
 
 static inline void anon_vma_lock(struct anon_vma *anon_vma)
 {
-        spin_lock(&anon_vma->root->lock);
+        mutex_lock(&anon_vma->root->mutex);
 }
 
 static inline void anon_vma_unlock(struct anon_vma *anon_vma)
 {
-        spin_unlock(&anon_vma->root->lock);
+        mutex_unlock(&anon_vma->root->mutex);
 }
 
 /*
@@ -218,20 +218,7 @@ int try_to_munlock(struct page *);
 /*
  * Called by memory-failure.c to kill processes.
  */
-struct anon_vma *__page_lock_anon_vma(struct page *page);
-
-static inline struct anon_vma *page_lock_anon_vma(struct page *page)
-{
-        struct anon_vma *anon_vma;
-
-        __cond_lock(RCU, anon_vma = __page_lock_anon_vma(page));
-
-        /* (void) is needed to make gcc happy */
-        (void) __cond_lock(&anon_vma->root->lock, anon_vma);
-
-        return anon_vma;
-}
-
+struct anon_vma *page_lock_anon_vma(struct page *page);
 void page_unlock_anon_vma(struct anon_vma *anon_vma);
 int page_mapped_in_vma(struct page *page, struct vm_area_struct *vma);
 
diff --git a/include/linux/rotary_encoder.h b/include/linux/rotary_encoder.h
index 215278b8df2a..3f594dce5716 100644
--- a/include/linux/rotary_encoder.h
+++ b/include/linux/rotary_encoder.h
@@ -10,6 +10,7 @@ struct rotary_encoder_platform_data {
         unsigned int inverted_b;
         bool relative_axis;
         bool rollover;
+        bool half_period;
 };
 
 #endif /* __ROTARY_ENCODER_H__ */
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 18d63cea2848..f18300eddfcb 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -315,7 +315,6 @@ extern int proc_dowatchdog_thresh(struct ctl_table *table, int write,
                                   void __user *buffer,
                                   size_t *lenp, loff_t *ppos);
 extern unsigned int  softlockup_panic;
-extern int softlockup_thresh;
 void lockup_detector_init(void);
 #else
 static inline void touch_softlockup_watchdog(void)
@@ -360,7 +359,7 @@ extern signed long schedule_timeout_interruptible(signed long timeout);
 extern signed long schedule_timeout_killable(signed long timeout);
 extern signed long schedule_timeout_uninterruptible(signed long timeout);
 asmlinkage void schedule(void);
-extern int mutex_spin_on_owner(struct mutex *lock, struct thread_info *owner);
+extern int mutex_spin_on_owner(struct mutex *lock, struct task_struct *owner);
 
 struct nsproxy;
 struct user_namespace;
@@ -653,9 +652,8 @@ struct signal_struct {
  * Bits in flags field of signal_struct.
  */
 #define SIGNAL_STOP_STOPPED     0x00000001 /* job control stop in effect */
-#define SIGNAL_STOP_DEQUEUED    0x00000002 /* stop signal dequeued */
-#define SIGNAL_STOP_CONTINUED   0x00000004 /* SIGCONT since WCONTINUED reap */
-#define SIGNAL_GROUP_EXIT       0x00000008 /* group exit in progress */
+#define SIGNAL_STOP_CONTINUED   0x00000002 /* SIGCONT since WCONTINUED reap */
+#define SIGNAL_GROUP_EXIT       0x00000004 /* group exit in progress */
 /*
  * Pending notifications to parent.
  */
@@ -731,10 +729,6 @@ struct sched_info {
         /* timestamps */
         unsigned long long last_arrival,/* when we last ran on a cpu */
                            last_queued; /* when we were last queued to run */
-#ifdef CONFIG_SCHEDSTATS
-        /* BKL stats */
-        unsigned int bkl_count;
-#endif
 };
 #endif /* defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT) */
 
@@ -792,17 +786,39 @@ enum cpu_idle_type {
 };
 
 /*
- * sched-domains (multiprocessor balancing) declarations:
+ * Increase resolution of nice-level calculations for 64-bit architectures.
+ * The extra resolution improves shares distribution and load balancing of
+ * low-weight task groups (eg. nice +19 on an autogroup), deeper taskgroup
+ * hierarchies, especially on larger systems. This is not a user-visible change
+ * and does not change the user-interface for setting shares/weights.
+ *
+ * We increase resolution only if we have enough bits to allow this increased
+ * resolution (i.e. BITS_PER_LONG > 32). The costs for increasing resolution
+ * when BITS_PER_LONG <= 32 are pretty high and the returns do not justify the
+ * increased costs.
  */
+#if BITS_PER_LONG > 32
+# define SCHED_LOAD_RESOLUTION  10
+# define scale_load(w)          ((w) << SCHED_LOAD_RESOLUTION)
+# define scale_load_down(w)     ((w) >> SCHED_LOAD_RESOLUTION)
+#else
+# define SCHED_LOAD_RESOLUTION  0
+# define scale_load(w)          (w)
+# define scale_load_down(w)     (w)
+#endif
 
-/*
- * Increase resolution of nice-level calculations:
- */
-#define SCHED_LOAD_SHIFT        10
+#define SCHED_LOAD_SHIFT        (10 + SCHED_LOAD_RESOLUTION)
 #define SCHED_LOAD_SCALE        (1L << SCHED_LOAD_SHIFT)
 
-#define SCHED_LOAD_SCALE_FUZZ   SCHED_LOAD_SCALE
+/*
+ * Increase resolution of cpu_power calculations
+ */
+#define SCHED_POWER_SHIFT       10
+#define SCHED_POWER_SCALE       (1L << SCHED_POWER_SHIFT)
 
+/*
+ * sched-domains (multiprocessor balancing) declarations:
+ */
 #ifdef CONFIG_SMP
 #define SD_LOAD_BALANCE         0x0001  /* Do load balancing on this domain. */
 #define SD_BALANCE_NEWIDLE      0x0002  /* Balance when about to become idle */
@@ -868,6 +884,7 @@ static inline int sd_power_saving_flags(void)
 
 struct sched_group {
         struct sched_group *next;       /* Must be a circular list */
+        atomic_t ref;
 
         /*
          * CPU power of this group, SCHED_LOAD_SCALE being max power for a
@@ -882,9 +899,6 @@ struct sched_group {
          * NOTE: this field is variable length. (Allocated dynamically
          * by attaching extra space to the end of the structure,
          * depending on how many CPUs the kernel has booted up with)
-         *
-         * It is also be embedded into static data structures at build
-         * time. (See 'struct static_sched_group' in kernel/sched.c)
          */
         unsigned long cpumask[0];
 };
@@ -894,17 +908,6 @@ static inline struct cpumask *sched_group_cpus(struct sched_group *sg)
         return to_cpumask(sg->cpumask);
 }
 
-enum sched_domain_level {
-        SD_LV_NONE = 0,
-        SD_LV_SIBLING,
-        SD_LV_MC,
-        SD_LV_BOOK,
-        SD_LV_CPU,
-        SD_LV_NODE,
-        SD_LV_ALLNODES,
-        SD_LV_MAX
-};
-
 struct sched_domain_attr {
         int relax_domain_level;
 };
@@ -913,6 +916,8 @@ struct sched_domain_attr {
         .relax_domain_level = -1,                       \
 }
 
+extern int sched_domain_level_max;
+
 struct sched_domain {
         /* These fields must be setup */
         struct sched_domain *parent;    /* top domain must be null terminated */
@@ -930,7 +935,7 @@ struct sched_domain {
         unsigned int forkexec_idx;
         unsigned int smt_gain;
         int flags;                      /* See SD_* */
-        enum sched_domain_level level;
+        int level;
 
         /* Runtime fields. */
         unsigned long last_balance;     /* init to jiffies. units in jiffies */
@@ -973,6 +978,10 @@ struct sched_domain {
 #ifdef CONFIG_SCHED_DEBUG
         char *name;
 #endif
+        union {
+                void *private;          /* used during construction */
+                struct rcu_head rcu;    /* used during destruction */
+        };
 
         unsigned int span_weight;
         /*
@@ -981,9 +990,6 @@ struct sched_domain {
          * NOTE: this field is variable length. (Allocated dynamically
          * by attaching extra space to the end of the structure,
          * depending on how many CPUs the kernel has booted up with)
-         *
-         * It is also be embedded into static data structures at build
-         * time. (See 'struct static_sched_domain' in kernel/sched.c)
          */
         unsigned long span[0];
 };
@@ -1048,8 +1054,12 @@ struct sched_domain;
 #define WF_FORK         0x02            /* child wakeup after fork */
 
 #define ENQUEUE_WAKEUP          1
-#define ENQUEUE_WAKING          2
-#define ENQUEUE_HEAD            4
+#define ENQUEUE_HEAD            2
+#ifdef CONFIG_SMP
+#define ENQUEUE_WAKING          4       /* sched_class::task_waking was called */
+#else
+#define ENQUEUE_WAKING          0
+#endif
 
 #define DEQUEUE_SLEEP           1
 
@@ -1067,12 +1077,11 @@ struct sched_class {
         void (*put_prev_task) (struct rq *rq, struct task_struct *p);
 
 #ifdef CONFIG_SMP
-        int  (*select_task_rq)(struct rq *rq, struct task_struct *p,
-                               int sd_flag, int flags);
+        int  (*select_task_rq)(struct task_struct *p, int sd_flag, int flags);
 
         void (*pre_schedule) (struct rq *this_rq, struct task_struct *task);
         void (*post_schedule) (struct rq *this_rq);
-        void (*task_waking) (struct rq *this_rq, struct task_struct *task);
+        void (*task_waking) (struct task_struct *task);
         void (*task_woken) (struct rq *this_rq, struct task_struct *task);
 
         void (*set_cpus_allowed)(struct task_struct *p,
@@ -1197,13 +1206,11 @@ struct task_struct {
         unsigned int flags;     /* per process flags, defined below */
         unsigned int ptrace;
 
-        int lock_depth;         /* BKL lock depth */
-
 #ifdef CONFIG_SMP
-#ifdef __ARCH_WANT_UNLOCKED_CTXSW
-        int oncpu;
-#endif
+        struct task_struct *wake_entry;
+        int on_cpu;
 #endif
+        int on_rq;
 
         int prio, static_prio, normal_prio;
         unsigned int rt_priority;
@@ -1264,6 +1271,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 personality;
         unsigned did_exec:1;
@@ -1274,6 +1282,7 @@ struct task_struct {
 
         /* Revert to default priority/policy when forking */
         unsigned sched_reset_on_fork:1;
+        unsigned sched_contributes_to_load:1;
 
         pid_t pid;
         pid_t tgid;
@@ -1537,6 +1546,9 @@ struct task_struct {
                 unsigned long memsw_nr_pages; /* uncharged mem+swap usage */
         } memcg_batch;
 #endif
+#ifdef CONFIG_HAVE_HW_BREAKPOINT
+        atomic_t ptrace_bp_refcnt;
+#endif
 };
 
 /* Future-safe accessor for struct task_struct's cpus_allowed. */
@@ -1741,7 +1753,6 @@ extern void thread_group_times(struct task_struct *p, cputime_t *ut, cputime_t *
 #define PF_FROZEN       0x00010000      /* frozen for system suspend */
 #define PF_FSTRANS      0x00020000      /* inside a filesystem transaction */
 #define PF_KSWAPD       0x00040000      /* I am kswapd */
-#define PF_OOM_ORIGIN   0x00080000      /* Allocating much memory to others */
 #define PF_LESS_THROTTLE 0x00100000     /* Throttle me less: I clean memory */
 #define PF_KTHREAD      0x00200000      /* I am a kernel thread */
 #define PF_RANDOMIZE    0x00400000      /* randomize virtual address space */
@@ -1780,6 +1791,17 @@ extern void thread_group_times(struct task_struct *p, cputime_t *ut, cputime_t *
 #define tsk_used_math(p) ((p)->flags & PF_USED_MATH)
 #define used_math() tsk_used_math(current)
 
+/*
+ * task->group_stop 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);
+
 #ifdef CONFIG_PREEMPT_RCU
 
 #define RCU_READ_UNLOCK_BLOCKED (1 << 0) /* blocked while in RCU read-side. */
@@ -2060,14 +2082,13 @@ extern void xtime_update(unsigned long ticks);
 
 extern int wake_up_state(struct task_struct *tsk, unsigned int state);
 extern int wake_up_process(struct task_struct *tsk);
-extern void wake_up_new_task(struct task_struct *tsk,
-                                unsigned long clone_flags);
+extern void wake_up_new_task(struct task_struct *tsk);
 #ifdef CONFIG_SMP
  extern void kick_process(struct task_struct *tsk);
 #else
  static inline void kick_process(struct task_struct *tsk) { }
 #endif
-extern void sched_fork(struct task_struct *p, int clone_flags);
+extern void sched_fork(struct task_struct *p);
 extern void sched_dead(struct task_struct *p);
 
 extern void proc_caches_init(void);
@@ -2155,6 +2176,7 @@ static inline void mmdrop(struct mm_struct * mm)
         if (unlikely(atomic_dec_and_test(&mm->mm_count)))
                 __mmdrop(mm);
 }
+extern int mm_init_cpumask(struct mm_struct *mm, struct mm_struct *oldmm);
 
 /* mmput gets rid of the mappings and all user-space */
 extern void mmput(struct mm_struct *);
@@ -2192,8 +2214,10 @@ extern void set_task_comm(struct task_struct *tsk, char *from);
 extern char *get_task_comm(char *to, struct task_struct *tsk);
 
 #ifdef CONFIG_SMP
+void scheduler_ipi(void);
 extern unsigned long wait_task_inactive(struct task_struct *, long match_state);
 #else
+static inline void scheduler_ipi(void) { }
 static inline unsigned long wait_task_inactive(struct task_struct *p,
                                                long match_state)
 {
diff --git a/include/linux/seqlock.h b/include/linux/seqlock.h
index e98cd2e57194..06d69648fc86 100644
--- a/include/linux/seqlock.h
+++ b/include/linux/seqlock.h
@@ -88,12 +88,12 @@ static __always_inline unsigned read_seqbegin(const seqlock_t *sl)
         unsigned ret;
 
 repeat:
-        ret = sl->sequence;
-        smp_rmb();
+        ret = ACCESS_ONCE(sl->sequence);
         if (unlikely(ret & 1)) {
                 cpu_relax();
                 goto repeat;
         }
+        smp_rmb();
 
         return ret;
 }
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index 758c5b0c6fd3..a5c31146a337 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -45,7 +45,8 @@
 #define PORT_OCTEON     17      /* Cavium OCTEON internal UART */
 #define PORT_AR7        18      /* Texas Instruments AR7 internal UART */
 #define PORT_U6_16550A  19      /* ST-Ericsson U6xxx internal UART */
-#define PORT_MAX_8250   19      /* max port ID */
+#define PORT_TEGRA      20      /* NVIDIA Tegra internal UART */
+#define PORT_MAX_8250   20      /* max port ID */
 
 /*
  * ARM specific type numbers.  These are not currently guaranteed
@@ -202,6 +203,9 @@
 /* VIA VT8500 SoC */
 #define PORT_VT8500     97
 
+/* Xilinx PSS UART */
+#define PORT_XUARTPS    98
+
 #ifdef __KERNEL__
 
 #include <linux/compiler.h>
diff --git a/include/linux/serial_reg.h b/include/linux/serial_reg.h
index 3ecb71a9e505..c75bda37c18e 100644
--- a/include/linux/serial_reg.h
+++ b/include/linux/serial_reg.h
@@ -57,6 +57,7 @@
  * ST16C654:     8  16  56  60           8  16  32  56  PORT_16654
  * TI16C750:     1  16  32  56          xx  xx  xx  xx  PORT_16750
  * TI16C752:     8  16  56  60           8  16  32  56
+ * Tegra:        1   4   8  14          16   8   4   1  PORT_TEGRA
  */
 #define UART_FCR_R_TRIG_00      0x00
 #define UART_FCR_R_TRIG_01      0x40
@@ -118,6 +119,7 @@
 #define UART_MCR_DTR            0x01 /* DTR complement */
 
 #define UART_LSR        5       /* In:  Line Status Register */
+#define UART_LSR_FIFOE          0x80 /* Fifo error */
 #define UART_LSR_TEMT           0x40 /* Transmitter empty */
 #define UART_LSR_THRE           0x20 /* Transmit-hold-register empty */
 #define UART_LSR_BI             0x10 /* Break interrupt indicator */
diff --git a/include/linux/shmem_fs.h b/include/linux/shmem_fs.h
index 399be5ad2f99..2b7fec840517 100644
--- a/include/linux/shmem_fs.h
+++ b/include/linux/shmem_fs.h
@@ -9,6 +9,8 @@
 
 #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;
@@ -17,8 +19,12 @@ struct shmem_inode_info {
         unsigned long           next_index;     /* highest alloced index + 1 */
         struct shared_policy    policy;         /* NUMA memory alloc policy */
         struct page             *i_indirect;    /* top indirect blocks page */
-        swp_entry_t             i_direct[SHMEM_NR_DIRECT]; /* first blocks */
+        union {
+                swp_entry_t     i_direct[SHMEM_NR_DIRECT]; /* first blocks */
+                char            inline_symlink[SHMEM_SYMLINK_INLINE_LEN];
+        };
         struct list_head        swaplist;       /* chain of maybes on swap */
+        struct list_head        xattr_list;     /* list of shmem_xattr */
         struct inode            vfs_inode;
 };
 
diff --git a/include/linux/sht15.h b/include/linux/sht15.h
index 046bce05ecab..f85c7c523da0 100644
--- a/include/linux/sht15.h
+++ b/include/linux/sht15.h
@@ -8,17 +8,27 @@
  * 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.
+ *
+ * For further information, see the Documentation/hwmon/sht15 file.
  */
 
 /**
  * struct sht15_platform_data - sht15 connectivity info
- * @gpio_data:  no. of gpio to which bidirectional data line is connected
- * @gpio_sck:   no. of gpio to which the data clock is connected.
- * @supply_mv:  supply voltage in mv. Overridden by regulator if available.
- **/
+ * @gpio_data:          no. of gpio to which bidirectional data line is
+ *                      connected.
+ * @gpio_sck:           no. of gpio to which the data clock is connected.
+ * @supply_mv:          supply voltage in mv. Overridden by regulator if
+ *                      available.
+ * @checksum:           flag to indicate the checksum should be validated.
+ * @no_otp_reload:      flag to indicate no reload from OTP.
+ * @low_resolution:     flag to indicate the temp/humidity resolution to use.
+ */
 struct sht15_platform_data {
         int gpio_data;
         int gpio_sck;
         int supply_mv;
+        bool checksum;
+        bool no_otp_reload;
+        bool low_resolution;
 };
 
diff --git a/include/linux/signal.h b/include/linux/signal.h
index fcd2b14b1932..a822300a253b 100644
--- a/include/linux/signal.h
+++ b/include/linux/signal.h
@@ -7,6 +7,8 @@
 #ifdef __KERNEL__
 #include <linux/list.h>
 
+struct task_struct;
+
 /* for sysctl */
 extern int print_fatal_signals;
 /*
@@ -123,13 +125,13 @@ _SIG_SET_BINOP(sigorsets, _sig_or)
 #define _sig_and(x,y)   ((x) & (y))
 _SIG_SET_BINOP(sigandsets, _sig_and)
 
-#define _sig_nand(x,y)  ((x) & ~(y))
-_SIG_SET_BINOP(signandsets, _sig_nand)
+#define _sig_andn(x,y)  ((x) & ~(y))
+_SIG_SET_BINOP(sigandnsets, _sig_andn)
 
 #undef _SIG_SET_BINOP
 #undef _sig_or
 #undef _sig_and
-#undef _sig_nand
+#undef _sig_andn
 
 #define _SIG_SET_OP(name, op)                                           \
 static inline void name(sigset_t *set)                                  \
@@ -234,6 +236,9 @@ static inline int valid_signal(unsigned long sig)
         return sig <= _NSIG ? 1 : 0;
 }
 
+struct timespec;
+struct pt_regs;
+
 extern int next_signal(struct sigpending *pending, sigset_t *mask);
 extern int do_send_sig_info(int sig, struct siginfo *info,
                                 struct task_struct *p, bool group);
@@ -242,10 +247,12 @@ extern int __group_send_sig_info(int, struct siginfo *, struct task_struct *);
 extern long do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig,
                                  siginfo_t *info);
 extern long do_sigpending(void __user *, unsigned long);
+extern int do_sigtimedwait(const sigset_t *, siginfo_t *,
+                                const struct timespec *);
 extern int sigprocmask(int, sigset_t *, sigset_t *);
+extern void set_current_blocked(const sigset_t *);
 extern int show_unhandled_signals;
 
-struct pt_regs;
 extern int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka, struct pt_regs *regs, void *cookie);
 extern void exit_signals(struct task_struct *tsk);
 
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index d0ae90af0b40..e8b78ce14474 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -391,8 +391,8 @@ struct sk_buff {
 
         __u32                   rxhash;
 
+        __u16                   queue_mapping;
         kmemcheck_bitfield_begin(flags2);
-        __u16                   queue_mapping:16;
 #ifdef CONFIG_IPV6_NDISC_NODETYPE
         __u8                    ndisc_nodetype:2;
 #endif
@@ -1442,7 +1442,7 @@ extern int ___pskb_trim(struct sk_buff *skb, unsigned int len);
 
 static inline void __skb_trim(struct sk_buff *skb, unsigned int len)
 {
-        if (unlikely(skb->data_len)) {
+        if (unlikely(skb_is_nonlinear(skb))) {
                 WARN_ON(1);
                 return;
         }
@@ -1782,7 +1782,7 @@ static inline int pskb_trim_rcsum(struct sk_buff *skb, unsigned int len)
 
 #define skb_queue_walk(queue, skb) \
                 for (skb = (queue)->next;                                       \
-                     prefetch(skb->next), (skb != (struct sk_buff *)(queue));   \
+                     skb != (struct sk_buff *)(queue);                          \
                      skb = skb->next)
 
 #define skb_queue_walk_safe(queue, skb, tmp)                                    \
@@ -1791,7 +1791,7 @@ static inline int pskb_trim_rcsum(struct sk_buff *skb, unsigned int len)
                      skb = tmp, tmp = skb->next)
 
 #define skb_queue_walk_from(queue, skb)                                         \
-                for (; prefetch(skb->next), (skb != (struct sk_buff *)(queue)); \
+                for (; skb != (struct sk_buff *)(queue);                        \
                      skb = skb->next)
 
 #define skb_queue_walk_from_safe(queue, skb, tmp)                               \
@@ -1801,7 +1801,7 @@ static inline int pskb_trim_rcsum(struct sk_buff *skb, unsigned int len)
 
 #define skb_queue_reverse_walk(queue, skb) \
                 for (skb = (queue)->prev;                                       \
-                     prefetch(skb->prev), (skb != (struct sk_buff *)(queue));   \
+                     skb != (struct sk_buff *)(queue);                          \
                      skb = skb->prev)
 
 #define skb_queue_reverse_walk_safe(queue, skb, tmp)                            \
diff --git a/include/linux/slub_def.h b/include/linux/slub_def.h
index 45ca123e8002..c8668d161dd8 100644
--- a/include/linux/slub_def.h
+++ b/include/linux/slub_def.h
@@ -37,9 +37,7 @@ enum stat_item {
 
 struct kmem_cache_cpu {
         void **freelist;        /* Pointer to next available object */
-#ifdef CONFIG_CMPXCHG_LOCAL
         unsigned long tid;      /* Globally unique transaction id */
-#endif
         struct page *page;      /* The slab from which we are allocating */
         int node;               /* The node of the page (or -1 for debug) */
 #ifdef CONFIG_SLUB_STATS
@@ -179,7 +177,8 @@ static __always_inline int kmalloc_index(size_t size)
         if (size <=   4 * 1024) return 12;
 /*
  * The following is only needed to support architectures with a larger page
- * size than 4k.
+ * size than 4k. We need to support 2 * PAGE_SIZE here. So for a 64k page
+ * size we would have to go up to 128k.
  */
         if (size <=   8 * 1024) return 13;
         if (size <=  16 * 1024) return 14;
@@ -190,7 +189,8 @@ static __always_inline int kmalloc_index(size_t size)
         if (size <= 512 * 1024) return 19;
         if (size <= 1024 * 1024) return 20;
         if (size <=  2 * 1024 * 1024) return 21;
-        return -1;
+        BUG();
+        return -1; /* Will never be reached */
 
 /*
  * What we really wanted to do and cannot do because of compiler issues is:
diff --git a/include/linux/smsc911x.h b/include/linux/smsc911x.h
index 7144e8aa1e41..4dde70e74822 100644
--- a/include/linux/smsc911x.h
+++ b/include/linux/smsc911x.h
@@ -29,6 +29,7 @@ struct smsc911x_platform_config {
         unsigned int irq_polarity;
         unsigned int irq_type;
         unsigned int flags;
+        unsigned int shift;
         phy_interface_t phy_interface;
         unsigned char mac[6];
 };
diff --git a/include/linux/socket.h b/include/linux/socket.h
index d2b5e982f079..4ef98e422fde 100644
--- a/include/linux/socket.h
+++ b/include/linux/socket.h
@@ -333,5 +333,7 @@ struct timespec;
 
 extern int __sys_recvmmsg(int fd, struct mmsghdr __user *mmsg, unsigned int vlen,
                           unsigned int flags, struct timespec *timeout);
+extern int __sys_sendmmsg(int fd, struct mmsghdr __user *mmsg,
+                          unsigned int vlen, unsigned int flags);
 #endif /* not kernel and not glibc */
 #endif /* _LINUX_SOCKET_H */
diff --git a/include/linux/spi/ads7846.h b/include/linux/spi/ads7846.h
index 92bd0839d5b4..c64de9dd7631 100644
--- a/include/linux/spi/ads7846.h
+++ b/include/linux/spi/ads7846.h
@@ -14,7 +14,8 @@ enum ads7846_filter {
 struct ads7846_platform_data {
         u16     model;                  /* 7843, 7845, 7846, 7873. */
         u16     vref_delay_usecs;       /* 0 for external vref; etc */
-        u16     vref_mv;                /* external vref value, milliVolts */
+        u16     vref_mv;                /* external vref value, milliVolts
+                                         * ads7846: if 0, use internal vref */
         bool    keep_vref_on;           /* set to keep vref on for differential
                                          * measurements as well */
         bool    swap_xy;                /* swap x and y axes */
diff --git a/include/linux/spinlock_up.h b/include/linux/spinlock_up.h
index b14f6a91e19f..a26e2fb604e6 100644
--- a/include/linux/spinlock_up.h
+++ b/include/linux/spinlock_up.h
@@ -5,6 +5,8 @@
 # error "please don't include this file directly"
 #endif
 
+#include <asm/processor.h>      /* for cpu_relax() */
+
 /*
  * include/linux/spinlock_up.h - UP-debug version of spinlocks.
  *
diff --git a/include/linux/ssb/ssb.h b/include/linux/ssb/ssb.h
index 9659eff52ca2..252e44821787 100644
--- a/include/linux/ssb/ssb.h
+++ b/include/linux/ssb/ssb.h
@@ -308,7 +308,7 @@ struct ssb_bus {
 
         /* ID information about the Chip. */
         u16 chip_id;
-        u16 chip_rev;
+        u8 chip_rev;
         u16 sprom_offset;
         u16 sprom_size;         /* number of words in sprom */
         u8 chip_package;
@@ -404,7 +404,9 @@ extern bool ssb_is_sprom_available(struct ssb_bus *bus);
 
 /* Set a fallback SPROM.
  * See kdoc at the function definition for complete documentation. */
-extern int ssb_arch_set_fallback_sprom(const struct ssb_sprom *sprom);
+extern int ssb_arch_register_fallback_sprom(
+                int (*sprom_callback)(struct ssb_bus *bus,
+                struct ssb_sprom *out));
 
 /* Suspend a SSB bus.
  * Call this from the parent bus suspend routine. */
@@ -518,6 +520,7 @@ extern int ssb_bus_may_powerdown(struct ssb_bus *bus);
  * Otherwise static always-on powercontrol will be used. */
 extern int ssb_bus_powerup(struct ssb_bus *bus, bool dynamic_pctl);
 
+extern void ssb_commit_settings(struct ssb_bus *bus);
 
 /* Various helper functions */
 extern u32 ssb_admatch_base(u32 adm);
diff --git a/include/linux/ssb/ssb_driver_chipcommon.h b/include/linux/ssb/ssb_driver_chipcommon.h
index 2cdf249b4e5f..a08d693d8324 100644
--- a/include/linux/ssb/ssb_driver_chipcommon.h
+++ b/include/linux/ssb/ssb_driver_chipcommon.h
@@ -123,6 +123,8 @@
 #define SSB_CHIPCO_FLASHDATA            0x0048
 #define SSB_CHIPCO_BCAST_ADDR           0x0050
 #define SSB_CHIPCO_BCAST_DATA           0x0054
+#define SSB_CHIPCO_GPIOPULLUP           0x0058          /* Rev >= 20 only */
+#define SSB_CHIPCO_GPIOPULLDOWN         0x005C          /* Rev >= 20 only */
 #define SSB_CHIPCO_GPIOIN               0x0060
 #define SSB_CHIPCO_GPIOOUT              0x0064
 #define SSB_CHIPCO_GPIOOUTEN            0x0068
@@ -131,6 +133,9 @@
 #define SSB_CHIPCO_GPIOIRQ              0x0074
 #define SSB_CHIPCO_WATCHDOG             0x0080
 #define SSB_CHIPCO_GPIOTIMER            0x0088          /* LED powersave (corerev >= 16) */
+#define  SSB_CHIPCO_GPIOTIMER_OFFTIME   0x0000FFFF
+#define  SSB_CHIPCO_GPIOTIMER_OFFTIME_SHIFT     0
+#define  SSB_CHIPCO_GPIOTIMER_ONTIME    0xFFFF0000
 #define  SSB_CHIPCO_GPIOTIMER_ONTIME_SHIFT      16
 #define SSB_CHIPCO_GPIOTOUTM            0x008C          /* LED powersave (corerev >= 16) */
 #define SSB_CHIPCO_CLOCK_N              0x0090
@@ -189,8 +194,10 @@
 #define  SSB_CHIPCO_CLKCTLST_HAVEALPREQ 0x00000008 /* ALP available request */
 #define  SSB_CHIPCO_CLKCTLST_HAVEHTREQ  0x00000010 /* HT available request */
 #define  SSB_CHIPCO_CLKCTLST_HWCROFF    0x00000020 /* Force HW clock request off */
-#define  SSB_CHIPCO_CLKCTLST_HAVEHT     0x00010000 /* HT available */
-#define  SSB_CHIPCO_CLKCTLST_HAVEALP    0x00020000 /* APL available */
+#define  SSB_CHIPCO_CLKCTLST_HAVEALP    0x00010000 /* ALP available */
+#define  SSB_CHIPCO_CLKCTLST_HAVEHT     0x00020000 /* HT available */
+#define  SSB_CHIPCO_CLKCTLST_4328A0_HAVEHT      0x00010000 /* 4328a0 has reversed bits */
+#define  SSB_CHIPCO_CLKCTLST_4328A0_HAVEALP     0x00020000 /* 4328a0 has reversed bits */
 #define SSB_CHIPCO_HW_WORKAROUND        0x01E4 /* Hardware workaround (rev >= 20) */
 #define SSB_CHIPCO_UART0_DATA           0x0300
 #define SSB_CHIPCO_UART0_IMR            0x0304
diff --git a/include/linux/ssb/ssb_regs.h b/include/linux/ssb/ssb_regs.h
index 402955ae48ce..efbf459d571c 100644
--- a/include/linux/ssb/ssb_regs.h
+++ b/include/linux/ssb/ssb_regs.h
@@ -97,7 +97,7 @@
 #define  SSB_INTVEC_ENET1       0x00000040 /* Enable interrupts for enet 1 */
 #define SSB_TMSLOW              0x0F98     /* SB Target State Low */
 #define  SSB_TMSLOW_RESET       0x00000001 /* Reset */
-#define  SSB_TMSLOW_REJECT_22   0x00000002 /* Reject (Backplane rev 2.2) */
+#define  SSB_TMSLOW_REJECT      0x00000002 /* Reject (Standard Backplane) */
 #define  SSB_TMSLOW_REJECT_23   0x00000004 /* Reject (Backplane rev 2.3) */
 #define  SSB_TMSLOW_CLOCK       0x00010000 /* Clock Enable */
 #define  SSB_TMSLOW_FGC         0x00020000 /* Force Gated Clocks On */
diff --git a/include/linux/stmmac.h b/include/linux/stmmac.h
index f29197a4b227..9529e49b0385 100644
--- a/include/linux/stmmac.h
+++ b/include/linux/stmmac.h
@@ -26,6 +26,8 @@
 #ifndef __STMMAC_PLATFORM_DATA
 #define __STMMAC_PLATFORM_DATA
 
+#include <linux/platform_device.h>
+
 /* platform data for platform device structure's platform_data field */
 
 /* Private data for the STM on-board ethernet driver */
diff --git a/include/linux/string.h b/include/linux/string.h
index a716ee2a8adb..a176db2f2c85 100644
--- a/include/linux/string.h
+++ b/include/linux/string.h
@@ -123,6 +123,7 @@ extern char **argv_split(gfp_t gfp, const char *str, int *argcp);
 extern void argv_free(char **argv);
 
 extern bool sysfs_streq(const char *s1, const char *s2);
+extern int strtobool(const char *s, bool *res);
 
 #ifdef CONFIG_BINARY_PRINTF
 int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args);
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index b8b380443d05..8c03b98df5f9 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -610,6 +610,8 @@ asmlinkage long sys_send(int, void __user *, size_t, unsigned);
 asmlinkage long sys_sendto(int, void __user *, size_t, unsigned,
                                 struct sockaddr __user *, int);
 asmlinkage long sys_sendmsg(int fd, struct msghdr __user *msg, unsigned flags);
+asmlinkage long sys_sendmmsg(int fd, struct mmsghdr __user *msg,
+                             unsigned int vlen, unsigned flags);
 asmlinkage long sys_recv(int, void __user *, size_t, unsigned);
 asmlinkage long sys_recvfrom(int, void __user *, size_t, unsigned,
                                 struct sockaddr __user *, int __user *);
diff --git a/include/linux/sysdev.h b/include/linux/sysdev.h
index dfb078db8ebb..d35e783a598c 100644
--- a/include/linux/sysdev.h
+++ b/include/linux/sysdev.h
@@ -34,12 +34,6 @@ struct sysdev_class {
         struct list_head        drivers;
         struct sysdev_class_attribute **attrs;
         struct kset             kset;
-#ifndef CONFIG_ARCH_NO_SYSDEV_OPS
-        /* Default operations for these types of devices */
-        int     (*shutdown)(struct sys_device *);
-        int     (*suspend)(struct sys_device *, pm_message_t state);
-        int     (*resume)(struct sys_device *);
-#endif
 };
 
 struct sysdev_class_attribute {
@@ -77,11 +71,6 @@ struct sysdev_driver {
         struct list_head        entry;
         int     (*add)(struct sys_device *);
         int     (*remove)(struct sys_device *);
-#ifndef CONFIG_ARCH_NO_SYSDEV_OPS
-        int     (*shutdown)(struct sys_device *);
-        int     (*suspend)(struct sys_device *, pm_message_t state);
-        int     (*resume)(struct sys_device *);
-#endif
 };
 
 
diff --git a/include/linux/sysfs.h b/include/linux/sysfs.h
index 30b881555fa5..c3acda60eee0 100644
--- a/include/linux/sysfs.h
+++ b/include/linux/sysfs.h
@@ -176,7 +176,6 @@ struct sysfs_dirent *sysfs_get_dirent(struct sysfs_dirent *parent_sd,
                                       const unsigned char *name);
 struct sysfs_dirent *sysfs_get(struct sysfs_dirent *sd);
 void sysfs_put(struct sysfs_dirent *sd);
-void sysfs_printk_last_file(void);
 
 /* Called to clear a ns tag when it is no longer valid */
 void sysfs_exit_ns(enum kobj_ns_type type, const void *tag);
@@ -348,10 +347,6 @@ static inline int __must_check sysfs_init(void)
         return 0;
 }
 
-static inline void sysfs_printk_last_file(void)
-{
-}
-
 #endif /* CONFIG_SYSFS */
 
 #endif /* _SYSFS_H_ */
diff --git a/include/linux/thread_info.h b/include/linux/thread_info.h
index 20fc303947d3..8d03f079688c 100644
--- a/include/linux/thread_info.h
+++ b/include/linux/thread_info.h
@@ -29,7 +29,7 @@ struct restart_block {
                 } futex;
                 /* For nanosleep */
                 struct {
-                        clockid_t index;
+                        clockid_t clockid;
                         struct timespec __user *rmtp;
 #ifdef CONFIG_COMPAT
                         struct compat_timespec __user *compat_rmtp;
diff --git a/include/linux/ti_wilink_st.h b/include/linux/ti_wilink_st.h
index 7071ec5d0118..b004e557caa9 100644
--- a/include/linux/ti_wilink_st.h
+++ b/include/linux/ti_wilink_st.h
@@ -140,12 +140,12 @@ extern long st_unregister(struct st_proto_s *);
  */
 struct st_data_s {
         unsigned long st_state;
-        struct tty_struct *tty;
         struct sk_buff *tx_skb;
 #define ST_TX_SENDING   1
 #define ST_TX_WAKEUP    2
         unsigned long tx_state;
         struct st_proto_s *list[ST_MAX_CHANNELS];
+        bool is_registered[ST_MAX_CHANNELS];
         unsigned long rx_state;
         unsigned long rx_count;
         struct sk_buff *rx_skb;
@@ -155,6 +155,7 @@ struct st_data_s {
         unsigned char   protos_registered;
         unsigned long ll_state;
         void *kim_data;
+        struct tty_struct *tty;
 };
 
 /*
diff --git a/include/linux/time.h b/include/linux/time.h
index 454a26205787..b3061782dec3 100644
--- a/include/linux/time.h
+++ b/include/linux/time.h
@@ -126,6 +126,7 @@ struct timespec __current_kernel_time(void); /* does not take xtime_lock */
 struct timespec get_monotonic_coarse(void);
 void get_xtime_and_monotonic_and_sleep_offset(struct timespec *xtim,
                                 struct timespec *wtom, struct timespec *sleep);
+void timekeeping_inject_sleeptime(struct timespec *delta);
 
 #define CURRENT_TIME            (current_kernel_time())
 #define CURRENT_TIME_SEC        ((struct timespec) { get_seconds(), 0 })
@@ -294,6 +295,8 @@ struct itimerval {
 #define CLOCK_REALTIME_COARSE           5
 #define CLOCK_MONOTONIC_COARSE          6
 #define CLOCK_BOOTTIME                  7
+#define CLOCK_REALTIME_ALARM            8
+#define CLOCK_BOOTTIME_ALARM            9
 
 /*
  * The IDs of various hardware clocks:
diff --git a/include/linux/timerfd.h b/include/linux/timerfd.h
index 2d0792983f8c..d3b57fa12225 100644
--- a/include/linux/timerfd.h
+++ b/include/linux/timerfd.h
@@ -19,6 +19,7 @@
  * shared O_* flags.
  */
 #define TFD_TIMER_ABSTIME (1 << 0)
+#define TFD_TIMER_CANCEL_ON_SET (1 << 1)
 #define TFD_CLOEXEC O_CLOEXEC
 #define TFD_NONBLOCK O_NONBLOCK
 
@@ -26,6 +27,6 @@
 /* Flags for timerfd_create.  */
 #define TFD_CREATE_FLAGS TFD_SHARED_FCNTL_FLAGS
 /* Flags for timerfd_settime.  */
-#define TFD_SETTIME_FLAGS TFD_TIMER_ABSTIME
+#define TFD_SETTIME_FLAGS (TFD_TIMER_ABSTIME | TFD_TIMER_CANCEL_ON_SET)
 
 #endif /* _LINUX_TIMERFD_H */
diff --git a/include/linux/timerqueue.h b/include/linux/timerqueue.h
index a520fd70a59f..5088727478fd 100644
--- a/include/linux/timerqueue.h
+++ b/include/linux/timerqueue.h
@@ -39,7 +39,7 @@ struct timerqueue_node *timerqueue_getnext(struct timerqueue_head *head)
 
 static inline void timerqueue_init(struct timerqueue_node *node)
 {
-        RB_CLEAR_NODE(&node->node);
+        rb_init_node(&node->node);
 }
 
 static inline void timerqueue_init_head(struct timerqueue_head *head)
diff --git a/include/linux/tipc.h b/include/linux/tipc.h
index a5b994a204d2..f2d90091cc20 100644
--- a/include/linux/tipc.h
+++ b/include/linux/tipc.h
@@ -101,7 +101,7 @@ static inline unsigned int tipc_node(__u32 addr)
  * Limiting values for messages
  */
 
-#define TIPC_MAX_USER_MSG_SIZE  66000
+#define TIPC_MAX_USER_MSG_SIZE  66000U
 
 /*
  * Message importance levels
diff --git a/include/linux/tracehook.h b/include/linux/tracehook.h
index ebcfa4ebdbf8..e95f5236611f 100644
--- a/include/linux/tracehook.h
+++ b/include/linux/tracehook.h
@@ -469,33 +469,6 @@ static inline int tracehook_get_signal(struct task_struct *task,
 }
 
 /**
- * tracehook_notify_jctl - report about job control stop/continue
- * @notify:             zero, %CLD_STOPPED or %CLD_CONTINUED
- * @why:                %CLD_STOPPED or %CLD_CONTINUED
- *
- * This is called when we might call do_notify_parent_cldstop().
- *
- * @notify is zero if we would not ordinarily send a %SIGCHLD,
- * or is the %CLD_STOPPED or %CLD_CONTINUED .si_code for %SIGCHLD.
- *
- * @why is %CLD_STOPPED when about to stop for job control;
- * we are already in %TASK_STOPPED state, about to call schedule().
- * It might also be that we have just exited (check %PF_EXITING),
- * but need to report that a group-wide stop is complete.
- *
- * @why is %CLD_CONTINUED when waking up after job control stop and
- * ready to make a delayed @notify report.
- *
- * Return the %CLD_* value for %SIGCHLD, or zero to generate no signal.
- *
- * Called with the siglock held.
- */
-static inline int tracehook_notify_jctl(int notify, int why)
-{
-        return notify ?: (current->ptrace & PT_PTRACED) ? why : 0;
-}
-
-/**
  * tracehook_finish_jctl - report about return from job control stop
  *
  * This is called by do_signal_stop() after wakeup.
diff --git a/include/linux/tracepoint.h b/include/linux/tracepoint.h
index 97c84a58efb8..d530a4460a0b 100644
--- a/include/linux/tracepoint.h
+++ b/include/linux/tracepoint.h
@@ -29,7 +29,7 @@ struct tracepoint_func {
 
 struct tracepoint {
         const char *name;               /* Tracepoint name */
-        int state;                      /* State. */
+        struct jump_label_key key;
         void (*regfunc)(void);
         void (*unregfunc)(void);
         struct tracepoint_func __rcu *funcs;
@@ -146,9 +146,7 @@ void tracepoint_update_probe_range(struct tracepoint * const *begin,
         extern struct tracepoint __tracepoint_##name;                   \
         static inline void trace_##name(proto)                          \
         {                                                               \
-                JUMP_LABEL(&__tracepoint_##name.state, do_trace);       \
-                return;                                                 \
-do_trace:                                                               \
+                if (static_branch(&__tracepoint_##name.key))            \
                         __DO_TRACE(&__tracepoint_##name,                \
                                 TP_PROTO(data_proto),                   \
                                 TP_ARGS(data_args),                     \
@@ -176,14 +174,14 @@ do_trace:								\
  * structures, so we create an array of pointers that will be used for iteration
  * on the tracepoints.
  */
-#define DEFINE_TRACE_FN(name, reg, unreg)                               \
-        static const char __tpstrtab_##name[]                           \
-        __attribute__((section("__tracepoints_strings"))) = #name;      \
-        struct tracepoint __tracepoint_##name                           \
-        __attribute__((section("__tracepoints"))) =                     \
-                { __tpstrtab_##name, 0, reg, unreg, NULL };             \
-        static struct tracepoint * const __tracepoint_ptr_##name __used \
-        __attribute__((section("__tracepoints_ptrs"))) =                \
+#define DEFINE_TRACE_FN(name, reg, unreg)                                \
+        static const char __tpstrtab_##name[]                            \
+        __attribute__((section("__tracepoints_strings"))) = #name;       \
+        struct tracepoint __tracepoint_##name                            \
+        __attribute__((section("__tracepoints"))) =                      \
+                { __tpstrtab_##name, JUMP_LABEL_INIT, reg, unreg, NULL };\
+        static struct tracepoint * const __tracepoint_ptr_##name __used  \
+        __attribute__((section("__tracepoints_ptrs"))) =                 \
                 &__tracepoint_##name;
 
 #define DEFINE_TRACE(name)                                              \
diff --git a/include/linux/tty.h b/include/linux/tty.h
index 9f469c700550..d6f05292e456 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -50,6 +50,8 @@
 #define N_CAIF          20      /* CAIF protocol for talking to modems */
 #define N_GSM0710       21      /* GSM 0710 Mux */
 #define N_TI_WL         22      /* for TI's WL BT, FM, GPS combo chips */
+#define N_TRACESINK     23      /* Trace data routing for MIPI P1149.7 */
+#define N_TRACEROUTER   24      /* Trace data routing for MIPI P1149.7 */
 
 /*
  * This character is the same as _POSIX_VDISABLE: it cannot be used as
@@ -472,6 +474,7 @@ extern int tty_add_file(struct tty_struct *tty, 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);
+extern void deinitialize_tty_struct(struct tty_struct *tty);
 extern struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx,
                                                                 int first_ok);
 extern int tty_release(struct inode *inode, struct file *filp);
@@ -525,6 +528,7 @@ extern int tty_set_ldisc(struct tty_struct *tty, int ldisc);
 extern int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty);
 extern void tty_ldisc_release(struct tty_struct *tty, struct tty_struct *o_tty);
 extern void tty_ldisc_init(struct tty_struct *tty);
+extern void tty_ldisc_deinit(struct tty_struct *tty);
 extern void tty_ldisc_begin(void);
 /* This last one is just for the tty layer internals and shouldn't be used elsewhere */
 extern void tty_ldisc_enable(struct tty_struct *tty);
diff --git a/include/linux/tty_ldisc.h b/include/linux/tty_ldisc.h
index ff7dc08696a8..5b07792ccb46 100644
--- a/include/linux/tty_ldisc.h
+++ b/include/linux/tty_ldisc.h
@@ -76,7 +76,7 @@
  *      tty device.  It is solely the responsibility of the line
  *      discipline to handle poll requests.
  *
- * void (*receive_buf)(struct tty_struct *, const unsigned char *cp,
+ * unsigned int (*receive_buf)(struct tty_struct *, const unsigned char *cp,
  *                     char *fp, int count);
  *
  *      This function is called by the low-level tty driver to send
@@ -84,7 +84,8 @@
  *      processing.  <cp> is a pointer to the buffer of input
  *      character received by the device.  <fp> is a pointer to a
  *      pointer of flag bytes which indicate whether a character was
- *      received with a parity error, etc.
+ *      received with a parity error, etc. Returns the amount of bytes
+ *      received.
  * 
  * void (*write_wakeup)(struct tty_struct *);
  *
@@ -140,8 +141,8 @@ struct tty_ldisc_ops {
         /*
          * The following routines are called from below.
          */
-        void    (*receive_buf)(struct tty_struct *, const unsigned char *cp,
-                               char *fp, int count);
+        unsigned int (*receive_buf)(struct tty_struct *,
+                        const unsigned char *cp, char *fp, int count);
         void    (*write_wakeup)(struct tty_struct *);
         void    (*dcd_change)(struct tty_struct *, unsigned int,
                                 struct pps_event_time *);
diff --git a/include/linux/usb.h b/include/linux/usb.h
index 65f78ca5d88e..73c7df489607 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -806,8 +806,10 @@ struct usbdrv_wrap {
  * @resume: Called when the device is being resumed by the system.
  * @reset_resume: Called when the suspended device has been reset instead
  *      of being resumed.
- * @pre_reset: Called by usb_reset_device() when the device
- *      is about to be reset.
+ * @pre_reset: Called by usb_reset_device() when the device is about to be
+ *      reset.  This routine must not return until the driver has no active
+ *      URBs for the device, and no more URBs may be submitted until the
+ *      post_reset method is called.
  * @post_reset: Called by usb_reset_device() after the device
  *      has been reset
  * @id_table: USB drivers use ID table to support hotplugging.
diff --git a/include/linux/usb/ch9.h b/include/linux/usb/ch9.h
index b72f305ce6bd..0fd3fbdd8283 100644
--- a/include/linux/usb/ch9.h
+++ b/include/linux/usb/ch9.h
@@ -579,7 +579,7 @@ struct usb_ss_ep_comp_descriptor {
 
         __u8  bMaxBurst;
         __u8  bmAttributes;
-        __u16 wBytesPerInterval;
+        __le16 wBytesPerInterval;
 } __attribute__ ((packed));
 
 #define USB_DT_SS_EP_COMP_SIZE          6
diff --git a/include/linux/usb/composite.h b/include/linux/usb/composite.h
index 882a084a8411..b78cba466d3d 100644
--- a/include/linux/usb/composite.h
+++ b/include/linux/usb/composite.h
@@ -37,6 +37,14 @@
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
 
+/*
+ * USB function drivers should return USB_GADGET_DELAYED_STATUS if they
+ * wish to delay the data/status stages of the control transfer till they
+ * are ready. The control transfer will then be kept from completing till
+ * all the function drivers that requested for USB_GADGET_DELAYED_STAUS
+ * invoke usb_composite_setup_continue().
+ */
+#define USB_GADGET_DELAYED_STATUS       0x7fff  /* Impossibly large value */
 
 struct usb_configuration;
 
@@ -285,6 +293,7 @@ struct usb_composite_driver {
 extern int usb_composite_probe(struct usb_composite_driver *driver,
                                int (*bind)(struct usb_composite_dev *cdev));
 extern void usb_composite_unregister(struct usb_composite_driver *driver);
+extern void usb_composite_setup_continue(struct usb_composite_dev *cdev);
 
 
 /**
@@ -342,7 +351,12 @@ struct usb_composite_dev {
          */
         unsigned                        deactivations;
 
-        /* protects at least deactivation count */
+        /* the composite driver won't complete the control transfer's
+         * data/status stages till delayed_status is zero.
+         */
+        int                             delayed_status;
+
+        /* protects deactivations and delayed_status counts*/
         spinlock_t                      lock;
 };
 
diff --git a/include/linux/usb/ehci_def.h b/include/linux/usb/ehci_def.h
index e49dfd45baa4..7cc95ee3606b 100644
--- a/include/linux/usb/ehci_def.h
+++ b/include/linux/usb/ehci_def.h
@@ -25,10 +25,15 @@
 struct ehci_caps {
         /* these fields are specified as 8 and 16 bit registers,
          * but some hosts can't perform 8 or 16 bit PCI accesses.
+         * some hosts treat caplength and hciversion as parts of a 32-bit
+         * register, others treat them as two separate registers, this
+         * affects the memory map for big endian controllers.
          */
         u32             hc_capbase;
-#define HC_LENGTH(p)            (((p)>>00)&0x00ff)      /* bits 7:0 */
-#define HC_VERSION(p)           (((p)>>16)&0xffff)      /* bits 31:16 */
+#define HC_LENGTH(ehci, p)      (0x00ff&((p) >> /* bits 7:0 / offset 00h */ \
+                                (ehci_big_endian_capbase(ehci) ? 24 : 0)))
+#define HC_VERSION(ehci, p)     (0xffff&((p) >> /* bits 31:16 / offset 02h */ \
+                                (ehci_big_endian_capbase(ehci) ? 0 : 16)))
         u32             hcs_params;     /* HCSPARAMS - offset 0x4 */
 #define HCS_DEBUG_PORT(p)       (((p)>>20)&0xf) /* bits 23:20, debug port? */
 #define HCS_INDICATOR(p)        ((p)&(1 << 16)) /* true: has port indicators */
@@ -52,7 +57,7 @@ struct ehci_caps {
 #define HCC_PGM_FRAMELISTLEN(p) ((p)&(1 << 1))  /* true: periodic_size changes*/
 #define HCC_64BIT_ADDR(p)       ((p)&(1))       /* true: can use 64-bit addr */
         u8              portroute[8];    /* nibbles for routing - offset 0xC */
-} __attribute__ ((packed));
+};
 
 
 /* Section 2.3 Host Controller Operational Registers */
@@ -150,7 +155,7 @@ struct ehci_regs {
 #define PORT_CSC        (1<<1)          /* connect status change */
 #define PORT_CONNECT    (1<<0)          /* device connected */
 #define PORT_RWC_BITS   (PORT_CSC | PORT_PEC | PORT_OCC)
-} __attribute__ ((packed));
+};
 
 #define USBMODE         0x68            /* USB Device mode */
 #define USBMODE_SDIS    (1<<3)          /* Stream disable */
@@ -194,7 +199,7 @@ struct ehci_dbg_port {
         u32     data47;
         u32     address;
 #define DBGP_EPADDR(dev, ep)    (((dev)<<8)|(ep))
-} __attribute__ ((packed));
+};
 
 #ifdef CONFIG_EARLY_PRINTK_DBGP
 #include <linux/init.h>
diff --git a/include/linux/usb/gadget.h b/include/linux/usb/gadget.h
index e538172c0f64..dd1571db55e7 100644
--- a/include/linux/usb/gadget.h
+++ b/include/linux/usb/gadget.h
@@ -890,8 +890,8 @@ static inline void usb_free_descriptors(struct usb_descriptor_header **v)
 /* utility wrapping a simple endpoint selection policy */
 
 extern struct usb_ep *usb_ep_autoconfig(struct usb_gadget *,
-                        struct usb_endpoint_descriptor *) __devinit;
+                        struct usb_endpoint_descriptor *);
 
-extern void usb_ep_autoconfig_reset(struct usb_gadget *) __devinit;
+extern void usb_ep_autoconfig_reset(struct usb_gadget *);
 
 #endif /* __LINUX_USB_GADGET_H */
diff --git a/include/linux/usb/msm_hsusb.h b/include/linux/usb/msm_hsusb.h
index 3657403eac18..00311fe9d0df 100644
--- a/include/linux/usb/msm_hsusb.h
+++ b/include/linux/usb/msm_hsusb.h
@@ -2,7 +2,7 @@
  *
  * Copyright (C) 2008 Google, Inc.
  * Author: Brian Swetland <swetland@google.com>
- * Copyright (c) 2009-2010, Code Aurora Forum. All rights reserved.
+ * Copyright (c) 2009-2011, Code Aurora Forum. All rights reserved.
  *
  * This software is licensed under the terms of the GNU General Public
  * License version 2, as published by the Free Software Foundation, and
@@ -54,6 +54,64 @@ enum otg_control_type {
 };
 
 /**
+ * PHY used in
+ *
+ * INVALID_PHY                  Unsupported PHY
+ * CI_45NM_INTEGRATED_PHY       Chipidea 45nm integrated PHY
+ * SNPS_28NM_INTEGRATED_PHY     Synopsis 28nm integrated PHY
+ *
+ */
+enum msm_usb_phy_type {
+        INVALID_PHY = 0,
+        CI_45NM_INTEGRATED_PHY,
+        SNPS_28NM_INTEGRATED_PHY,
+};
+
+#define IDEV_CHG_MAX    1500
+#define IUNIT           100
+
+/**
+ * Different states involved in USB charger detection.
+ *
+ * USB_CHG_STATE_UNDEFINED      USB charger is not connected or detection
+ *                              process is not yet started.
+ * USB_CHG_STATE_WAIT_FOR_DCD   Waiting for Data pins contact.
+ * USB_CHG_STATE_DCD_DONE       Data pin contact is detected.
+ * USB_CHG_STATE_PRIMARY_DONE   Primary detection is completed (Detects
+ *                              between SDP and DCP/CDP).
+ * USB_CHG_STATE_SECONDARY_DONE Secondary detection is completed (Detects
+ *                              between DCP and CDP).
+ * USB_CHG_STATE_DETECTED       USB charger type is determined.
+ *
+ */
+enum usb_chg_state {
+        USB_CHG_STATE_UNDEFINED = 0,
+        USB_CHG_STATE_WAIT_FOR_DCD,
+        USB_CHG_STATE_DCD_DONE,
+        USB_CHG_STATE_PRIMARY_DONE,
+        USB_CHG_STATE_SECONDARY_DONE,
+        USB_CHG_STATE_DETECTED,
+};
+
+/**
+ * USB charger types
+ *
+ * USB_INVALID_CHARGER  Invalid USB charger.
+ * USB_SDP_CHARGER      Standard downstream port. Refers to a downstream port
+ *                      on USB2.0 compliant host/hub.
+ * USB_DCP_CHARGER      Dedicated charger port (AC charger/ Wall charger).
+ * USB_CDP_CHARGER      Charging downstream port. Enumeration can happen and
+ *                      IDEV_CHG_MAX can be drawn irrespective of USB state.
+ *
+ */
+enum usb_chg_type {
+        USB_INVALID_CHARGER = 0,
+        USB_SDP_CHARGER,
+        USB_DCP_CHARGER,
+        USB_CDP_CHARGER,
+};
+
+/**
  * struct msm_otg_platform_data - platform device data
  *              for msm_otg driver.
  * @phy_init_seq: PHY configuration sequence. val, reg pairs
@@ -64,7 +122,8 @@ enum otg_control_type {
  * @otg_control: OTG switch controlled by user/Id pin
  * @default_mode: Default operational mode. Applicable only if
  *              OTG switch is controller by user.
- *
+ * @pclk_src_name: pclk is derived from ebi1_usb_clk in case of 7x27 and 8k
+ *              dfab_usb_hs_clk in case of 8660 and 8960.
  */
 struct msm_otg_platform_data {
         int *phy_init_seq;
@@ -73,7 +132,9 @@ struct msm_otg_platform_data {
         enum usb_mode_type mode;
         enum otg_control_type otg_control;
         enum usb_mode_type default_mode;
+        enum msm_usb_phy_type phy_type;
         void (*setup_gpio)(enum usb_otg_state state);
+        char *pclk_src_name;
 };
 
 /**
@@ -83,6 +144,7 @@ struct msm_otg_platform_data {
  * @irq: IRQ number assigned for HSUSB controller.
  * @clk: clock struct of usb_hs_clk.
  * @pclk: clock struct of usb_hs_pclk.
+ * @pclk_src: pclk source for voting.
  * @phy_reset_clk: clock struct of usb_phy_clk.
  * @core_clk: clock struct of usb_hs_core_clk.
  * @regs: ioremapped register base address.
@@ -90,7 +152,12 @@ struct msm_otg_platform_data {
  * @sm_work: OTG state machine work.
  * @in_lpm: indicates low power mode (LPM) state.
  * @async_int: Async interrupt arrived.
- *
+ * @cur_power: The amount of mA available from downstream port.
+ * @chg_work: Charger detection work.
+ * @chg_state: The state of charger detection process.
+ * @chg_type: The type of charger attached.
+ * @dcd_retires: The retry count used to track Data contact
+ *               detection process.
  */
 struct msm_otg {
         struct otg_transceiver otg;
@@ -98,6 +165,7 @@ struct msm_otg {
         int irq;
         struct clk *clk;
         struct clk *pclk;
+        struct clk *pclk_src;
         struct clk *phy_reset_clk;
         struct clk *core_clk;
         void __iomem *regs;
@@ -107,6 +175,11 @@ struct msm_otg {
         struct work_struct sm_work;
         atomic_t in_lpm;
         int async_int;
+        unsigned cur_power;
+        struct delayed_work chg_work;
+        enum usb_chg_state chg_state;
+        enum usb_chg_type chg_type;
+        u8 dcd_retries;
 };
 
 #endif
diff --git a/include/linux/usb/msm_hsusb_hw.h b/include/linux/usb/msm_hsusb_hw.h
index 7d1babbff071..6e97a2d3d39f 100644
--- a/include/linux/usb/msm_hsusb_hw.h
+++ b/include/linux/usb/msm_hsusb_hw.h
@@ -24,6 +24,7 @@
 #define USB_PORTSC           (MSM_USB_BASE + 0x0184)
 #define USB_OTGSC            (MSM_USB_BASE + 0x01A4)
 #define USB_USBMODE          (MSM_USB_BASE + 0x01A8)
+#define USB_PHY_CTRL         (MSM_USB_BASE + 0x0240)
 
 #define USBCMD_RESET   2
 #define USB_USBINTR          (MSM_USB_BASE + 0x0148)
@@ -42,6 +43,7 @@
 
 #define ASYNC_INTR_CTRL         (1 << 29) /* Enable async interrupt */
 #define ULPI_STP_CTRL           (1 << 30) /* Block communication with PHY */
+#define PHY_RETEN               (1 << 1) /* PHY retention enable/disable */
 
 /* OTG definitions */
 #define OTGSC_INTSTS_MASK       (0x7f << 16)
diff --git a/include/linux/usb/otg.h b/include/linux/usb/otg.h
index 6e40718f5abe..d87f44f5b04e 100644
--- a/include/linux/usb/otg.h
+++ b/include/linux/usb/otg.h
@@ -168,6 +168,7 @@ otg_shutdown(struct otg_transceiver *otg)
 #ifdef CONFIG_USB_OTG_UTILS
 extern struct otg_transceiver *otg_get_transceiver(void);
 extern void otg_put_transceiver(struct otg_transceiver *);
+extern const char *otg_state_string(enum usb_otg_state state);
 #else
 static inline struct otg_transceiver *otg_get_transceiver(void)
 {
@@ -177,6 +178,11 @@ static inline struct otg_transceiver *otg_get_transceiver(void)
 static inline void otg_put_transceiver(struct otg_transceiver *x)
 {
 }
+
+static inline const char *otg_state_string(enum usb_otg_state state)
+{
+        return NULL;
+}
 #endif
 
 /* Context: can sleep */
diff --git a/include/linux/usb/renesas_usbhs.h b/include/linux/usb/renesas_usbhs.h
new file mode 100644
index 000000000000..3a7f1d982dd6
--- /dev/null
+++ b/include/linux/usb/renesas_usbhs.h
@@ -0,0 +1,156 @@
+/*
+ * Renesas USB
+ *
+ * Copyright (C) 2011 Renesas Solutions Corp.
+ * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
+ *
+ * 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 RENESAS_USB_H
+#define RENESAS_USB_H
+#include <linux/platform_device.h>
+#include <linux/usb/ch9.h>
+
+/*
+ * module type
+ *
+ * it will be return value from get_id
+ */
+enum {
+        USBHS_HOST = 0,
+        USBHS_GADGET,
+        USBHS_MAX,
+};
+
+/*
+ * callback functions table for driver
+ *
+ * These functions are called from platform for driver.
+ * Callback function's pointer will be set before
+ * renesas_usbhs_platform_callback :: hardware_init was called
+ */
+struct renesas_usbhs_driver_callback {
+        int (*notify_hotplug)(struct platform_device *pdev);
+};
+
+/*
+ * callback functions for platform
+ *
+ * These functions are called from driver for platform
+ */
+struct renesas_usbhs_platform_callback {
+
+        /*
+         * option:
+         *
+         * Hardware init function for platform.
+         * it is called when driver was probed.
+         */
+        int (*hardware_init)(struct platform_device *pdev);
+
+        /*
+         * option:
+         *
+         * Hardware exit function for platform.
+         * it is called when driver was removed
+         */
+        void (*hardware_exit)(struct platform_device *pdev);
+
+        /*
+         * option:
+         *
+         * Phy reset for platform
+         */
+        void (*phy_reset)(struct platform_device *pdev);
+
+        /*
+         * get USB ID function
+         *  - USBHS_HOST
+         *  - USBHS_GADGET
+         */
+        int (*get_id)(struct platform_device *pdev);
+
+        /*
+         * get VBUS status function.
+         */
+        int (*get_vbus)(struct platform_device *pdev);
+};
+
+/*
+ * parameters for renesas usbhs
+ *
+ * some register needs USB chip specific parameters.
+ * This struct show it to driver
+ */
+struct renesas_usbhs_driver_param {
+        /*
+         * pipe settings
+         */
+        u32 *pipe_type; /* array of USB_ENDPOINT_XFER_xxx (from ep0) */
+        int pipe_size; /* pipe_type array size */
+
+        /*
+         * option:
+         *
+         * for BUSWAIT :: BWAIT
+         * */
+        int buswait_bwait;
+
+        /*
+         * option:
+         *
+         * delay time from notify_hotplug callback
+         */
+        int detection_delay;
+};
+
+/*
+ * option:
+ *
+ * platform information for renesas_usbhs driver.
+ */
+struct renesas_usbhs_platform_info {
+        /*
+         * option:
+         *
+         * platform set these functions before
+         * call platform_add_devices if needed
+         */
+        struct renesas_usbhs_platform_callback  platform_callback;
+
+        /*
+         * driver set these callback functions pointer.
+         * platform can use it on callback functions
+         */
+        struct renesas_usbhs_driver_callback    driver_callback;
+
+        /*
+         * option:
+         *
+         * driver use these param for some register
+         */
+        struct renesas_usbhs_driver_param       driver_param;
+};
+
+/*
+ * macro for platform
+ */
+#define renesas_usbhs_get_info(pdev)\
+        ((struct renesas_usbhs_platform_info *)(pdev)->dev.platform_data)
+
+#define renesas_usbhs_call_notify_hotplug(pdev)                         \
+        ({                                                              \
+                struct renesas_usbhs_driver_callback *dc;               \
+                dc = &(renesas_usbhs_get_info(pdev)->driver_callback);  \
+                if (dc && dc->notify_hotplug)                           \
+                        dc->notify_hotplug(pdev);                       \
+        })
+#endif /* RENESAS_USB_H */
diff --git a/include/linux/usb/rndis_host.h b/include/linux/usb/rndis_host.h
index 05ef52861988..88fceb718c77 100644
--- a/include/linux/usb/rndis_host.h
+++ b/include/linux/usb/rndis_host.h
@@ -256,6 +256,8 @@ struct rndis_keepalive_c {	/* IN (optionally OUT) */
 #define FLAG_RNDIS_PHYM_NOT_WIRELESS    0x0001
 #define FLAG_RNDIS_PHYM_WIRELESS        0x0002
 
+/* Flags for driver_info::data */
+#define RNDIS_DRIVER_DATA_POLL_STATUS   1       /* poll status before control */
 
 extern void rndis_status(struct usbnet *dev, struct urb *urb);
 extern int
diff --git a/include/linux/uvcvideo.h b/include/linux/uvcvideo.h
new file mode 100644
index 000000000000..f46a53f060d7
--- /dev/null
+++ b/include/linux/uvcvideo.h
@@ -0,0 +1,69 @@
+#ifndef __LINUX_UVCVIDEO_H_
+#define __LINUX_UVCVIDEO_H_
+
+#include <linux/ioctl.h>
+#include <linux/types.h>
+
+/*
+ * Dynamic controls
+ */
+
+/* Data types for UVC control data */
+#define UVC_CTRL_DATA_TYPE_RAW          0
+#define UVC_CTRL_DATA_TYPE_SIGNED       1
+#define UVC_CTRL_DATA_TYPE_UNSIGNED     2
+#define UVC_CTRL_DATA_TYPE_BOOLEAN      3
+#define UVC_CTRL_DATA_TYPE_ENUM         4
+#define UVC_CTRL_DATA_TYPE_BITMASK      5
+
+/* Control flags */
+#define UVC_CTRL_FLAG_SET_CUR           (1 << 0)
+#define UVC_CTRL_FLAG_GET_CUR           (1 << 1)
+#define UVC_CTRL_FLAG_GET_MIN           (1 << 2)
+#define UVC_CTRL_FLAG_GET_MAX           (1 << 3)
+#define UVC_CTRL_FLAG_GET_RES           (1 << 4)
+#define UVC_CTRL_FLAG_GET_DEF           (1 << 5)
+/* Control should be saved at suspend and restored at resume. */
+#define UVC_CTRL_FLAG_RESTORE           (1 << 6)
+/* Control can be updated by the camera. */
+#define UVC_CTRL_FLAG_AUTO_UPDATE       (1 << 7)
+
+#define UVC_CTRL_FLAG_GET_RANGE \
+        (UVC_CTRL_FLAG_GET_CUR | UVC_CTRL_FLAG_GET_MIN | \
+         UVC_CTRL_FLAG_GET_MAX | UVC_CTRL_FLAG_GET_RES | \
+         UVC_CTRL_FLAG_GET_DEF)
+
+struct uvc_menu_info {
+        __u32 value;
+        __u8 name[32];
+};
+
+struct uvc_xu_control_mapping {
+        __u32 id;
+        __u8 name[32];
+        __u8 entity[16];
+        __u8 selector;
+
+        __u8 size;
+        __u8 offset;
+        __u32 v4l2_type;
+        __u32 data_type;
+
+        struct uvc_menu_info __user *menu_info;
+        __u32 menu_count;
+
+        __u32 reserved[4];
+};
+
+struct uvc_xu_control_query {
+        __u8 unit;
+        __u8 selector;
+        __u8 query;
+        __u16 size;
+        __u8 __user *data;
+};
+
+#define UVCIOC_CTRL_MAP         _IOWR('u', 0x20, struct uvc_xu_control_mapping)
+#define UVCIOC_CTRL_QUERY       _IOWR('u', 0x21, struct uvc_xu_control_query)
+
+#endif
diff --git a/include/linux/v4l2-mediabus.h b/include/linux/v4l2-mediabus.h
index de5c15921025..5ea7f753a348 100644
--- a/include/linux/v4l2-mediabus.h
+++ b/include/linux/v4l2-mediabus.h
@@ -89,6 +89,9 @@ enum v4l2_mbus_pixelcode {
         V4L2_MBUS_FMT_SGBRG12_1X12 = 0x3010,
         V4L2_MBUS_FMT_SGRBG12_1X12 = 0x3011,
         V4L2_MBUS_FMT_SRGGB12_1X12 = 0x3012,
+
+        /* JPEG compressed formats - next is 0x4002 */
+        V4L2_MBUS_FMT_JPEG_1X8 = 0x4001,
 };
 
 /**
diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
index be82c8ead1af..8a4c309d2344 100644
--- a/include/linux/videodev2.h
+++ b/include/linux/videodev2.h
@@ -311,6 +311,9 @@ struct v4l2_pix_format {
 #define V4L2_PIX_FMT_Y12     v4l2_fourcc('Y', '1', '2', ' ') /* 12  Greyscale     */
 #define V4L2_PIX_FMT_Y16     v4l2_fourcc('Y', '1', '6', ' ') /* 16  Greyscale     */
 
+/* Grey bit-packed formats */
+#define V4L2_PIX_FMT_Y10BPACK    v4l2_fourcc('Y', '1', '0', 'B') /* 10  Greyscale bit-packed */
+
 /* Palette formats */
 #define V4L2_PIX_FMT_PAL8    v4l2_fourcc('P', 'A', 'L', '8') /*  8  8-bit palette */
 
@@ -333,6 +336,7 @@ struct v4l2_pix_format {
 #define V4L2_PIX_FMT_YUV420  v4l2_fourcc('Y', 'U', '1', '2') /* 12  YUV 4:2:0     */
 #define V4L2_PIX_FMT_HI240   v4l2_fourcc('H', 'I', '2', '4') /*  8  8-bit color   */
 #define V4L2_PIX_FMT_HM12    v4l2_fourcc('H', 'M', '1', '2') /*  8  YUV 4:2:0 16x16 macroblocks */
+#define V4L2_PIX_FMT_M420    v4l2_fourcc('M', '4', '2', '0') /* 12  YUV 4:2:0 2 lines y, 1 line uv interleaved */
 
 /* two planes -- one Y, one Cr + Cb interleaved  */
 #define V4L2_PIX_FMT_NV12    v4l2_fourcc('N', 'V', '1', '2') /* 12  Y/CbCr 4:2:0  */
diff --git a/include/linux/vmstat.h b/include/linux/vmstat.h
index 2b3831b58aa4..51359837511a 100644
--- a/include/linux/vmstat.h
+++ b/include/linux/vmstat.h
@@ -261,6 +261,7 @@ extern void dec_zone_state(struct zone *, enum zone_stat_item);
 extern void __dec_zone_state(struct zone *, enum zone_stat_item);
 
 void refresh_cpu_vm_stats(int);
+void refresh_zone_stat_thresholds(void);
 
 int calculate_pressure_threshold(struct zone *zone);
 int calculate_normal_threshold(struct zone *zone);
@@ -313,6 +314,10 @@ static inline void __dec_zone_page_state(struct page *page,
 #define set_pgdat_percpu_threshold(pgdat, callback) { }
 
 static inline void refresh_cpu_vm_stats(int cpu) { }
-#endif
+static inline void refresh_zone_stat_thresholds(void) { }
+
+#endif          /* CONFIG_SMP */
+
+extern const char * const vmstat_text[];
 
 #endif /* _LINUX_VMSTAT_H */
diff --git a/include/linux/wl12xx.h b/include/linux/wl12xx.h
index bebb8efea0a6..4b697395326e 100644
--- a/include/linux/wl12xx.h
+++ b/include/linux/wl12xx.h
@@ -24,12 +24,26 @@
 #ifndef _LINUX_WL12XX_H
 #define _LINUX_WL12XX_H
 
-/* The board reference clock values */
+/* Reference clock values */
 enum {
-        WL12XX_REFCLOCK_19 = 0, /* 19.2 MHz */
-        WL12XX_REFCLOCK_26 = 1, /* 26 MHz */
-        WL12XX_REFCLOCK_38 = 2, /* 38.4 MHz */
-        WL12XX_REFCLOCK_54 = 3, /* 54 MHz */
+        WL12XX_REFCLOCK_19      = 0, /* 19.2 MHz */
+        WL12XX_REFCLOCK_26      = 1, /* 26 MHz */
+        WL12XX_REFCLOCK_38      = 2, /* 38.4 MHz */
+        WL12XX_REFCLOCK_52      = 3, /* 52 MHz */
+        WL12XX_REFCLOCK_38_XTAL = 4, /* 38.4 MHz, XTAL */
+        WL12XX_REFCLOCK_26_XTAL = 5, /* 26 MHz, XTAL */
+};
+
+/* TCXO clock values */
+enum {
+        WL12XX_TCXOCLOCK_19_2   = 0, /* 19.2MHz */
+        WL12XX_TCXOCLOCK_26     = 1, /* 26 MHz */
+        WL12XX_TCXOCLOCK_38_4   = 2, /* 38.4MHz */
+        WL12XX_TCXOCLOCK_52     = 3, /* 52 MHz */
+        WL12XX_TCXOCLOCK_16_368 = 4, /* 16.368 MHz */
+        WL12XX_TCXOCLOCK_32_736 = 5, /* 32.736 MHz */
+        WL12XX_TCXOCLOCK_16_8   = 6, /* 16.8 MHz */
+        WL12XX_TCXOCLOCK_33_6   = 7, /* 33.6 MHz */
 };
 
 struct wl12xx_platform_data {
@@ -38,8 +52,13 @@ struct wl12xx_platform_data {
         int irq;
         bool use_eeprom;
         int board_ref_clock;
+        int board_tcxo_clock;
+        unsigned long platform_quirks;
 };
 
+/* Platform does not support level trigger interrupts */
+#define WL12XX_PLATFORM_QUIRK_EDGE_IRQ  BIT(0)
+
 #ifdef CONFIG_WL12XX_PLATFORM_DATA
 
 int wl12xx_set_platform_data(const struct wl12xx_platform_data *data);
diff --git a/include/linux/xattr.h b/include/linux/xattr.h
index 6050783005bd..aed54c50aa66 100644
--- a/include/linux/xattr.h
+++ b/include/linux/xattr.h
@@ -13,10 +13,6 @@
 #define XATTR_CREATE    0x1     /* set value, fail if attr already exists */
 #define XATTR_REPLACE   0x2     /* set value, fail if attr does not exist */
 
-#ifdef  __KERNEL__
-
-#include <linux/types.h>
-
 /* Namespaces */
 #define XATTR_OS2_PREFIX "os2."
 #define XATTR_OS2_PREFIX_LEN (sizeof (XATTR_OS2_PREFIX) - 1)
@@ -53,6 +49,10 @@
 #define XATTR_CAPS_SUFFIX "capability"
 #define XATTR_NAME_CAPS XATTR_SECURITY_PREFIX XATTR_CAPS_SUFFIX
 
+#ifdef  __KERNEL__
+
+#include <linux/types.h>
+
 struct inode;
 struct dentry;