363 files changed, 8650 insertions, 5424 deletions

diff --git a/include/linux/Kbuild b/include/linux/Kbuild
index c94e71781b79..a25555381097 100644
--- a/include/linux/Kbuild
+++ b/include/linux/Kbuild
@@ -238,6 +238,7 @@ header-y += magic.h
 header-y += major.h
 header-y += map_to_7segment.h
 header-y += matroxfb.h
+header-y += mdio.h
 header-y += media.h
 header-y += mempolicy.h
 header-y += meye.h
@@ -304,6 +305,7 @@ header-y += poll.h
 header-y += posix_types.h
 header-y += ppdev.h
 header-y += ppp-comp.h
+header-y += ppp-ioctl.h
 header-y += ppp_defs.h
 header-y += pps.h
 header-y += prctl.h
diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index 3f968665899b..f53fea61f40a 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -151,6 +151,7 @@ extern int ec_write(u8 addr, u8 val);
 extern int ec_transaction(u8 command,
                           const u8 *wdata, unsigned wdata_len,
                           u8 *rdata, unsigned rdata_len);
+extern acpi_handle ec_get_handle(void);
 
 #if defined(CONFIG_ACPI_WMI) || defined(CONFIG_ACPI_WMI_MODULE)
 
diff --git a/include/linux/altera_uart.h b/include/linux/altera_uart.h
index a10a90791976..c022c82db7ca 100644
--- a/include/linux/altera_uart.h
+++ b/include/linux/altera_uart.h
@@ -5,8 +5,6 @@
 #ifndef __ALTUART_H
 #define __ALTUART_H
 
-#include <linux/init.h>
-
 struct altera_uart_platform_uart {
         unsigned long mapbase;  /* Physical address base */
         unsigned int irq;       /* Interrupt vector */
@@ -14,6 +12,4 @@ struct altera_uart_platform_uart {
         unsigned int bus_shift; /* Bus shift (address stride) */
 };
 
-int __init early_altera_uart_setup(struct altera_uart_platform_uart *platp);
-
 #endif /* __ALTUART_H */
diff --git a/include/linux/amba/bus.h b/include/linux/amba/bus.h
index 724c69c40bb8..7847e197730a 100644
--- a/include/linux/amba/bus.h
+++ b/include/linux/amba/bus.h
@@ -60,6 +60,9 @@ extern struct bus_type amba_bustype;
 
 int amba_driver_register(struct amba_driver *);
 void amba_driver_unregister(struct amba_driver *);
+struct amba_device *amba_device_alloc(const char *, resource_size_t, size_t);
+void amba_device_put(struct amba_device *);
+int amba_device_add(struct amba_device *, struct resource *);
 int amba_device_register(struct amba_device *, struct resource *);
 void amba_device_unregister(struct amba_device *);
 struct amba_device *amba_find_device(const char *, struct device *, unsigned int, unsigned int);
@@ -89,4 +92,46 @@ void amba_release_regions(struct amba_device *);
 #define amba_manf(d)    AMBA_MANF_BITS((d)->periphid)
 #define amba_part(d)    AMBA_PART_BITS((d)->periphid)
 
+#define __AMBA_DEV(busid, data, mask)                           \
+        {                                                       \
+                .coherent_dma_mask = mask,                      \
+                .init_name = busid,                             \
+                .platform_data = data,                          \
+        }
+
+/*
+ * APB devices do not themselves have the ability to address memory,
+ * so DMA masks should be zero (much like USB peripheral devices.)
+ * The DMA controller DMA masks should be used instead (much like
+ * USB host controllers in conventional PCs.)
+ */
+#define AMBA_APB_DEVICE(name, busid, id, base, irqs, data)      \
+struct amba_device name##_device = {                            \
+        .dev = __AMBA_DEV(busid, data, 0),                      \
+        .res = DEFINE_RES_MEM(base, SZ_4K),                     \
+        .irq = irqs,                                            \
+        .periphid = id,                                         \
+}
+
+/*
+ * AHB devices are DMA capable, so set their DMA masks
+ */
+#define AMBA_AHB_DEVICE(name, busid, id, base, irqs, data)      \
+struct amba_device name##_device = {                            \
+        .dev = __AMBA_DEV(busid, data, ~0ULL),                  \
+        .res = DEFINE_RES_MEM(base, SZ_4K),                     \
+        .dma_mask = ~0ULL,                                      \
+        .irq = irqs,                                            \
+        .periphid = id,                                         \
+}
+
+/*
+ * module_amba_driver() - Helper macro for drivers that don't do anything
+ * special in module init/exit.  This eliminates a lot of boilerplate.  Each
+ * module may only use this macro once, and calling it replaces module_init()
+ * and module_exit()
+ */
+#define module_amba_driver(__amba_drv) \
+        module_driver(__amba_drv, amba_driver_register, amba_driver_unregister)
+
 #endif
diff --git a/include/linux/amba/mmci.h b/include/linux/amba/mmci.h
index 0101e9c17fa1..32a89cf5ec45 100644
--- a/include/linux/amba/mmci.h
+++ b/include/linux/amba/mmci.h
@@ -6,6 +6,19 @@
 
 #include <linux/mmc/host.h>
 
+
+/*
+ * These defines is places here due to access is needed from machine
+ * configuration files. The ST Micro version does not have ROD and
+ * reuse the voltage registers for direction settings.
+ */
+#define MCI_ST_DATA2DIREN       (1 << 2)
+#define MCI_ST_CMDDIREN         (1 << 3)
+#define MCI_ST_DATA0DIREN       (1 << 4)
+#define MCI_ST_DATA31DIREN      (1 << 5)
+#define MCI_ST_FBCLKEN          (1 << 7)
+#define MCI_ST_DATA74DIREN      (1 << 8)
+
 /* Just some dummy forwarding */
 struct dma_chan;
 
@@ -18,7 +31,8 @@ struct dma_chan;
  * @ocr_mask: available voltages on the 4 pins from the block, this
  * is ignored if a regulator is used, see the MMC_VDD_* masks in
  * mmc/host.h
- * @vdd_handler: a callback function to translate a MMC_VDD_*
+ * @ios_handler: a callback function to act on specfic ios changes,
+ * used for example to control a levelshifter
  * mask into a value to be binary (or set some other custom bits
  * in MMCIPWR) or:ed and written into the MMCIPWR register of the
  * block.  May also control external power based on the power_mode.
@@ -31,6 +45,8 @@ struct dma_chan;
  * @capabilities: the capabilities of the block as implemented in
  * this platform, signify anything MMC_CAP_* from mmc/host.h
  * @capabilities2: more capabilities, MMC_CAP2_* from mmc/host.h
+ * @sigdir: a bit field indicating for what bits in the MMC bus the host
+ * should enable signal direction indication.
  * @dma_filter: function used to select an appropriate RX and TX
  * DMA channel to be used for DMA, if and only if you're deploying the
  * generic DMA engine
@@ -46,14 +62,14 @@ struct dma_chan;
 struct mmci_platform_data {
         unsigned int f_max;
         unsigned int ocr_mask;
-        u32 (*vdd_handler)(struct device *, unsigned int vdd,
-                           unsigned char power_mode);
+        int (*ios_handler)(struct device *, struct mmc_ios *);
         unsigned int (*status)(struct device *);
         int     gpio_wp;
         int     gpio_cd;
         bool    cd_invert;
         unsigned long capabilities;
         unsigned long capabilities2;
+        u32 sigdir;
         bool (*dma_filter)(struct dma_chan *chan, void *filter_param);
         void *dma_rx_param;
         void *dma_tx_param;
diff --git a/include/linux/amba/pl022.h b/include/linux/amba/pl022.h
index 572f637299c9..b8c51124ed19 100644
--- a/include/linux/amba/pl022.h
+++ b/include/linux/amba/pl022.h
@@ -25,8 +25,6 @@
 #ifndef _SSP_PL022_H
 #define _SSP_PL022_H
 
-#include <linux/device.h>
-
 /**
  * whether SSP is in loopback mode or not
  */
@@ -241,6 +239,8 @@ struct dma_chan;
  * @autosuspend_delay: delay in ms following transfer completion before the
  *     runtime power management system suspends the device. A setting of 0
  *     indicates no delay and the device will be suspended immediately.
+ * @rt: indicates the controller should run the message pump with realtime
+ *     priority to minimise the transfer latency on the bus.
  */
 struct pl022_ssp_controller {
         u16 bus_id;
@@ -250,6 +250,7 @@ struct pl022_ssp_controller {
         void *dma_rx_param;
         void *dma_tx_param;
         int autosuspend_delay;
+        bool rt;
 };
 
 /**
diff --git a/include/linux/amd-iommu.h b/include/linux/amd-iommu.h
index ef00610837d4..15f6b9edd0b1 100644
--- a/include/linux/amd-iommu.h
+++ b/include/linux/amd-iommu.h
@@ -28,7 +28,7 @@ struct task_struct;
 struct pci_dev;
 
 extern int amd_iommu_detect(void);
-
+extern int amd_iommu_init_hardware(void);
 
 /**
  * amd_iommu_enable_device_erratum() - Enable erratum workaround for device
diff --git a/include/linux/apple_bl.h b/include/linux/apple_bl.h
new file mode 100644
index 000000000000..47bedc0eee69
--- /dev/null
+++ b/include/linux/apple_bl.h
@@ -0,0 +1,26 @@
+/*
+ * apple_bl exported symbols
+ */
+
+#ifndef _LINUX_APPLE_BL_H
+#define _LINUX_APPLE_BL_H
+
+#ifdef CONFIG_BACKLIGHT_APPLE
+
+extern int apple_bl_register(void);
+extern void apple_bl_unregister(void);
+
+#else /* !CONFIG_BACKLIGHT_APPLE */
+
+static inline int apple_bl_register(void)
+{
+        return 0;
+}
+
+static inline void apple_bl_unregister(void)
+{
+}
+
+#endif /* !CONFIG_BACKLIGHT_APPLE */
+
+#endif /* _LINUX_APPLE_BL_H */
diff --git a/include/linux/atmdev.h b/include/linux/atmdev.h
index f4ff882cb2da..06fd4bbc58f6 100644
--- a/include/linux/atmdev.h
+++ b/include/linux/atmdev.h
@@ -213,10 +213,10 @@ struct atm_cirange {
 
 #ifdef __KERNEL__
 
-#include <linux/device.h>
 #include <linux/wait.h> /* wait_queue_head_t */
 #include <linux/time.h> /* struct timeval */
 #include <linux/net.h>
+#include <linux/bug.h>
 #include <linux/skbuff.h> /* struct sk_buff */
 #include <linux/uio.h>
 #include <net/sock.h>
@@ -249,6 +249,7 @@ struct k_atm_dev_stats {
         struct k_atm_aal_stats aal5;
 };
 
+struct device;
 
 enum {
         ATM_VF_ADDR,            /* Address is in use. Set by anybody, cleared
diff --git a/include/linux/atmel_tc.h b/include/linux/atmel_tc.h
index 53ba65e30caa..1d14b1dc1aee 100644
--- a/include/linux/atmel_tc.h
+++ b/include/linux/atmel_tc.h
@@ -34,10 +34,19 @@
 struct clk;
 
 /**
+ * struct atmel_tcb_config - SoC data for a Timer/Counter Block
+ * @counter_width: size in bits of a timer counter register
+ */
+struct atmel_tcb_config {
+        size_t  counter_width;
+};
+
+/**
  * struct atmel_tc - information about a Timer/Counter Block
  * @pdev: physical device
  * @iomem: resource associated with the I/O register
  * @regs: mapping through which the I/O registers can be accessed
+ * @tcb_config: configuration data from SoC
  * @irq: irq for each of the three channels
  * @clk: internal clock source for each of the three channels
  * @node: list node, for tclib internal use
@@ -54,6 +63,7 @@ struct atmel_tc {
         struct platform_device  *pdev;
         struct resource         *iomem;
         void __iomem            *regs;
+        struct atmel_tcb_config *tcb_config;
         int                     irq[3];
         struct clk              *clk[3];
         struct list_head        node;
diff --git a/include/linux/atomic.h b/include/linux/atomic.h
index 42b77b5446d2..70cfcb2d63c4 100644
--- a/include/linux/atomic.h
+++ b/include/linux/atomic.h
@@ -24,7 +24,9 @@ static inline int atomic_add_unless(atomic_t *v, int a, int u)
  * Atomically increments @v by 1, so long as @v is non-zero.
  * Returns non-zero if @v was non-zero, and zero otherwise.
  */
+#ifndef atomic_inc_not_zero
 #define atomic_inc_not_zero(v)          atomic_add_unless((v), 1, 0)
+#endif
 
 /**
  * atomic_inc_not_zero_hint - increment if not null
diff --git a/include/linux/attribute_container.h b/include/linux/attribute_container.h
index c3ab81428c66..896c6892f327 100644
--- a/include/linux/attribute_container.h
+++ b/include/linux/attribute_container.h
@@ -9,10 +9,11 @@
 #ifndef _ATTRIBUTE_CONTAINER_H_
 #define _ATTRIBUTE_CONTAINER_H_
 
-#include <linux/device.h>
 #include <linux/list.h>
 #include <linux/klist.h>
 
+struct device;
+
 struct attribute_container {
         struct list_head        node;
         struct klist            containers;
diff --git a/include/linux/audit.h b/include/linux/audit.h
index 9ff7a2c48b50..ed3ef1972496 100644
--- a/include/linux/audit.h
+++ b/include/linux/audit.h
@@ -684,7 +684,7 @@ extern void		    audit_log_untrustedstring(struct audit_buffer *ab,
                                                       const char *string);
 extern void                 audit_log_d_path(struct audit_buffer *ab,
                                              const char *prefix,
-                                             struct path *path);
+                                             const struct path *path);
 extern void                 audit_log_key(struct audit_buffer *ab,
                                           char *key);
 extern void                 audit_log_lost(const char *message);
diff --git a/include/linux/bcma/bcma.h b/include/linux/bcma/bcma.h
index 83c209f39493..5af9a075498f 100644
--- a/include/linux/bcma/bcma.h
+++ b/include/linux/bcma/bcma.h
@@ -136,6 +136,7 @@ struct bcma_device {
         bool dev_registered;
 
         u8 core_index;
+        u8 core_unit;
 
         u32 addr;
         u32 wrap;
@@ -175,6 +176,12 @@ int __bcma_driver_register(struct bcma_driver *drv, struct module *owner);
 
 extern void bcma_driver_unregister(struct bcma_driver *drv);
 
+/* Set a fallback SPROM.
+ * See kdoc at the function definition for complete documentation. */
+extern int bcma_arch_register_fallback_sprom(
+                int (*sprom_callback)(struct bcma_bus *bus,
+                struct ssb_sprom *out));
+
 struct bcma_bus {
         /* The MMIO area. */
         void __iomem *mmio;
@@ -195,6 +202,7 @@ struct bcma_bus {
         struct list_head cores;
         u8 nr_cores;
         u8 init_done:1;
+        u8 num;
 
         struct bcma_drv_cc drv_cc;
         struct bcma_drv_pci drv_pci;
@@ -282,6 +290,7 @@ static inline void bcma_maskset16(struct bcma_device *cc,
         bcma_write16(cc, offset, (bcma_read16(cc, offset) & mask) | set);
 }
 
+extern struct bcma_device *bcma_find_core(struct bcma_bus *bus, u16 coreid);
 extern bool bcma_core_is_enabled(struct bcma_device *core);
 extern void bcma_core_disable(struct bcma_device *core, u32 flags);
 extern int bcma_core_enable(struct bcma_device *core, u32 flags);
diff --git a/include/linux/bcma/bcma_driver_chipcommon.h b/include/linux/bcma/bcma_driver_chipcommon.h
index a33086a7530b..8bbfe31fbac8 100644
--- a/include/linux/bcma/bcma_driver_chipcommon.h
+++ b/include/linux/bcma/bcma_driver_chipcommon.h
@@ -56,6 +56,9 @@
 #define  BCMA_CC_OTPS_HW_PROTECT        0x00000001
 #define  BCMA_CC_OTPS_SW_PROTECT        0x00000002
 #define  BCMA_CC_OTPS_CID_PROTECT       0x00000004
+#define  BCMA_CC_OTPS_GU_PROG_IND       0x00000F00      /* General Use programmed indication */
+#define  BCMA_CC_OTPS_GU_PROG_IND_SHIFT 8
+#define  BCMA_CC_OTPS_GU_PROG_HW        0x00000100      /* HW region programmed */
 #define BCMA_CC_OTPC                    0x0014          /* OTP control */
 #define  BCMA_CC_OTPC_RECWAIT           0xFF000000
 #define  BCMA_CC_OTPC_PROGWAIT          0x00FFFF00
@@ -72,6 +75,8 @@
 #define  BCMA_CC_OTPP_READ              0x40000000
 #define  BCMA_CC_OTPP_START             0x80000000
 #define  BCMA_CC_OTPP_BUSY              0x80000000
+#define BCMA_CC_OTPL                    0x001C          /* OTP layout */
+#define  BCMA_CC_OTPL_GURGN_OFFSET      0x00000FFF      /* offset of general use region */
 #define BCMA_CC_IRQSTAT                 0x0020
 #define BCMA_CC_IRQMASK                 0x0024
 #define  BCMA_CC_IRQ_GPIO               0x00000001      /* gpio intr */
@@ -79,6 +84,10 @@
 #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_CHIPST_4313_SPROM_PRESENT      1
+#define  BCMA_CC_CHIPST_4313_OTP_PRESENT        2
+#define  BCMA_CC_CHIPST_4331_SPROM_PRESENT      2
+#define  BCMA_CC_CHIPST_4331_OTP_PRESENT        4
 #define BCMA_CC_JCMD                    0x0030          /* Rev >= 10 only */
 #define  BCMA_CC_JCMD_START             0x80000000
 #define  BCMA_CC_JCMD_BUSY              0x80000000
@@ -181,6 +190,22 @@
 #define BCMA_CC_FLASH_CFG               0x0128
 #define  BCMA_CC_FLASH_CFG_DS           0x0010  /* Data size, 0=8bit, 1=16bit */
 #define BCMA_CC_FLASH_WAITCNT           0x012C
+#define BCMA_CC_SROM_CONTROL            0x0190
+#define  BCMA_CC_SROM_CONTROL_START     0x80000000
+#define  BCMA_CC_SROM_CONTROL_BUSY      0x80000000
+#define  BCMA_CC_SROM_CONTROL_OPCODE    0x60000000
+#define  BCMA_CC_SROM_CONTROL_OP_READ   0x00000000
+#define  BCMA_CC_SROM_CONTROL_OP_WRITE  0x20000000
+#define  BCMA_CC_SROM_CONTROL_OP_WRDIS  0x40000000
+#define  BCMA_CC_SROM_CONTROL_OP_WREN   0x60000000
+#define  BCMA_CC_SROM_CONTROL_OTPSEL    0x00000010
+#define  BCMA_CC_SROM_CONTROL_LOCK      0x00000008
+#define  BCMA_CC_SROM_CONTROL_SIZE_MASK 0x00000006
+#define  BCMA_CC_SROM_CONTROL_SIZE_1K   0x00000000
+#define  BCMA_CC_SROM_CONTROL_SIZE_4K   0x00000002
+#define  BCMA_CC_SROM_CONTROL_SIZE_16K  0x00000004
+#define  BCMA_CC_SROM_CONTROL_SIZE_SHIFT        1
+#define  BCMA_CC_SROM_CONTROL_PRESENT   0x00000001
 /* 0x1E0 is defined as shared BCMA_CLKCTLST */
 #define BCMA_CC_HW_WORKAROUND           0x01E4 /* Hardware workaround (rev >= 20) */
 #define BCMA_CC_UART0_DATA              0x0300
@@ -240,7 +265,6 @@
 #define BCMA_CC_PLLCTL_ADDR             0x0660
 #define BCMA_CC_PLLCTL_DATA             0x0664
 #define BCMA_CC_SPROM                   0x0800 /* SPROM beginning */
-#define BCMA_CC_SPROM_PCIE6             0x0830 /* SPROM beginning on PCIe rev >= 6 */
 
 /* Divider allocation in 4716/47162/5356 */
 #define BCMA_CC_PMU5_MAINPLL_CPU        1
diff --git a/include/linux/bcma/bcma_driver_pci.h b/include/linux/bcma/bcma_driver_pci.h
index 3871b668caf9..46c71e27d31f 100644
--- a/include/linux/bcma/bcma_driver_pci.h
+++ b/include/linux/bcma/bcma_driver_pci.h
@@ -53,6 +53,35 @@ struct pci_dev;
 #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_CONFIG_ADDR               0x0120  /* pcie config space access */
+#define BCMA_CORE_PCI_CONFIG_DATA               0x0124  /* pcie config space access */
+#define BCMA_CORE_PCI_MDIO_CONTROL              0x0128  /* controls the mdio access */
+#define  BCMA_CORE_PCI_MDIOCTL_DIVISOR_MASK     0x7f    /* clock to be used on MDIO */
+#define  BCMA_CORE_PCI_MDIOCTL_DIVISOR_VAL      0x2
+#define  BCMA_CORE_PCI_MDIOCTL_PREAM_EN         0x80    /* Enable preamble sequnce */
+#define  BCMA_CORE_PCI_MDIOCTL_ACCESS_DONE      0x100   /* Tranaction complete */
+#define BCMA_CORE_PCI_MDIO_DATA                 0x012c  /* Data to the mdio access */
+#define  BCMA_CORE_PCI_MDIODATA_MASK            0x0000ffff /* data 2 bytes */
+#define  BCMA_CORE_PCI_MDIODATA_TA              0x00020000 /* Turnaround */
+#define  BCMA_CORE_PCI_MDIODATA_REGADDR_SHF_OLD 18      /* Regaddr shift (rev < 10) */
+#define  BCMA_CORE_PCI_MDIODATA_REGADDR_MASK_OLD        0x003c0000 /* Regaddr Mask (rev < 10) */
+#define  BCMA_CORE_PCI_MDIODATA_DEVADDR_SHF_OLD 22      /* Physmedia devaddr shift (rev < 10) */
+#define  BCMA_CORE_PCI_MDIODATA_DEVADDR_MASK_OLD        0x0fc00000 /* Physmedia devaddr Mask (rev < 10) */
+#define  BCMA_CORE_PCI_MDIODATA_REGADDR_SHF     18      /* Regaddr shift */
+#define  BCMA_CORE_PCI_MDIODATA_REGADDR_MASK    0x007c0000 /* Regaddr Mask */
+#define  BCMA_CORE_PCI_MDIODATA_DEVADDR_SHF     23      /* Physmedia devaddr shift */
+#define  BCMA_CORE_PCI_MDIODATA_DEVADDR_MASK    0x0f800000 /* Physmedia devaddr Mask */
+#define  BCMA_CORE_PCI_MDIODATA_WRITE           0x10000000 /* write Transaction */
+#define  BCMA_CORE_PCI_MDIODATA_READ            0x20000000 /* Read Transaction */
+#define  BCMA_CORE_PCI_MDIODATA_START           0x40000000 /* start of Transaction */
+#define  BCMA_CORE_PCI_MDIODATA_DEV_ADDR        0x0     /* dev address for serdes */
+#define  BCMA_CORE_PCI_MDIODATA_BLK_ADDR        0x1F    /* blk address for serdes */
+#define  BCMA_CORE_PCI_MDIODATA_DEV_PLL         0x1d    /* SERDES PLL Dev */
+#define  BCMA_CORE_PCI_MDIODATA_DEV_TX          0x1e    /* SERDES TX Dev */
+#define  BCMA_CORE_PCI_MDIODATA_DEV_RX          0x1f    /* SERDES RX Dev */
+#define BCMA_CORE_PCI_PCIEIND_ADDR              0x0130  /* indirect access to the internal register */
+#define BCMA_CORE_PCI_PCIEIND_DATA              0x0134  /* Data to/from the internal regsiter */
+#define BCMA_CORE_PCI_CLKREQENCTRL              0x0138  /*  >= rev 6, Clkreq rdma control */
 #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) */
@@ -72,20 +101,114 @@ struct pci_dev;
 #define  BCMA_CORE_PCI_SBTOPCI_RC_READL         0x00000010 /* Memory read line */
 #define  BCMA_CORE_PCI_SBTOPCI_RC_READM         0x00000020 /* Memory read multiple */
 
+/* PCIE protocol PHY diagnostic registers */
+#define BCMA_CORE_PCI_PLP_MODEREG               0x200   /* Mode */
+#define BCMA_CORE_PCI_PLP_STATUSREG             0x204   /* Status */
+#define  BCMA_CORE_PCI_PLP_POLARITYINV_STAT     0x10    /* Status reg PCIE_PLP_STATUSREG */
+#define BCMA_CORE_PCI_PLP_LTSSMCTRLREG          0x208   /* LTSSM control */
+#define BCMA_CORE_PCI_PLP_LTLINKNUMREG          0x20c   /* Link Training Link number */
+#define BCMA_CORE_PCI_PLP_LTLANENUMREG          0x210   /* Link Training Lane number */
+#define BCMA_CORE_PCI_PLP_LTNFTSREG             0x214   /* Link Training N_FTS */
+#define BCMA_CORE_PCI_PLP_ATTNREG               0x218   /* Attention */
+#define BCMA_CORE_PCI_PLP_ATTNMASKREG           0x21C   /* Attention Mask */
+#define BCMA_CORE_PCI_PLP_RXERRCTR              0x220   /* Rx Error */
+#define BCMA_CORE_PCI_PLP_RXFRMERRCTR           0x224   /* Rx Framing Error */
+#define BCMA_CORE_PCI_PLP_RXERRTHRESHREG        0x228   /* Rx Error threshold */
+#define BCMA_CORE_PCI_PLP_TESTCTRLREG           0x22C   /* Test Control reg */
+#define BCMA_CORE_PCI_PLP_SERDESCTRLOVRDREG     0x230   /* SERDES Control Override */
+#define BCMA_CORE_PCI_PLP_TIMINGOVRDREG         0x234   /* Timing param override */
+#define BCMA_CORE_PCI_PLP_RXTXSMDIAGREG         0x238   /* RXTX State Machine Diag */
+#define BCMA_CORE_PCI_PLP_LTSSMDIAGREG          0x23C   /* LTSSM State Machine Diag */
+
+/* PCIE protocol DLLP diagnostic registers */
+#define BCMA_CORE_PCI_DLLP_LCREG                0x100   /* Link Control */
+#define BCMA_CORE_PCI_DLLP_LSREG                0x104   /* Link Status */
+#define BCMA_CORE_PCI_DLLP_LAREG                0x108   /* Link Attention */
+#define  BCMA_CORE_PCI_DLLP_LSREG_LINKUP        (1 << 16)
+#define BCMA_CORE_PCI_DLLP_LAMASKREG            0x10C   /* Link Attention Mask */
+#define BCMA_CORE_PCI_DLLP_NEXTTXSEQNUMREG      0x110   /* Next Tx Seq Num */
+#define BCMA_CORE_PCI_DLLP_ACKEDTXSEQNUMREG     0x114   /* Acked Tx Seq Num */
+#define BCMA_CORE_PCI_DLLP_PURGEDTXSEQNUMREG    0x118   /* Purged Tx Seq Num */
+#define BCMA_CORE_PCI_DLLP_RXSEQNUMREG          0x11C   /* Rx Sequence Number */
+#define BCMA_CORE_PCI_DLLP_LRREG                0x120   /* Link Replay */
+#define BCMA_CORE_PCI_DLLP_LACKTOREG            0x124   /* Link Ack Timeout */
+#define BCMA_CORE_PCI_DLLP_PMTHRESHREG          0x128   /* Power Management Threshold */
+#define BCMA_CORE_PCI_DLLP_RTRYWPREG            0x12C   /* Retry buffer write ptr */
+#define BCMA_CORE_PCI_DLLP_RTRYRPREG            0x130   /* Retry buffer Read ptr */
+#define BCMA_CORE_PCI_DLLP_RTRYPPREG            0x134   /* Retry buffer Purged ptr */
+#define BCMA_CORE_PCI_DLLP_RTRRWREG             0x138   /* Retry buffer Read/Write */
+#define BCMA_CORE_PCI_DLLP_ECTHRESHREG          0x13C   /* Error Count Threshold */
+#define BCMA_CORE_PCI_DLLP_TLPERRCTRREG         0x140   /* TLP Error Counter */
+#define BCMA_CORE_PCI_DLLP_ERRCTRREG            0x144   /* Error Counter */
+#define BCMA_CORE_PCI_DLLP_NAKRXCTRREG          0x148   /* NAK Received Counter */
+#define BCMA_CORE_PCI_DLLP_TESTREG              0x14C   /* Test */
+#define BCMA_CORE_PCI_DLLP_PKTBIST              0x150   /* Packet BIST */
+#define BCMA_CORE_PCI_DLLP_PCIE11               0x154   /* DLLP PCIE 1.1 reg */
+
+/* SERDES RX registers */
+#define BCMA_CORE_PCI_SERDES_RX_CTRL            1       /* Rx cntrl */
+#define  BCMA_CORE_PCI_SERDES_RX_CTRL_FORCE     0x80    /* rxpolarity_force */
+#define  BCMA_CORE_PCI_SERDES_RX_CTRL_POLARITY  0x40    /* rxpolarity_value */
+#define BCMA_CORE_PCI_SERDES_RX_TIMER1          2       /* Rx Timer1 */
+#define BCMA_CORE_PCI_SERDES_RX_CDR             6       /* CDR */
+#define BCMA_CORE_PCI_SERDES_RX_CDRBW           7       /* CDR BW */
+
+/* SERDES PLL registers */
+#define BCMA_CORE_PCI_SERDES_PLL_CTRL           1       /* PLL control reg */
+#define BCMA_CORE_PCI_PLL_CTRL_FREQDET_EN       0x4000  /* bit 14 is FREQDET on */
+
 /* PCIcore specific boardflags */
 #define BCMA_CORE_PCI_BFL_NOPCI                 0x00000400 /* Board leaves PCI floating */
 
+/* PCIE Config space accessing MACROS */
+#define BCMA_CORE_PCI_CFG_BUS_SHIFT             24      /* Bus shift */
+#define BCMA_CORE_PCI_CFG_SLOT_SHIFT            19      /* Slot/Device shift */
+#define BCMA_CORE_PCI_CFG_FUN_SHIFT             16      /* Function shift */
+#define BCMA_CORE_PCI_CFG_OFF_SHIFT             0       /* Register shift */
+
+#define BCMA_CORE_PCI_CFG_BUS_MASK              0xff    /* Bus mask */
+#define BCMA_CORE_PCI_CFG_SLOT_MASK             0x1f    /* Slot/Device mask */
+#define BCMA_CORE_PCI_CFG_FUN_MASK              7       /* Function mask */
+#define BCMA_CORE_PCI_CFG_OFF_MASK              0xfff   /* Register mask */
+
+/* PCIE Root Capability Register bits (Host mode only) */
+#define BCMA_CORE_PCI_RC_CRS_VISIBILITY         0x0001
+
+struct bcma_drv_pci;
+
+#ifdef CONFIG_BCMA_DRIVER_PCI_HOSTMODE
+struct bcma_drv_pci_host {
+        struct bcma_drv_pci *pdev;
+
+        u32 host_cfg_addr;
+        spinlock_t cfgspace_lock;
+
+        struct pci_controller pci_controller;
+        struct pci_ops pci_ops;
+        struct resource mem_resource;
+        struct resource io_resource;
+};
+#endif
+
 struct bcma_drv_pci {
         struct bcma_device *core;
         u8 setup_done:1;
+        u8 hostmode:1;
+
+#ifdef CONFIG_BCMA_DRIVER_PCI_HOSTMODE
+        struct bcma_drv_pci_host *host_controller;
+#endif
 };
 
 /* 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);
+extern void __devinit bcma_core_pci_init(struct bcma_drv_pci *pc);
 extern int bcma_core_pci_irq_ctl(struct bcma_drv_pci *pc,
                                  struct bcma_device *core, bool enable);
 
+extern int bcma_core_pci_pcibios_map_irq(const struct pci_dev *dev);
+extern int bcma_core_pci_plat_dev_init(struct pci_dev *dev);
+
 #endif /* LINUX_BCMA_DRIVER_PCI_H_ */
diff --git a/include/linux/bcma/bcma_regs.h b/include/linux/bcma/bcma_regs.h
index 9faae2ae02e8..5a71d5719640 100644
--- a/include/linux/bcma/bcma_regs.h
+++ b/include/linux/bcma/bcma_regs.h
@@ -56,4 +56,31 @@
 #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 */
 
+/* SiliconBackplane Address Map.
+ * All regions may not exist on all chips.
+ */
+#define BCMA_SOC_SDRAM_BASE             0x00000000U     /* Physical SDRAM */
+#define BCMA_SOC_PCI_MEM                0x08000000U     /* Host Mode sb2pcitranslation0 (64 MB) */
+#define BCMA_SOC_PCI_MEM_SZ             (64 * 1024 * 1024)
+#define BCMA_SOC_PCI_CFG                0x0c000000U     /* Host Mode sb2pcitranslation1 (64 MB) */
+#define BCMA_SOC_SDRAM_SWAPPED          0x10000000U     /* Byteswapped Physical SDRAM */
+#define BCMA_SOC_SDRAM_R2               0x80000000U     /* Region 2 for sdram (512 MB) */
+
+
+#define BCMA_SOC_PCI_DMA                0x40000000U     /* Client Mode sb2pcitranslation2 (1 GB) */
+#define BCMA_SOC_PCI_DMA2               0x80000000U     /* Client Mode sb2pcitranslation2 (1 GB) */
+#define BCMA_SOC_PCI_DMA_SZ             0x40000000U     /* Client Mode sb2pcitranslation2 size in bytes */
+#define BCMA_SOC_PCIE_DMA_L32           0x00000000U     /* PCIE Client Mode sb2pcitranslation2
+                                                         * (2 ZettaBytes), low 32 bits
+                                                         */
+#define BCMA_SOC_PCIE_DMA_H32           0x80000000U     /* PCIE Client Mode sb2pcitranslation2
+                                                         * (2 ZettaBytes), high 32 bits
+                                                         */
+
+#define BCMA_SOC_PCI1_MEM               0x40000000U     /* Host Mode sb2pcitranslation0 (64 MB) */
+#define BCMA_SOC_PCI1_CFG               0x44000000U     /* Host Mode sb2pcitranslation1 (64 MB) */
+#define BCMA_SOC_PCIE1_DMA_H32          0xc0000000U     /* PCIE Client Mode sb2pcitranslation2
+                                                         * (2 ZettaBytes), high 32 bits
+                                                         */
+
 #endif /* LINUX_BCMA_REGS_H_ */
diff --git a/include/linux/binfmts.h b/include/linux/binfmts.h
index 0092102db2de..366422bc1633 100644
--- a/include/linux/binfmts.h
+++ b/include/linux/binfmts.h
@@ -92,17 +92,17 @@ struct linux_binfmt {
         unsigned long min_coredump;     /* minimal dump size */
 };
 
-extern int __register_binfmt(struct linux_binfmt *fmt, int insert);
+extern void __register_binfmt(struct linux_binfmt *fmt, int insert);
 
 /* Registration of default binfmt handlers */
-static inline int register_binfmt(struct linux_binfmt *fmt)
+static inline void register_binfmt(struct linux_binfmt *fmt)
 {
-        return __register_binfmt(fmt, 0);
+        __register_binfmt(fmt, 0);
 }
 /* Same as above, but adds a new binfmt at the top of the list */
-static inline int insert_binfmt(struct linux_binfmt *fmt)
+static inline void insert_binfmt(struct linux_binfmt *fmt)
 {
-        return __register_binfmt(fmt, 1);
+        __register_binfmt(fmt, 1);
 }
 
 extern void unregister_binfmt(struct linux_binfmt *);
diff --git a/include/linux/bio.h b/include/linux/bio.h
index 129a9c097958..4d94eb8bcbcc 100644
--- a/include/linux/bio.h
+++ b/include/linux/bio.h
@@ -23,6 +23,7 @@
 #include <linux/highmem.h>
 #include <linux/mempool.h>
 #include <linux/ioprio.h>
+#include <linux/bug.h>
 
 #ifdef CONFIG_BLOCK
 
@@ -101,10 +102,10 @@ static inline int bio_has_allocated_vec(struct bio *bio)
  * I/O completely on that queue (see ide-dma for example)
  */
 #define __bio_kmap_atomic(bio, idx, kmtype)                             \
-        (kmap_atomic(bio_iovec_idx((bio), (idx))->bv_page, kmtype) +    \
+        (kmap_atomic(bio_iovec_idx((bio), (idx))->bv_page) +    \
                 bio_iovec_idx((bio), (idx))->bv_offset)
 
-#define __bio_kunmap_atomic(addr, kmtype) kunmap_atomic(addr, kmtype)
+#define __bio_kunmap_atomic(addr, kmtype) kunmap_atomic(addr)
 
 /*
  * merge helpers etc
@@ -317,7 +318,7 @@ static inline char *bvec_kmap_irq(struct bio_vec *bvec, unsigned long *flags)
          * balancing is a lot nicer this way
          */
         local_irq_save(*flags);
-        addr = (unsigned long) kmap_atomic(bvec->bv_page, KM_BIO_SRC_IRQ);
+        addr = (unsigned long) kmap_atomic(bvec->bv_page);
 
         BUG_ON(addr & ~PAGE_MASK);
 
@@ -328,7 +329,7 @@ static inline void bvec_kunmap_irq(char *buffer, unsigned long *flags)
 {
         unsigned long ptr = (unsigned long) buffer & PAGE_MASK;
 
-        kunmap_atomic((void *) ptr, KM_BIO_SRC_IRQ);
+        kunmap_atomic((void *) ptr);
         local_irq_restore(*flags);
 }
 
diff --git a/include/linux/bit_spinlock.h b/include/linux/bit_spinlock.h
index ac4d9f8b52e9..3b5bafce4337 100644
--- a/include/linux/bit_spinlock.h
+++ b/include/linux/bit_spinlock.h
@@ -4,6 +4,7 @@
 #include <linux/kernel.h>
 #include <linux/preempt.h>
 #include <linux/atomic.h>
+#include <linux/bug.h>
 
 /*
  *  bit-based spin_lock()
diff --git a/include/linux/bitops.h b/include/linux/bitops.h
index 94300fe46cce..a3b6b82108b9 100644
--- a/include/linux/bitops.h
+++ b/include/linux/bitops.h
@@ -27,11 +27,22 @@ extern unsigned long __sw_hweight64(__u64 w);
              (bit) = find_next_bit((addr), (size), (bit) + 1))
 
 /* same as for_each_set_bit() but use bit as value to start with */
-#define for_each_set_bit_cont(bit, addr, size) \
+#define for_each_set_bit_from(bit, addr, size) \
         for ((bit) = find_next_bit((addr), (size), (bit));      \
              (bit) < (size);                                    \
              (bit) = find_next_bit((addr), (size), (bit) + 1))
 
+#define for_each_clear_bit(bit, addr, size) \
+        for ((bit) = find_first_zero_bit((addr), (size));       \
+             (bit) < (size);                                    \
+             (bit) = find_next_zero_bit((addr), (size), (bit) + 1))
+
+/* same as for_each_clear_bit() but use bit as value to start with */
+#define for_each_clear_bit_from(bit, addr, size) \
+        for ((bit) = find_next_zero_bit((addr), (size), (bit)); \
+             (bit) < (size);                                    \
+             (bit) = find_next_zero_bit((addr), (size), (bit) + 1))
+
 static __inline__ int get_bitmask_order(unsigned int count)
 {
         int order;
diff --git a/include/linux/bug.h b/include/linux/bug.h
index d276b5510c83..72961c39576a 100644
--- a/include/linux/bug.h
+++ b/include/linux/bug.h
@@ -11,6 +11,67 @@ enum bug_trap_type {
 
 struct pt_regs;
 
+#ifdef __CHECKER__
+#define BUILD_BUG_ON_NOT_POWER_OF_2(n)
+#define BUILD_BUG_ON_ZERO(e) (0)
+#define BUILD_BUG_ON_NULL(e) ((void*)0)
+#define BUILD_BUG_ON(condition)
+#define BUILD_BUG() (0)
+#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))
+
+/* Force a compilation error if condition is true, but also produce a
+   result (of value 0 and type size_t), so the expression can be used
+   e.g. in a structure initializer (or where-ever else comma expressions
+   aren't permitted). */
+#define BUILD_BUG_ON_ZERO(e) (sizeof(struct { int:-!!(e); }))
+#define BUILD_BUG_ON_NULL(e) ((void *)sizeof(struct { int:-!!(e); }))
+
+/**
+ * BUILD_BUG_ON - break compile if a condition is true.
+ * @condition: the condition which the compiler should know is false.
+ *
+ * If you have some code which relies on certain constants being equal, or
+ * other compile-time-evaluated condition, you should use BUILD_BUG_ON to
+ * detect if someone changes it.
+ *
+ * The implementation uses gcc's reluctance to create a negative array, but
+ * gcc (as of 4.4) only emits that error for obvious cases (eg. not arguments
+ * to inline functions).  So as a fallback we use the optimizer; if it can't
+ * prove the condition is false, it will cause a link error on the undefined
+ * "__build_bug_on_failed".  This error message can be harder to track down
+ * though, hence the two different methods.
+ */
+#ifndef __OPTIMIZE__
+#define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)]))
+#else
+extern int __build_bug_on_failed;
+#define BUILD_BUG_ON(condition)                                 \
+        do {                                                    \
+                ((void)sizeof(char[1 - 2*!!(condition)]));      \
+                if (condition) __build_bug_on_failed = 1;       \
+        } while(0)
+#endif
+
+/**
+ * BUILD_BUG - break compile if used.
+ *
+ * If you have some code that you expect the compiler to eliminate at
+ * build time, you should use BUILD_BUG to detect if it is
+ * unexpectedly used.
+ */
+#define BUILD_BUG()                                             \
+        do {                                                    \
+                extern void __build_bug_failed(void)            \
+                        __linktime_error("BUILD_BUG failed");   \
+                __build_bug_failed();                           \
+        } while (0)
+
+#endif  /* __CHECKER__ */
+
 #ifdef CONFIG_GENERIC_BUG
 #include <asm-generic/bug.h>
 
diff --git a/include/linux/c2port.h b/include/linux/c2port.h
index a2f7d7413f30..4efabcb51347 100644
--- a/include/linux/c2port.h
+++ b/include/linux/c2port.h
@@ -9,11 +9,12 @@
  * the Free Software Foundation
  */
 
-#include <linux/device.h>
 #include <linux/kmemcheck.h>
 
 #define C2PORT_NAME_LEN                 32
 
+struct device;
+
 /*
  * C2 port basic structs
  */
diff --git a/include/linux/can/dev.h b/include/linux/can/dev.h
index a0969fcb72b9..5d2efe7e3f1b 100644
--- a/include/linux/can/dev.h
+++ b/include/linux/can/dev.h
@@ -92,7 +92,7 @@ void can_bus_off(struct net_device *dev);
 
 void can_put_echo_skb(struct sk_buff *skb, struct net_device *dev,
                       unsigned int idx);
-void can_get_echo_skb(struct net_device *dev, unsigned int idx);
+unsigned int can_get_echo_skb(struct net_device *dev, unsigned int idx);
 void can_free_echo_skb(struct net_device *dev, unsigned int idx);
 
 struct sk_buff *alloc_can_skb(struct net_device *dev, struct can_frame **cf);
diff --git a/include/linux/cdrom.h b/include/linux/cdrom.h
index 7c48029dffe6..dfd7f187c351 100644
--- a/include/linux/cdrom.h
+++ b/include/linux/cdrom.h
@@ -910,7 +910,6 @@ struct mode_page_header {
 
 #ifdef __KERNEL__
 #include <linux/fs.h>           /* not really needed, later.. */
-#include <linux/device.h>
 #include <linux/list.h>
 
 struct packet_command
diff --git a/include/linux/ceph/decode.h b/include/linux/ceph/decode.h
index c5b6939fb32a..220ae21e819b 100644
--- a/include/linux/ceph/decode.h
+++ b/include/linux/ceph/decode.h
@@ -1,8 +1,9 @@
 #ifndef __CEPH_DECODE_H
 #define __CEPH_DECODE_H
 
-#include <asm/unaligned.h>
+#include <linux/bug.h>
 #include <linux/time.h>
+#include <asm/unaligned.h>
 
 #include "types.h"
 
diff --git a/include/linux/ceph/libceph.h b/include/linux/ceph/libceph.h
index 95bd8502e715..e71d683982a6 100644
--- a/include/linux/ceph/libceph.h
+++ b/include/linux/ceph/libceph.h
@@ -7,6 +7,7 @@
 #include <linux/backing-dev.h>
 #include <linux/completion.h>
 #include <linux/exportfs.h>
+#include <linux/bug.h>
 #include <linux/fs.h>
 #include <linux/mempool.h>
 #include <linux/pagemap.h>
@@ -207,7 +208,7 @@ extern struct kmem_cache *ceph_cap_cachep;
 extern struct kmem_cache *ceph_dentry_cachep;
 extern struct kmem_cache *ceph_file_cachep;
 
-extern int ceph_parse_options(struct ceph_options **popt, char *options,
+extern struct ceph_options *ceph_parse_options(char *options,
                               const char *dev_name, const char *dev_name_end,
                               int (*parse_extra_token)(char *c, void *private),
                               void *private);
diff --git a/include/linux/ceph/mdsmap.h b/include/linux/ceph/mdsmap.h
index 4c5cb0880bba..9935fac8c107 100644
--- a/include/linux/ceph/mdsmap.h
+++ b/include/linux/ceph/mdsmap.h
@@ -1,6 +1,7 @@
 #ifndef _FS_CEPH_MDSMAP_H
 #define _FS_CEPH_MDSMAP_H
 
+#include <linux/bug.h>
 #include "types.h"
 
 /*
diff --git a/include/linux/ceph/messenger.h b/include/linux/ceph/messenger.h
index ffbeb2c217b4..3bff047f6b0f 100644
--- a/include/linux/ceph/messenger.h
+++ b/include/linux/ceph/messenger.h
@@ -14,8 +14,6 @@
 struct ceph_msg;
 struct ceph_connection;
 
-extern struct workqueue_struct *ceph_msgr_wq;       /* receive work queue */
-
 /*
  * Ceph defines these callbacks for handling connection events.
  */
@@ -54,7 +52,6 @@ struct ceph_connection_operations {
 struct ceph_messenger {
         struct ceph_entity_inst inst;    /* my name+address */
         struct ceph_entity_addr my_enc_addr;
-        struct page *zero_page;          /* used in certain error cases */
 
         bool nocrc;
 
@@ -101,7 +98,7 @@ struct ceph_msg {
 struct ceph_msg_pos {
         int page, page_pos;  /* which page; offset in page */
         int data_pos;        /* offset in data payload */
-        int did_page_crc;    /* true if we've calculated crc for current page */
+        bool did_page_crc;   /* true if we've calculated crc for current page */
 };
 
 /* ceph connection fault delay defaults, for exponential backoff */
diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h
index e9b602151caf..5a85b3415c1b 100644
--- a/include/linux/cgroup.h
+++ b/include/linux/cgroup.h
@@ -160,38 +160,6 @@ enum {
         CGRP_CLONE_CHILDREN,
 };
 
-/* which pidlist file are we talking about? */
-enum cgroup_filetype {
-        CGROUP_FILE_PROCS,
-        CGROUP_FILE_TASKS,
-};
-
-/*
- * A pidlist is a list of pids that virtually represents the contents of one
- * of the cgroup files ("procs" or "tasks"). We keep a list of such pidlists,
- * a pair (one each for procs, tasks) for each pid namespace that's relevant
- * to the cgroup.
- */
-struct cgroup_pidlist {
-        /*
-         * used to find which pidlist is wanted. doesn't change as long as
-         * this particular list stays in the list.
-         */
-        struct { enum cgroup_filetype type; struct pid_namespace *ns; } key;
-        /* array of xids */
-        pid_t *list;
-        /* how many elements the above list has */
-        int length;
-        /* how many files are using the current array */
-        int use_count;
-        /* each of these stored in a list by its cgroup */
-        struct list_head links;
-        /* pointer to the cgroup we belong to, for list removal purposes */
-        struct cgroup *owner;
-        /* protects the other fields */
-        struct rw_semaphore mutex;
-};
-
 struct cgroup {
         unsigned long flags;            /* "unsigned long" so bitops work */
 
@@ -484,23 +452,18 @@ int cgroup_taskset_size(struct cgroup_taskset *tset);
  */
 
 struct cgroup_subsys {
-        struct cgroup_subsys_state *(*create)(struct cgroup_subsys *ss,
-                                                  struct cgroup *cgrp);
-        int (*pre_destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);
-        void (*destroy)(struct cgroup_subsys *ss, struct cgroup *cgrp);
-        int (*can_attach)(struct cgroup_subsys *ss, struct cgroup *cgrp,
-                          struct cgroup_taskset *tset);
-        void (*cancel_attach)(struct cgroup_subsys *ss, struct cgroup *cgrp,
-                              struct cgroup_taskset *tset);
-        void (*attach)(struct cgroup_subsys *ss, struct cgroup *cgrp,
-                       struct cgroup_taskset *tset);
-        void (*fork)(struct cgroup_subsys *ss, struct task_struct *task);
-        void (*exit)(struct cgroup_subsys *ss, struct cgroup *cgrp,
-                        struct cgroup *old_cgrp, struct task_struct *task);
-        int (*populate)(struct cgroup_subsys *ss,
-                        struct cgroup *cgrp);
-        void (*post_clone)(struct cgroup_subsys *ss, struct cgroup *cgrp);
-        void (*bind)(struct cgroup_subsys *ss, struct cgroup *root);
+        struct cgroup_subsys_state *(*create)(struct cgroup *cgrp);
+        int (*pre_destroy)(struct cgroup *cgrp);
+        void (*destroy)(struct cgroup *cgrp);
+        int (*can_attach)(struct cgroup *cgrp, struct cgroup_taskset *tset);
+        void (*cancel_attach)(struct cgroup *cgrp, struct cgroup_taskset *tset);
+        void (*attach)(struct cgroup *cgrp, struct cgroup_taskset *tset);
+        void (*fork)(struct task_struct *task);
+        void (*exit)(struct cgroup *cgrp, struct cgroup *old_cgrp,
+                     struct task_struct *task);
+        int (*populate)(struct cgroup_subsys *ss, struct cgroup *cgrp);
+        void (*post_clone)(struct cgroup *cgrp);
+        void (*bind)(struct cgroup *root);
 
         int subsys_id;
         int active;
@@ -535,7 +498,7 @@ struct cgroup_subsys {
         struct list_head sibling;
         /* used when use_id == true */
         struct idr idr;
-        rwlock_t id_lock;
+        spinlock_t id_lock;
 
         /* should be defined only by modular subsystems */
         struct module *module;
@@ -602,11 +565,6 @@ int cgroup_scan_tasks(struct cgroup_scanner *scan);
 int cgroup_attach_task(struct cgroup *, struct task_struct *);
 int cgroup_attach_task_all(struct task_struct *from, struct task_struct *);
 
-static inline int cgroup_attach_task_current_cg(struct task_struct *tsk)
-{
-        return cgroup_attach_task_all(current, tsk);
-}
-
 /*
  * CSS ID is ID for cgroup_subsys_state structs under subsys. This only works
  * if cgroup_subsys.use_id == true. It can be used for looking up and scanning.
@@ -669,10 +627,6 @@ static inline int cgroup_attach_task_all(struct task_struct *from,
 {
         return 0;
 }
-static inline int cgroup_attach_task_current_cg(struct task_struct *t)
-{
-        return 0;
-}
 
 #endif /* !CONFIG_CGROUPS */
 
diff --git a/include/linux/cleancache.h b/include/linux/cleancache.h
index 04ffb2e6c9d0..42e55deee757 100644
--- a/include/linux/cleancache.h
+++ b/include/linux/cleancache.h
@@ -28,9 +28,9 @@ struct cleancache_ops {
                         pgoff_t, struct page *);
         void (*put_page)(int, struct cleancache_filekey,
                         pgoff_t, struct page *);
-        void (*flush_page)(int, struct cleancache_filekey, pgoff_t);
-        void (*flush_inode)(int, struct cleancache_filekey);
-        void (*flush_fs)(int);
+        void (*invalidate_page)(int, struct cleancache_filekey, pgoff_t);
+        void (*invalidate_inode)(int, struct cleancache_filekey);
+        void (*invalidate_fs)(int);
 };
 
 extern struct cleancache_ops
@@ -39,9 +39,9 @@ extern void __cleancache_init_fs(struct super_block *);
 extern void __cleancache_init_shared_fs(char *, struct super_block *);
 extern int  __cleancache_get_page(struct page *);
 extern void __cleancache_put_page(struct page *);
-extern void __cleancache_flush_page(struct address_space *, struct page *);
-extern void __cleancache_flush_inode(struct address_space *);
-extern void __cleancache_flush_fs(struct super_block *);
+extern void __cleancache_invalidate_page(struct address_space *, struct page *);
+extern void __cleancache_invalidate_inode(struct address_space *);
+extern void __cleancache_invalidate_fs(struct super_block *);
 extern int cleancache_enabled;
 
 #ifdef CONFIG_CLEANCACHE
@@ -99,24 +99,24 @@ static inline void cleancache_put_page(struct page *page)
                 __cleancache_put_page(page);
 }
 
-static inline void cleancache_flush_page(struct address_space *mapping,
+static inline void cleancache_invalidate_page(struct address_space *mapping,
                                         struct page *page)
 {
         /* careful... page->mapping is NULL sometimes when this is called */
         if (cleancache_enabled && cleancache_fs_enabled_mapping(mapping))
-                __cleancache_flush_page(mapping, page);
+                __cleancache_invalidate_page(mapping, page);
 }
 
-static inline void cleancache_flush_inode(struct address_space *mapping)
+static inline void cleancache_invalidate_inode(struct address_space *mapping)
 {
         if (cleancache_enabled && cleancache_fs_enabled_mapping(mapping))
-                __cleancache_flush_inode(mapping);
+                __cleancache_invalidate_inode(mapping);
 }
 
-static inline void cleancache_flush_fs(struct super_block *sb)
+static inline void cleancache_invalidate_fs(struct super_block *sb)
 {
         if (cleancache_enabled)
-                __cleancache_flush_fs(sb);
+                __cleancache_invalidate_fs(sb);
 }
 
 #endif /* _LINUX_CLEANCACHE_H */
diff --git a/include/linux/clk-private.h b/include/linux/clk-private.h
new file mode 100644
index 000000000000..5e4312b6f5cc
--- /dev/null
+++ b/include/linux/clk-private.h
@@ -0,0 +1,196 @@
+/*
+ *  linux/include/linux/clk-private.h
+ *
+ *  Copyright (c) 2010-2011 Jeremy Kerr <jeremy.kerr@canonical.com>
+ *  Copyright (C) 2011-2012 Linaro Ltd <mturquette@linaro.org>
+ *
+ * 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_CLK_PRIVATE_H
+#define __LINUX_CLK_PRIVATE_H
+
+#include <linux/clk-provider.h>
+#include <linux/list.h>
+
+/*
+ * WARNING: Do not include clk-private.h from any file that implements struct
+ * clk_ops.  Doing so is a layering violation!
+ *
+ * This header exists only to allow for statically initialized clock data.  Any
+ * static clock data must be defined in a separate file from the logic that
+ * implements the clock operations for that same data.
+ */
+
+#ifdef CONFIG_COMMON_CLK
+
+struct clk {
+        const char              *name;
+        const struct clk_ops    *ops;
+        struct clk_hw           *hw;
+        struct clk              *parent;
+        char                    **parent_names;
+        struct clk              **parents;
+        u8                      num_parents;
+        unsigned long           rate;
+        unsigned long           new_rate;
+        unsigned long           flags;
+        unsigned int            enable_count;
+        unsigned int            prepare_count;
+        struct hlist_head       children;
+        struct hlist_node       child_node;
+        unsigned int            notifier_count;
+#ifdef CONFIG_COMMON_CLK_DEBUG
+        struct dentry           *dentry;
+#endif
+};
+
+/*
+ * DOC: Basic clock implementations common to many platforms
+ *
+ * Each basic clock hardware type is comprised of a structure describing the
+ * clock hardware, implementations of the relevant callbacks in struct clk_ops,
+ * unique flags for that hardware type, a registration function and an
+ * alternative macro for static initialization
+ */
+
+extern struct clk_ops clk_fixed_rate_ops;
+
+#define DEFINE_CLK_FIXED_RATE(_name, _flags, _rate,             \
+                                _fixed_rate_flags)              \
+        static struct clk _name;                                \
+        static char *_name##_parent_names[] = {};               \
+        static struct clk_fixed_rate _name##_hw = {             \
+                .hw = {                                         \
+                        .clk = &_name,                          \
+                },                                              \
+                .fixed_rate = _rate,                            \
+                .flags = _fixed_rate_flags,                     \
+        };                                                      \
+        static struct clk _name = {                             \
+                .name = #_name,                                 \
+                .ops = &clk_fixed_rate_ops,                     \
+                .hw = &_name##_hw.hw,                           \
+                .parent_names = _name##_parent_names,           \
+                .num_parents =                                  \
+                        ARRAY_SIZE(_name##_parent_names),       \
+                .flags = _flags,                                \
+        };
+
+extern struct clk_ops clk_gate_ops;
+
+#define DEFINE_CLK_GATE(_name, _parent_name, _parent_ptr,       \
+                                _flags, _reg, _bit_idx,         \
+                                _gate_flags, _lock)             \
+        static struct clk _name;                                \
+        static char *_name##_parent_names[] = {                 \
+                _parent_name,                                   \
+        };                                                      \
+        static struct clk *_name##_parents[] = {                \
+                _parent_ptr,                                    \
+        };                                                      \
+        static struct clk_gate _name##_hw = {                   \
+                .hw = {                                         \
+                        .clk = &_name,                          \
+                },                                              \
+                .reg = _reg,                                    \
+                .bit_idx = _bit_idx,                            \
+                .flags = _gate_flags,                           \
+                .lock = _lock,                                  \
+        };                                                      \
+        static struct clk _name = {                             \
+                .name = #_name,                                 \
+                .ops = &clk_gate_ops,                           \
+                .hw = &_name##_hw.hw,                           \
+                .parent_names = _name##_parent_names,           \
+                .num_parents =                                  \
+                        ARRAY_SIZE(_name##_parent_names),       \
+                .parents = _name##_parents,                     \
+                .flags = _flags,                                \
+        };
+
+extern struct clk_ops clk_divider_ops;
+
+#define DEFINE_CLK_DIVIDER(_name, _parent_name, _parent_ptr,    \
+                                _flags, _reg, _shift, _width,   \
+                                _divider_flags, _lock)          \
+        static struct clk _name;                                \
+        static char *_name##_parent_names[] = {                 \
+                _parent_name,                                   \
+        };                                                      \
+        static struct clk *_name##_parents[] = {                \
+                _parent_ptr,                                    \
+        };                                                      \
+        static struct clk_divider _name##_hw = {                \
+                .hw = {                                         \
+                        .clk = &_name,                          \
+                },                                              \
+                .reg = _reg,                                    \
+                .shift = _shift,                                \
+                .width = _width,                                \
+                .flags = _divider_flags,                        \
+                .lock = _lock,                                  \
+        };                                                      \
+        static struct clk _name = {                             \
+                .name = #_name,                                 \
+                .ops = &clk_divider_ops,                        \
+                .hw = &_name##_hw.hw,                           \
+                .parent_names = _name##_parent_names,           \
+                .num_parents =                                  \
+                        ARRAY_SIZE(_name##_parent_names),       \
+                .parents = _name##_parents,                     \
+                .flags = _flags,                                \
+        };
+
+extern struct clk_ops clk_mux_ops;
+
+#define DEFINE_CLK_MUX(_name, _parent_names, _parents, _flags,  \
+                                _reg, _shift, _width,           \
+                                _mux_flags, _lock)              \
+        static struct clk _name;                                \
+        static struct clk_mux _name##_hw = {                    \
+                .hw = {                                         \
+                        .clk = &_name,                          \
+                },                                              \
+                .reg = _reg,                                    \
+                .shift = _shift,                                \
+                .width = _width,                                \
+                .flags = _mux_flags,                            \
+                .lock = _lock,                                  \
+        };                                                      \
+        static struct clk _name = {                             \
+                .name = #_name,                                 \
+                .ops = &clk_mux_ops,                            \
+                .hw = &_name##_hw.hw,                           \
+                .parent_names = _parent_names,                  \
+                .num_parents =                                  \
+                        ARRAY_SIZE(_parent_names),              \
+                .parents = _parents,                            \
+                .flags = _flags,                                \
+        };
+
+/**
+ * __clk_init - initialize the data structures in a struct clk
+ * @dev:        device initializing this clk, placeholder for now
+ * @clk:        clk being initialized
+ *
+ * Initializes the lists in struct clk, queries the hardware for the
+ * parent and rate and sets them both.
+ *
+ * Any struct clk passed into __clk_init must have the following members
+ * populated:
+ *      .name
+ *      .ops
+ *      .hw
+ *      .parent_names
+ *      .num_parents
+ *      .flags
+ *
+ * It is not necessary to call clk_register if __clk_init is used directly with
+ * statically initialized clock data.
+ */
+void __clk_init(struct device *dev, struct clk *clk);
+
+#endif /* CONFIG_COMMON_CLK */
+#endif /* CLK_PRIVATE_H */
diff --git a/include/linux/clk-provider.h b/include/linux/clk-provider.h
new file mode 100644
index 000000000000..5508897ad376
--- /dev/null
+++ b/include/linux/clk-provider.h
@@ -0,0 +1,300 @@
+/*
+ *  linux/include/linux/clk-provider.h
+ *
+ *  Copyright (c) 2010-2011 Jeremy Kerr <jeremy.kerr@canonical.com>
+ *  Copyright (C) 2011-2012 Linaro Ltd <mturquette@linaro.org>
+ *
+ * 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_CLK_PROVIDER_H
+#define __LINUX_CLK_PROVIDER_H
+
+#include <linux/clk.h>
+
+#ifdef CONFIG_COMMON_CLK
+
+/**
+ * struct clk_hw - handle for traversing from a struct clk to its corresponding
+ * hardware-specific structure.  struct clk_hw should be declared within struct
+ * clk_foo and then referenced by the struct clk instance that uses struct
+ * clk_foo's clk_ops
+ *
+ * clk: pointer to the struct clk instance that points back to this struct
+ * clk_hw instance
+ */
+struct clk_hw {
+        struct clk *clk;
+};
+
+/*
+ * flags used across common struct clk.  these flags should only affect the
+ * top-level framework.  custom flags for dealing with hardware specifics
+ * belong in struct clk_foo
+ */
+#define CLK_SET_RATE_GATE       BIT(0) /* must be gated across rate change */
+#define CLK_SET_PARENT_GATE     BIT(1) /* must be gated across re-parent */
+#define CLK_SET_RATE_PARENT     BIT(2) /* propagate rate change up one level */
+#define CLK_IGNORE_UNUSED       BIT(3) /* do not gate even if unused */
+#define CLK_IS_ROOT             BIT(4) /* root clk, has no parent */
+
+/**
+ * struct clk_ops -  Callback operations for hardware clocks; these are to
+ * be provided by the clock implementation, and will be called by drivers
+ * through the clk_* api.
+ *
+ * @prepare:    Prepare the clock for enabling. This must not return until
+ *              the clock is fully prepared, and it's safe to call clk_enable.
+ *              This callback is intended to allow clock implementations to
+ *              do any initialisation that may sleep. Called with
+ *              prepare_lock held.
+ *
+ * @unprepare:  Release the clock from its prepared state. This will typically
+ *              undo any work done in the @prepare callback. Called with
+ *              prepare_lock held.
+ *
+ * @enable:     Enable the clock atomically. This must not return until the
+ *              clock is generating a valid clock signal, usable by consumer
+ *              devices. Called with enable_lock held. This function must not
+ *              sleep.
+ *
+ * @disable:    Disable the clock atomically. Called with enable_lock held.
+ *              This function must not sleep.
+ *
+ * @recalc_rate Recalculate the rate of this clock, by quering hardware.  The
+ *              parent rate is an input parameter.  It is up to the caller to
+ *              insure that the prepare_mutex is held across this call.
+ *              Returns the calculated rate.  Optional, but recommended - if
+ *              this op is not set then clock rate will be initialized to 0.
+ *
+ * @round_rate: Given a target rate as input, returns the closest rate actually
+ *              supported by the clock.
+ *
+ * @get_parent: Queries the hardware to determine the parent of a clock.  The
+ *              return value is a u8 which specifies the index corresponding to
+ *              the parent clock.  This index can be applied to either the
+ *              .parent_names or .parents arrays.  In short, this function
+ *              translates the parent value read from hardware into an array
+ *              index.  Currently only called when the clock is initialized by
+ *              __clk_init.  This callback is mandatory for clocks with
+ *              multiple parents.  It is optional (and unnecessary) for clocks
+ *              with 0 or 1 parents.
+ *
+ * @set_parent: Change the input source of this clock; for clocks with multiple
+ *              possible parents specify a new parent by passing in the index
+ *              as a u8 corresponding to the parent in either the .parent_names
+ *              or .parents arrays.  This function in affect translates an
+ *              array index into the value programmed into the hardware.
+ *              Returns 0 on success, -EERROR otherwise.
+ *
+ * @set_rate:   Change the rate of this clock. If this callback returns
+ *              CLK_SET_RATE_PARENT, the rate change will be propagated to the
+ *              parent clock (which may propagate again if the parent clock
+ *              also sets this flag). The requested rate of the parent is
+ *              passed back from the callback in the second 'unsigned long *'
+ *              argument.  Note that it is up to the hardware clock's set_rate
+ *              implementation to insure that clocks do not run out of spec
+ *              when propgating the call to set_rate up to the parent.  One way
+ *              to do this is to gate the clock (via clk_disable and/or
+ *              clk_unprepare) before calling clk_set_rate, then ungating it
+ *              afterward.  If your clock also has the CLK_GATE_SET_RATE flag
+ *              set then this will insure safety.  Returns 0 on success,
+ *              -EERROR otherwise.
+ *
+ * The clk_enable/clk_disable and clk_prepare/clk_unprepare pairs allow
+ * implementations to split any work between atomic (enable) and sleepable
+ * (prepare) contexts.  If enabling a clock requires code that might sleep,
+ * this must be done in clk_prepare.  Clock enable code that will never be
+ * called in a sleepable context may be implement in clk_enable.
+ *
+ * Typically, drivers will call clk_prepare when a clock may be needed later
+ * (eg. when a device is opened), and clk_enable when the clock is actually
+ * required (eg. from an interrupt). Note that clk_prepare MUST have been
+ * called before clk_enable.
+ */
+struct clk_ops {
+        int             (*prepare)(struct clk_hw *hw);
+        void            (*unprepare)(struct clk_hw *hw);
+        int             (*enable)(struct clk_hw *hw);
+        void            (*disable)(struct clk_hw *hw);
+        int             (*is_enabled)(struct clk_hw *hw);
+        unsigned long   (*recalc_rate)(struct clk_hw *hw,
+                                        unsigned long parent_rate);
+        long            (*round_rate)(struct clk_hw *hw, unsigned long,
+                                        unsigned long *);
+        int             (*set_parent)(struct clk_hw *hw, u8 index);
+        u8              (*get_parent)(struct clk_hw *hw);
+        int             (*set_rate)(struct clk_hw *hw, unsigned long);
+        void            (*init)(struct clk_hw *hw);
+};
+
+/*
+ * DOC: Basic clock implementations common to many platforms
+ *
+ * Each basic clock hardware type is comprised of a structure describing the
+ * clock hardware, implementations of the relevant callbacks in struct clk_ops,
+ * unique flags for that hardware type, a registration function and an
+ * alternative macro for static initialization
+ */
+
+/**
+ * struct clk_fixed_rate - fixed-rate clock
+ * @hw:         handle between common and hardware-specific interfaces
+ * @fixed_rate: constant frequency of clock
+ */
+struct clk_fixed_rate {
+        struct          clk_hw hw;
+        unsigned long   fixed_rate;
+        u8              flags;
+};
+
+struct clk *clk_register_fixed_rate(struct device *dev, const char *name,
+                const char *parent_name, unsigned long flags,
+                unsigned long fixed_rate);
+
+/**
+ * struct clk_gate - gating clock
+ *
+ * @hw:         handle between common and hardware-specific interfaces
+ * @reg:        register controlling gate
+ * @bit_idx:    single bit controlling gate
+ * @flags:      hardware-specific flags
+ * @lock:       register lock
+ *
+ * Clock which can gate its output.  Implements .enable & .disable
+ *
+ * Flags:
+ * CLK_GATE_SET_DISABLE - by default this clock sets the bit at bit_idx to
+ *      enable the clock.  Setting this flag does the opposite: setting the bit
+ *      disable the clock and clearing it enables the clock
+ */
+struct clk_gate {
+        struct clk_hw hw;
+        void __iomem    *reg;
+        u8              bit_idx;
+        u8              flags;
+        spinlock_t      *lock;
+        char            *parent[1];
+};
+
+#define CLK_GATE_SET_TO_DISABLE         BIT(0)
+
+struct clk *clk_register_gate(struct device *dev, const char *name,
+                const char *parent_name, unsigned long flags,
+                void __iomem *reg, u8 bit_idx,
+                u8 clk_gate_flags, spinlock_t *lock);
+
+/**
+ * struct clk_divider - adjustable divider clock
+ *
+ * @hw:         handle between common and hardware-specific interfaces
+ * @reg:        register containing the divider
+ * @shift:      shift to the divider bit field
+ * @width:      width of the divider bit field
+ * @lock:       register lock
+ *
+ * Clock with an adjustable divider affecting its output frequency.  Implements
+ * .recalc_rate, .set_rate and .round_rate
+ *
+ * Flags:
+ * CLK_DIVIDER_ONE_BASED - by default the divisor is the value read from the
+ *      register plus one.  If CLK_DIVIDER_ONE_BASED is set then the divider is
+ *      the raw value read from the register, with the value of zero considered
+ *      invalid
+ * CLK_DIVIDER_POWER_OF_TWO - clock divisor is 2 raised to the value read from
+ *      the hardware register
+ */
+struct clk_divider {
+        struct clk_hw   hw;
+        void __iomem    *reg;
+        u8              shift;
+        u8              width;
+        u8              flags;
+        spinlock_t      *lock;
+        char            *parent[1];
+};
+
+#define CLK_DIVIDER_ONE_BASED           BIT(0)
+#define CLK_DIVIDER_POWER_OF_TWO        BIT(1)
+
+struct clk *clk_register_divider(struct device *dev, const char *name,
+                const char *parent_name, unsigned long flags,
+                void __iomem *reg, u8 shift, u8 width,
+                u8 clk_divider_flags, spinlock_t *lock);
+
+/**
+ * struct clk_mux - multiplexer clock
+ *
+ * @hw:         handle between common and hardware-specific interfaces
+ * @reg:        register controlling multiplexer
+ * @shift:      shift to multiplexer bit field
+ * @width:      width of mutliplexer bit field
+ * @num_clks:   number of parent clocks
+ * @lock:       register lock
+ *
+ * Clock with multiple selectable parents.  Implements .get_parent, .set_parent
+ * and .recalc_rate
+ *
+ * Flags:
+ * CLK_MUX_INDEX_ONE - register index starts at 1, not 0
+ * CLK_MUX_INDEX_BITWISE - register index is a single bit (power of two)
+ */
+struct clk_mux {
+        struct clk_hw   hw;
+        void __iomem    *reg;
+        u8              shift;
+        u8              width;
+        u8              flags;
+        spinlock_t      *lock;
+};
+
+#define CLK_MUX_INDEX_ONE               BIT(0)
+#define CLK_MUX_INDEX_BIT               BIT(1)
+
+struct clk *clk_register_mux(struct device *dev, const char *name,
+                char **parent_names, u8 num_parents, unsigned long flags,
+                void __iomem *reg, u8 shift, u8 width,
+                u8 clk_mux_flags, spinlock_t *lock);
+
+/**
+ * clk_register - allocate a new clock, register it and return an opaque cookie
+ * @dev: device that is registering this clock
+ * @name: clock name
+ * @ops: operations this clock supports
+ * @hw: link to hardware-specific clock data
+ * @parent_names: array of string names for all possible parents
+ * @num_parents: number of possible parents
+ * @flags: framework-level hints and quirks
+ *
+ * clk_register is the primary interface for populating the clock tree with new
+ * clock nodes.  It returns a pointer to the newly allocated struct clk which
+ * cannot be dereferenced by driver code but may be used in conjuction with the
+ * rest of the clock API.
+ */
+struct clk *clk_register(struct device *dev, const char *name,
+                const struct clk_ops *ops, struct clk_hw *hw,
+                char **parent_names, u8 num_parents, unsigned long flags);
+
+/* helper functions */
+const char *__clk_get_name(struct clk *clk);
+struct clk_hw *__clk_get_hw(struct clk *clk);
+u8 __clk_get_num_parents(struct clk *clk);
+struct clk *__clk_get_parent(struct clk *clk);
+inline int __clk_get_enable_count(struct clk *clk);
+inline int __clk_get_prepare_count(struct clk *clk);
+unsigned long __clk_get_rate(struct clk *clk);
+unsigned long __clk_get_flags(struct clk *clk);
+int __clk_is_enabled(struct clk *clk);
+struct clk *__clk_lookup(const char *name);
+
+/*
+ * FIXME clock api without lock protection
+ */
+int __clk_prepare(struct clk *clk);
+void __clk_unprepare(struct clk *clk);
+void __clk_reparent(struct clk *clk, struct clk *new_parent);
+unsigned long __clk_round_rate(struct clk *clk, unsigned long rate);
+
+#endif /* CONFIG_COMMON_CLK */
+#endif /* CLK_PROVIDER_H */
diff --git a/include/linux/clk.h b/include/linux/clk.h
index b9d46fa154b4..b0252726df61 100644
--- a/include/linux/clk.h
+++ b/include/linux/clk.h
@@ -3,6 +3,7 @@
  *
  *  Copyright (C) 2004 ARM Limited.
  *  Written by Deep Blue Solutions Limited.
+ *  Copyright (C) 2011-2012 Linaro Ltd <mturquette@linaro.org>
  *
  * 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
@@ -12,18 +13,75 @@
 #define __LINUX_CLK_H
 
 #include <linux/kernel.h>
+#include <linux/notifier.h>
 
 struct device;
 
-/*
- * The base API.
+struct clk;
+
+#ifdef CONFIG_COMMON_CLK
+
+/**
+ * DOC: clk notifier callback types
+ *
+ * PRE_RATE_CHANGE - called immediately before the clk rate is changed,
+ *     to indicate that the rate change will proceed.  Drivers must
+ *     immediately terminate any operations that will be affected by the
+ *     rate change.  Callbacks may either return NOTIFY_DONE or
+ *     NOTIFY_STOP.
+ *
+ * ABORT_RATE_CHANGE: called if the rate change failed for some reason
+ *     after PRE_RATE_CHANGE.  In this case, all registered notifiers on
+ *     the clk will be called with ABORT_RATE_CHANGE. Callbacks must
+ *     always return NOTIFY_DONE.
+ *
+ * POST_RATE_CHANGE - called after the clk rate change has successfully
+ *     completed.  Callbacks must always return NOTIFY_DONE.
+ *
  */
+#define PRE_RATE_CHANGE                 BIT(0)
+#define POST_RATE_CHANGE                BIT(1)
+#define ABORT_RATE_CHANGE               BIT(2)
 
+/**
+ * struct clk_notifier - associate a clk with a notifier
+ * @clk: struct clk * to associate the notifier with
+ * @notifier_head: a blocking_notifier_head for this clk
+ * @node: linked list pointers
+ *
+ * A list of struct clk_notifier is maintained by the notifier code.
+ * An entry is created whenever code registers the first notifier on a
+ * particular @clk.  Future notifiers on that @clk are added to the
+ * @notifier_head.
+ */
+struct clk_notifier {
+        struct clk                      *clk;
+        struct srcu_notifier_head       notifier_head;
+        struct list_head                node;
+};
 
-/*
- * struct clk - an machine class defined object / cookie.
+/**
+ * struct clk_notifier_data - rate data to pass to the notifier callback
+ * @clk: struct clk * being changed
+ * @old_rate: previous rate of this clk
+ * @new_rate: new rate of this clk
+ *
+ * For a pre-notifier, old_rate is the clk's rate before this rate
+ * change, and new_rate is what the rate will be in the future.  For a
+ * post-notifier, old_rate and new_rate are both set to the clk's
+ * current rate (this was done to optimize the implementation).
  */
-struct clk;
+struct clk_notifier_data {
+        struct clk              *clk;
+        unsigned long           old_rate;
+        unsigned long           new_rate;
+};
+
+int clk_notifier_register(struct clk *clk, struct notifier_block *nb);
+
+int clk_notifier_unregister(struct clk *clk, struct notifier_block *nb);
+
+#endif /* !CONFIG_COMMON_CLK */
 
 /**
  * clk_get - lookup and obtain a reference to a clock producer.
diff --git a/include/linux/clocksource.h b/include/linux/clocksource.h
index 081147da0564..fbe89e17124e 100644
--- a/include/linux/clocksource.h
+++ b/include/linux/clocksource.h
@@ -319,13 +319,6 @@ static inline void __clocksource_updatefreq_khz(struct clocksource *cs, u32 khz)
         __clocksource_updatefreq_scale(cs, 1000, khz);
 }
 
-static inline void
-clocksource_calc_mult_shift(struct clocksource *cs, u32 freq, u32 minsec)
-{
-        return clocks_calc_mult_shift(&cs->mult, &cs->shift, freq,
-                                      NSEC_PER_SEC, minsec);
-}
-
 #ifdef CONFIG_GENERIC_TIME_VSYSCALL
 extern void
 update_vsyscall(struct timespec *ts, struct timespec *wtm,
diff --git a/include/linux/compaction.h b/include/linux/compaction.h
index bb2bbdbe5464..51a90b7f2d60 100644
--- a/include/linux/compaction.h
+++ b/include/linux/compaction.h
@@ -23,6 +23,7 @@ extern int fragmentation_index(struct zone *zone, unsigned int order);
 extern unsigned long try_to_compact_pages(struct zonelist *zonelist,
                         int order, gfp_t gfp_mask, nodemask_t *mask,
                         bool sync);
+extern int compact_pgdat(pg_data_t *pgdat, int order);
 extern unsigned long compaction_suitable(struct zone *zone, int order);
 
 /* Do not skip compaction more than 64 times */
@@ -33,20 +34,26 @@ extern unsigned long compaction_suitable(struct zone *zone, int order);
  * allocation success. 1 << compact_defer_limit compactions are skipped up
  * to a limit of 1 << COMPACT_MAX_DEFER_SHIFT
  */
-static inline void defer_compaction(struct zone *zone)
+static inline void defer_compaction(struct zone *zone, int order)
 {
         zone->compact_considered = 0;
         zone->compact_defer_shift++;
 
+        if (order < zone->compact_order_failed)
+                zone->compact_order_failed = order;
+
         if (zone->compact_defer_shift > COMPACT_MAX_DEFER_SHIFT)
                 zone->compact_defer_shift = COMPACT_MAX_DEFER_SHIFT;
 }
 
 /* Returns true if compaction should be skipped this time */
-static inline bool compaction_deferred(struct zone *zone)
+static inline bool compaction_deferred(struct zone *zone, int order)
 {
         unsigned long defer_limit = 1UL << zone->compact_defer_shift;
 
+        if (order < zone->compact_order_failed)
+                return false;
+
         /* Avoid possible overflow */
         if (++zone->compact_considered > defer_limit)
                 zone->compact_considered = defer_limit;
@@ -62,16 +69,21 @@ static inline unsigned long try_to_compact_pages(struct zonelist *zonelist,
         return COMPACT_CONTINUE;
 }
 
+static inline int compact_pgdat(pg_data_t *pgdat, int order)
+{
+        return COMPACT_CONTINUE;
+}
+
 static inline unsigned long compaction_suitable(struct zone *zone, int order)
 {
         return COMPACT_SKIPPED;
 }
 
-static inline void defer_compaction(struct zone *zone)
+static inline void defer_compaction(struct zone *zone, int order)
 {
 }
 
-static inline bool compaction_deferred(struct zone *zone)
+static inline bool compaction_deferred(struct zone *zone, int order)
 {
         return 1;
 }
diff --git a/include/linux/compiler-gcc.h b/include/linux/compiler-gcc.h
index 3fd17c249221..e5834aa24b9e 100644
--- a/include/linux/compiler-gcc.h
+++ b/include/linux/compiler-gcc.h
@@ -87,7 +87,8 @@
  */
 #define __pure                          __attribute__((pure))
 #define __aligned(x)                    __attribute__((aligned(x)))
-#define __printf(a,b)                   __attribute__((format(printf,a,b)))
+#define __printf(a, b)                  __attribute__((format(printf, a, b)))
+#define __scanf(a, b)                   __attribute__((format(scanf, a, b)))
 #define  noinline                       __attribute__((noinline))
 #define __attribute_const__             __attribute__((__const__))
 #define __maybe_unused                  __attribute__((unused))
diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index 4a243546d142..923d093c9cea 100644
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -236,7 +236,7 @@ void ftrace_likely_update(struct ftrace_branch_data *f, int val, int expect);
 
 /*
  * Rather then using noinline to prevent stack consumption, use
- * noinline_for_stack instead.  For documentaiton reasons.
+ * noinline_for_stack instead.  For documentation reasons.
  */
 #define noinline_for_stack noinline
 
diff --git a/include/linux/connector.h b/include/linux/connector.h
index 3c9c54fd5690..76384074262d 100644
--- a/include/linux/connector.h
+++ b/include/linux/connector.h
@@ -43,6 +43,7 @@
 #define CN_IDX_DRBD                     0x8
 #define CN_VAL_DRBD                     0x1
 #define CN_KVP_IDX                      0x9     /* HyperV KVP */
+#define CN_KVP_VAL                      0x1     /* queries from the kernel */
 
 #define CN_NETLINK_USERS                10      /* Highest index + 1 */
 
diff --git a/include/linux/cpu.h b/include/linux/cpu.h
index 1f6587590a1a..ee28844ae68e 100644
--- a/include/linux/cpu.h
+++ b/include/linux/cpu.h
@@ -14,11 +14,12 @@
 #ifndef _LINUX_CPU_H_
 #define _LINUX_CPU_H_
 
-#include <linux/device.h>
 #include <linux/node.h>
 #include <linux/compiler.h>
 #include <linux/cpumask.h>
 
+struct device;
+
 struct cpu {
         int node_id;            /* The node which contains the CPU */
         int hotpluggable;       /* creates sysfs control file if hotpluggable */
@@ -44,6 +45,13 @@ extern ssize_t arch_cpu_release(const char *, size_t);
 #endif
 struct notifier_block;
 
+#ifdef CONFIG_ARCH_HAS_CPU_AUTOPROBE
+extern int arch_cpu_uevent(struct device *dev, struct kobj_uevent_env *env);
+extern ssize_t arch_print_cpu_modalias(struct device *dev,
+                                       struct device_attribute *attr,
+                                       char *bufptr);
+#endif
+
 /*
  * CPU notifier priorities.
  */
diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h
index 6216115c7789..b60f6ba01d0c 100644
--- a/include/linux/cpufreq.h
+++ b/include/linux/cpufreq.h
@@ -14,7 +14,6 @@
 #include <linux/mutex.h>
 #include <linux/notifier.h>
 #include <linux/threads.h>
-#include <linux/device.h>
 #include <linux/kobject.h>
 #include <linux/sysfs.h>
 #include <linux/completion.h>
@@ -35,6 +34,7 @@
 #ifdef CONFIG_CPU_FREQ
 int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list);
 int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list);
+extern void disable_cpufreq(void);
 #else           /* CONFIG_CPU_FREQ */
 static inline int cpufreq_register_notifier(struct notifier_block *nb,
                                                 unsigned int list)
@@ -46,6 +46,7 @@ static inline int cpufreq_unregister_notifier(struct notifier_block *nb,
 {
         return 0;
 }
+static inline void disable_cpufreq(void) { }
 #endif          /* CONFIG_CPU_FREQ */
 
 /* if (cpufreq_driver->target) exists, the ->governor decides what frequency
diff --git a/include/linux/cpumask.h b/include/linux/cpumask.h
index 4f7a63237471..7b9b75a529be 100644
--- a/include/linux/cpumask.h
+++ b/include/linux/cpumask.h
@@ -9,6 +9,7 @@
 #include <linux/kernel.h>
 #include <linux/threads.h>
 #include <linux/bitmap.h>
+#include <linux/bug.h>
 
 typedef struct cpumask { DECLARE_BITMAP(bits, NR_CPUS); } cpumask_t;
 
diff --git a/include/linux/cpuset.h b/include/linux/cpuset.h
index e9eaec522655..7a7e5fd2a277 100644
--- a/include/linux/cpuset.h
+++ b/include/linux/cpuset.h
@@ -89,42 +89,33 @@ extern void rebuild_sched_domains(void);
 extern void cpuset_print_task_mems_allowed(struct task_struct *p);
 
 /*
- * reading current mems_allowed and mempolicy in the fastpath must protected
- * by get_mems_allowed()
+ * get_mems_allowed is required when making decisions involving mems_allowed
+ * such as during page allocation. mems_allowed can be updated in parallel
+ * and depending on the new value an operation can fail potentially causing
+ * process failure. A retry loop with get_mems_allowed and put_mems_allowed
+ * prevents these artificial failures.
  */
-static inline void get_mems_allowed(void)
+static inline unsigned int get_mems_allowed(void)
 {
-        current->mems_allowed_change_disable++;
-
-        /*
-         * ensure that reading mems_allowed and mempolicy happens after the
-         * update of ->mems_allowed_change_disable.
-         *
-         * the write-side task finds ->mems_allowed_change_disable is not 0,
-         * and knows the read-side task is reading mems_allowed or mempolicy,
-         * so it will clear old bits lazily.
-         */
-        smp_mb();
+        return read_seqcount_begin(&current->mems_allowed_seq);
 }
 
-static inline void put_mems_allowed(void)
+/*
+ * If this returns false, the operation that took place after get_mems_allowed
+ * may have failed. It is up to the caller to retry the operation if
+ * appropriate.
+ */
+static inline bool put_mems_allowed(unsigned int seq)
 {
-        /*
-         * ensure that reading mems_allowed and mempolicy before reducing
-         * mems_allowed_change_disable.
-         *
-         * the write-side task will know that the read-side task is still
-         * reading mems_allowed or mempolicy, don't clears old bits in the
-         * nodemask.
-         */
-        smp_mb();
-        --ACCESS_ONCE(current->mems_allowed_change_disable);
+        return !read_seqcount_retry(&current->mems_allowed_seq, seq);
 }
 
 static inline void set_mems_allowed(nodemask_t nodemask)
 {
         task_lock(current);
+        write_seqcount_begin(&current->mems_allowed_seq);
         current->mems_allowed = nodemask;
+        write_seqcount_end(&current->mems_allowed_seq);
         task_unlock(current);
 }
 
@@ -234,12 +225,14 @@ static inline void set_mems_allowed(nodemask_t nodemask)
 {
 }
 
-static inline void get_mems_allowed(void)
+static inline unsigned int get_mems_allowed(void)
 {
+        return 0;
 }
 
-static inline void put_mems_allowed(void)
+static inline bool put_mems_allowed(unsigned int seq)
 {
+        return true;
 }
 
 #endif /* !CONFIG_CPUSETS */
diff --git a/include/linux/crash_dump.h b/include/linux/crash_dump.h
index b936763f2236..37e4f8da7cdf 100644
--- a/include/linux/crash_dump.h
+++ b/include/linux/crash_dump.h
@@ -3,7 +3,6 @@
 
 #ifdef CONFIG_CRASH_DUMP
 #include <linux/kexec.h>
-#include <linux/device.h>
 #include <linux/proc_fs.h>
 #include <linux/elf.h>
 
diff --git a/include/linux/crc32.h b/include/linux/crc32.h
index 391a259b2cc9..68267b64bb98 100644
--- a/include/linux/crc32.h
+++ b/include/linux/crc32.h
@@ -11,6 +11,8 @@
 extern u32  crc32_le(u32 crc, unsigned char const *p, size_t len);
 extern u32  crc32_be(u32 crc, unsigned char const *p, size_t len);
 
+extern u32  __crc32c_le(u32 crc, unsigned char const *p, size_t len);
+
 #define crc32(seed, data, length)  crc32_le(seed, (unsigned char const *)(data), length)
 
 /*
diff --git a/include/linux/crypto.h b/include/linux/crypto.h
index 8a94217b298e..b92eadf92d72 100644
--- a/include/linux/crypto.h
+++ b/include/linux/crypto.h
@@ -20,6 +20,7 @@
 #include <linux/atomic.h>
 #include <linux/kernel.h>
 #include <linux/list.h>
+#include <linux/bug.h>
 #include <linux/slab.h>
 #include <linux/string.h>
 #include <linux/uaccess.h>
@@ -75,6 +76,11 @@
  */
 #define CRYPTO_ALG_INSTANCE             0x00000800
 
+/* Set this bit if the algorithm provided is hardware accelerated but
+ * not available to userspace via instruction set or so.
+ */
+#define CRYPTO_ALG_KERN_DRIVER_ONLY     0x00001000
+
 /*
  * Transform masks and values (for crt_flags).
  */
@@ -309,6 +315,8 @@ struct crypto_alg {
  */
 int crypto_register_alg(struct crypto_alg *alg);
 int crypto_unregister_alg(struct crypto_alg *alg);
+int crypto_register_algs(struct crypto_alg *algs, int count);
+int crypto_unregister_algs(struct crypto_alg *algs, int count);
 
 /*
  * Algorithm query interface.
diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index ff5f5256d175..7e11f1418203 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -222,7 +222,6 @@ extern void shrink_dcache_for_umount(struct super_block *);
 extern int d_invalidate(struct dentry *);
 
 /* only used at mount-time */
-extern struct dentry * d_alloc_root(struct inode *);
 extern struct dentry * d_make_root(struct inode *);
 
 /* <clickety>-<click> the ramfs-type tree */
diff --git a/include/linux/dccp.h b/include/linux/dccp.h
index 710c04302a15..eaf95a023af4 100644
--- a/include/linux/dccp.h
+++ b/include/linux/dccp.h
@@ -376,8 +376,10 @@ static inline unsigned int dccp_hdr_len(const struct sk_buff *skb)
 /**
  * struct dccp_request_sock  -  represent DCCP-specific connection request
  * @dreq_inet_rsk: structure inherited from
- * @dreq_iss: initial sequence number sent on the Response (RFC 4340, 7.1)
- * @dreq_isr: initial sequence number received on the Request
+ * @dreq_iss: initial sequence number, sent on the first Response (RFC 4340, 7.1)
+ * @dreq_gss: greatest sequence number sent (for retransmitted Responses)
+ * @dreq_isr: initial sequence number received in the first Request
+ * @dreq_gsr: greatest sequence number received (for retransmitted Request(s))
  * @dreq_service: service code present on the Request (there is just one)
  * @dreq_featneg: feature negotiation options for this connection
  * The following two fields are analogous to the ones in dccp_sock:
@@ -387,7 +389,9 @@ static inline unsigned int dccp_hdr_len(const struct sk_buff *skb)
 struct dccp_request_sock {
         struct inet_request_sock dreq_inet_rsk;
         __u64                    dreq_iss;
+        __u64                    dreq_gss;
         __u64                    dreq_isr;
+        __u64                    dreq_gsr;
         __be32                   dreq_service;
         struct list_head         dreq_featneg;
         __u32                    dreq_timestamp_echo;
diff --git a/include/linux/debug_locks.h b/include/linux/debug_locks.h
index 5033fb88c107..94f20c1488a1 100644
--- a/include/linux/debug_locks.h
+++ b/include/linux/debug_locks.h
@@ -3,6 +3,7 @@
 
 #include <linux/kernel.h>
 #include <linux/atomic.h>
+#include <linux/bug.h>
 #include <asm/system.h>
 
 struct task_struct;
diff --git a/include/linux/debugfs.h b/include/linux/debugfs.h
index 6169c26fd8c8..ae36b72c22f3 100644
--- a/include/linux/debugfs.h
+++ b/include/linux/debugfs.h
@@ -86,7 +86,7 @@ struct dentry *debugfs_create_blob(const char *name, umode_t mode,
                                   struct dentry *parent,
                                   struct debugfs_blob_wrapper *blob);
 
-struct dentry *debugfs_create_regset32(const char *name, mode_t mode,
+struct dentry *debugfs_create_regset32(const char *name, umode_t mode,
                                      struct dentry *parent,
                                      struct debugfs_regset32 *regset);
 
@@ -208,7 +208,7 @@ static inline struct dentry *debugfs_create_blob(const char *name, umode_t mode,
 }
 
 static inline struct dentry *debugfs_create_regset32(const char *name,
-                                   mode_t mode, struct dentry *parent,
+                                   umode_t mode, struct dentry *parent,
                                    struct debugfs_regset32 *regset)
 {
         return ERR_PTR(-ENODEV);
diff --git a/include/linux/devfreq.h b/include/linux/devfreq.h
index 98ce8124b1cc..281c72a3b9d5 100644
--- a/include/linux/devfreq.h
+++ b/include/linux/devfreq.h
@@ -44,6 +44,14 @@ struct devfreq_dev_status {
         void *private_data;
 };
 
+/*
+ * The resulting frequency should be at most this. (this bound is the
+ * least upper bound; thus, the resulting freq should be lower or same)
+ * If the flag is not set, the resulting frequency should be at most the
+ * bound (greatest lower bound)
+ */
+#define DEVFREQ_FLAG_LEAST_UPPER_BOUND          0x1
+
 /**
  * struct devfreq_dev_profile - Devfreq's user device profile
  * @initial_freq        The operating frequency when devfreq_add_device() is
@@ -54,6 +62,8 @@ struct devfreq_dev_status {
  *                      higher than any operable frequency, set maximum.
  *                      Before returning, target function should set
  *                      freq at the current frequency.
+ *                      The "flags" parameter's possible values are
+ *                      explained above with "DEVFREQ_FLAG_*" macros.
  * @get_dev_status      The device should provide the current performance
  *                      status to devfreq, which is used by governors.
  * @exit                An optional callback that is called when devfreq
@@ -66,7 +76,7 @@ struct devfreq_dev_profile {
         unsigned long initial_freq;
         unsigned int polling_ms;
 
-        int (*target)(struct device *dev, unsigned long *freq);
+        int (*target)(struct device *dev, unsigned long *freq, u32 flags);
         int (*get_dev_status)(struct device *dev,
                               struct devfreq_dev_status *stat);
         void (*exit)(struct device *dev);
@@ -124,6 +134,8 @@ struct devfreq_governor {
  *              touch this.
  * @being_removed       a flag to mark that this object is being removed in
  *                      order to prevent trying to remove the object multiple times.
+ * @min_freq    Limit minimum frequency requested by user (0: none)
+ * @max_freq    Limit maximum frequency requested by user (0: none)
  *
  * This structure stores the devfreq information for a give device.
  *
@@ -149,6 +161,9 @@ struct devfreq {
         void *data; /* private data for governors */
 
         bool being_removed;
+
+        unsigned long min_freq;
+        unsigned long max_freq;
 };
 
 #if defined(CONFIG_PM_DEVFREQ)
@@ -160,7 +175,7 @@ extern int devfreq_remove_device(struct devfreq *devfreq);
 
 /* Helper functions for devfreq user device driver with OPP. */
 extern struct opp *devfreq_recommended_opp(struct device *dev,
-                                           unsigned long *freq);
+                                           unsigned long *freq, u32 flags);
 extern int devfreq_register_opp_notifier(struct device *dev,
                                          struct devfreq *devfreq);
 extern int devfreq_unregister_opp_notifier(struct device *dev,
@@ -200,18 +215,18 @@ struct devfreq_simple_ondemand_data {
 static struct devfreq *devfreq_add_device(struct device *dev,
                                           struct devfreq_dev_profile *profile,
                                           struct devfreq_governor *governor,
-                                          void *data);
+                                          void *data)
 {
         return NULL;
 }
 
-static int devfreq_remove_device(struct devfreq *devfreq);
+static int devfreq_remove_device(struct devfreq *devfreq)
 {
         return 0;
 }
 
 static struct opp *devfreq_recommended_opp(struct device *dev,
-                                           unsigned long *freq)
+                                           unsigned long *freq, u32 flags)
 {
         return -EINVAL;
 }
diff --git a/include/linux/device.h b/include/linux/device.h
index b63fb393aa58..5ad17cccdd71 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -238,8 +238,6 @@ struct device_driver {
 extern int __must_check driver_register(struct device_driver *drv);
 extern void driver_unregister(struct device_driver *drv);
 
-extern struct device_driver *get_driver(struct device_driver *drv);
-extern void put_driver(struct device_driver *drv);
 extern struct device_driver *driver_find(const char *name,
                                          struct bus_type *bus);
 extern int driver_probe_done(void);
@@ -264,10 +262,6 @@ extern int __must_check driver_create_file(struct device_driver *driver,
 extern void driver_remove_file(struct device_driver *driver,
                                const struct driver_attribute *attr);
 
-extern int __must_check driver_add_kobj(struct device_driver *drv,
-                                        struct kobject *kobj,
-                                        const char *fmt, ...);
-
 extern int __must_check driver_for_each_device(struct device_driver *drv,
                                                struct device *start,
                                                void *data,
@@ -946,14 +940,14 @@ int _dev_info(const struct device *dev, const char *fmt, ...)
 
 #define dev_info(dev, fmt, arg...) _dev_info(dev, fmt, ##arg)
 
-#if defined(DEBUG)
-#define dev_dbg(dev, format, arg...)            \
-        dev_printk(KERN_DEBUG, dev, format, ##arg)
-#elif defined(CONFIG_DYNAMIC_DEBUG)
+#if defined(CONFIG_DYNAMIC_DEBUG)
 #define dev_dbg(dev, format, ...)                    \
 do {                                                 \
         dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \
 } while (0)
+#elif defined(DEBUG)
+#define dev_dbg(dev, format, arg...)            \
+        dev_printk(KERN_DEBUG, dev, format, ##arg)
 #else
 #define dev_dbg(dev, format, arg...)                            \
 ({                                                              \
@@ -1007,19 +1001,20 @@ extern long sysfs_deprecated;
  * @__driver: driver name
  * @__register: register function for this driver type
  * @__unregister: unregister function for this driver type
+ * @...: Additional arguments to be passed to __register and __unregister.
  *
  * Use this macro to construct bus specific macros for registering
  * drivers, and do not use it on its own.
  */
-#define module_driver(__driver, __register, __unregister) \
+#define module_driver(__driver, __register, __unregister, ...) \
 static int __init __driver##_init(void) \
 { \
-        return __register(&(__driver)); \
+        return __register(&(__driver) , ##__VA_ARGS__); \
 } \
 module_init(__driver##_init); \
 static void __exit __driver##_exit(void) \
 { \
-        __unregister(&(__driver)); \
+        __unregister(&(__driver) , ##__VA_ARGS__); \
 } \
 module_exit(__driver##_exit);
 
diff --git a/include/linux/dma-buf.h b/include/linux/dma-buf.h
index f8ac076afa52..887dcd487062 100644
--- a/include/linux/dma-buf.h
+++ b/include/linux/dma-buf.h
@@ -26,11 +26,11 @@
 
 #include <linux/file.h>
 #include <linux/err.h>
-#include <linux/device.h>
 #include <linux/scatterlist.h>
 #include <linux/list.h>
 #include <linux/dma-mapping.h>
 
+struct device;
 struct dma_buf;
 struct dma_buf_attachment;
 
diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h
index 679b349d9b66..a5966f691ef8 100644
--- a/include/linux/dmaengine.h
+++ b/include/linux/dmaengine.h
@@ -23,6 +23,7 @@
 
 #include <linux/device.h>
 #include <linux/uio.h>
+#include <linux/bug.h>
 #include <linux/scatterlist.h>
 #include <linux/bitmap.h>
 #include <asm/page.h>
diff --git a/include/linux/dynamic_debug.h b/include/linux/dynamic_debug.h
index 0564e3c39882..7e3c53a900d8 100644
--- a/include/linux/dynamic_debug.h
+++ b/include/linux/dynamic_debug.h
@@ -15,20 +15,24 @@ struct _ddebug {
         const char *function;
         const char *filename;
         const char *format;
-        unsigned int lineno:24;
+        unsigned int lineno:18;
         /*
          * The flags field controls the behaviour at the callsite.
          * The bits here are changed dynamically when the user
          * writes commands to <debugfs>/dynamic_debug/control
          */
-#define _DPRINTK_FLAGS_PRINT   (1<<0)  /* printk() a message using the format */
+#define _DPRINTK_FLAGS_NONE     0
+#define _DPRINTK_FLAGS_PRINT    (1<<0) /* printk() a message using the format */
 #define _DPRINTK_FLAGS_INCL_MODNAME     (1<<1)
 #define _DPRINTK_FLAGS_INCL_FUNCNAME    (1<<2)
 #define _DPRINTK_FLAGS_INCL_LINENO      (1<<3)
 #define _DPRINTK_FLAGS_INCL_TID         (1<<4)
+#if defined DEBUG
+#define _DPRINTK_FLAGS_DEFAULT _DPRINTK_FLAGS_PRINT
+#else
 #define _DPRINTK_FLAGS_DEFAULT 0
+#endif
         unsigned int flags:8;
-        char enabled;
 } __attribute__((aligned(8)));
 
 
@@ -62,21 +66,20 @@ int __dynamic_netdev_dbg(struct _ddebug *descriptor,
                 .format = (fmt),                                \
                 .lineno = __LINE__,                             \
                 .flags =  _DPRINTK_FLAGS_DEFAULT,               \
-                .enabled = false,                               \
         }
 
 #define dynamic_pr_debug(fmt, ...)                              \
 do {                                                            \
         DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt);         \
-        if (unlikely(descriptor.enabled))                       \
+        if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT))  \
                 __dynamic_pr_debug(&descriptor, pr_fmt(fmt),    \
                                    ##__VA_ARGS__);              \
 } while (0)
 
 #define dynamic_dev_dbg(dev, fmt, ...)                          \
 do {                                                            \
-        DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt); \
-        if (unlikely(descriptor.enabled))                       \
+        DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt);         \
+        if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT))  \
                 __dynamic_dev_dbg(&descriptor, dev, fmt,        \
                                   ##__VA_ARGS__);               \
 } while (0)
@@ -84,7 +87,7 @@ do {								\
 #define dynamic_netdev_dbg(dev, fmt, ...)                       \
 do {                                                            \
         DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt);         \
-        if (unlikely(descriptor.enabled))                       \
+        if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT))  \
                 __dynamic_netdev_dbg(&descriptor, dev, fmt,     \
                                      ##__VA_ARGS__);            \
 } while (0)
diff --git a/include/linux/edac.h b/include/linux/edac.h
index e3e3d26c638e..c621d762bb2c 100644
--- a/include/linux/edac.h
+++ b/include/linux/edac.h
@@ -13,7 +13,11 @@
 #define _LINUX_EDAC_H_
 
 #include <linux/atomic.h>
-#include <linux/device.h>
+#include <linux/kobject.h>
+#include <linux/completion.h>
+#include <linux/workqueue.h>
+
+struct device;
 
 #define EDAC_OPSTATE_INVAL      -1
 #define EDAC_OPSTATE_POLL       0
diff --git a/include/linux/efi.h b/include/linux/efi.h
index 37c300712e02..47fbf6b3dc77 100644
--- a/include/linux/efi.h
+++ b/include/linux/efi.h
@@ -315,6 +315,16 @@ typedef efi_status_t efi_query_capsule_caps_t(efi_capsule_header_t **capsules,
 
 typedef struct {
         efi_guid_t guid;
+        u64 table;
+} efi_config_table_64_t;
+
+typedef struct {
+        efi_guid_t guid;
+        u32 table;
+} efi_config_table_32_t;
+
+typedef struct {
+        efi_guid_t guid;
         unsigned long table;
 } efi_config_table_t;
 
@@ -329,6 +339,40 @@ typedef struct {
 
 typedef struct {
         efi_table_hdr_t hdr;
+        u64 fw_vendor;  /* physical addr of CHAR16 vendor string */
+        u32 fw_revision;
+        u32 __pad1;
+        u64 con_in_handle;
+        u64 con_in;
+        u64 con_out_handle;
+        u64 con_out;
+        u64 stderr_handle;
+        u64 stderr;
+        u64 runtime;
+        u64 boottime;
+        u32 nr_tables;
+        u32 __pad2;
+        u64 tables;
+} efi_system_table_64_t;
+
+typedef struct {
+        efi_table_hdr_t hdr;
+        u32 fw_vendor;  /* physical addr of CHAR16 vendor string */
+        u32 fw_revision;
+        u32 con_in_handle;
+        u32 con_in;
+        u32 con_out_handle;
+        u32 con_out;
+        u32 stderr_handle;
+        u32 stderr;
+        u32 runtime;
+        u32 boottime;
+        u32 nr_tables;
+        u32 tables;
+} efi_system_table_32_t;
+
+typedef struct {
+        efi_table_hdr_t hdr;
         unsigned long fw_vendor;        /* physical addr of CHAR16 vendor string */
         u32 fw_revision;
         unsigned long con_in_handle;
@@ -497,6 +541,7 @@ extern int __init efi_setup_pcdp_console(char *);
 #ifdef CONFIG_EFI
 # ifdef CONFIG_X86
    extern int efi_enabled;
+   extern bool efi_64bit;
 # else
 #  define efi_enabled 1
 # endif
diff --git a/include/linux/elfcore.h b/include/linux/elfcore.h
index 394a3e0e4a6b..0698c79fbcb2 100644
--- a/include/linux/elfcore.h
+++ b/include/linux/elfcore.h
@@ -6,6 +6,7 @@
 #include <linux/time.h>
 #ifdef __KERNEL__
 #include <linux/user.h>
+#include <linux/bug.h>
 #endif
 #include <linux/ptrace.h>
 #include <linux/elf.h>
diff --git a/include/linux/errno.h b/include/linux/errno.h
index 46685832ed99..2d09bfa5c262 100644
--- a/include/linux/errno.h
+++ b/include/linux/errno.h
@@ -16,6 +16,7 @@
 #define ERESTARTNOHAND  514     /* restart if no handler.. */
 #define ENOIOCTLCMD     515     /* No ioctl command */
 #define ERESTART_RESTARTBLOCK 516 /* restart by calling sys_restart_syscall */
+#define EPROBE_DEFER    517     /* Driver requests probe retry */
 
 /* Defined for the NFSv3 protocol */
 #define EBADHANDLE      521     /* Illegal NFS file handle */
diff --git a/include/linux/etherdevice.h b/include/linux/etherdevice.h
index 05955cf09937..8a1835855faa 100644
--- a/include/linux/etherdevice.h
+++ b/include/linux/etherdevice.h
@@ -140,17 +140,18 @@ static inline void random_ether_addr(u8 *addr)
 }
 
 /**
- * dev_hw_addr_random - Create random MAC and set device flag
+ * eth_hw_addr_random - Generate software assigned random Ethernet and
+ * set device flag
  * @dev: pointer to net_device structure
- * @hwaddr: Pointer to a six-byte array containing the Ethernet address
  *
- * Generate random MAC to be used by a device and set addr_assign_type
- * so the state can be read by sysfs and be used by udev.
+ * Generate a random Ethernet address (MAC) to be used by a net device
+ * and set addr_assign_type so the state can be read by sysfs and be
+ * used by userspace.
  */
-static inline void dev_hw_addr_random(struct net_device *dev, u8 *hwaddr)
+static inline void eth_hw_addr_random(struct net_device *dev)
 {
         dev->addr_assign_type |= NET_ADDR_RANDOM;
-        random_ether_addr(hwaddr);
+        random_ether_addr(dev->dev_addr);
 }
 
 /**
diff --git a/include/linux/ethtool.h b/include/linux/ethtool.h
index da5b2de99ae4..e1d9e0ede309 100644
--- a/include/linux/ethtool.h
+++ b/include/linux/ethtool.h
@@ -30,10 +30,15 @@ struct ethtool_cmd {
                                  * access it */
         __u8    duplex;         /* Duplex, half or full */
         __u8    port;           /* Which connector port */
-        __u8    phy_address;
+        __u8    phy_address;    /* MDIO PHY address (PRTAD for clause 45).
+                                 * May be read-only or read-write
+                                 * depending on the driver.
+                                 */
         __u8    transceiver;    /* Which transceiver to use */
         __u8    autoneg;        /* Enable or disable autonegotiation */
-        __u8    mdio_support;
+        __u8    mdio_support;   /* MDIO protocols supported.  Read-only.
+                                 * Not set by all drivers.
+                                 */
         __u32   maxtxpkt;       /* Tx pkts before generating tx int */
         __u32   maxrxpkt;       /* Rx pkts before generating rx int */
         __u16   speed_hi;       /* The forced speed (upper
@@ -59,6 +64,20 @@ static inline __u32 ethtool_cmd_speed(const struct ethtool_cmd *ep)
         return (ep->speed_hi << 16) | ep->speed;
 }
 
+/* Device supports clause 22 register access to PHY or peripherals
+ * using the interface defined in <linux/mii.h>.  This should not be
+ * set if there are known to be no such peripherals present or if
+ * the driver only emulates clause 22 registers for compatibility.
+ */
+#define ETH_MDIO_SUPPORTS_C22   1
+
+/* Device supports clause 45 register access to PHY or peripherals
+ * using the interface defined in <linux/mii.h> and <linux/mdio.h>.
+ * This should not be set if there are known to be no such peripherals
+ * present.
+ */
+#define ETH_MDIO_SUPPORTS_C45   2
+
 #define ETHTOOL_FWVERS_LEN      32
 #define ETHTOOL_BUSINFO_LEN     32
 /* these strings are set to whatever the driver author decides... */
diff --git a/include/linux/ext3_fs.h b/include/linux/ext3_fs.h
index f957085d40ed..f5a84eef6ed2 100644
--- a/include/linux/ext3_fs.h
+++ b/include/linux/ext3_fs.h
@@ -18,6 +18,7 @@
 
 #include <linux/types.h>
 #include <linux/magic.h>
+#include <linux/bug.h>
 
 /*
  * The second extended filesystem constants/structures
diff --git a/include/linux/fb.h b/include/linux/fb.h
index c18122f40543..d31cb682e173 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -407,7 +407,6 @@ struct fb_cursor {
 
 #include <linux/fs.h>
 #include <linux/init.h>
-#include <linux/device.h>
 #include <linux/workqueue.h>
 #include <linux/notifier.h>
 #include <linux/list.h>
@@ -1003,6 +1002,7 @@ extern ssize_t fb_sys_write(struct fb_info *info, const char __user *buf,
 /* drivers/video/fbmem.c */
 extern int register_framebuffer(struct fb_info *fb_info);
 extern int unregister_framebuffer(struct fb_info *fb_info);
+extern int unlink_framebuffer(struct fb_info *fb_info);
 extern void remove_conflicting_framebuffers(struct apertures_struct *a,
                                 const char *name, bool primary);
 extern int fb_prepare_logo(struct fb_info *fb_info, int rotate);
diff --git a/include/linux/file.h b/include/linux/file.h
index 21a79958541c..58bf158c53d9 100644
--- a/include/linux/file.h
+++ b/include/linux/file.h
@@ -12,7 +12,6 @@
 struct file;
 
 extern void fput(struct file *);
-extern void drop_file_write_access(struct file *file);
 
 struct file_operations;
 struct vfsmount;
diff --git a/include/linux/firewire-cdev.h b/include/linux/firewire-cdev.h
index 357dbfc2829e..d50036953497 100644
--- a/include/linux/firewire-cdev.h
+++ b/include/linux/firewire-cdev.h
@@ -207,12 +207,16 @@ struct fw_cdev_event_request2 {
  * @closure:    See &fw_cdev_event_common;
  *              set by %FW_CDEV_CREATE_ISO_CONTEXT ioctl
  * @type:       See &fw_cdev_event_common; always %FW_CDEV_EVENT_ISO_INTERRUPT
- * @cycle:      Cycle counter of the interrupt packet
+ * @cycle:      Cycle counter of the last completed packet
  * @header_length: Total length of following headers, in bytes
  * @header:     Stripped headers, if any
  *
  * This event is sent when the controller has completed an &fw_cdev_iso_packet
- * with the %FW_CDEV_ISO_INTERRUPT bit set.
+ * with the %FW_CDEV_ISO_INTERRUPT bit set, when explicitly requested with
+ * %FW_CDEV_IOC_FLUSH_ISO, or when there have been so many completed packets
+ * without the interrupt bit set that the kernel's internal buffer for @header
+ * is about to overflow.  (In the last case, kernels with ABI version < 5 drop
+ * header data up to the next interrupt packet.)
  *
  * Isochronous transmit events (context type %FW_CDEV_ISO_CONTEXT_TRANSMIT):
  *
@@ -267,9 +271,9 @@ struct fw_cdev_event_iso_interrupt {
  *
  * This event is sent in multichannel contexts (context type
  * %FW_CDEV_ISO_CONTEXT_RECEIVE_MULTICHANNEL) for &fw_cdev_iso_packet buffer
- * chunks that have the %FW_CDEV_ISO_INTERRUPT bit set.  Whether this happens
- * when a packet is completed and/or when a buffer chunk is completed depends
- * on the hardware implementation.
+ * chunks that have been completely filled and that have the
+ * %FW_CDEV_ISO_INTERRUPT bit set, or when explicitly requested with
+ * %FW_CDEV_IOC_FLUSH_ISO.
  *
  * The buffer is continuously filled with the following data, per packet:
  *  - the 1394 iso packet header as described at &fw_cdev_event_iso_interrupt,
@@ -419,6 +423,9 @@ union fw_cdev_event {
 #define FW_CDEV_IOC_RECEIVE_PHY_PACKETS _IOW('#', 0x16, struct fw_cdev_receive_phy_packets)
 #define FW_CDEV_IOC_SET_ISO_CHANNELS    _IOW('#', 0x17, struct fw_cdev_set_iso_channels)
 
+/* available since kernel version 3.4 */
+#define FW_CDEV_IOC_FLUSH_ISO           _IOW('#', 0x18, struct fw_cdev_flush_iso)
+
 /*
  * ABI version history
  *  1  (2.6.22)  - initial version
@@ -441,6 +448,9 @@ union fw_cdev_event {
  *               - added %FW_CDEV_EVENT_ISO_INTERRUPT_MULTICHANNEL,
  *                 %FW_CDEV_ISO_CONTEXT_RECEIVE_MULTICHANNEL, and
  *                 %FW_CDEV_IOC_SET_ISO_CHANNELS
+ *  5  (3.4)     - send %FW_CDEV_EVENT_ISO_INTERRUPT events when needed to
+ *                 avoid dropping data
+ *               - added %FW_CDEV_IOC_FLUSH_ISO
  */
 
 /**
@@ -851,6 +861,25 @@ struct fw_cdev_stop_iso {
 };
 
 /**
+ * struct fw_cdev_flush_iso - flush completed iso packets
+ * @handle:     handle of isochronous context to flush
+ *
+ * For %FW_CDEV_ISO_CONTEXT_TRANSMIT or %FW_CDEV_ISO_CONTEXT_RECEIVE contexts,
+ * report any completed packets.
+ *
+ * For %FW_CDEV_ISO_CONTEXT_RECEIVE_MULTICHANNEL contexts, report the current
+ * offset in the receive buffer, if it has changed; this is typically in the
+ * middle of some buffer chunk.
+ *
+ * Any %FW_CDEV_EVENT_ISO_INTERRUPT or %FW_CDEV_EVENT_ISO_INTERRUPT_MULTICHANNEL
+ * events generated by this ioctl are sent synchronously, i.e., are available
+ * for reading from the file descriptor when this ioctl returns.
+ */
+struct fw_cdev_flush_iso {
+        __u32 handle;
+};
+
+/**
  * struct fw_cdev_get_cycle_timer - read cycle timer register
  * @local_time:   system time, in microseconds since the Epoch
  * @cycle_timer:  Cycle Time register contents
diff --git a/include/linux/firewire.h b/include/linux/firewire.h
index 84ccf8e04fa6..4db7b68f0582 100644
--- a/include/linux/firewire.h
+++ b/include/linux/firewire.h
@@ -2,7 +2,6 @@
 #define _LINUX_FIREWIRE_H
 
 #include <linux/completion.h>
-#include <linux/device.h>
 #include <linux/dma-mapping.h>
 #include <linux/kernel.h>
 #include <linux/kref.h>
@@ -17,9 +16,6 @@
 #include <linux/atomic.h>
 #include <asm/byteorder.h>
 
-#define fw_notify(s, args...) printk(KERN_NOTICE KBUILD_MODNAME ": " s, ## args)
-#define fw_error(s, args...) printk(KERN_ERR KBUILD_MODNAME ": " s, ## args)
-
 #define CSR_REGISTER_BASE               0xfffff0000000ULL
 
 /* register offsets are relative to CSR_REGISTER_BASE */
@@ -68,6 +64,8 @@
 #define CSR_MODEL               0x17
 #define CSR_DIRECTORY_ID        0x20
 
+struct device;
+
 struct fw_csr_iterator {
         const u32 *p;
         const u32 *end;
@@ -203,18 +201,6 @@ static inline int fw_device_is_shutdown(struct fw_device *device)
         return atomic_read(&device->state) == FW_DEVICE_SHUTDOWN;
 }
 
-static inline struct fw_device *fw_device_get(struct fw_device *device)
-{
-        get_device(&device->device);
-
-        return device;
-}
-
-static inline void fw_device_put(struct fw_device *device)
-{
-        put_device(&device->device);
-}
-
 int fw_device_enable_phys_dma(struct fw_device *device);
 
 /*
@@ -441,6 +427,7 @@ int fw_iso_context_queue(struct fw_iso_context *ctx,
                          struct fw_iso_buffer *buffer,
                          unsigned long payload);
 void fw_iso_context_queue_flush(struct fw_iso_context *ctx);
+int fw_iso_context_flush_completions(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);
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 69cd5bb640f5..c437f914d537 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -389,6 +389,7 @@ struct inodes_stat_t {
 #include <linux/prio_tree.h>
 #include <linux/init.h>
 #include <linux/pid.h>
+#include <linux/bug.h>
 #include <linux/mutex.h>
 #include <linux/capability.h>
 #include <linux/semaphore.h>
@@ -1459,6 +1460,7 @@ struct super_block {
         u8 s_uuid[16];                          /* UUID */
 
         void                    *s_fs_info;     /* Filesystem private info */
+        unsigned int            s_max_links;
         fmode_t                 s_mode;
 
         /* Granularity of c/m/atime in ns.
@@ -1811,11 +1813,11 @@ static inline void inode_inc_iversion(struct inode *inode)
        spin_unlock(&inode->i_lock);
 }
 
-extern void touch_atime(struct vfsmount *mnt, struct dentry *dentry);
+extern void touch_atime(struct path *);
 static inline void file_accessed(struct file *file)
 {
         if (!(file->f_flags & O_NOATIME))
-                touch_atime(file->f_path.mnt, file->f_path.dentry);
+                touch_atime(&file->f_path);
 }
 
 int sync_inode(struct inode *inode, struct writeback_control *wbc);
@@ -1870,19 +1872,6 @@ extern struct dentry *mount_pseudo(struct file_system_type *, char *,
         const struct dentry_operations *dops,
         unsigned long);
 
-static inline void sb_mark_dirty(struct super_block *sb)
-{
-        sb->s_dirt = 1;
-}
-static inline void sb_mark_clean(struct super_block *sb)
-{
-        sb->s_dirt = 0;
-}
-static inline int sb_is_dirty(struct super_block *sb)
-{
-        return sb->s_dirt;
-}
-
 /* Alas, no aliases. Too much hassle with bringing module.h everywhere */
 #define fops_get(fops) \
         (((fops) && try_module_get((fops)->owner) ? (fops) : NULL))
@@ -2304,7 +2293,10 @@ extern struct inode * igrab(struct inode *);
 extern ino_t iunique(struct super_block *, ino_t);
 extern int inode_needs_sync(struct inode *inode);
 extern int generic_delete_inode(struct inode *inode);
-extern int generic_drop_inode(struct inode *inode);
+static inline int generic_drop_inode(struct inode *inode)
+{
+        return !inode->i_nlink || inode_unhashed(inode);
+}
 
 extern struct inode *ilookup5_nowait(struct super_block *sb,
                 unsigned long hashval, int (*test)(struct inode *, void *),
diff --git a/include/linux/fsnotify.h b/include/linux/fsnotify.h
index 2a53f10712b3..a6dfe6944564 100644
--- a/include/linux/fsnotify.h
+++ b/include/linux/fsnotify.h
@@ -14,6 +14,7 @@
 #include <linux/fsnotify_backend.h>
 #include <linux/audit.h>
 #include <linux/slab.h>
+#include <linux/bug.h>
 
 /*
  * fsnotify_d_instantiate - instantiate a dentry for inode
diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h
index 028e26f0bf08..72a6cabb4d5b 100644
--- a/include/linux/ftrace.h
+++ b/include/linux/ftrace.h
@@ -31,16 +31,33 @@ ftrace_enable_sysctl(struct ctl_table *table, int write,
 
 typedef void (*ftrace_func_t)(unsigned long ip, unsigned long parent_ip);
 
+/*
+ * FTRACE_OPS_FL_* bits denote the state of ftrace_ops struct and are
+ * set in the flags member.
+ *
+ * ENABLED - set/unset when ftrace_ops is registered/unregistered
+ * GLOBAL  - set manualy by ftrace_ops user to denote the ftrace_ops
+ *           is part of the global tracers sharing the same filter
+ *           via set_ftrace_* debugfs files.
+ * DYNAMIC - set when ftrace_ops is registered to denote dynamically
+ *           allocated ftrace_ops which need special care
+ * CONTROL - set manualy by ftrace_ops user to denote the ftrace_ops
+ *           could be controled by following calls:
+ *             ftrace_function_local_enable
+ *             ftrace_function_local_disable
+ */
 enum {
         FTRACE_OPS_FL_ENABLED           = 1 << 0,
         FTRACE_OPS_FL_GLOBAL            = 1 << 1,
         FTRACE_OPS_FL_DYNAMIC           = 1 << 2,
+        FTRACE_OPS_FL_CONTROL           = 1 << 3,
 };
 
 struct ftrace_ops {
         ftrace_func_t                   func;
         struct ftrace_ops               *next;
         unsigned long                   flags;
+        int __percpu                    *disabled;
 #ifdef CONFIG_DYNAMIC_FTRACE
         struct ftrace_hash              *notrace_hash;
         struct ftrace_hash              *filter_hash;
@@ -97,6 +114,55 @@ int register_ftrace_function(struct ftrace_ops *ops);
 int unregister_ftrace_function(struct ftrace_ops *ops);
 void clear_ftrace_function(void);
 
+/**
+ * ftrace_function_local_enable - enable controlled ftrace_ops on current cpu
+ *
+ * This function enables tracing on current cpu by decreasing
+ * the per cpu control variable.
+ * It must be called with preemption disabled and only on ftrace_ops
+ * registered with FTRACE_OPS_FL_CONTROL. If called without preemption
+ * disabled, this_cpu_ptr will complain when CONFIG_DEBUG_PREEMPT is enabled.
+ */
+static inline void ftrace_function_local_enable(struct ftrace_ops *ops)
+{
+        if (WARN_ON_ONCE(!(ops->flags & FTRACE_OPS_FL_CONTROL)))
+                return;
+
+        (*this_cpu_ptr(ops->disabled))--;
+}
+
+/**
+ * ftrace_function_local_disable - enable controlled ftrace_ops on current cpu
+ *
+ * This function enables tracing on current cpu by decreasing
+ * the per cpu control variable.
+ * It must be called with preemption disabled and only on ftrace_ops
+ * registered with FTRACE_OPS_FL_CONTROL. If called without preemption
+ * disabled, this_cpu_ptr will complain when CONFIG_DEBUG_PREEMPT is enabled.
+ */
+static inline void ftrace_function_local_disable(struct ftrace_ops *ops)
+{
+        if (WARN_ON_ONCE(!(ops->flags & FTRACE_OPS_FL_CONTROL)))
+                return;
+
+        (*this_cpu_ptr(ops->disabled))++;
+}
+
+/**
+ * ftrace_function_local_disabled - returns ftrace_ops disabled value
+ *                                  on current cpu
+ *
+ * This function returns value of ftrace_ops::disabled on current cpu.
+ * It must be called with preemption disabled and only on ftrace_ops
+ * registered with FTRACE_OPS_FL_CONTROL. If called without preemption
+ * disabled, this_cpu_ptr will complain when CONFIG_DEBUG_PREEMPT is enabled.
+ */
+static inline int ftrace_function_local_disabled(struct ftrace_ops *ops)
+{
+        WARN_ON_ONCE(!(ops->flags & FTRACE_OPS_FL_CONTROL));
+        return *this_cpu_ptr(ops->disabled);
+}
+
 extern void ftrace_stub(unsigned long a0, unsigned long a1);
 
 #else /* !CONFIG_FUNCTION_TRACER */
@@ -178,12 +244,13 @@ struct dyn_ftrace {
 };
 
 int ftrace_force_update(void);
-void ftrace_set_filter(struct ftrace_ops *ops, unsigned char *buf,
+int 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 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);
+void ftrace_free_filter(struct ftrace_ops *ops);
 
 int register_ftrace_command(struct ftrace_func_command *cmd);
 int unregister_ftrace_command(struct ftrace_func_command *cmd);
@@ -314,9 +381,6 @@ extern void ftrace_enable_daemon(void);
 #else
 static inline int skip_trace(unsigned long ip) { return 0; }
 static inline int ftrace_force_update(void) { return 0; }
-static inline void ftrace_set_filter(unsigned char *buf, int len, int reset)
-{
-}
 static inline void ftrace_disable_daemon(void) { }
 static inline void ftrace_enable_daemon(void) { }
 static inline void ftrace_release_mod(struct module *mod) {}
@@ -340,6 +404,9 @@ static inline int ftrace_text_reserved(void *start, void *end)
  */
 #define ftrace_regex_open(ops, flag, inod, file) ({ -ENODEV; })
 #define ftrace_set_early_filter(ops, buf, enable) do { } while (0)
+#define ftrace_set_filter(ops, buf, len, reset) ({ -ENODEV; })
+#define ftrace_set_notrace(ops, buf, len, reset) ({ -ENODEV; })
+#define ftrace_free_filter(ops) do { } while (0)
 
 static inline ssize_t ftrace_filter_write(struct file *file, const char __user *ubuf,
                             size_t cnt, loff_t *ppos) { return -ENODEV; }
diff --git a/include/linux/ftrace_event.h b/include/linux/ftrace_event.h
index c3da42dd22ba..dd478fc8f9f5 100644
--- a/include/linux/ftrace_event.h
+++ b/include/linux/ftrace_event.h
@@ -146,6 +146,10 @@ enum trace_reg {
         TRACE_REG_UNREGISTER,
         TRACE_REG_PERF_REGISTER,
         TRACE_REG_PERF_UNREGISTER,
+        TRACE_REG_PERF_OPEN,
+        TRACE_REG_PERF_CLOSE,
+        TRACE_REG_PERF_ADD,
+        TRACE_REG_PERF_DEL,
 };
 
 struct ftrace_event_call;
@@ -157,7 +161,7 @@ struct ftrace_event_class {
         void                    *perf_probe;
 #endif
         int                     (*reg)(struct ftrace_event_call *event,
-                                       enum trace_reg type);
+                                       enum trace_reg type, void *data);
         int                     (*define_fields)(struct ftrace_event_call *);
         struct list_head        *(*get_fields)(struct ftrace_event_call *);
         struct list_head        fields;
@@ -165,7 +169,7 @@ struct ftrace_event_class {
 };
 
 extern int ftrace_event_reg(struct ftrace_event_call *event,
-                            enum trace_reg type);
+                            enum trace_reg type, void *data);
 
 enum {
         TRACE_EVENT_FL_ENABLED_BIT,
@@ -241,6 +245,7 @@ enum {
         FILTER_STATIC_STRING,
         FILTER_DYN_STRING,
         FILTER_PTR_STRING,
+        FILTER_TRACE_FN,
 };
 
 #define EVENT_STORAGE_SIZE 128
diff --git a/include/linux/gfs2_ondisk.h b/include/linux/gfs2_ondisk.h
index b148087f49a6..fa98bdb073b9 100644
--- a/include/linux/gfs2_ondisk.h
+++ b/include/linux/gfs2_ondisk.h
@@ -168,6 +168,7 @@ struct gfs2_rindex {
 #define GFS2_RGF_METAONLY       0x00000002
 #define GFS2_RGF_DATAONLY       0x00000004
 #define GFS2_RGF_NOALLOC        0x00000008
+#define GFS2_RGF_TRIMMED        0x00000010
 
 struct gfs2_rgrp {
         struct gfs2_meta_header rg_header;
diff --git a/include/linux/gpio.h b/include/linux/gpio.h
index 38ac48b7d3a8..6155ecf192b0 100644
--- a/include/linux/gpio.h
+++ b/include/linux/gpio.h
@@ -14,6 +14,12 @@
 #define GPIOF_OUT_INIT_LOW      (GPIOF_DIR_OUT | GPIOF_INIT_LOW)
 #define GPIOF_OUT_INIT_HIGH     (GPIOF_DIR_OUT | GPIOF_INIT_HIGH)
 
+/* Gpio pin is open drain */
+#define GPIOF_OPEN_DRAIN        (1 << 2)
+
+/* Gpio pin is open source */
+#define GPIOF_OPEN_SOURCE       (1 << 3)
+
 /**
  * struct gpio - a structure describing a GPIO with configuration
  * @gpio:       the GPIO number
@@ -34,6 +40,7 @@ struct gpio {
 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/errno.h>
+#include <linux/bug.h>
 
 struct device;
 struct gpio_chip;
diff --git a/include/linux/highmem.h b/include/linux/highmem.h
index 3a93f73a8acc..d3999b4e26cc 100644
--- a/include/linux/highmem.h
+++ b/include/linux/highmem.h
@@ -3,6 +3,7 @@
 
 #include <linux/fs.h>
 #include <linux/kernel.h>
+#include <linux/bug.h>
 #include <linux/mm.h>
 #include <linux/uaccess.h>
 #include <linux/hardirq.h>
@@ -55,12 +56,12 @@ static inline void kunmap(struct page *page)
 {
 }
 
-static inline void *__kmap_atomic(struct page *page)
+static inline void *kmap_atomic(struct page *page)
 {
         pagefault_disable();
         return page_address(page);
 }
-#define kmap_atomic_prot(page, prot)    __kmap_atomic(page)
+#define kmap_atomic_prot(page, prot)    kmap_atomic(page)
 
 static inline void __kunmap_atomic(void *addr)
 {
@@ -109,27 +110,62 @@ static inline void kmap_atomic_idx_pop(void)
 #endif
 
 /*
- * Make both: kmap_atomic(page, idx) and kmap_atomic(page) work.
+ * NOTE:
+ * kmap_atomic() and kunmap_atomic() with two arguments are deprecated.
+ * We only keep them for backward compatibility, any usage of them
+ * are now warned.
  */
-#define kmap_atomic(page, args...) __kmap_atomic(page)
+
+#define PASTE(a, b) a ## b
+#define PASTE2(a, b) PASTE(a, b)
+
+#define NARG_(_2, _1, n, ...) n
+#define NARG(...) NARG_(__VA_ARGS__, 2, 1, :)
+
+static inline void __deprecated *kmap_atomic_deprecated(struct page *page,
+                                                        enum km_type km)
+{
+        return kmap_atomic(page);
+}
+
+#define kmap_atomic1(...) kmap_atomic(__VA_ARGS__)
+#define kmap_atomic2(...) kmap_atomic_deprecated(__VA_ARGS__)
+#define kmap_atomic(...) PASTE2(kmap_atomic, NARG(__VA_ARGS__)(__VA_ARGS__))
+
+static inline void __deprecated __kunmap_atomic_deprecated(void *addr,
+                                                        enum km_type km)
+{
+        __kunmap_atomic(addr);
+}
 
 /*
  * Prevent people trying to call kunmap_atomic() as if it were kunmap()
  * kunmap_atomic() should get the return value of kmap_atomic, not the page.
  */
-#define kunmap_atomic(addr, args...)                            \
-do {                                                            \
-        BUILD_BUG_ON(__same_type((addr), struct page *));       \
-        __kunmap_atomic(addr);                                  \
+#define kunmap_atomic_deprecated(addr, km)                      \
+do {                                                            \
+        BUILD_BUG_ON(__same_type((addr), struct page *));       \
+        __kunmap_atomic_deprecated(addr, km);                   \
 } while (0)
 
+#define kunmap_atomic_withcheck(addr)                           \
+do {                                                            \
+        BUILD_BUG_ON(__same_type((addr), struct page *));       \
+        __kunmap_atomic(addr);                                  \
+} while (0)
+
+#define kunmap_atomic1(...) kunmap_atomic_withcheck(__VA_ARGS__)
+#define kunmap_atomic2(...) kunmap_atomic_deprecated(__VA_ARGS__)
+#define kunmap_atomic(...) PASTE2(kunmap_atomic, NARG(__VA_ARGS__)(__VA_ARGS__))
+/**** End of C pre-processor tricks for deprecated macros ****/
+
 /* when CONFIG_HIGHMEM is not set these will be plain clear/copy_page */
 #ifndef clear_user_highpage
 static inline void clear_user_highpage(struct page *page, unsigned long vaddr)
 {
-        void *addr = kmap_atomic(page, KM_USER0);
+        void *addr = kmap_atomic(page);
         clear_user_page(addr, vaddr, page);
-        kunmap_atomic(addr, KM_USER0);
+        kunmap_atomic(addr);
 }
 #endif
 
@@ -180,16 +216,16 @@ alloc_zeroed_user_highpage_movable(struct vm_area_struct *vma,
 
 static inline void clear_highpage(struct page *page)
 {
-        void *kaddr = kmap_atomic(page, KM_USER0);
+        void *kaddr = kmap_atomic(page);
         clear_page(kaddr);
-        kunmap_atomic(kaddr, KM_USER0);
+        kunmap_atomic(kaddr);
 }
 
 static inline void zero_user_segments(struct page *page,
         unsigned start1, unsigned end1,
         unsigned start2, unsigned end2)
 {
-        void *kaddr = kmap_atomic(page, KM_USER0);
+        void *kaddr = kmap_atomic(page);
 
         BUG_ON(end1 > PAGE_SIZE || end2 > PAGE_SIZE);
 
@@ -199,7 +235,7 @@ static inline void zero_user_segments(struct page *page,
         if (end2 > start2)
                 memset(kaddr + start2, 0, end2 - start2);
 
-        kunmap_atomic(kaddr, KM_USER0);
+        kunmap_atomic(kaddr);
         flush_dcache_page(page);
 }
 
@@ -228,11 +264,11 @@ static inline void copy_user_highpage(struct page *to, struct page *from,
 {
         char *vfrom, *vto;
 
-        vfrom = kmap_atomic(from, KM_USER0);
-        vto = kmap_atomic(to, KM_USER1);
+        vfrom = kmap_atomic(from);
+        vto = kmap_atomic(to);
         copy_user_page(vto, vfrom, vaddr, to);
-        kunmap_atomic(vto, KM_USER1);
-        kunmap_atomic(vfrom, KM_USER0);
+        kunmap_atomic(vto);
+        kunmap_atomic(vfrom);
 }
 
 #endif
@@ -241,11 +277,11 @@ static inline void copy_highpage(struct page *to, struct page *from)
 {
         char *vfrom, *vto;
 
-        vfrom = kmap_atomic(from, KM_USER0);
-        vto = kmap_atomic(to, KM_USER1);
+        vfrom = kmap_atomic(from);
+        vto = kmap_atomic(to);
         copy_page(vto, vfrom);
-        kunmap_atomic(vto, KM_USER1);
-        kunmap_atomic(vfrom, KM_USER0);
+        kunmap_atomic(vto);
+        kunmap_atomic(vfrom);
 }
 
 #endif /* _LINUX_HIGHMEM_H */
diff --git a/include/linux/huge_mm.h b/include/linux/huge_mm.h
index 1b921299abc4..c8af7a2efb52 100644
--- a/include/linux/huge_mm.h
+++ b/include/linux/huge_mm.h
@@ -51,6 +51,9 @@ extern pmd_t *page_check_address_pmd(struct page *page,
                                      unsigned long address,
                                      enum page_check_address_pmd_flag flag);
 
+#define HPAGE_PMD_ORDER (HPAGE_PMD_SHIFT-PAGE_SHIFT)
+#define HPAGE_PMD_NR (1<<HPAGE_PMD_ORDER)
+
 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
 #define HPAGE_PMD_SHIFT HPAGE_SHIFT
 #define HPAGE_PMD_MASK HPAGE_MASK
@@ -102,8 +105,6 @@ extern void __split_huge_page_pmd(struct mm_struct *mm, pmd_t *pmd);
                 BUG_ON(pmd_trans_splitting(*____pmd) ||                 \
                        pmd_trans_huge(*____pmd));                       \
         } while (0)
-#define HPAGE_PMD_ORDER (HPAGE_PMD_SHIFT-PAGE_SHIFT)
-#define HPAGE_PMD_NR (1<<HPAGE_PMD_ORDER)
 #if HPAGE_PMD_ORDER > MAX_ORDER
 #error "hugepages can't be allocated by the buddy allocator"
 #endif
@@ -113,6 +114,18 @@ extern void __vma_adjust_trans_huge(struct vm_area_struct *vma,
                                     unsigned long start,
                                     unsigned long end,
                                     long adjust_next);
+extern int __pmd_trans_huge_lock(pmd_t *pmd,
+                                 struct vm_area_struct *vma);
+/* mmap_sem must be held on entry */
+static inline int pmd_trans_huge_lock(pmd_t *pmd,
+                                      struct vm_area_struct *vma)
+{
+        VM_BUG_ON(!rwsem_is_locked(&vma->vm_mm->mmap_sem));
+        if (pmd_trans_huge(*pmd))
+                return __pmd_trans_huge_lock(pmd, vma);
+        else
+                return 0;
+}
 static inline void vma_adjust_trans_huge(struct vm_area_struct *vma,
                                          unsigned long start,
                                          unsigned long end,
@@ -146,9 +159,9 @@ static inline struct page *compound_trans_head(struct page *page)
         return page;
 }
 #else /* CONFIG_TRANSPARENT_HUGEPAGE */
-#define HPAGE_PMD_SHIFT ({ BUG(); 0; })
-#define HPAGE_PMD_MASK ({ BUG(); 0; })
-#define HPAGE_PMD_SIZE ({ BUG(); 0; })
+#define HPAGE_PMD_SHIFT ({ BUILD_BUG(); 0; })
+#define HPAGE_PMD_MASK ({ BUILD_BUG(); 0; })
+#define HPAGE_PMD_SIZE ({ BUILD_BUG(); 0; })
 
 #define hpage_nr_pages(x) 1
 
@@ -176,6 +189,11 @@ static inline void vma_adjust_trans_huge(struct vm_area_struct *vma,
                                          long adjust_next)
 {
 }
+static inline int pmd_trans_huge_lock(pmd_t *pmd,
+                                      struct vm_area_struct *vma)
+{
+        return 0;
+}
 #endif /* CONFIG_TRANSPARENT_HUGEPAGE */
 
 #endif /* _LINUX_HUGE_MM_H */
diff --git a/include/linux/hugetlb.h b/include/linux/hugetlb.h
index d9d6c868b86b..000837e126e6 100644
--- a/include/linux/hugetlb.h
+++ b/include/linux/hugetlb.h
@@ -14,6 +14,15 @@ struct user_struct;
 #include <linux/shm.h>
 #include <asm/tlbflush.h>
 
+struct hugepage_subpool {
+        spinlock_t lock;
+        long count;
+        long max_hpages, used_hpages;
+};
+
+struct hugepage_subpool *hugepage_new_subpool(long nr_blocks);
+void hugepage_put_subpool(struct hugepage_subpool *spool);
+
 int PageHuge(struct page *page);
 
 void reset_vma_resv_huge_pages(struct vm_area_struct *vma);
@@ -128,35 +137,14 @@ enum {
 };
 
 #ifdef CONFIG_HUGETLBFS
-struct hugetlbfs_config {
-        uid_t   uid;
-        gid_t   gid;
-        umode_t mode;
-        long    nr_blocks;
-        long    nr_inodes;
-        struct hstate *hstate;
-};
-
 struct hugetlbfs_sb_info {
-        long    max_blocks;   /* blocks allowed */
-        long    free_blocks;  /* blocks free */
         long    max_inodes;   /* inodes allowed */
         long    free_inodes;  /* inodes free */
         spinlock_t      stat_lock;
         struct hstate *hstate;
+        struct hugepage_subpool *spool;
 };
 
-
-struct hugetlbfs_inode_info {
-        struct shared_policy policy;
-        struct inode vfs_inode;
-};
-
-static inline struct hugetlbfs_inode_info *HUGETLBFS_I(struct inode *inode)
-{
-        return container_of(inode, struct hugetlbfs_inode_info, vfs_inode);
-}
-
 static inline struct hugetlbfs_sb_info *HUGETLBFS_SB(struct super_block *sb)
 {
         return sb->s_fs_info;
@@ -164,10 +152,9 @@ static inline struct hugetlbfs_sb_info *HUGETLBFS_SB(struct super_block *sb)
 
 extern const struct file_operations hugetlbfs_file_operations;
 extern const struct vm_operations_struct hugetlb_vm_ops;
-struct file *hugetlb_file_setup(const char *name, size_t size, vm_flags_t acct,
+struct file *hugetlb_file_setup(const char *name, unsigned long addr,
+                                size_t size, vm_flags_t acct,
                                 struct user_struct **user, int creat_flags);
-int hugetlb_get_quota(struct address_space *mapping, long delta);
-void hugetlb_put_quota(struct address_space *mapping, long delta);
 
 static inline int is_file_hugepages(struct file *file)
 {
@@ -179,15 +166,11 @@ static inline int is_file_hugepages(struct file *file)
         return 0;
 }
 
-static inline void set_file_hugepages(struct file *file)
-{
-        file->f_op = &hugetlbfs_file_operations;
-}
 #else /* !CONFIG_HUGETLBFS */
 
 #define is_file_hugepages(file)                 0
-#define set_file_hugepages(file)                BUG()
-static inline struct file *hugetlb_file_setup(const char *name, size_t size,
+static inline struct file *
+hugetlb_file_setup(const char *name, unsigned long addr, size_t size,
                 vm_flags_t acctflag, struct user_struct **user, int creat_flags)
 {
         return ERR_PTR(-ENOSYS);
diff --git a/include/linux/hwmon-sysfs.h b/include/linux/hwmon-sysfs.h
index a90c09d331c1..1c7b89ae6bdc 100644
--- a/include/linux/hwmon-sysfs.h
+++ b/include/linux/hwmon-sysfs.h
@@ -20,6 +20,8 @@
 #ifndef _LINUX_HWMON_SYSFS_H
 #define _LINUX_HWMON_SYSFS_H
 
+#include <linux/device.h>
+
 struct sensor_device_attribute{
         struct device_attribute dev_attr;
         int index;
diff --git a/include/linux/hwmon.h b/include/linux/hwmon.h
index 6b6ee702b007..82b29ae6ebb0 100644
--- a/include/linux/hwmon.h
+++ b/include/linux/hwmon.h
@@ -14,7 +14,7 @@
 #ifndef _HWMON_H_
 #define _HWMON_H_
 
-#include <linux/device.h>
+struct device;
 
 struct device *hwmon_device_register(struct device *dev);
 
diff --git a/include/linux/hwspinlock.h b/include/linux/hwspinlock.h
index aad6bd4b3efd..3343298e40e8 100644
--- a/include/linux/hwspinlock.h
+++ b/include/linux/hwspinlock.h
@@ -20,12 +20,12 @@
 
 #include <linux/err.h>
 #include <linux/sched.h>
-#include <linux/device.h>
 
 /* hwspinlock mode argument */
 #define HWLOCK_IRQSTATE 0x01    /* Disable interrupts, save state */
 #define HWLOCK_IRQ      0x02    /* Disable interrupts, don't save state */
 
+struct device;
 struct hwspinlock;
 struct hwspinlock_device;
 struct hwspinlock_ops;
diff --git a/include/linux/hyperv.h b/include/linux/hyperv.h
index 0ae065a5fcb2..5852545e6bba 100644
--- a/include/linux/hyperv.h
+++ b/include/linux/hyperv.h
@@ -25,6 +25,173 @@
 #ifndef _HYPERV_H
 #define _HYPERV_H
 
+#include <linux/types.h>
+
+/*
+ * An implementation of HyperV key value pair (KVP) functionality for Linux.
+ *
+ *
+ * Copyright (C) 2010, Novell, Inc.
+ * Author : K. Y. Srinivasan <ksrinivasan@novell.com>
+ *
+ */
+
+/*
+ * Maximum value size - used for both key names and value data, and includes
+ * any applicable NULL terminators.
+ *
+ * Note:  This limit is somewhat arbitrary, but falls easily within what is
+ * supported for all native guests (back to Win 2000) and what is reasonable
+ * for the IC KVP exchange functionality.  Note that Windows Me/98/95 are
+ * limited to 255 character key names.
+ *
+ * MSDN recommends not storing data values larger than 2048 bytes in the
+ * registry.
+ *
+ * Note:  This value is used in defining the KVP exchange message - this value
+ * cannot be modified without affecting the message size and compatibility.
+ */
+
+/*
+ * bytes, including any null terminators
+ */
+#define HV_KVP_EXCHANGE_MAX_VALUE_SIZE          (2048)
+
+
+/*
+ * Maximum key size - the registry limit for the length of an entry name
+ * is 256 characters, including the null terminator
+ */
+
+#define HV_KVP_EXCHANGE_MAX_KEY_SIZE            (512)
+
+/*
+ * In Linux, we implement the KVP functionality in two components:
+ * 1) The kernel component which is packaged as part of the hv_utils driver
+ * is responsible for communicating with the host and responsible for
+ * implementing the host/guest protocol. 2) A user level daemon that is
+ * responsible for data gathering.
+ *
+ * Host/Guest Protocol: The host iterates over an index and expects the guest
+ * to assign a key name to the index and also return the value corresponding to
+ * the key. The host will have atmost one KVP transaction outstanding at any
+ * given point in time. The host side iteration stops when the guest returns
+ * an error. Microsoft has specified the following mapping of key names to
+ * host specified index:
+ *
+ *      Index           Key Name
+ *      0               FullyQualifiedDomainName
+ *      1               IntegrationServicesVersion
+ *      2               NetworkAddressIPv4
+ *      3               NetworkAddressIPv6
+ *      4               OSBuildNumber
+ *      5               OSName
+ *      6               OSMajorVersion
+ *      7               OSMinorVersion
+ *      8               OSVersion
+ *      9               ProcessorArchitecture
+ *
+ * The Windows host expects the Key Name and Key Value to be encoded in utf16.
+ *
+ * Guest Kernel/KVP Daemon Protocol: As noted earlier, we implement all of the
+ * data gathering functionality in a user mode daemon. The user level daemon
+ * is also responsible for binding the key name to the index as well. The
+ * kernel and user-level daemon communicate using a connector channel.
+ *
+ * The user mode component first registers with the
+ * the kernel component. Subsequently, the kernel component requests, data
+ * for the specified keys. In response to this message the user mode component
+ * fills in the value corresponding to the specified key. We overload the
+ * sequence field in the cn_msg header to define our KVP message types.
+ *
+ *
+ * The kernel component simply acts as a conduit for communication between the
+ * Windows host and the user-level daemon. The kernel component passes up the
+ * index received from the Host to the user-level daemon. If the index is
+ * valid (supported), the corresponding key as well as its
+ * value (both are strings) is returned. If the index is invalid
+ * (not supported), a NULL key string is returned.
+ */
+
+
+/*
+ * Registry value types.
+ */
+
+#define REG_SZ 1
+#define REG_U32 4
+#define REG_U64 8
+
+enum hv_kvp_exchg_op {
+        KVP_OP_GET = 0,
+        KVP_OP_SET,
+        KVP_OP_DELETE,
+        KVP_OP_ENUMERATE,
+        KVP_OP_REGISTER,
+        KVP_OP_COUNT /* Number of operations, must be last. */
+};
+
+enum hv_kvp_exchg_pool {
+        KVP_POOL_EXTERNAL = 0,
+        KVP_POOL_GUEST,
+        KVP_POOL_AUTO,
+        KVP_POOL_AUTO_EXTERNAL,
+        KVP_POOL_AUTO_INTERNAL,
+        KVP_POOL_COUNT /* Number of pools, must be last. */
+};
+
+struct hv_kvp_hdr {
+        __u8 operation;
+        __u8 pool;
+        __u16 pad;
+} __attribute__((packed));
+
+struct hv_kvp_exchg_msg_value {
+        __u32 value_type;
+        __u32 key_size;
+        __u32 value_size;
+        __u8 key[HV_KVP_EXCHANGE_MAX_KEY_SIZE];
+        union {
+                __u8 value[HV_KVP_EXCHANGE_MAX_VALUE_SIZE];
+                __u32 value_u32;
+                __u64 value_u64;
+        };
+} __attribute__((packed));
+
+struct hv_kvp_msg_enumerate {
+        __u32 index;
+        struct hv_kvp_exchg_msg_value data;
+} __attribute__((packed));
+
+struct hv_kvp_msg_get {
+        struct hv_kvp_exchg_msg_value data;
+};
+
+struct hv_kvp_msg_set {
+        struct hv_kvp_exchg_msg_value data;
+};
+
+struct hv_kvp_msg_delete {
+        __u32 key_size;
+        __u8 key[HV_KVP_EXCHANGE_MAX_KEY_SIZE];
+};
+
+struct hv_kvp_register {
+        __u8 version[HV_KVP_EXCHANGE_MAX_KEY_SIZE];
+};
+
+struct hv_kvp_msg {
+        struct hv_kvp_hdr       kvp_hdr;
+        union {
+                struct hv_kvp_msg_get           kvp_get;
+                struct hv_kvp_msg_set           kvp_set;
+                struct hv_kvp_msg_delete        kvp_delete;
+                struct hv_kvp_msg_enumerate     kvp_enum_data;
+                struct hv_kvp_register          kvp_register;
+        } body;
+} __attribute__((packed));
+
+#ifdef __KERNEL__
 #include <linux/scatterlist.h>
 #include <linux/list.h>
 #include <linux/uuid.h>
@@ -785,6 +952,7 @@ void vmbus_driver_unregister(struct hv_driver *hv_driver);
 
 #define HV_S_OK                         0x00000000
 #define HV_E_FAIL                       0x80004005
+#define HV_S_CONT                       0x80070103
 #define HV_ERROR_NOT_SUPPORTED          0x80070032
 #define HV_ERROR_MACHINE_LOCKED         0x800704F7
 
@@ -870,4 +1038,9 @@ struct hyperv_service_callback {
 extern void vmbus_prep_negotiate_resp(struct icmsg_hdr *,
                                       struct icmsg_negotiate *, u8 *);
 
+int hv_kvp_init(struct hv_util_service *);
+void hv_kvp_deinit(void);
+void hv_kvp_onchannelcallback(void *);
+
+#endif /* __KERNEL__ */
 #endif /* _HYPERV_H */
diff --git a/include/linux/i2c-algo-bit.h b/include/linux/i2c-algo-bit.h
index 4f98148c11c3..63904ba6887e 100644
--- a/include/linux/i2c-algo-bit.h
+++ b/include/linux/i2c-algo-bit.h
@@ -15,7 +15,8 @@
 
     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.                */
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+    MA 02110-1301 USA.                                                       */
 /* ------------------------------------------------------------------------- */
 
 /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and even
@@ -49,5 +50,6 @@ struct i2c_algo_bit_data {
 
 int i2c_bit_add_bus(struct i2c_adapter *);
 int i2c_bit_add_numbered_bus(struct i2c_adapter *);
+extern const struct i2c_algorithm i2c_bit_algo;
 
 #endif /* _LINUX_I2C_ALGO_BIT_H */
diff --git a/include/linux/i2c-algo-pcf.h b/include/linux/i2c-algo-pcf.h
index 0f91a957a690..538e8f41a319 100644
--- a/include/linux/i2c-algo-pcf.h
+++ b/include/linux/i2c-algo-pcf.h
@@ -16,7 +16,8 @@
 
     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.                */
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+    MA 02110-1301 USA.                                                       */
 /* ------------------------------------------------------------------------- */
 
 /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and even
diff --git a/include/linux/i2c-dev.h b/include/linux/i2c-dev.h
index fd53bfd26470..8a7406b2114d 100644
--- a/include/linux/i2c-dev.h
+++ b/include/linux/i2c-dev.h
@@ -16,7 +16,8 @@
 
     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.
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+    MA 02110-1301 USA.
 */
 
 #ifndef _LINUX_I2C_DEV_H
diff --git a/include/linux/i2c-mux.h b/include/linux/i2c-mux.h
index 34536effd652..747f0cde4164 100644
--- a/include/linux/i2c-mux.h
+++ b/include/linux/i2c-mux.h
@@ -18,7 +18,8 @@
  *
  * 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.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301 USA.
  */
 
 #ifndef _LINUX_I2C_MUX_H
diff --git a/include/linux/i2c-smbus.h b/include/linux/i2c-smbus.h
index 63f57a8c8b31..017fb40f702a 100644
--- a/include/linux/i2c-smbus.h
+++ b/include/linux/i2c-smbus.h
@@ -15,7 +15,8 @@
  *
  * 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.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301 USA.
  */
 
 #ifndef _LINUX_I2C_SMBUS_H
diff --git a/include/linux/i2c.h b/include/linux/i2c.h
index 8e25a9167f13..195d8b3d9cfb 100644
--- a/include/linux/i2c.h
+++ b/include/linux/i2c.h
@@ -17,7 +17,8 @@
 
     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.                */
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+    MA 02110-1301 USA.                                                       */
 /* ------------------------------------------------------------------------- */
 
 /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and
diff --git a/include/linux/i2c/at24.h b/include/linux/i2c/at24.h
index 8ace93024d60..285025a9cdc9 100644
--- a/include/linux/i2c/at24.h
+++ b/include/linux/i2c/at24.h
@@ -1,19 +1,42 @@
+/*
+ * at24.h - platform_data for the at24 (generic eeprom) driver
+ * (C) Copyright 2008 by Pengutronix
+ * (C) Copyright 2012 by Wolfram Sang
+ * same license as the driver
+ */
+
 #ifndef _LINUX_AT24_H
 #define _LINUX_AT24_H
 
 #include <linux/types.h>
 #include <linux/memory.h>
 
-/*
- * As seen through Linux I2C, differences between the most common types of I2C
- * memory include:
- * - How much memory is available (usually specified in bit)?
- * - What write page size does it support?
- * - Special flags (16 bit addresses, read_only, world readable...)?
+/**
+ * struct at24_platform_data - data to set up at24 (generic eeprom) driver
+ * @byte_len: size of eeprom in byte
+ * @page_size: number of byte which can be written in one go
+ * @flags: tunable options, check AT24_FLAG_* defines
+ * @setup: an optional callback invoked after eeprom is probed; enables kernel
+        code to access eeprom via memory_accessor, see example
+ * @context: optional parameter passed to setup()
  *
  * If you set up a custom eeprom type, please double-check the parameters.
  * Especially page_size needs extra care, as you risk data loss if your value
  * is bigger than what the chip actually supports!
+ *
+ * An example in pseudo code for a setup() callback:
+ *
+ * void get_mac_addr(struct memory_accessor *mem_acc, void *context)
+ * {
+ *      u8 *mac_addr = ethernet_pdata->mac_addr;
+ *      off_t offset = context;
+ *
+ *      // Read MAC addr from EEPROM
+ *      if (mem_acc->read(mem_acc, mac_addr, offset, ETH_ALEN) == ETH_ALEN)
+ *              pr_info("Read MAC addr from EEPROM: %pM\n", mac_addr);
+ * }
+ *
+ * This function pointer and context can now be set up in at24_platform_data.
  */
 
 struct at24_platform_data {
diff --git a/include/linux/i2c/tc35876x.h b/include/linux/i2c/tc35876x.h
new file mode 100644
index 000000000000..cd6a51c71e7e
--- /dev/null
+++ b/include/linux/i2c/tc35876x.h
@@ -0,0 +1,11 @@
+
+#ifndef _TC35876X_H
+#define _TC35876X_H
+
+struct tc35876x_platform_data {
+        int gpio_bridge_reset;
+        int gpio_panel_bl_en;
+        int gpio_panel_vadd;
+};
+
+#endif /* _TC35876X_H */
diff --git a/include/linux/i2c/twl.h b/include/linux/i2c/twl.h
index 78d3465251d6..2463b6100333 100644
--- a/include/linux/i2c/twl.h
+++ b/include/linux/i2c/twl.h
@@ -712,6 +712,9 @@ struct twl4030_platform_data {
         struct regulator_init_data              *vaux1;
         struct regulator_init_data              *vaux2;
         struct regulator_init_data              *vaux3;
+        struct regulator_init_data              *vdd1;
+        struct regulator_init_data              *vdd2;
+        struct regulator_init_data              *vdd3;
         /* TWL4030 LDO regulators */
         struct regulator_init_data              *vpll1;
         struct regulator_init_data              *vpll2;
@@ -720,8 +723,6 @@ struct twl4030_platform_data {
         struct regulator_init_data              *vsim;
         struct regulator_init_data              *vaux4;
         struct regulator_init_data              *vio;
-        struct regulator_init_data              *vdd1;
-        struct regulator_init_data              *vdd2;
         struct regulator_init_data              *vintana1;
         struct regulator_init_data              *vintana2;
         struct regulator_init_data              *vintdig;
@@ -733,6 +734,8 @@ struct twl4030_platform_data {
         struct regulator_init_data              *vcxio;
         struct regulator_init_data              *vusb;
         struct regulator_init_data              *clk32kg;
+        struct regulator_init_data              *v1v8;
+        struct regulator_init_data              *v2v1;
         /* TWL6025 LDO regulators */
         struct regulator_init_data              *ldo1;
         struct regulator_init_data              *ldo2;
@@ -749,9 +752,16 @@ struct twl4030_platform_data {
         struct regulator_init_data              *vio6025;
 };
 
+struct twl_regulator_driver_data {
+        int             (*set_voltage)(void *data, int target_uV);
+        int             (*get_voltage)(void *data);
+        void            *data;
+        unsigned long   features;
+};
+
 /*----------------------------------------------------------------------*/
 
-int twl4030_sih_setup(int module);
+int twl4030_sih_setup(struct device *dev, int module, int irq_base);
 
 /* Offsets to Power Registers */
 #define TWL4030_VDAC_DEV_GRP            0x3B
diff --git a/include/linux/i2o.h b/include/linux/i2o.h
index a6deef4f4f67..d23c3c20b201 100644
--- a/include/linux/i2o.h
+++ b/include/linux/i2o.h
@@ -24,6 +24,7 @@
 #define I2O_MAX_DRIVERS         8
 
 #include <linux/pci.h>
+#include <linux/bug.h>
 #include <linux/dma-mapping.h>
 #include <linux/string.h>
 #include <linux/slab.h>
diff --git a/include/linux/ide.h b/include/linux/ide.h
index 501370b61ee5..7afe15f916da 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -14,7 +14,6 @@
 #include <linux/interrupt.h>
 #include <linux/bitops.h>
 #include <linux/bio.h>
-#include <linux/device.h>
 #include <linux/pci.h>
 #include <linux/completion.h>
 #include <linux/pm.h>
@@ -43,6 +42,8 @@
 #define ERROR_RESET     3       /* Reset controller every 4th retry */
 #define ERROR_RECAL     1       /* Recalibrate every 2nd retry */
 
+struct device;
+
 /* Error codes returned in rq->errors to the higher part of the driver. */
 enum {
         IDE_DRV_ERROR_GENERAL   = 101,
diff --git a/include/linux/if.h b/include/linux/if.h
index 06b6ef60c821..f995c663c493 100644
--- a/include/linux/if.h
+++ b/include/linux/if.h
@@ -80,6 +80,8 @@
                                          * skbs on transmit */
 #define IFF_UNICAST_FLT 0x20000         /* Supports unicast filtering   */
 #define IFF_TEAM_PORT   0x40000         /* device used as team port */
+#define IFF_SUPP_NOFCS  0x80000         /* device supports sending custom FCS */
+
 
 #define IF_GET_IFACE    0x0001          /* for querying only */
 #define IF_GET_PROTO    0x0002
diff --git a/include/linux/if_ppp.h b/include/linux/if_ppp.h
index c9ad38322576..9048fabb7a4e 100644
--- a/include/linux/if_ppp.h
+++ b/include/linux/if_ppp.h
@@ -1,173 +1 @@
-/*
- * if_ppp.h - Point-to-Point Protocol definitions.
- *
- * Copyright (c) 1989 Carnegie Mellon University.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms are permitted
- * provided that the above copyright notice and this paragraph are
- * duplicated in all such forms and that any documentation,
- * advertising materials, and other materials related to such
- * distribution and use acknowledge that the software was developed
- * by Carnegie Mellon University.  The name of the
- * University may not be used to endorse or promote products derived
- * from this software without specific prior written permission.
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
- * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
- *
- */
-
-/*
- *  ==FILEVERSION 20050812==
- *
- *  NOTE TO MAINTAINERS:
- *     If you modify this file at all, please set the above date.
- *     if_ppp.h is shipped with a PPP distribution as well as with the kernel;
- *     if everyone increases the FILEVERSION number above, then scripts
- *     can do the right thing when deciding whether to install a new if_ppp.h
- *     file.  Don't change the format of that line otherwise, so the
- *     installation script can recognize it.
- */
-
-#ifndef _IF_PPP_H_
-#define _IF_PPP_H_
-
-#include <linux/types.h>
-#include <linux/compiler.h>
-
-/*
- * Packet sizes
- */
-
-#define PPP_MTU         1500    /* Default MTU (size of Info field) */
-#define PPP_MAXMRU      65000   /* Largest MRU we allow */
-#define PROTO_IPX       0x002b  /* protocol numbers */
-#define PROTO_DNA_RT    0x0027  /* DNA Routing */
-
-
-/*
- * Bit definitions for flags.
- */
-
-#define SC_COMP_PROT    0x00000001      /* protocol compression (output) */
-#define SC_COMP_AC      0x00000002      /* header compression (output) */
-#define SC_COMP_TCP     0x00000004      /* TCP (VJ) compression (output) */
-#define SC_NO_TCP_CCID  0x00000008      /* disable VJ connection-id comp. */
-#define SC_REJ_COMP_AC  0x00000010      /* reject adrs/ctrl comp. on input */
-#define SC_REJ_COMP_TCP 0x00000020      /* reject TCP (VJ) comp. on input */
-#define SC_CCP_OPEN     0x00000040      /* Look at CCP packets */
-#define SC_CCP_UP       0x00000080      /* May send/recv compressed packets */
-#define SC_ENABLE_IP    0x00000100      /* IP packets may be exchanged */
-#define SC_LOOP_TRAFFIC 0x00000200      /* send traffic to pppd */
-#define SC_MULTILINK    0x00000400      /* do multilink encapsulation */
-#define SC_MP_SHORTSEQ  0x00000800      /* use short MP sequence numbers */
-#define SC_COMP_RUN     0x00001000      /* compressor has been inited */
-#define SC_DECOMP_RUN   0x00002000      /* decompressor has been inited */
-#define SC_MP_XSHORTSEQ 0x00004000      /* transmit short MP seq numbers */
-#define SC_DEBUG        0x00010000      /* enable debug messages */
-#define SC_LOG_INPKT    0x00020000      /* log contents of good pkts recvd */
-#define SC_LOG_OUTPKT   0x00040000      /* log contents of pkts sent */
-#define SC_LOG_RAWIN    0x00080000      /* log all chars received */
-#define SC_LOG_FLUSH    0x00100000      /* log all chars flushed */
-#define SC_SYNC         0x00200000      /* synchronous serial mode */
-#define SC_MUST_COMP    0x00400000      /* no uncompressed packets may be sent or received */
-#define SC_MASK         0x0f600fff      /* bits that user can change */
-
-/* state bits */
-#define SC_XMIT_BUSY    0x10000000      /* (used by isdn_ppp?) */
-#define SC_RCV_ODDP     0x08000000      /* have rcvd char with odd parity */
-#define SC_RCV_EVNP     0x04000000      /* have rcvd char with even parity */
-#define SC_RCV_B7_1     0x02000000      /* have rcvd char with bit 7 = 1 */
-#define SC_RCV_B7_0     0x01000000      /* have rcvd char with bit 7 = 0 */
-#define SC_DC_FERROR    0x00800000      /* fatal decomp error detected */
-#define SC_DC_ERROR     0x00400000      /* non-fatal decomp error detected */
-
-/*
- * Ioctl definitions.
- */
-
-struct npioctl {
-        int             protocol;       /* PPP protocol, e.g. PPP_IP */
-        enum NPmode     mode;
-};
-
-/* Structure describing a CCP configuration option, for PPPIOCSCOMPRESS */
-struct ppp_option_data {
-        __u8    __user *ptr;
-        __u32   length;
-        int     transmit;
-};
-
-struct ifpppstatsreq {
-        struct ifreq     b;
-        struct ppp_stats stats;                 /* statistic information */
-};
-
-struct ifpppcstatsreq {
-        struct ifreq          b;
-        struct ppp_comp_stats stats;
-};
-
-/* For PPPIOCGL2TPSTATS */
-struct pppol2tp_ioc_stats {
-        __u16           tunnel_id;      /* redundant */
-        __u16           session_id;     /* if zero, get tunnel stats */
-        __u32           using_ipsec:1;  /* valid only for session_id == 0 */
-        __aligned_u64   tx_packets;
-        __aligned_u64   tx_bytes;
-        __aligned_u64   tx_errors;
-        __aligned_u64   rx_packets;
-        __aligned_u64   rx_bytes;
-        __aligned_u64   rx_seq_discards;
-        __aligned_u64   rx_oos_packets;
-        __aligned_u64   rx_errors;
-};
-
-#define ifr__name       b.ifr_ifrn.ifrn_name
-#define stats_ptr       b.ifr_ifru.ifru_data
-
-/*
- * Ioctl definitions.
- */
-
-#define PPPIOCGFLAGS    _IOR('t', 90, int)      /* get configuration flags */
-#define PPPIOCSFLAGS    _IOW('t', 89, int)      /* set configuration flags */
-#define PPPIOCGASYNCMAP _IOR('t', 88, int)      /* get async map */
-#define PPPIOCSASYNCMAP _IOW('t', 87, int)      /* set async map */
-#define PPPIOCGUNIT     _IOR('t', 86, int)      /* get ppp unit number */
-#define PPPIOCGRASYNCMAP _IOR('t', 85, int)     /* get receive async map */
-#define PPPIOCSRASYNCMAP _IOW('t', 84, int)     /* set receive async map */
-#define PPPIOCGMRU      _IOR('t', 83, int)      /* get max receive unit */
-#define PPPIOCSMRU      _IOW('t', 82, int)      /* set max receive unit */
-#define PPPIOCSMAXCID   _IOW('t', 81, int)      /* set VJ max slot ID */
-#define PPPIOCGXASYNCMAP _IOR('t', 80, ext_accm) /* get extended ACCM */
-#define PPPIOCSXASYNCMAP _IOW('t', 79, ext_accm) /* set extended ACCM */
-#define PPPIOCXFERUNIT  _IO('t', 78)            /* transfer PPP unit */
-#define PPPIOCSCOMPRESS _IOW('t', 77, struct ppp_option_data)
-#define PPPIOCGNPMODE   _IOWR('t', 76, struct npioctl) /* get NP mode */
-#define PPPIOCSNPMODE   _IOW('t', 75, struct npioctl)  /* set NP mode */
-#define PPPIOCSPASS     _IOW('t', 71, struct sock_fprog) /* set pass filter */
-#define PPPIOCSACTIVE   _IOW('t', 70, struct sock_fprog) /* set active filt */
-#define PPPIOCGDEBUG    _IOR('t', 65, int)      /* Read debug level */
-#define PPPIOCSDEBUG    _IOW('t', 64, int)      /* Set debug level */
-#define PPPIOCGIDLE     _IOR('t', 63, struct ppp_idle) /* get idle time */
-#define PPPIOCNEWUNIT   _IOWR('t', 62, int)     /* create new ppp unit */
-#define PPPIOCATTACH    _IOW('t', 61, int)      /* attach to ppp unit */
-#define PPPIOCDETACH    _IOW('t', 60, int)      /* detach from ppp unit/chan */
-#define PPPIOCSMRRU     _IOW('t', 59, int)      /* set multilink MRU */
-#define PPPIOCCONNECT   _IOW('t', 58, int)      /* connect channel to unit */
-#define PPPIOCDISCONN   _IO('t', 57)            /* disconnect channel */
-#define PPPIOCATTCHAN   _IOW('t', 56, int)      /* attach to ppp channel */
-#define PPPIOCGCHAN     _IOR('t', 55, int)      /* get ppp channel number */
-#define PPPIOCGL2TPSTATS _IOR('t', 54, struct pppol2tp_ioc_stats)
-
-#define SIOCGPPPSTATS   (SIOCDEVPRIVATE + 0)
-#define SIOCGPPPVER     (SIOCDEVPRIVATE + 1)    /* NEVER change this!! */
-#define SIOCGPPPCSTATS  (SIOCDEVPRIVATE + 2)
-
-#if !defined(ifr_mtu)
-#define ifr_mtu ifr_ifru.ifru_metric
-#endif
-
-#endif /* _IF_PPP_H_ */
+#include <linux/ppp-ioctl.h>
diff --git a/include/linux/if_vlan.h b/include/linux/if_vlan.h
index 13aff1e2183b..a810987cb80e 100644
--- a/include/linux/if_vlan.h
+++ b/include/linux/if_vlan.h
@@ -17,11 +17,11 @@
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>
 #include <linux/rtnetlink.h>
+#include <linux/bug.h>
 
-#define VLAN_HLEN       4               /* The additional bytes (on top of the Ethernet header)
-                                         * that VLAN requires.
+#define VLAN_HLEN       4               /* The additional bytes required by VLAN
+                                         * (in addition to the Ethernet header)
                                          */
-#define VLAN_ETH_ALEN   6               /* Octets in one ethernet addr   */
 #define VLAN_ETH_HLEN   18              /* Total octets in header.       */
 #define VLAN_ETH_ZLEN   64              /* Min. octets in frame sans FCS */
 
@@ -177,7 +177,7 @@ static inline struct sk_buff *vlan_insert_tag(struct sk_buff *skb, u16 vlan_tci)
         veth = (struct vlan_ethhdr *)skb_push(skb, VLAN_HLEN);
 
         /* Move the mac addresses to the beginning of the new header. */
-        memmove(skb->data, skb->data + VLAN_HLEN, 2 * VLAN_ETH_ALEN);
+        memmove(skb->data, skb->data + VLAN_HLEN, 2 * ETH_ALEN);
         skb->mac_header -= VLAN_HLEN;
 
         /* first, the ethernet type */
diff --git a/include/linux/in.h b/include/linux/in.h
index 01129c0ea87c..e0337f11d92e 100644
--- a/include/linux/in.h
+++ b/include/linux/in.h
@@ -111,6 +111,7 @@ struct in_addr {
 #define MCAST_LEAVE_SOURCE_GROUP        47
 #define MCAST_MSFILTER                  48
 #define IP_MULTICAST_ALL                49
+#define IP_UNICAST_IF                   50
 
 #define MCAST_EXCLUDE   0
 #define MCAST_INCLUDE   1
diff --git a/include/linux/in6.h b/include/linux/in6.h
index 097a34b55560..5c83d9e3eb8f 100644
--- a/include/linux/in6.h
+++ b/include/linux/in6.h
@@ -271,6 +271,7 @@ struct in6_flowlabel_req {
 #define IPV6_ORIGDSTADDR        74
 #define IPV6_RECVORIGDSTADDR    IPV6_ORIGDSTADDR
 #define IPV6_TRANSPARENT        75
+#define IPV6_UNICAST_IF         76
 
 /*
  * Multicast Routing:
diff --git a/include/linux/inetdevice.h b/include/linux/inetdevice.h
index 5f8146695b7f..597f4a9f3240 100644
--- a/include/linux/inetdevice.h
+++ b/include/linux/inetdevice.h
@@ -139,6 +139,7 @@ static inline void ipv4_devconf_setall(struct in_device *in_dev)
           IN_DEV_ORCONF((in_dev), ACCEPT_REDIRECTS)))
 
 #define IN_DEV_ARPFILTER(in_dev)        IN_DEV_ORCONF((in_dev), ARPFILTER)
+#define IN_DEV_ARP_ACCEPT(in_dev)       IN_DEV_ORCONF((in_dev), ARP_ACCEPT)
 #define IN_DEV_ARP_ANNOUNCE(in_dev)     IN_DEV_MAXCONF((in_dev), ARP_ANNOUNCE)
 #define IN_DEV_ARP_IGNORE(in_dev)       IN_DEV_MAXCONF((in_dev), ARP_IGNORE)
 #define IN_DEV_ARP_NOTIFY(in_dev)       IN_DEV_MAXCONF((in_dev), ARP_NOTIFY)
diff --git a/include/linux/init_task.h b/include/linux/init_task.h
index 9c66b1ada9d7..e4baff5f7ff4 100644
--- a/include/linux/init_task.h
+++ b/include/linux/init_task.h
@@ -29,6 +29,13 @@ extern struct fs_struct init_fs;
 #define INIT_GROUP_RWSEM(sig)
 #endif
 
+#ifdef CONFIG_CPUSETS
+#define INIT_CPUSET_SEQ                                                 \
+        .mems_allowed_seq = SEQCNT_ZERO,
+#else
+#define INIT_CPUSET_SEQ
+#endif
+
 #define INIT_SIGNALS(sig) {                                             \
         .nr_threads     = 1,                                            \
         .wait_chldexit  = __WAIT_QUEUE_HEAD_INITIALIZER(sig.wait_chldexit),\
@@ -149,7 +156,7 @@ extern struct cred init_cred;
         },                                                              \
         .rt             = {                                             \
                 .run_list       = LIST_HEAD_INIT(tsk.rt.run_list),      \
-                .time_slice     = HZ,                                   \
+                .time_slice     = RR_TIMESLICE,                         \
                 .nr_cpus_allowed = NR_CPUS,                             \
         },                                                              \
         .tasks          = LIST_HEAD_INIT(tsk.tasks),                    \
@@ -192,6 +199,7 @@ extern struct cred init_cred;
         INIT_FTRACE_GRAPH                                               \
         INIT_TRACE_RECURSION                                            \
         INIT_TASK_RCU_PREEMPT(tsk)                                      \
+        INIT_CPUSET_SEQ                                                 \
 }
 
 
diff --git a/include/linux/input.h b/include/linux/input.h
index 3862e32c4eeb..a81671453575 100644
--- a/include/linux/input.h
+++ b/include/linux/input.h
@@ -114,6 +114,31 @@ struct input_keymap_entry {
 #define EVIOCGUNIQ(len)         _IOC(_IOC_READ, 'E', 0x08, len)         /* get unique identifier */
 #define EVIOCGPROP(len)         _IOC(_IOC_READ, 'E', 0x09, len)         /* get device properties */
 
+/**
+ * EVIOCGMTSLOTS(len) - get MT slot values
+ *
+ * The ioctl buffer argument should be binary equivalent to
+ *
+ * struct input_mt_request_layout {
+ *      __u32 code;
+ *      __s32 values[num_slots];
+ * };
+ *
+ * where num_slots is the (arbitrary) number of MT slots to extract.
+ *
+ * The ioctl size argument (len) is the size of the buffer, which
+ * should satisfy len = (num_slots + 1) * sizeof(__s32).  If len is
+ * too small to fit all available slots, the first num_slots are
+ * returned.
+ *
+ * Before the call, code is set to the wanted ABS_MT event type. On
+ * return, values[] is filled with the slot values for the specified
+ * ABS_MT code.
+ *
+ * If the request code is not an ABS_MT value, -EINVAL is returned.
+ */
+#define EVIOCGMTSLOTS(len)      _IOC(_IOC_READ, 'E', 0x0a, len)
+
 #define EVIOCGKEY(len)          _IOC(_IOC_READ, 'E', 0x18, len)         /* get global key state */
 #define EVIOCGLED(len)          _IOC(_IOC_READ, 'E', 0x19, len)         /* get all LEDs */
 #define EVIOCGSND(len)          _IOC(_IOC_READ, 'E', 0x1a, len)         /* get all sounds status */
@@ -129,6 +154,8 @@ struct input_keymap_entry {
 
 #define EVIOCGRAB               _IOW('E', 0x90, int)                    /* Grab/Release device */
 
+#define EVIOCSCLOCKID           _IOW('E', 0xa0, int)                    /* Set clockid to be used for timestamps */
+
 /*
  * Device properties and quirks
  */
diff --git a/include/linux/input/cyttsp.h b/include/linux/input/cyttsp.h
new file mode 100644
index 000000000000..5af7c66f1fca
--- /dev/null
+++ b/include/linux/input/cyttsp.h
@@ -0,0 +1,58 @@
+/*
+ * Header file for:
+ * Cypress TrueTouch(TM) Standard Product (TTSP) touchscreen drivers.
+ * For use with Cypress Txx3xx parts.
+ * Supported parts include:
+ * CY8CTST341
+ * CY8CTMA340
+ *
+ * Copyright (C) 2009, 2010, 2011 Cypress Semiconductor, Inc.
+ * Copyright (C) 2012 Javier Martinez Canillas <javier@dowhile0.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2, and only version 2, as published by the
+ * Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * 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.
+ *
+ * Contact Cypress Semiconductor at www.cypress.com (kev@cypress.com)
+ *
+ */
+#ifndef _CYTTSP_H_
+#define _CYTTSP_H_
+
+#define CY_SPI_NAME "cyttsp-spi"
+#define CY_I2C_NAME "cyttsp-i2c"
+/* Active Power state scanning/processing refresh interval */
+#define CY_ACT_INTRVL_DFLT 0x00 /* ms */
+/* touch timeout for the Active power */
+#define CY_TCH_TMOUT_DFLT 0xFF /* ms */
+/* Low Power state scanning/processing refresh interval */
+#define CY_LP_INTRVL_DFLT 0x0A /* ms */
+/* Active distance in pixels for a gesture to be reported */
+#define CY_ACT_DIST_DFLT 0xF8 /* pixels */
+
+struct cyttsp_platform_data {
+        u32 maxx;
+        u32 maxy;
+        bool use_hndshk;
+        u8 act_dist;    /* Active distance */
+        u8 act_intrvl;  /* Active refresh interval; ms */
+        u8 tch_tmout;   /* Active touch timeout; ms */
+        u8 lp_intrvl;   /* Low power refresh interval; ms */
+        int (*init)(void);
+        void (*exit)(void);
+        char *name;
+        s16 irq_gpio;
+        u8 *bl_keys;
+};
+
+#endif /* _CYTTSP_H_ */
diff --git a/include/linux/input/ili210x.h b/include/linux/input/ili210x.h
new file mode 100644
index 000000000000..a5471245a13c
--- /dev/null
+++ b/include/linux/input/ili210x.h
@@ -0,0 +1,10 @@
+#ifndef _ILI210X_H
+#define _ILI210X_H
+
+struct ili210x_platform_data {
+        unsigned long irq_flags;
+        unsigned int poll_period;
+        bool (*get_pendown_state)(void);
+};
+
+#endif
diff --git a/include/linux/input/kxtj9.h b/include/linux/input/kxtj9.h
index f6bac89537b8..d415579b56fe 100644
--- a/include/linux/input/kxtj9.h
+++ b/include/linux/input/kxtj9.h
@@ -24,6 +24,7 @@
 
 struct kxtj9_platform_data {
         unsigned int min_interval;      /* minimum poll interval (in milli-seconds) */
+        unsigned int init_interval;     /* initial poll interval (in milli-seconds) */
 
         /*
          * By default, x is axis 0, y is axis 1, z is axis 2; these can be
@@ -52,16 +53,6 @@ struct kxtj9_platform_data {
         #define KXTJ9_G_8G              (1 << 4)
         u8 g_range;
 
-        /* DATA_CTRL_REG: controls the output data rate of the part */
-        #define ODR12_5F                0
-        #define ODR25F                  1
-        #define ODR50F                  2
-        #define ODR100F                 3
-        #define ODR200F                 4
-        #define ODR400F                 5
-        #define ODR800F                 6
-        u8 data_odr_init;
-
         int (*init)(void);
         void (*exit)(void);
         int (*power_on)(void);
diff --git a/include/linux/input/matrix_keypad.h b/include/linux/input/matrix_keypad.h
index fe7c4b9ae270..6c07ced0af81 100644
--- a/include/linux/input/matrix_keypad.h
+++ b/include/linux/input/matrix_keypad.h
@@ -3,6 +3,7 @@
 
 #include <linux/types.h>
 #include <linux/input.h>
+#include <linux/of.h>
 
 #define MATRIX_MAX_ROWS         32
 #define MATRIX_MAX_COLS         32
@@ -106,4 +107,22 @@ matrix_keypad_build_keymap(const struct matrix_keymap_data *keymap_data,
         __clear_bit(KEY_RESERVED, keybit);
 }
 
+#ifdef CONFIG_INPUT_OF_MATRIX_KEYMAP
+struct matrix_keymap_data *
+matrix_keyboard_of_fill_keymap(struct device_node *np, const char *propname);
+
+void matrix_keyboard_of_free_keymap(const struct matrix_keymap_data *kd);
+#else
+static inline struct matrix_keymap_data *
+matrix_keyboard_of_fill_keymap(struct device_node *np, const char *propname)
+{
+        return NULL;
+}
+
+static inline void
+matrix_keyboard_of_free_keymap(const struct matrix_keymap_data *kd)
+{
+}
+#endif
+
 #endif /* _MATRIX_KEYPAD_H */
diff --git a/include/linux/input/mt.h b/include/linux/input/mt.h
index 318bb82325a6..f86737586e19 100644
--- a/include/linux/input/mt.h
+++ b/include/linux/input/mt.h
@@ -48,10 +48,14 @@ static inline void input_mt_slot(struct input_dev *dev, int slot)
         input_event(dev, EV_ABS, ABS_MT_SLOT, slot);
 }
 
+static inline bool input_is_mt_value(int axis)
+{
+        return axis >= ABS_MT_FIRST && axis <= ABS_MT_LAST;
+}
+
 static inline bool input_is_mt_axis(int axis)
 {
-        return axis == ABS_MT_SLOT ||
-                (axis >= ABS_MT_FIRST && axis <= ABS_MT_LAST);
+        return axis == ABS_MT_SLOT || input_is_mt_value(axis);
 }
 
 void input_mt_report_slot_state(struct input_dev *dev,
diff --git a/include/linux/input/ti_tscadc.h b/include/linux/input/ti_tscadc.h
new file mode 100644
index 000000000000..b10a527a92a4
--- /dev/null
+++ b/include/linux/input/ti_tscadc.h
@@ -0,0 +1,17 @@
+#ifndef __LINUX_TI_TSCADC_H
+#define __LINUX_TI_TSCADC_H
+
+/**
+ * struct tsc_data      Touchscreen wire configuration
+ * @wires:              Wires refer to application modes
+ *                      i.e. 4/5/8 wire touchscreen support
+ *                      on the platform.
+ * @x_plate_resistance: X plate resistance.
+ */
+
+struct tsc_data {
+        int wires;
+        int x_plate_resistance;
+};
+
+#endif
diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h
index a64b00e286f5..3f830e005118 100644
--- a/include/linux/interrupt.h
+++ b/include/linux/interrupt.h
@@ -20,7 +20,6 @@
 #include <linux/atomic.h>
 #include <asm/ptrace.h>
 #include <asm/system.h>
-#include <trace/events/irq.h>
 
 /*
  * These correspond to the IORESOURCE_IRQ_* defines in
@@ -456,11 +455,7 @@ asmlinkage void do_softirq(void);
 asmlinkage void __do_softirq(void);
 extern void open_softirq(int nr, void (*action)(struct softirq_action *));
 extern void softirq_init(void);
-static inline void __raise_softirq_irqoff(unsigned int nr)
-{
-        trace_softirq_raise(nr);
-        or_softirq_pending(1UL << nr);
-}
+extern void __raise_softirq_irqoff(unsigned int nr);
 
 extern void raise_softirq_irqoff(unsigned int nr);
 extern void raise_softirq(unsigned int nr);
diff --git a/include/linux/io-mapping.h b/include/linux/io-mapping.h
index e44e84f0156c..657fab4efab3 100644
--- a/include/linux/io-mapping.h
+++ b/include/linux/io-mapping.h
@@ -20,6 +20,7 @@
 
 #include <linux/types.h>
 #include <linux/slab.h>
+#include <linux/bug.h>
 #include <asm/io.h>
 #include <asm/page.h>
 
diff --git a/include/linux/ioport.h b/include/linux/ioport.h
index 9d57a71775b5..e885ba23de70 100644
--- a/include/linux/ioport.h
+++ b/include/linux/ioport.h
@@ -23,12 +23,6 @@ struct resource {
         struct resource *parent, *sibling, *child;
 };
 
-struct resource_list {
-        struct resource_list *next;
-        struct resource *res;
-        struct pci_dev *dev;
-};
-
 /*
  * IO resources have these defined flags.
  */
diff --git a/include/linux/ipmi.h b/include/linux/ipmi.h
index bbd156bb953b..48dcba9b2065 100644
--- a/include/linux/ipmi.h
+++ b/include/linux/ipmi.h
@@ -220,10 +220,10 @@ struct kernel_ipmi_msg {
  * The in-kernel interface.
  */
 #include <linux/list.h>
-#include <linux/device.h>
 #include <linux/proc_fs.h>
 
 struct module;
+struct device;
 
 /* Opaque type for a IPMI message user.  One of these is needed to
    send and receive messages. */
diff --git a/include/linux/ipmi_smi.h b/include/linux/ipmi_smi.h
index 3ef0d8b6aa6f..fcb5d44ea635 100644
--- a/include/linux/ipmi_smi.h
+++ b/include/linux/ipmi_smi.h
@@ -36,10 +36,11 @@
 
 #include <linux/ipmi_msgdefs.h>
 #include <linux/proc_fs.h>
-#include <linux/device.h>
 #include <linux/platform_device.h>
 #include <linux/ipmi.h>
 
+struct device;
+
 /* This files describes the interface for IPMI system management interface
    drivers to bind into the IPMI message handler. */
 
diff --git a/include/linux/ipv6.h b/include/linux/ipv6.h
index 6318268dcaf5..8260ef779762 100644
--- a/include/linux/ipv6.h
+++ b/include/linux/ipv6.h
@@ -233,6 +233,11 @@ static inline struct ipv6hdr *ipipv6_hdr(const struct sk_buff *skb)
         return (struct ipv6hdr *)skb_transport_header(skb);
 }
 
+static inline __u8 ipv6_tclass(const struct ipv6hdr *iph)
+{
+        return (ntohl(*(__be32 *)iph) >> 20) & 0xff;
+}
+
 /* 
    This structure contains results of exthdrs parsing
    as offsets from skb->nh.
@@ -324,6 +329,7 @@ struct ipv6_pinfo {
                                 __unused_2:6;
         __s16                   mcast_hops:9;
 #endif
+        int                     ucast_oif;
         int                     mcast_oif;
 
         /* pktoption flags */
@@ -360,7 +366,7 @@ struct ipv6_pinfo {
                                 dontfrag:1;
         __u8                    min_hopcount;
         __u8                    tclass;
-        __u8                    padding;
+        __u8                    rcv_tclass;
 
         __u32                   dst_cookie;
 
diff --git a/include/linux/irqdomain.h b/include/linux/irqdomain.h
index bd4272b61a14..ead4a4215797 100644
--- a/include/linux/irqdomain.h
+++ b/include/linux/irqdomain.h
@@ -9,99 +9,182 @@
  * representation into a hardware irq number that can be mapped back to a
  * Linux irq number without any extra platform support code.
  *
- * irq_domain is expected to be embedded in an interrupt controller's private
- * data structure.
+ * Interrupt controller "domain" data structure. This could be defined as a
+ * irq domain controller. That is, it handles the mapping between hardware
+ * and virtual interrupt numbers for a given interrupt domain. The domain
+ * structure is generally created by the PIC code for a given PIC instance
+ * (though a domain can cover more than one PIC if they have a flat number
+ * model). It's the domain callbacks that are responsible for setting the
+ * irq_chip on a given irq_desc after it's been mapped.
+ *
+ * The host code and data structures are agnostic to whether or not
+ * we use an open firmware device-tree. We do have references to struct
+ * device_node in two places: in irq_find_host() to find the host matching
+ * a given interrupt controller node, and of course as an argument to its
+ * counterpart domain->ops->match() callback. However, those are treated as
+ * generic pointers by the core and the fact that it's actually a device-node
+ * pointer is purely a convention between callers and implementation. This
+ * code could thus be used on other architectures by replacing those two
+ * by some sort of arch-specific void * "token" used to identify interrupt
+ * controllers.
  */
+
 #ifndef _LINUX_IRQDOMAIN_H
 #define _LINUX_IRQDOMAIN_H
 
-#include <linux/irq.h>
-#include <linux/mod_devicetable.h>
+#include <linux/types.h>
+#include <linux/radix-tree.h>
 
-#ifdef CONFIG_IRQ_DOMAIN
 struct device_node;
 struct irq_domain;
+struct of_device_id;
+
+/* Number of irqs reserved for a legacy isa controller */
+#define NUM_ISA_INTERRUPTS      16
+
+/* This type is the placeholder for a hardware interrupt number. It has to
+ * be big enough to enclose whatever representation is used by a given
+ * platform.
+ */
+typedef unsigned long irq_hw_number_t;
 
 /**
  * struct irq_domain_ops - Methods for irq_domain objects
- * @to_irq: (optional) given a local hardware irq number, return the linux
- *          irq number.  If to_irq is not implemented, then the irq_domain
- *          will use this translation: irq = (domain->irq_base + hwirq)
- * @dt_translate: Given a device tree node and interrupt specifier, decode
- *                the hardware irq number and linux irq type value.
+ * @match: Match an interrupt controller device node to a host, returns
+ *         1 on a match
+ * @map: Create or update a mapping between a virtual irq number and a hw
+ *       irq number. This is called only once for a given mapping.
+ * @unmap: Dispose of such a mapping
+ * @xlate: Given a device tree node and interrupt specifier, decode
+ *         the hardware irq number and linux irq type value.
+ *
+ * Functions below are provided by the driver and called whenever a new mapping
+ * is created or an old mapping is disposed. The driver can then proceed to
+ * whatever internal data structures management is required. It also needs
+ * to setup the irq_desc when returning from map().
  */
 struct irq_domain_ops {
-        unsigned int (*to_irq)(struct irq_domain *d, unsigned long hwirq);
-
-#ifdef CONFIG_OF
-        int (*dt_translate)(struct irq_domain *d, struct device_node *node,
-                            const u32 *intspec, unsigned int intsize,
-                            unsigned long *out_hwirq, unsigned int *out_type);
-#endif /* CONFIG_OF */
+        int (*match)(struct irq_domain *d, struct device_node *node);
+        int (*map)(struct irq_domain *d, unsigned int virq, irq_hw_number_t hw);
+        void (*unmap)(struct irq_domain *d, unsigned int virq);
+        int (*xlate)(struct irq_domain *d, struct device_node *node,
+                     const u32 *intspec, unsigned int intsize,
+                     unsigned long *out_hwirq, unsigned int *out_type);
 };
 
 /**
  * struct irq_domain - Hardware interrupt number translation object
- * @list: Element in global irq_domain list.
+ * @link: Element in global irq_domain list.
+ * @revmap_type: Method used for reverse mapping hwirq numbers to linux irq. This
+ *               will be one of the IRQ_DOMAIN_MAP_* values.
+ * @revmap_data: Revmap method specific data.
+ * @ops: pointer to irq_domain methods
+ * @host_data: private data pointer for use by owner.  Not touched by irq_domain
+ *             core code.
  * @irq_base: Start of irq_desc range assigned to the irq_domain.  The creator
  *            of the irq_domain is responsible for allocating the array of
  *            irq_desc structures.
  * @nr_irq: Number of irqs managed by the irq domain
  * @hwirq_base: Starting number for hwirqs managed by the irq domain
- * @ops: pointer to irq_domain methods
- * @priv: private data pointer for use by owner.  Not touched by irq_domain
- *        core code.
  * @of_node: (optional) Pointer to device tree nodes associated with the
  *           irq_domain.  Used when decoding device tree interrupt specifiers.
  */
 struct irq_domain {
-        struct list_head list;
-        unsigned int irq_base;
-        unsigned int nr_irq;
-        unsigned int hwirq_base;
+        struct list_head link;
+
+        /* type of reverse mapping_technique */
+        unsigned int revmap_type;
+        union {
+                struct {
+                        unsigned int size;
+                        unsigned int first_irq;
+                        irq_hw_number_t first_hwirq;
+                } legacy;
+                struct {
+                        unsigned int size;
+                        unsigned int *revmap;
+                } linear;
+                struct radix_tree_root tree;
+        } revmap_data;
         const struct irq_domain_ops *ops;
-        void *priv;
+        void *host_data;
+        irq_hw_number_t inval_irq;
+
+        /* Optional device node pointer */
         struct device_node *of_node;
 };
 
-/**
- * irq_domain_to_irq() - Translate from a hardware irq to a linux irq number
- *
- * Returns the linux irq number associated with a hardware irq.  By default,
- * the mapping is irq == domain->irq_base + hwirq, but this mapping can
- * be overridden if the irq_domain implements a .to_irq() hook.
- */
-static inline unsigned int irq_domain_to_irq(struct irq_domain *d,
-                                             unsigned long hwirq)
+#ifdef CONFIG_IRQ_DOMAIN
+struct irq_domain *irq_domain_add_legacy(struct device_node *of_node,
+                                         unsigned int size,
+                                         unsigned int first_irq,
+                                         irq_hw_number_t first_hwirq,
+                                         const struct irq_domain_ops *ops,
+                                         void *host_data);
+struct irq_domain *irq_domain_add_linear(struct device_node *of_node,
+                                         unsigned int size,
+                                         const struct irq_domain_ops *ops,
+                                         void *host_data);
+struct irq_domain *irq_domain_add_nomap(struct device_node *of_node,
+                                         const struct irq_domain_ops *ops,
+                                         void *host_data);
+struct irq_domain *irq_domain_add_tree(struct device_node *of_node,
+                                         const struct irq_domain_ops *ops,
+                                         void *host_data);
+
+extern struct irq_domain *irq_find_host(struct device_node *node);
+extern void irq_set_default_host(struct irq_domain *host);
+extern void irq_set_virq_count(unsigned int count);
+
+static inline struct irq_domain *irq_domain_add_legacy_isa(
+                                struct device_node *of_node,
+                                const struct irq_domain_ops *ops,
+                                void *host_data)
 {
-        if (d->ops->to_irq)
-                return d->ops->to_irq(d, hwirq);
-        if (WARN_ON(hwirq < d->hwirq_base))
-                return 0;
-        return d->irq_base + hwirq - d->hwirq_base;
+        return irq_domain_add_legacy(of_node, NUM_ISA_INTERRUPTS, 0, 0, ops,
+                                     host_data);
 }
+extern struct irq_domain *irq_find_host(struct device_node *node);
+extern void irq_set_default_host(struct irq_domain *host);
+extern void irq_set_virq_count(unsigned int count);
 
-#define irq_domain_for_each_hwirq(d, hw) \
-        for (hw = d->hwirq_base; hw < d->hwirq_base + d->nr_irq; hw++)
 
-#define irq_domain_for_each_irq(d, hw, irq) \
-        for (hw = d->hwirq_base, irq = irq_domain_to_irq(d, hw); \
-             hw < d->hwirq_base + d->nr_irq; \
-             hw++, irq = irq_domain_to_irq(d, hw))
+extern unsigned int irq_create_mapping(struct irq_domain *host,
+                                       irq_hw_number_t hwirq);
+extern void irq_dispose_mapping(unsigned int virq);
+extern unsigned int irq_find_mapping(struct irq_domain *host,
+                                     irq_hw_number_t hwirq);
+extern unsigned int irq_create_direct_mapping(struct irq_domain *host);
+extern void irq_radix_revmap_insert(struct irq_domain *host, unsigned int virq,
+                                    irq_hw_number_t hwirq);
+extern unsigned int irq_radix_revmap_lookup(struct irq_domain *host,
+                                            irq_hw_number_t hwirq);
+extern unsigned int irq_linear_revmap(struct irq_domain *host,
+                                      irq_hw_number_t hwirq);
 
-extern void irq_domain_add(struct irq_domain *domain);
-extern void irq_domain_del(struct irq_domain *domain);
+extern const struct irq_domain_ops irq_domain_simple_ops;
 
-extern struct irq_domain_ops irq_domain_simple_ops;
-#endif /* CONFIG_IRQ_DOMAIN */
+/* stock xlate functions */
+int irq_domain_xlate_onecell(struct irq_domain *d, struct device_node *ctrlr,
+                        const u32 *intspec, unsigned int intsize,
+                        irq_hw_number_t *out_hwirq, unsigned int *out_type);
+int irq_domain_xlate_twocell(struct irq_domain *d, struct device_node *ctrlr,
+                        const u32 *intspec, unsigned int intsize,
+                        irq_hw_number_t *out_hwirq, unsigned int *out_type);
+int irq_domain_xlate_onetwocell(struct irq_domain *d, struct device_node *ctrlr,
+                        const u32 *intspec, unsigned int intsize,
+                        irq_hw_number_t *out_hwirq, unsigned int *out_type);
 
-#if defined(CONFIG_IRQ_DOMAIN) && defined(CONFIG_OF_IRQ)
-extern void irq_domain_add_simple(struct device_node *controller, int irq_base);
+#if defined(CONFIG_OF_IRQ)
 extern void irq_domain_generate_simple(const struct of_device_id *match,
                                         u64 phys_base, unsigned int irq_start);
-#else /* CONFIG_IRQ_DOMAIN && CONFIG_OF_IRQ */
+#else /* CONFIG_OF_IRQ */
 static inline void irq_domain_generate_simple(const struct of_device_id *match,
                                         u64 phys_base, unsigned int irq_start) { }
-#endif /* CONFIG_IRQ_DOMAIN && CONFIG_OF_IRQ */
+#endif /* !CONFIG_OF_IRQ */
+
+#else /* CONFIG_IRQ_DOMAIN */
+static inline void irq_dispose_mapping(unsigned int virq) { }
+#endif /* !CONFIG_IRQ_DOMAIN */
 
 #endif /* _LINUX_IRQDOMAIN_H */
diff --git a/include/linux/isdn.h b/include/linux/isdn.h
index 4ccf95d681b4..292f27a793d4 100644
--- a/include/linux/isdn.h
+++ b/include/linux/isdn.h
@@ -187,7 +187,7 @@ typedef struct {
 #endif
 
 #include <linux/ppp_defs.h>
-#include <linux/if_ppp.h>
+#include <linux/ppp-ioctl.h>
 
 #include <linux/isdn_ppp.h>
 #endif
diff --git a/include/linux/ivtv.h b/include/linux/ivtv.h
index 062d20f74322..42bf725751af 100644
--- a/include/linux/ivtv.h
+++ b/include/linux/ivtv.h
@@ -58,7 +58,11 @@ struct ivtv_dma_frame {
         __u32 src_height;
 };
 
-#define IVTV_IOC_DMA_FRAME  _IOW ('V', BASE_VIDIOC_PRIVATE+0, struct ivtv_dma_frame)
+#define IVTV_IOC_DMA_FRAME              _IOW ('V', BASE_VIDIOC_PRIVATE+0, struct ivtv_dma_frame)
+
+/* Select the passthrough mode (if the argument is non-zero). In the passthrough
+   mode the output of the encoder is passed immediately into the decoder. */
+#define IVTV_IOC_PASSTHROUGH_MODE       _IOW ('V', BASE_VIDIOC_PRIVATE+1, int)
 
 /* Deprecated defines: applications should use the defines from videodev2.h */
 #define IVTV_SLICED_TYPE_TELETEXT_B     V4L2_MPEG_VBI_IVTV_TELETEXT_B
diff --git a/include/linux/jbd2.h b/include/linux/jbd2.h
index 5557baefed60..912c30a8ddb1 100644
--- a/include/linux/jbd2.h
+++ b/include/linux/jbd2.h
@@ -971,6 +971,10 @@ extern void __journal_clean_data_list(transaction_t *transaction);
 /* Log buffer allocation */
 extern struct journal_head * jbd2_journal_get_descriptor_buffer(journal_t *);
 int jbd2_journal_next_log_block(journal_t *, unsigned long long *);
+int jbd2_journal_get_log_tail(journal_t *journal, tid_t *tid,
+                              unsigned long *block);
+void __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
+void jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
 
 /* Commit management */
 extern void jbd2_journal_commit_transaction(journal_t *);
@@ -1020,6 +1024,11 @@ jbd2_journal_write_metadata_buffer(transaction_t	  *transaction,
 /* Transaction locking */
 extern void             __wait_on_journal (journal_t *);
 
+/* Transaction cache support */
+extern void jbd2_journal_destroy_transaction_cache(void);
+extern int  jbd2_journal_init_transaction_cache(void);
+extern void jbd2_journal_free_transaction(transaction_t *);
+
 /*
  * Journal locking.
  *
@@ -1082,7 +1091,8 @@ extern int	   jbd2_journal_destroy    (journal_t *);
 extern int         jbd2_journal_recover    (journal_t *journal);
 extern int         jbd2_journal_wipe       (journal_t *, int);
 extern int         jbd2_journal_skip_recovery   (journal_t *);
-extern void        jbd2_journal_update_superblock       (journal_t *, int);
+extern void        jbd2_journal_update_sb_log_tail      (journal_t *, tid_t,
+                                unsigned long, int);
 extern void        __jbd2_journal_abort_hard    (journal_t *);
 extern void        jbd2_journal_abort      (journal_t *, int);
 extern int         jbd2_journal_errno      (journal_t *);
diff --git a/include/linux/journal-head.h b/include/linux/journal-head.h
index 423cb6d78ee0..c18b46f8aeeb 100644
--- a/include/linux/journal-head.h
+++ b/include/linux/journal-head.h
@@ -66,6 +66,8 @@ struct journal_head {
          * transaction (if there is one).  Only applies to buffers on a
          * transaction's data or metadata journaling list.
          * [j_list_lock] [jbd_lock_bh_state()]
+         * Either of these locks is enough for reading, both are needed for
+         * changes.
          */
         transaction_t *b_transaction;
 
diff --git a/include/linux/jump_label.h b/include/linux/jump_label.h
index 5ce8b140428f..c513a40510f5 100644
--- a/include/linux/jump_label.h
+++ b/include/linux/jump_label.h
@@ -1,22 +1,69 @@
 #ifndef _LINUX_JUMP_LABEL_H
 #define _LINUX_JUMP_LABEL_H
 
+/*
+ * Jump label support
+ *
+ * Copyright (C) 2009-2012 Jason Baron <jbaron@redhat.com>
+ * Copyright (C) 2011-2012 Peter Zijlstra <pzijlstr@redhat.com>
+ *
+ * Jump labels provide an interface to generate dynamic branches using
+ * self-modifying code. Assuming toolchain and architecture support the result
+ * of a "if (static_key_false(&key))" statement is a unconditional branch (which
+ * defaults to false - and the true block is placed out of line).
+ *
+ * However at runtime we can change the branch target using
+ * static_key_slow_{inc,dec}(). These function as a 'reference' count on the key
+ * object and for as long as there are references all branches referring to
+ * that particular key will point to the (out of line) true block.
+ *
+ * Since this relies on modifying code the static_key_slow_{inc,dec}() functions
+ * must be considered absolute slow paths (machine wide synchronization etc.).
+ * OTOH, since the affected branches are unconditional their runtime overhead
+ * will be absolutely minimal, esp. in the default (off) case where the total
+ * effect is a single NOP of appropriate size. The on case will patch in a jump
+ * to the out-of-line block.
+ *
+ * When the control is directly exposed to userspace it is prudent to delay the
+ * decrement to avoid high frequency code modifications which can (and do)
+ * cause significant performance degradation. Struct static_key_deferred and
+ * static_key_slow_dec_deferred() provide for this.
+ *
+ * Lacking toolchain and or architecture support, it falls back to a simple
+ * conditional branch.
+ *
+ * struct static_key my_key = STATIC_KEY_INIT_TRUE;
+ *
+ *   if (static_key_true(&my_key)) {
+ *   }
+ *
+ * will result in the true case being in-line and starts the key with a single
+ * reference. Mixing static_key_true() and static_key_false() on the same key is not
+ * allowed.
+ *
+ * Not initializing the key (static data is initialized to 0s anyway) is the
+ * same as using STATIC_KEY_INIT_FALSE and static_key_false() is
+ * equivalent with static_branch().
+ *
+*/
+
 #include <linux/types.h>
 #include <linux/compiler.h>
 #include <linux/workqueue.h>
 
 #if defined(CC_HAVE_ASM_GOTO) && defined(CONFIG_JUMP_LABEL)
 
-struct jump_label_key {
+struct static_key {
         atomic_t enabled;
+/* Set lsb bit to 1 if branch is default true, 0 ot */
         struct jump_entry *entries;
 #ifdef CONFIG_MODULES
-        struct jump_label_mod *next;
+        struct static_key_mod *next;
 #endif
 };
 
-struct jump_label_key_deferred {
-        struct jump_label_key key;
+struct static_key_deferred {
+        struct static_key key;
         unsigned long timeout;
         struct delayed_work work;
 };
@@ -34,13 +81,34 @@ struct module;
 
 #ifdef HAVE_JUMP_LABEL
 
-#ifdef CONFIG_MODULES
-#define JUMP_LABEL_INIT {ATOMIC_INIT(0), NULL, NULL}
-#else
-#define JUMP_LABEL_INIT {ATOMIC_INIT(0), NULL}
-#endif
+#define JUMP_LABEL_TRUE_BRANCH 1UL
+
+static
+inline struct jump_entry *jump_label_get_entries(struct static_key *key)
+{
+        return (struct jump_entry *)((unsigned long)key->entries
+                                                & ~JUMP_LABEL_TRUE_BRANCH);
+}
 
-static __always_inline bool static_branch(struct jump_label_key *key)
+static inline bool jump_label_get_branch_default(struct static_key *key)
+{
+        if ((unsigned long)key->entries & JUMP_LABEL_TRUE_BRANCH)
+                return true;
+        return false;
+}
+
+static __always_inline bool static_key_false(struct static_key *key)
+{
+        return arch_static_branch(key);
+}
+
+static __always_inline bool static_key_true(struct static_key *key)
+{
+        return !static_key_false(key);
+}
+
+/* Deprecated. Please use 'static_key_false() instead. */
+static __always_inline bool static_branch(struct static_key *key)
 {
         return arch_static_branch(key);
 }
@@ -56,21 +124,23 @@ extern void arch_jump_label_transform(struct jump_entry *entry,
 extern void arch_jump_label_transform_static(struct jump_entry *entry,
                                              enum jump_label_type type);
 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 void jump_label_dec_deferred(struct jump_label_key_deferred *key);
-extern bool jump_label_enabled(struct jump_label_key *key);
+extern void static_key_slow_inc(struct static_key *key);
+extern void static_key_slow_dec(struct static_key *key);
+extern void static_key_slow_dec_deferred(struct static_key_deferred *key);
 extern void jump_label_apply_nops(struct module *mod);
-extern void jump_label_rate_limit(struct jump_label_key_deferred *key,
-                unsigned long rl);
+extern void
+jump_label_rate_limit(struct static_key_deferred *key, unsigned long rl);
+
+#define STATIC_KEY_INIT_TRUE ((struct static_key) \
+        { .enabled = ATOMIC_INIT(1), .entries = (void *)1 })
+#define STATIC_KEY_INIT_FALSE ((struct static_key) \
+        { .enabled = ATOMIC_INIT(0), .entries = (void *)0 })
 
 #else  /* !HAVE_JUMP_LABEL */
 
 #include <linux/atomic.h>
 
-#define JUMP_LABEL_INIT {ATOMIC_INIT(0)}
-
-struct jump_label_key {
+struct static_key {
         atomic_t enabled;
 };
 
@@ -78,30 +148,45 @@ static __always_inline void jump_label_init(void)
 {
 }
 
-struct jump_label_key_deferred {
-        struct jump_label_key  key;
+struct static_key_deferred {
+        struct static_key  key;
 };
 
-static __always_inline bool static_branch(struct jump_label_key *key)
+static __always_inline bool static_key_false(struct static_key *key)
+{
+        if (unlikely(atomic_read(&key->enabled)) > 0)
+                return true;
+        return false;
+}
+
+static __always_inline bool static_key_true(struct static_key *key)
 {
-        if (unlikely(atomic_read(&key->enabled)))
+        if (likely(atomic_read(&key->enabled)) > 0)
                 return true;
         return false;
 }
 
-static inline void jump_label_inc(struct jump_label_key *key)
+/* Deprecated. Please use 'static_key_false() instead. */
+static __always_inline bool static_branch(struct static_key *key)
+{
+        if (unlikely(atomic_read(&key->enabled)) > 0)
+                return true;
+        return false;
+}
+
+static inline void static_key_slow_inc(struct static_key *key)
 {
         atomic_inc(&key->enabled);
 }
 
-static inline void jump_label_dec(struct jump_label_key *key)
+static inline void static_key_slow_dec(struct static_key *key)
 {
         atomic_dec(&key->enabled);
 }
 
-static inline void jump_label_dec_deferred(struct jump_label_key_deferred *key)
+static inline void static_key_slow_dec_deferred(struct static_key_deferred *key)
 {
-        jump_label_dec(&key->key);
+        static_key_slow_dec(&key->key);
 }
 
 static inline int jump_label_text_reserved(void *start, void *end)
@@ -112,23 +197,30 @@ 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) {}
 
-static inline bool jump_label_enabled(struct jump_label_key *key)
-{
-        return !!atomic_read(&key->enabled);
-}
-
 static inline int jump_label_apply_nops(struct module *mod)
 {
         return 0;
 }
 
-static inline void jump_label_rate_limit(struct jump_label_key_deferred *key,
+static inline void
+jump_label_rate_limit(struct static_key_deferred *key,
                 unsigned long rl)
 {
 }
+
+#define STATIC_KEY_INIT_TRUE ((struct static_key) \
+                { .enabled = ATOMIC_INIT(1) })
+#define STATIC_KEY_INIT_FALSE ((struct static_key) \
+                { .enabled = ATOMIC_INIT(0) })
+
 #endif  /* HAVE_JUMP_LABEL */
 
-#define jump_label_key_enabled  ((struct jump_label_key){ .enabled = ATOMIC_INIT(1), })
-#define jump_label_key_disabled ((struct jump_label_key){ .enabled = ATOMIC_INIT(0), })
+#define STATIC_KEY_INIT STATIC_KEY_INIT_FALSE
+#define jump_label_enabled static_key_enabled
+
+static inline bool static_key_enabled(struct static_key *key)
+{
+        return (atomic_read(&key->enabled) > 0);
+}
 
 #endif  /* _LINUX_JUMP_LABEL_H */
diff --git a/include/linux/jz4740-adc.h b/include/linux/jz4740-adc.h
index 9053f95e9687..8184578fbfa4 100644
--- a/include/linux/jz4740-adc.h
+++ b/include/linux/jz4740-adc.h
@@ -2,7 +2,7 @@
 #ifndef __LINUX_JZ4740_ADC
 #define __LINUX_JZ4740_ADC
 
-#include <linux/device.h>
+struct device;
 
 /*
  * jz4740_adc_set_config - Configure a JZ4740 adc device
diff --git a/include/linux/kbd_kern.h b/include/linux/kbd_kern.h
index ec2d17bc1f1e..daf4a3a40ee0 100644
--- a/include/linux/kbd_kern.h
+++ b/include/linux/kbd_kern.h
@@ -7,8 +7,6 @@
 
 extern struct tasklet_struct keyboard_tasklet;
 
-extern int shift_state;
-
 extern char *func_table[MAX_NR_FUNC];
 extern char func_buf[];
 extern char *funcbufptr;
@@ -65,8 +63,6 @@ struct kbd_struct {
 #define VC_META         4       /* 0 - meta, 1 - meta=prefix with ESC */
 };
 
-extern struct kbd_struct kbd_table[];
-
 extern int kbd_init(void);
 
 extern unsigned char getledstate(void);
@@ -79,6 +75,7 @@ extern void (*kbd_ledfunc)(unsigned int led);
 extern int set_console(int nr);
 extern void schedule_console_callback(void);
 
+/* FIXME: review locking for vt.c callers */
 static inline void set_leds(void)
 {
         tasklet_schedule(&keyboard_tasklet);
@@ -142,8 +139,6 @@ static inline void chg_vc_kbd_led(struct kbd_struct * kbd, int flag)
 
 struct console;
 
-int getkeycode(unsigned int scancode);
-int setkeycode(unsigned int scancode, unsigned int keycode);
 void compute_shiftstate(void);
 
 /* defkeymap.c */
diff --git a/include/linux/kernel-page-flags.h b/include/linux/kernel-page-flags.h
index bd92a89f4b0a..26a65711676f 100644
--- a/include/linux/kernel-page-flags.h
+++ b/include/linux/kernel-page-flags.h
@@ -30,6 +30,7 @@
 #define KPF_NOPAGE              20
 
 #define KPF_KSM                 21
+#define KPF_THP                 22
 
 /* kernel hacking assistances
  * WARNING: subject to change, never rely on them!
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index e8343422240a..5db52d0ff1d4 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -20,7 +20,6 @@
 #include <linux/printk.h>
 #include <linux/dynamic_debug.h>
 #include <asm/byteorder.h>
-#include <asm/bug.h>
 
 #define USHRT_MAX       ((u16)(~0U))
 #define SHRT_MAX        ((s16)(USHRT_MAX>>1))
@@ -85,6 +84,19 @@
 }                                                       \
 )
 
+/*
+ * Multiplies an integer by a fraction, while avoiding unnecessary
+ * overflow or loss of precision.
+ */
+#define mult_frac(x, numer, denom)(                     \
+{                                                       \
+        typeof(x) quot = (x) / (denom);                 \
+        typeof(x) rem  = (x) % (denom);                 \
+        (quot * (numer)) + ((rem * (numer)) / (denom)); \
+}                                                       \
+)
+
+
 #define _RET_IP_                (unsigned long)__builtin_return_address(0)
 #define _THIS_IP_  ({ __label__ __here; __here: (unsigned long)&&__here; })
 
@@ -299,6 +311,8 @@ extern long long simple_strtoll(const char *,char **,unsigned int);
 #define strict_strtoull kstrtoull
 #define strict_strtoll  kstrtoll
 
+extern int num_to_str(char *buf, int size, unsigned long long num);
+
 /* lib/printf utilities */
 
 extern __printf(2, 3) int sprintf(char *buf, const char * fmt, ...);
@@ -315,10 +329,10 @@ extern __printf(2, 3)
 char *kasprintf(gfp_t gfp, const char *fmt, ...);
 extern char *kvasprintf(gfp_t gfp, const char *fmt, va_list args);
 
-extern int sscanf(const char *, const char *, ...)
-        __attribute__ ((format (scanf, 2, 3)));
-extern int vsscanf(const char *, const char *, va_list)
-        __attribute__ ((format (scanf, 2, 0)));
+extern __scanf(2, 3)
+int sscanf(const char *, const char *, ...);
+extern __scanf(2, 0)
+int vsscanf(const char *, const char *, va_list);
 
 extern int get_option(char **str, int *pint);
 extern char *get_options(const char *str, int nints, int *ints);
@@ -662,67 +676,6 @@ static inline void ftrace_dump(enum ftrace_dump_mode oops_dump_mode) { }
         const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
         (type *)( (char *)__mptr - offsetof(type,member) );})
 
-#ifdef __CHECKER__
-#define BUILD_BUG_ON_NOT_POWER_OF_2(n)
-#define BUILD_BUG_ON_ZERO(e) (0)
-#define BUILD_BUG_ON_NULL(e) ((void*)0)
-#define BUILD_BUG_ON(condition)
-#define BUILD_BUG() (0)
-#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))
-
-/* Force a compilation error if condition is true, but also produce a
-   result (of value 0 and type size_t), so the expression can be used
-   e.g. in a structure initializer (or where-ever else comma expressions
-   aren't permitted). */
-#define BUILD_BUG_ON_ZERO(e) (sizeof(struct { int:-!!(e); }))
-#define BUILD_BUG_ON_NULL(e) ((void *)sizeof(struct { int:-!!(e); }))
-
-/**
- * BUILD_BUG_ON - break compile if a condition is true.
- * @condition: the condition which the compiler should know is false.
- *
- * If you have some code which relies on certain constants being equal, or
- * other compile-time-evaluated condition, you should use BUILD_BUG_ON to
- * detect if someone changes it.
- *
- * The implementation uses gcc's reluctance to create a negative array, but
- * gcc (as of 4.4) only emits that error for obvious cases (eg. not arguments
- * to inline functions).  So as a fallback we use the optimizer; if it can't
- * prove the condition is false, it will cause a link error on the undefined
- * "__build_bug_on_failed".  This error message can be harder to track down
- * though, hence the two different methods.
- */
-#ifndef __OPTIMIZE__
-#define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)]))
-#else
-extern int __build_bug_on_failed;
-#define BUILD_BUG_ON(condition)                                 \
-        do {                                                    \
-                ((void)sizeof(char[1 - 2*!!(condition)]));      \
-                if (condition) __build_bug_on_failed = 1;       \
-        } while(0)
-#endif
-
-/**
- * BUILD_BUG - break compile if used.
- *
- * If you have some code that you expect the compiler to eliminate at
- * build time, you should use BUILD_BUG to detect if it is
- * unexpectedly used.
- */
-#define BUILD_BUG()                                             \
-        do {                                                    \
-                extern void __build_bug_failed(void)            \
-                        __linktime_error("BUILD_BUG failed");   \
-                __build_bug_failed();                           \
-        } while (0)
-
-#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 5253471cd2ea..96933b1e5d24 100644
--- a/include/linux/key.h
+++ b/include/linux/key.h
@@ -155,6 +155,7 @@ struct key {
 #define KEY_FLAG_IN_QUOTA       3       /* set if key consumes quota */
 #define KEY_FLAG_USER_CONSTRUCT 4       /* set if key is being constructed in userspace */
 #define KEY_FLAG_NEGATIVE       5       /* set if key is negative */
+#define KEY_FLAG_ROOT_CAN_CLEAR 6       /* set if key can be cleared by root without permission */
 
         /* the description string
          * - this is used to match a key against search criteria
@@ -276,6 +277,8 @@ static inline key_serial_t key_serial(const struct key *key)
         return key ? key->serial : 0;
 }
 
+extern void key_set_timeout(struct key *, unsigned);
+
 /**
  * key_is_instantiated - Determine if a key has been positively instantiated
  * @key: The key to check.
diff --git a/include/linux/keyboard.h b/include/linux/keyboard.h
index 33a63f62d57f..86e5214ae735 100644
--- a/include/linux/keyboard.h
+++ b/include/linux/keyboard.h
@@ -24,8 +24,6 @@
 
 #ifdef __KERNEL__
 struct notifier_block;
-extern const int NR_TYPES;
-extern const int max_vals[];
 extern unsigned short *key_maps[MAX_NR_KEYMAPS];
 extern unsigned short plain_map[NR_KEYS];
 
diff --git a/include/linux/kmod.h b/include/linux/kmod.h
index 722f477c4ef7..9efeae679106 100644
--- a/include/linux/kmod.h
+++ b/include/linux/kmod.h
@@ -48,11 +48,10 @@ static inline int request_module_nowait(const char *name, ...) { return -ENOSYS;
 struct cred;
 struct file;
 
-enum umh_wait {
-        UMH_NO_WAIT = -1,       /* don't wait at all */
-        UMH_WAIT_EXEC = 0,      /* wait for the exec, but not the process */
-        UMH_WAIT_PROC = 1,      /* wait for the process to complete */
-};
+#define UMH_NO_WAIT     0       /* don't wait at all */
+#define UMH_WAIT_EXEC   1       /* wait for the exec, but not the process */
+#define UMH_WAIT_PROC   2       /* wait for the process to complete */
+#define UMH_KILLABLE    4       /* wait for EXEC/PROC killable */
 
 struct subprocess_info {
         struct work_struct work;
@@ -60,7 +59,7 @@ struct subprocess_info {
         char *path;
         char **argv;
         char **envp;
-        enum umh_wait wait;
+        int wait;
         int retval;
         int (*init)(struct subprocess_info *info, struct cred *new);
         void (*cleanup)(struct subprocess_info *info);
@@ -78,15 +77,14 @@ void call_usermodehelper_setfns(struct subprocess_info *info,
                     void *data);
 
 /* Actually execute the sub-process */
-int call_usermodehelper_exec(struct subprocess_info *info, enum umh_wait wait);
+int call_usermodehelper_exec(struct subprocess_info *info, int wait);
 
 /* Free the subprocess_info. This is only needed if you're not going
    to call call_usermodehelper_exec */
 void call_usermodehelper_freeinfo(struct subprocess_info *info);
 
 static inline int
-call_usermodehelper_fns(char *path, char **argv, char **envp,
-                        enum umh_wait wait,
+call_usermodehelper_fns(char *path, char **argv, char **envp, int wait,
                         int (*init)(struct subprocess_info *info, struct cred *new),
                         void (*cleanup)(struct subprocess_info *), void *data)
 {
@@ -104,7 +102,7 @@ call_usermodehelper_fns(char *path, char **argv, char **envp,
 }
 
 static inline int
-call_usermodehelper(char *path, char **argv, char **envp, enum umh_wait wait)
+call_usermodehelper(char *path, char **argv, char **envp, int wait)
 {
         return call_usermodehelper_fns(path, argv, envp, wait,
                                        NULL, NULL, NULL);
diff --git a/include/linux/kprobes.h b/include/linux/kprobes.h
index dce6e4dbeda7..b6e1f8c00577 100644
--- a/include/linux/kprobes.h
+++ b/include/linux/kprobes.h
@@ -33,6 +33,7 @@
 #include <linux/list.h>
 #include <linux/notifier.h>
 #include <linux/smp.h>
+#include <linux/bug.h>
 #include <linux/percpu.h>
 #include <linux/spinlock.h>
 #include <linux/rcupdate.h>
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
index 900c76337e8f..ca1b153585d3 100644
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@ -13,6 +13,7 @@
 #include <linux/spinlock.h>
 #include <linux/signal.h>
 #include <linux/sched.h>
+#include <linux/bug.h>
 #include <linux/mm.h>
 #include <linux/mmu_notifier.h>
 #include <linux/preempt.h>
diff --git a/include/linux/led-lm3530.h b/include/linux/led-lm3530.h
index 8eb12357a110..eeae6e742471 100644
--- a/include/linux/led-lm3530.h
+++ b/include/linux/led-lm3530.h
@@ -72,6 +72,12 @@ enum lm3530_als_mode {
         LM3530_INPUT_CEIL,      /* Max of ALS1 and ALS2 */
 };
 
+/* PWM Platform Specific Data */
+struct lm3530_pwm_data {
+        void (*pwm_set_intensity) (int brightness, int max_brightness);
+        int (*pwm_get_intensity) (int max_brightness);
+};
+
 /**
  * struct lm3530_platform_data
  * @mode: mode of operation i.e. Manual, ALS or PWM
@@ -87,6 +93,7 @@ enum lm3530_als_mode {
  * @als_vmin: als input voltage calibrated for max brightness in mV
  * @als_vmax: als input voltage calibrated for min brightness in mV
  * @brt_val: brightness value (0-255)
+ * @pwm_data: PWM control functions (only valid when the mode is PWM)
  */
 struct lm3530_platform_data {
         enum lm3530_mode mode;
@@ -107,6 +114,8 @@ struct lm3530_platform_data {
         u32 als_vmax;
 
         u8 brt_val;
+
+        struct lm3530_pwm_data pwm_data;
 };
 
 #endif  /* _LINUX_LED_LM3530_H__ */
diff --git a/include/linux/leds-lp5521.h b/include/linux/leds-lp5521.h
index fd548d2a8775..3f071ec019b2 100644
--- a/include/linux/leds-lp5521.h
+++ b/include/linux/leds-lp5521.h
@@ -26,15 +26,37 @@
 /* See Documentation/leds/leds-lp5521.txt */
 
 struct lp5521_led_config {
+        char            *name;
         u8              chan_nr;
         u8              led_current; /* mA x10, 0 if led is not connected */
         u8              max_current;
 };
 
+struct lp5521_led_pattern {
+        u8 *r;
+        u8 *g;
+        u8 *b;
+        u8 size_r;
+        u8 size_g;
+        u8 size_b;
+};
+
 #define LP5521_CLOCK_AUTO       0
 #define LP5521_CLOCK_INT        1
 #define LP5521_CLOCK_EXT        2
 
+/* Bits in CONFIG register */
+#define LP5521_PWM_HF                   0x40    /* PWM: 0 = 256Hz, 1 = 558Hz */
+#define LP5521_PWRSAVE_EN               0x20    /* 1 = Power save mode */
+#define LP5521_CP_MODE_OFF              0       /* Charge pump (CP) off */
+#define LP5521_CP_MODE_BYPASS           8       /* CP forced to bypass mode */
+#define LP5521_CP_MODE_1X5              0x10    /* CP forced to 1.5x mode */
+#define LP5521_CP_MODE_AUTO             0x18    /* Automatic mode selection */
+#define LP5521_R_TO_BATT                4       /* R out: 0 = CP, 1 = Vbat */
+#define LP5521_CLK_SRC_EXT              0       /* Ext-clk source (CLK_32K) */
+#define LP5521_CLK_INT                  1       /* Internal clock */
+#define LP5521_CLK_AUTO                 2       /* Automatic clock selection */
+
 struct lp5521_platform_data {
         struct lp5521_led_config *led_config;
         u8      num_channels;
@@ -43,6 +65,9 @@ struct lp5521_platform_data {
         void    (*release_resources)(void);
         void    (*enable)(bool state);
         const char *label;
+        u8      update_config;
+        struct lp5521_led_pattern *patterns;
+        int num_patterns;
 };
 
 #endif /* __LINUX_LP5521_H */
diff --git a/include/linux/libata.h b/include/linux/libata.h
index cafc09a64fe4..42378d637ffb 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -996,6 +996,7 @@ extern int ata_sas_scsi_ioctl(struct ata_port *ap, struct scsi_device *dev,
 extern void ata_sas_port_destroy(struct ata_port *);
 extern struct ata_port *ata_sas_port_alloc(struct ata_host *,
                                            struct ata_port_info *, struct Scsi_Host *);
+extern int ata_sas_async_port_init(struct ata_port *);
 extern int ata_sas_port_init(struct ata_port *);
 extern int ata_sas_port_start(struct ata_port *ap);
 extern void ata_sas_port_stop(struct ata_port *ap);
@@ -1147,6 +1148,7 @@ static inline int ata_acpi_cbl_80wire(struct ata_port *ap,
  * EH - drivers/ata/libata-eh.c
  */
 extern void ata_port_schedule_eh(struct ata_port *ap);
+extern void ata_port_wait_eh(struct ata_port *ap);
 extern int ata_link_abort(struct ata_link *link);
 extern int ata_port_abort(struct ata_port *ap);
 extern int ata_port_freeze(struct ata_port *ap);
diff --git a/include/linux/lockd/bind.h b/include/linux/lockd/bind.h
index fbc48f898521..11a966e5f829 100644
--- a/include/linux/lockd/bind.h
+++ b/include/linux/lockd/bind.h
@@ -42,6 +42,7 @@ struct nlmclnt_initdata {
         unsigned short          protocol;
         u32                     nfs_version;
         int                     noresvport;
+        struct net              *net;
 };
 
 /*
diff --git a/include/linux/lockd/lockd.h b/include/linux/lockd/lockd.h
index 88a114fce477..f04ce6ac6d04 100644
--- a/include/linux/lockd/lockd.h
+++ b/include/linux/lockd/lockd.h
@@ -67,6 +67,7 @@ struct nlm_host {
         struct list_head        h_reclaim;      /* Locks in RECLAIM state */
         struct nsm_handle       *h_nsmhandle;   /* NSM status handle */
         char                    *h_addrbuf;     /* address eyecatcher */
+        struct net              *net;           /* host net */
 };
 
 /*
@@ -188,7 +189,7 @@ struct nlm_block {
 /*
  * Global variables
  */
-extern struct rpc_program       nlm_program;
+extern const struct rpc_program nlm_program;
 extern struct svc_procedure     nlmsvc_procedures[];
 #ifdef CONFIG_LOCKD_V4
 extern struct svc_procedure     nlmsvc_procedures4[];
@@ -222,7 +223,8 @@ struct nlm_host  *nlmclnt_lookup_host(const struct sockaddr *sap,
                                         const unsigned short protocol,
                                         const u32 version,
                                         const char *hostname,
-                                        int noresvport);
+                                        int noresvport,
+                                        struct net *net);
 void              nlmclnt_release_host(struct nlm_host *);
 struct nlm_host  *nlmsvc_lookup_host(const struct svc_rqst *rqstp,
                                         const char *hostname,
@@ -232,6 +234,7 @@ struct rpc_clnt * nlm_bind_host(struct nlm_host *);
 void              nlm_rebind_host(struct nlm_host *);
 struct nlm_host * nlm_get_host(struct nlm_host *);
 void              nlm_shutdown_hosts(void);
+void              nlm_shutdown_hosts_net(struct net *net);
 void              nlm_host_rebooted(const struct nlm_reboot *);
 
 /*
diff --git a/include/linux/lockd/xdr4.h b/include/linux/lockd/xdr4.h
index 7353821341ed..e58c88b52ce1 100644
--- a/include/linux/lockd/xdr4.h
+++ b/include/linux/lockd/xdr4.h
@@ -42,6 +42,6 @@ int	nlmclt_encode_lockargs(struct rpc_rqst *, u32 *, struct nlm_args *);
 int     nlmclt_encode_cancargs(struct rpc_rqst *, u32 *, struct nlm_args *);
 int     nlmclt_encode_unlockargs(struct rpc_rqst *, u32 *, struct nlm_args *);
  */
-extern struct rpc_version nlm_version4;
+extern const struct rpc_version nlm_version4;
 
 #endif /* LOCKD_XDR4_H */
diff --git a/include/linux/lp855x.h b/include/linux/lp855x.h
new file mode 100644
index 000000000000..781a490a451b
--- /dev/null
+++ b/include/linux/lp855x.h
@@ -0,0 +1,131 @@
+/*
+ * LP855x Backlight Driver
+ *
+ *                      Copyright (C) 2011 Texas Instruments
+ *
+ * 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 _LP855X_H
+#define _LP855X_H
+
+#define BL_CTL_SHFT     (0)
+#define BRT_MODE_SHFT   (1)
+#define BRT_MODE_MASK   (0x06)
+
+/* Enable backlight. Only valid when BRT_MODE=10(I2C only) */
+#define ENABLE_BL       (1)
+#define DISABLE_BL      (0)
+
+#define I2C_CONFIG(id)  id ## _I2C_CONFIG
+#define PWM_CONFIG(id)  id ## _PWM_CONFIG
+
+/* DEVICE CONTROL register - LP8550 */
+#define LP8550_PWM_CONFIG       (LP8550_PWM_ONLY << BRT_MODE_SHFT)
+#define LP8550_I2C_CONFIG       ((ENABLE_BL << BL_CTL_SHFT) | \
+                                (LP8550_I2C_ONLY << BRT_MODE_SHFT))
+
+/* DEVICE CONTROL register - LP8551 */
+#define LP8551_PWM_CONFIG       LP8550_PWM_CONFIG
+#define LP8551_I2C_CONFIG       LP8550_I2C_CONFIG
+
+/* DEVICE CONTROL register - LP8552 */
+#define LP8552_PWM_CONFIG       LP8550_PWM_CONFIG
+#define LP8552_I2C_CONFIG       LP8550_I2C_CONFIG
+
+/* DEVICE CONTROL register - LP8553 */
+#define LP8553_PWM_CONFIG       LP8550_PWM_CONFIG
+#define LP8553_I2C_CONFIG       LP8550_I2C_CONFIG
+
+/* DEVICE CONTROL register - LP8556 */
+#define LP8556_PWM_CONFIG       (LP8556_PWM_ONLY << BRT_MODE_SHFT)
+#define LP8556_COMB1_CONFIG     (LP8556_COMBINED1 << BRT_MODE_SHFT)
+#define LP8556_I2C_CONFIG       ((ENABLE_BL << BL_CTL_SHFT) | \
+                                (LP8556_I2C_ONLY << BRT_MODE_SHFT))
+#define LP8556_COMB2_CONFIG     (LP8556_COMBINED2 << BRT_MODE_SHFT)
+
+/* ROM area boundary */
+#define EEPROM_START    (0xA0)
+#define EEPROM_END      (0xA7)
+#define EPROM_START     (0xA0)
+#define EPROM_END       (0xAF)
+
+enum lp855x_chip_id {
+        LP8550,
+        LP8551,
+        LP8552,
+        LP8553,
+        LP8556,
+};
+
+enum lp855x_brightness_ctrl_mode {
+        PWM_BASED = 1,
+        REGISTER_BASED,
+};
+
+enum lp8550_brighntess_source {
+        LP8550_PWM_ONLY,
+        LP8550_I2C_ONLY = 2,
+};
+
+enum lp8551_brighntess_source {
+        LP8551_PWM_ONLY = LP8550_PWM_ONLY,
+        LP8551_I2C_ONLY = LP8550_I2C_ONLY,
+};
+
+enum lp8552_brighntess_source {
+        LP8552_PWM_ONLY = LP8550_PWM_ONLY,
+        LP8552_I2C_ONLY = LP8550_I2C_ONLY,
+};
+
+enum lp8553_brighntess_source {
+        LP8553_PWM_ONLY = LP8550_PWM_ONLY,
+        LP8553_I2C_ONLY = LP8550_I2C_ONLY,
+};
+
+enum lp8556_brightness_source {
+        LP8556_PWM_ONLY,
+        LP8556_COMBINED1,       /* pwm + i2c before the shaper block */
+        LP8556_I2C_ONLY,
+        LP8556_COMBINED2,       /* pwm + i2c after the shaper block */
+};
+
+struct lp855x_pwm_data {
+        void (*pwm_set_intensity) (int brightness, int max_brightness);
+        int (*pwm_get_intensity) (int max_brightness);
+};
+
+struct lp855x_rom_data {
+        u8 addr;
+        u8 val;
+};
+
+/**
+ * struct lp855x_platform_data
+ * @name : Backlight driver name. If it is not defined, default name is set.
+ * @mode : brightness control by pwm or lp855x register
+ * @device_control : value of DEVICE CONTROL register
+ * @initial_brightness : initial value of backlight brightness
+ * @pwm_data : platform specific pwm generation functions.
+                Only valid when mode is PWM_BASED.
+ * @load_new_rom_data :
+        0 : use default configuration data
+        1 : update values of eeprom or eprom registers on loading driver
+ * @size_program : total size of lp855x_rom_data
+ * @rom_data : list of new eeprom/eprom registers
+ */
+struct lp855x_platform_data {
+        char *name;
+        enum lp855x_brightness_ctrl_mode mode;
+        u8 device_control;
+        int initial_brightness;
+        struct lp855x_pwm_data pwm_data;
+        u8 load_new_rom_data;
+        int size_program;
+        struct lp855x_rom_data *rom_data;
+};
+
+#endif
diff --git a/include/linux/magic.h b/include/linux/magic.h
index 2d4beab0d5b7..e15192cb9cf4 100644
--- a/include/linux/magic.h
+++ b/include/linux/magic.h
@@ -9,7 +9,6 @@
 #define CRAMFS_MAGIC            0x28cd3d45      /* some random number */
 #define CRAMFS_MAGIC_WEND       0x453dcd28      /* magic number with the wrong endianess */
 #define DEBUGFS_MAGIC          0x64626720
-#define SYSFS_MAGIC             0x62656572
 #define SECURITYFS_MAGIC        0x73636673
 #define SELINUX_MAGIC           0xf97cff8c
 #define RAMFS_MAGIC             0x858458f6      /* some random number */
@@ -27,7 +26,6 @@
 #define HPFS_SUPER_MAGIC        0xf995e849
 #define ISOFS_SUPER_MAGIC       0x9660
 #define JFFS2_SUPER_MAGIC       0x72b6
-#define ANON_INODE_FS_MAGIC     0x09041934
 #define PSTOREFS_MAGIC          0x6165676C
 
 #define MINIX_SUPER_MAGIC       0x137F          /* minix v1 fs, 14 char names */
@@ -40,8 +38,8 @@
 #define NCP_SUPER_MAGIC         0x564c          /* Guess, what 0x564c is :-) */
 #define NFS_SUPER_MAGIC         0x6969
 #define OPENPROM_SUPER_MAGIC    0x9fa1
-#define PROC_SUPER_MAGIC        0x9fa0
 #define QNX4_SUPER_MAGIC        0x002f          /* qnx4 fs detection */
+#define QNX6_SUPER_MAGIC        0x68191122      /* qnx6 fs detection */
 
 #define REISERFS_SUPER_MAGIC    0x52654973      /* used by gcc */
                                         /* used by file system utilities that
@@ -51,15 +49,24 @@
 #define REISER2FS_JR_SUPER_MAGIC_STRING "ReIsEr3Fs"
 
 #define SMB_SUPER_MAGIC         0x517B
-#define USBDEVICE_SUPER_MAGIC   0x9fa2
 #define CGROUP_SUPER_MAGIC      0x27e0eb
 
-#define FUTEXFS_SUPER_MAGIC     0xBAD1DEA
 
 #define STACK_END_MAGIC         0x57AC6E9D
 
+#define V9FS_MAGIC              0x01021997
+
+#define BDEVFS_MAGIC            0x62646576
+#define BINFMTFS_MAGIC          0x42494e4d
 #define DEVPTS_SUPER_MAGIC      0x1cd1
+#define FUTEXFS_SUPER_MAGIC     0xBAD1DEA
+#define PIPEFS_MAGIC            0x50495045
+#define PROC_SUPER_MAGIC        0x9fa0
 #define SOCKFS_MAGIC            0x534F434B
-#define V9FS_MAGIC              0x01021997
+#define SYSFS_MAGIC             0x62656572
+#define USBDEVICE_SUPER_MAGIC   0x9fa2
+#define MTD_INODE_FS_MAGIC      0x11307854
+#define ANON_INODE_FS_MAGIC     0x09041934
+
 
 #endif /* __LINUX_MAGIC_H__ */
diff --git a/include/linux/maple.h b/include/linux/maple.h
index d9a51b9b3300..c37288b23e0c 100644
--- a/include/linux/maple.h
+++ b/include/linux/maple.h
@@ -1,9 +1,9 @@
 #ifndef __LINUX_MAPLE_H
 #define __LINUX_MAPLE_H
 
-#include <linux/device.h>
 #include <mach/maple.h>
 
+struct device;
 extern struct bus_type maple_bus_type;
 
 /* Maple Bus command and response codes */
diff --git a/include/linux/math64.h b/include/linux/math64.h
index 23fcdfcba81b..b8ba85544721 100644
--- a/include/linux/math64.h
+++ b/include/linux/math64.h
@@ -6,6 +6,8 @@
 
 #if BITS_PER_LONG == 64
 
+#define div64_long(x,y) div64_s64((x),(y))
+
 /**
  * div_u64_rem - unsigned 64bit divide with 32bit divisor with remainder
  *
@@ -45,6 +47,8 @@ static inline s64 div64_s64(s64 dividend, s64 divisor)
 
 #elif BITS_PER_LONG == 32
 
+#define div64_long(x,y) div_s64((x),(y))
+
 #ifndef div_u64_rem
 static inline u64 div_u64_rem(u64 dividend, u32 divisor, u32 *remainder)
 {
diff --git a/include/linux/mdio.h b/include/linux/mdio.h
index b1494aced217..dfb947959ec9 100644
--- a/include/linux/mdio.h
+++ b/include/linux/mdio.h
@@ -10,6 +10,7 @@
 #ifndef __LINUX_MDIO_H__
 #define __LINUX_MDIO_H__
 
+#include <linux/types.h>
 #include <linux/mii.h>
 
 /* MDIO Manageable Devices (MMDs). */
@@ -273,6 +274,8 @@ static inline __u16 mdio_phy_id_c45(int prtad, int devad)
         return MDIO_PHY_ID_C45 | (prtad << 5) | devad;
 }
 
+#ifdef __KERNEL__
+
 static inline bool mdio_phy_id_is_c45(int phy_id)
 {
         return (phy_id & MDIO_PHY_ID_C45) && !(phy_id & ~MDIO_PHY_ID_C45_MASK);
@@ -288,11 +291,6 @@ static inline __u16 mdio_phy_id_devad(int phy_id)
         return phy_id & MDIO_PHY_ID_DEVAD;
 }
 
-#define MDIO_SUPPORTS_C22               1
-#define MDIO_SUPPORTS_C45               2
-
-#ifdef __KERNEL__ 
-
 /**
  * struct mdio_if_info - Ethernet controller MDIO interface
  * @prtad: PRTAD of the PHY (%MDIO_PRTAD_NONE if not present/unknown)
@@ -321,6 +319,8 @@ struct mdio_if_info {
 
 #define MDIO_PRTAD_NONE                 (-1)
 #define MDIO_DEVAD_NONE                 (-1)
+#define MDIO_SUPPORTS_C22               1
+#define MDIO_SUPPORTS_C45               2
 #define MDIO_EMULATE_C22                4
 
 struct ethtool_cmd;
diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h
index b80de520670b..f94efd2f6c27 100644
--- a/include/linux/memcontrol.h
+++ b/include/linux/memcontrol.h
@@ -77,7 +77,8 @@ extern void mem_cgroup_uncharge_end(void);
 extern void mem_cgroup_uncharge_page(struct page *page);
 extern void mem_cgroup_uncharge_cache_page(struct page *page);
 
-extern void mem_cgroup_out_of_memory(struct mem_cgroup *memcg, gfp_t gfp_mask);
+extern void mem_cgroup_out_of_memory(struct mem_cgroup *memcg, gfp_t gfp_mask,
+                                     int order);
 int task_in_mem_cgroup(struct task_struct *task, const struct mem_cgroup *memcg);
 
 extern struct mem_cgroup *try_get_mem_cgroup_from_page(struct page *page);
@@ -140,6 +141,34 @@ static inline bool mem_cgroup_disabled(void)
         return false;
 }
 
+void __mem_cgroup_begin_update_page_stat(struct page *page, bool *locked,
+                                         unsigned long *flags);
+
+extern atomic_t memcg_moving;
+
+static inline void mem_cgroup_begin_update_page_stat(struct page *page,
+                                        bool *locked, unsigned long *flags)
+{
+        if (mem_cgroup_disabled())
+                return;
+        rcu_read_lock();
+        *locked = false;
+        if (atomic_read(&memcg_moving))
+                __mem_cgroup_begin_update_page_stat(page, locked, flags);
+}
+
+void __mem_cgroup_end_update_page_stat(struct page *page,
+                                unsigned long *flags);
+static inline void mem_cgroup_end_update_page_stat(struct page *page,
+                                        bool *locked, unsigned long *flags)
+{
+        if (mem_cgroup_disabled())
+                return;
+        if (*locked)
+                __mem_cgroup_end_update_page_stat(page, flags);
+        rcu_read_unlock();
+}
+
 void mem_cgroup_update_page_stat(struct page *page,
                                  enum mem_cgroup_page_stat_item idx,
                                  int val);
@@ -298,21 +327,6 @@ static inline void mem_cgroup_iter_break(struct mem_cgroup *root,
 {
 }
 
-static inline int mem_cgroup_get_reclaim_priority(struct mem_cgroup *memcg)
-{
-        return 0;
-}
-
-static inline void mem_cgroup_note_reclaim_priority(struct mem_cgroup *memcg,
-                                                int priority)
-{
-}
-
-static inline void mem_cgroup_record_reclaim_priority(struct mem_cgroup *memcg,
-                                                int priority)
-{
-}
-
 static inline bool mem_cgroup_disabled(void)
 {
         return true;
@@ -355,6 +369,16 @@ mem_cgroup_print_oom_info(struct mem_cgroup *memcg, struct task_struct *p)
 {
 }
 
+static inline void mem_cgroup_begin_update_page_stat(struct page *page,
+                                        bool *locked, unsigned long *flags)
+{
+}
+
+static inline void mem_cgroup_end_update_page_stat(struct page *page,
+                                        bool *locked, unsigned long *flags)
+{
+}
+
 static inline void mem_cgroup_inc_page_stat(struct page *page,
                                             enum mem_cgroup_page_stat_item idx)
 {
@@ -391,7 +415,7 @@ static inline void mem_cgroup_replace_page_cache(struct page *oldpage,
                                 struct page *newpage)
 {
 }
-#endif /* CONFIG_CGROUP_MEM_CONT */
+#endif /* CONFIG_CGROUP_MEM_RES_CTLR */
 
 #if !defined(CONFIG_CGROUP_MEM_RES_CTLR) || !defined(CONFIG_DEBUG_VM)
 static inline bool
diff --git a/include/linux/memory_hotplug.h b/include/linux/memory_hotplug.h
index 0b8e2a742600..910550f3b70e 100644
--- a/include/linux/memory_hotplug.h
+++ b/include/linux/memory_hotplug.h
@@ -4,6 +4,7 @@
 #include <linux/mmzone.h>
 #include <linux/spinlock.h>
 #include <linux/notifier.h>
+#include <linux/bug.h>
 
 struct page;
 struct zone;
diff --git a/include/linux/mfd/88pm860x.h b/include/linux/mfd/88pm860x.h
index 92be3476c9f5..84d071ade1d8 100644
--- a/include/linux/mfd/88pm860x.h
+++ b/include/linux/mfd/88pm860x.h
@@ -263,6 +263,22 @@ enum {
 #define PM8607_PD_PREBIAS_MASK          (0x1F << 0)
 #define PM8607_PD_PRECHG_MASK           (7 << 5)
 
+#define PM8606_REF_GP_OSC_OFF         0
+#define PM8606_REF_GP_OSC_ON          1
+#define PM8606_REF_GP_OSC_UNKNOWN     2
+
+/* Clients of reference group and 8MHz oscillator in 88PM8606 */
+enum pm8606_ref_gp_and_osc_clients {
+        REF_GP_NO_CLIENTS       = 0,
+        WLED1_DUTY              = (1<<0), /*PF 0x02.7:0*/
+        WLED2_DUTY              = (1<<1), /*PF 0x04.7:0*/
+        WLED3_DUTY              = (1<<2), /*PF 0x06.7:0*/
+        RGB1_ENABLE             = (1<<3), /*PF 0x07.1*/
+        RGB2_ENABLE             = (1<<4), /*PF 0x07.2*/
+        LDO_VBR_EN              = (1<<5), /*PF 0x12.0*/
+        REF_GP_MAX_CLIENT       = 0xFFFF
+};
+
 /* Interrupt Number in 88PM8607 */
 enum {
         PM8607_IRQ_ONKEY,
@@ -298,6 +314,7 @@ enum {
 struct pm860x_chip {
         struct device           *dev;
         struct mutex            irq_lock;
+        struct mutex            osc_lock;
         struct i2c_client       *client;
         struct i2c_client       *companion;     /* companion chip client */
         struct regmap           *regmap;
@@ -305,12 +322,15 @@ struct pm860x_chip {
 
         int                     buck3_double;   /* DVC ramp slope double */
         unsigned short          companion_addr;
+        unsigned short          osc_vote;
         int                     id;
         int                     irq_mode;
         int                     irq_base;
         int                     core_irq;
         unsigned char           chip_version;
+        unsigned char           osc_status;
 
+        unsigned int            wakeup_flag;
 };
 
 enum {
@@ -369,6 +389,9 @@ struct pm860x_platform_data {
         int             num_regulators;
 };
 
+extern int pm8606_osc_enable(struct pm860x_chip *, unsigned short);
+extern int pm8606_osc_disable(struct pm860x_chip *, unsigned short);
+
 extern int pm860x_reg_read(struct i2c_client *, int);
 extern int pm860x_reg_write(struct i2c_client *, int, unsigned char);
 extern int pm860x_bulk_read(struct i2c_client *, int, int, unsigned char *);
diff --git a/include/linux/mfd/abx500.h b/include/linux/mfd/abx500.h
index 9970337ff041..5fa697477b71 100644
--- a/include/linux/mfd/abx500.h
+++ b/include/linux/mfd/abx500.h
@@ -14,9 +14,10 @@
  * Author: Rickard Andersson <rickard.andersson@stericsson.com>
  */
 
-#include <linux/device.h>
 #include <linux/regulator/machine.h>
 
+struct device;
+
 #ifndef MFD_ABX500_H
 #define MFD_ABX500_H
 
@@ -33,13 +34,6 @@
 #define AB5500_1_1      0x21
 #define AB5500_2_0      0x24
 
-/* AB8500 CIDs*/
-#define AB8500_CUT1P0   0x10
-#define AB8500_CUT1P1   0x11
-#define AB8500_CUT2P0   0x20
-#define AB8500_CUT3P0   0x30
-#define AB8500_CUT3P3   0x33
-
 /*
  * AB3100, EVENTA1, A2 and A3 event register flags
  * these are catenated into a single 32-bit flag in the code
diff --git a/include/linux/mfd/abx500/ab5500.h b/include/linux/mfd/abx500/ab5500.h
index a720051ae933..54f820ed73bb 100644
--- a/include/linux/mfd/abx500/ab5500.h
+++ b/include/linux/mfd/abx500/ab5500.h
@@ -6,7 +6,7 @@
 #ifndef MFD_AB5500_H
 #define MFD_AB5500_H
 
-#include <linux/device.h>
+struct device;
 
 enum ab5500_devid {
         AB5500_DEVID_ADC,
diff --git a/include/linux/mfd/abx500/ab8500-gpio.h b/include/linux/mfd/abx500/ab8500-gpio.h
index 488a8c920a29..2387c207ea86 100644
--- a/include/linux/mfd/abx500/ab8500-gpio.h
+++ b/include/linux/mfd/abx500/ab8500-gpio.h
@@ -10,12 +10,14 @@
 
 /*
  * Platform data to register a block: only the initial gpio/irq number.
+ * Array sizes are large enough to contain all AB8500 and AB9540 GPIO
+ * registers.
  */
 
 struct ab8500_gpio_platform_data {
         int gpio_base;
         u32 irq_base;
-        u8  config_reg[7];
+        u8  config_reg[8];
 };
 
 #endif /* _AB8500_GPIO_H */
diff --git a/include/linux/mfd/abx500/ab8500-sysctrl.h b/include/linux/mfd/abx500/ab8500-sysctrl.h
index 10da0291f8f8..10eb50973c39 100644
--- a/include/linux/mfd/abx500/ab8500-sysctrl.h
+++ b/include/linux/mfd/abx500/ab8500-sysctrl.h
@@ -71,6 +71,13 @@ static inline int ab8500_sysctrl_clear(u16 reg, u8 bits)
 #define AB8500_SWATCTRL                 0x230
 #define AB8500_HIQCLKCTRL               0x232
 #define AB8500_VSIMSYSCLKCTRL           0x233
+#define AB9540_SYSCLK12BUFCTRL          0x234
+#define AB9540_SYSCLK12CONFCTRL         0x235
+#define AB9540_SYSCLK12BUFCTRL2         0x236
+#define AB9540_SYSCLK12BUF1VALID        0x237
+#define AB9540_SYSCLK12BUF2VALID        0x238
+#define AB9540_SYSCLK12BUF3VALID        0x239
+#define AB9540_SYSCLK12BUF4VALID        0x23A
 
 /* Bits */
 #define AB8500_TURNONSTATUS_PORNVBAT BIT(0)
@@ -251,4 +258,40 @@ static inline int ab8500_sysctrl_clear(u16 reg, u8 bits)
 #define AB8500_VSIMSYSCLKCTRL_VSIMSYSCLKREQ7VALID BIT(6)
 #define AB8500_VSIMSYSCLKCTRL_VSIMSYSCLKREQ8VALID BIT(7)
 
+#define AB9540_SYSCLK12BUFCTRL_SYSCLK12BUF1ENA BIT(0)
+#define AB9540_SYSCLK12BUFCTRL_SYSCLK12BUF2ENA BIT(1)
+#define AB9540_SYSCLK12BUFCTRL_SYSCLK12BUF3ENA BIT(2)
+#define AB9540_SYSCLK12BUFCTRL_SYSCLK12BUF4ENA BIT(3)
+#define AB9540_SYSCLK12BUFCTRL_SYSCLK12BUFENA_MASK 0x0F
+#define AB9540_SYSCLK12BUFCTRL_SYSCLK12BUF1STRE BIT(4)
+#define AB9540_SYSCLK12BUFCTRL_SYSCLK12BUF2STRE BIT(5)
+#define AB9540_SYSCLK12BUFCTRL_SYSCLK12BUF3STRE BIT(6)
+#define AB9540_SYSCLK12BUFCTRL_SYSCLK12BUF4STRE BIT(7)
+#define AB9540_SYSCLK12BUFCTRL_SYSCLK12BUFSTRE_MASK 0xF0
+
+#define AB9540_SYSCLK12CONFCTRL_PLL26TO38ENA BIT(0)
+#define AB9540_SYSCLK12CONFCTRL_SYSCLK12USBMUXSEL BIT(1)
+#define AB9540_SYSCLK12CONFCTRL_INT384MHZMUXSEL_MASK 0x0C
+#define AB9540_SYSCLK12CONFCTRL_INT384MHZMUXSEL_SHIFT 2
+#define AB9540_SYSCLK12CONFCTRL_SYSCLK12BUFMUX BIT(4)
+#define AB9540_SYSCLK12CONFCTRL_SYSCLK12PLLMUX BIT(5)
+#define AB9540_SYSCLK12CONFCTRL_SYSCLK2MUXVALID BIT(6)
+
+#define AB9540_SYSCLK12BUFCTRL2_SYSCLK12BUF1PDENA BIT(0)
+#define AB9540_SYSCLK12BUFCTRL2_SYSCLK12BUF2PDENA BIT(1)
+#define AB9540_SYSCLK12BUFCTRL2_SYSCLK12BUF3PDENA BIT(2)
+#define AB9540_SYSCLK12BUFCTRL2_SYSCLK12BUF4PDENA BIT(3)
+
+#define AB9540_SYSCLK12BUF1VALID_SYSCLK12BUF1VALID_MASK 0xFF
+#define AB9540_SYSCLK12BUF1VALID_SYSCLK12BUF1VALID_SHIFT 0
+
+#define AB9540_SYSCLK12BUF2VALID_SYSCLK12BUF2VALID_MASK 0xFF
+#define AB9540_SYSCLK12BUF2VALID_SYSCLK12BUF2VALID_SHIFT 0
+
+#define AB9540_SYSCLK12BUF3VALID_SYSCLK12BUF3VALID_MASK 0xFF
+#define AB9540_SYSCLK12BUF3VALID_SYSCLK12BUF3VALID_SHIFT 0
+
+#define AB9540_SYSCLK12BUF4VALID_SYSCLK12BUF4VALID_MASK 0xFF
+#define AB9540_SYSCLK12BUF4VALID_SYSCLK12BUF4VALID_SHIFT 0
+
 #endif /* __AB8500_SYSCTRL_H */
diff --git a/include/linux/mfd/abx500/ab8500.h b/include/linux/mfd/abx500/ab8500.h
index 838c6b487cc5..fccc3002f271 100644
--- a/include/linux/mfd/abx500/ab8500.h
+++ b/include/linux/mfd/abx500/ab8500.h
@@ -7,7 +7,32 @@
 #ifndef MFD_AB8500_H
 #define MFD_AB8500_H
 
-#include <linux/device.h>
+#include <linux/mutex.h>
+
+struct device;
+
+/*
+ * AB IC versions
+ *
+ * AB8500_VERSION_AB8500 should be 0xFF but will never be read as need a
+ * non-supported multi-byte I2C access via PRCMU. Set to 0x00 to ease the
+ * print of version string.
+ */
+enum ab8500_version {
+        AB8500_VERSION_AB8500 = 0x0,
+        AB8500_VERSION_AB8505 = 0x1,
+        AB8500_VERSION_AB9540 = 0x2,
+        AB8500_VERSION_AB8540 = 0x3,
+        AB8500_VERSION_UNDEFINED,
+};
+
+/* AB8500 CIDs*/
+#define AB8500_CUTEARLY 0x00
+#define AB8500_CUT1P0   0x10
+#define AB8500_CUT1P1   0x11
+#define AB8500_CUT2P0   0x20
+#define AB8500_CUT3P0   0x30
+#define AB8500_CUT3P3   0x33
 
 /*
  * AB8500 bank addresses
@@ -35,30 +60,34 @@
 
 /*
  * Interrupts
+ * Values used to index into array ab8500_irq_regoffset[] defined in
+ * drivers/mdf/ab8500-core.c
  */
-
-#define AB8500_INT_MAIN_EXT_CH_NOT_OK   0
-#define AB8500_INT_UN_PLUG_TV_DET       1
-#define AB8500_INT_PLUG_TV_DET          2
+/* Definitions for AB8500 and AB9540 */
+/* ab8500_irq_regoffset[0] -> IT[Source|Latch|Mask]1 */
+#define AB8500_INT_MAIN_EXT_CH_NOT_OK   0 /* not 8505/9540 */
+#define AB8500_INT_UN_PLUG_TV_DET       1 /* not 8505/9540 */
+#define AB8500_INT_PLUG_TV_DET          2 /* not 8505/9540 */
 #define AB8500_INT_TEMP_WARM            3
 #define AB8500_INT_PON_KEY2DB_F         4
 #define AB8500_INT_PON_KEY2DB_R         5
 #define AB8500_INT_PON_KEY1DB_F         6
 #define AB8500_INT_PON_KEY1DB_R         7
+/* ab8500_irq_regoffset[1] -> IT[Source|Latch|Mask]2 */
 #define AB8500_INT_BATT_OVV             8
-#define AB8500_INT_MAIN_CH_UNPLUG_DET   10
-#define AB8500_INT_MAIN_CH_PLUG_DET     11
-#define AB8500_INT_USB_ID_DET_F         12
-#define AB8500_INT_USB_ID_DET_R         13
+#define AB8500_INT_MAIN_CH_UNPLUG_DET   10 /* not 8505 */
+#define AB8500_INT_MAIN_CH_PLUG_DET     11 /* not 8505 */
 #define AB8500_INT_VBUS_DET_F           14
 #define AB8500_INT_VBUS_DET_R           15
+/* ab8500_irq_regoffset[2] -> IT[Source|Latch|Mask]3 */
 #define AB8500_INT_VBUS_CH_DROP_END     16
 #define AB8500_INT_RTC_60S              17
 #define AB8500_INT_RTC_ALARM            18
 #define AB8500_INT_BAT_CTRL_INDB        20
 #define AB8500_INT_CH_WD_EXP            21
 #define AB8500_INT_VBUS_OVV             22
-#define AB8500_INT_MAIN_CH_DROP_END     23
+#define AB8500_INT_MAIN_CH_DROP_END     23 /* not 8505/9540 */
+/* ab8500_irq_regoffset[3] -> IT[Source|Latch|Mask]4 */
 #define AB8500_INT_CCN_CONV_ACC         24
 #define AB8500_INT_INT_AUD              25
 #define AB8500_INT_CCEOC                26
@@ -67,7 +96,8 @@
 #define AB8500_INT_LOW_BAT_R            29
 #define AB8500_INT_BUP_CHG_NOT_OK       30
 #define AB8500_INT_BUP_CHG_OK           31
-#define AB8500_INT_GP_HW_ADC_CONV_END   32
+/* ab8500_irq_regoffset[4] -> IT[Source|Latch|Mask]5 */
+#define AB8500_INT_GP_HW_ADC_CONV_END   32 /* not 8505 */
 #define AB8500_INT_ACC_DETECT_1DB_F     33
 #define AB8500_INT_ACC_DETECT_1DB_R     34
 #define AB8500_INT_ACC_DETECT_22DB_F    35
@@ -75,38 +105,43 @@
 #define AB8500_INT_ACC_DETECT_21DB_F    37
 #define AB8500_INT_ACC_DETECT_21DB_R    38
 #define AB8500_INT_GP_SW_ADC_CONV_END   39
-#define AB8500_INT_GPIO6R               40
-#define AB8500_INT_GPIO7R               41
-#define AB8500_INT_GPIO8R               42
-#define AB8500_INT_GPIO9R               43
+/* ab8500_irq_regoffset[5] -> IT[Source|Latch|Mask]7 */
+#define AB8500_INT_GPIO6R               40 /* not 8505/9540 */
+#define AB8500_INT_GPIO7R               41 /* not 8505/9540 */
+#define AB8500_INT_GPIO8R               42 /* not 8505/9540 */
+#define AB8500_INT_GPIO9R               43 /* not 8505/9540 */
 #define AB8500_INT_GPIO10R              44
 #define AB8500_INT_GPIO11R              45
-#define AB8500_INT_GPIO12R              46
+#define AB8500_INT_GPIO12R              46 /* not 8505 */
 #define AB8500_INT_GPIO13R              47
-#define AB8500_INT_GPIO24R              48
-#define AB8500_INT_GPIO25R              49
-#define AB8500_INT_GPIO36R              50
-#define AB8500_INT_GPIO37R              51
-#define AB8500_INT_GPIO38R              52
-#define AB8500_INT_GPIO39R              53
+/* ab8500_irq_regoffset[6] -> IT[Source|Latch|Mask]8 */
+#define AB8500_INT_GPIO24R              48 /* not 8505 */
+#define AB8500_INT_GPIO25R              49 /* not 8505 */
+#define AB8500_INT_GPIO36R              50 /* not 8505/9540 */
+#define AB8500_INT_GPIO37R              51 /* not 8505/9540 */
+#define AB8500_INT_GPIO38R              52 /* not 8505/9540 */
+#define AB8500_INT_GPIO39R              53 /* not 8505/9540 */
 #define AB8500_INT_GPIO40R              54
 #define AB8500_INT_GPIO41R              55
-#define AB8500_INT_GPIO6F               56
-#define AB8500_INT_GPIO7F               57
-#define AB8500_INT_GPIO8F               58
-#define AB8500_INT_GPIO9F               59
+/* ab8500_irq_regoffset[7] -> IT[Source|Latch|Mask]9 */
+#define AB8500_INT_GPIO6F               56 /* not 8505/9540 */
+#define AB8500_INT_GPIO7F               57 /* not 8505/9540 */
+#define AB8500_INT_GPIO8F               58 /* not 8505/9540 */
+#define AB8500_INT_GPIO9F               59 /* not 8505/9540 */
 #define AB8500_INT_GPIO10F              60
 #define AB8500_INT_GPIO11F              61
-#define AB8500_INT_GPIO12F              62
+#define AB8500_INT_GPIO12F              62 /* not 8505 */
 #define AB8500_INT_GPIO13F              63
-#define AB8500_INT_GPIO24F              64
-#define AB8500_INT_GPIO25F              65
-#define AB8500_INT_GPIO36F              66
-#define AB8500_INT_GPIO37F              67
-#define AB8500_INT_GPIO38F              68
-#define AB8500_INT_GPIO39F              69
+/* ab8500_irq_regoffset[8] -> IT[Source|Latch|Mask]10 */
+#define AB8500_INT_GPIO24F              64 /* not 8505 */
+#define AB8500_INT_GPIO25F              65 /* not 8505 */
+#define AB8500_INT_GPIO36F              66 /* not 8505/9540 */
+#define AB8500_INT_GPIO37F              67 /* not 8505/9540 */
+#define AB8500_INT_GPIO38F              68 /* not 8505/9540 */
+#define AB8500_INT_GPIO39F              69 /* not 8505/9540 */
 #define AB8500_INT_GPIO40F              70
 #define AB8500_INT_GPIO41F              71
+/* ab8500_irq_regoffset[9] -> IT[Source|Latch|Mask]12 */
 #define AB8500_INT_ADP_SOURCE_ERROR     72
 #define AB8500_INT_ADP_SINK_ERROR       73
 #define AB8500_INT_ADP_PROBE_PLUG       74
@@ -114,30 +149,67 @@
 #define AB8500_INT_ADP_SENSE_OFF        76
 #define AB8500_INT_USB_PHY_POWER_ERR    78
 #define AB8500_INT_USB_LINK_STATUS      79
+/* ab8500_irq_regoffset[10] -> IT[Source|Latch|Mask]19 */
 #define AB8500_INT_BTEMP_LOW            80
 #define AB8500_INT_BTEMP_LOW_MEDIUM     81
 #define AB8500_INT_BTEMP_MEDIUM_HIGH    82
 #define AB8500_INT_BTEMP_HIGH           83
-#define AB8500_INT_USB_CHARGER_NOT_OK   89
+/* ab8500_irq_regoffset[11] -> IT[Source|Latch|Mask]20 */
+#define AB8500_INT_SRP_DETECT           88
+#define AB8500_INT_USB_CHARGER_NOT_OKR  89
 #define AB8500_INT_ID_WAKEUP_R          90
 #define AB8500_INT_ID_DET_R1R           92
 #define AB8500_INT_ID_DET_R2R           93
 #define AB8500_INT_ID_DET_R3R           94
 #define AB8500_INT_ID_DET_R4R           95
+/* ab8500_irq_regoffset[12] -> IT[Source|Latch|Mask]21 */
 #define AB8500_INT_ID_WAKEUP_F          96
 #define AB8500_INT_ID_DET_R1F           98
 #define AB8500_INT_ID_DET_R2F           99
 #define AB8500_INT_ID_DET_R3F           100
 #define AB8500_INT_ID_DET_R4F           101
-#define AB8500_INT_USB_CHG_DET_DONE     102
+#define AB8500_INT_CHAUTORESTARTAFTSEC  102
+#define AB8500_INT_CHSTOPBYSEC          103
+/* ab8500_irq_regoffset[13] -> IT[Source|Latch|Mask]22 */
 #define AB8500_INT_USB_CH_TH_PROT_F     104
 #define AB8500_INT_USB_CH_TH_PROT_R    105
-#define AB8500_INT_MAIN_CH_TH_PROT_F   106
-#define AB8500_INT_MAIN_CH_TH_PROT_R    107
-#define AB8500_INT_USB_CHARGER_NOT_OKF  111
+#define AB8500_INT_MAIN_CH_TH_PROT_F    106 /* not 8505/9540 */
+#define AB8500_INT_MAIN_CH_TH_PROT_R    107 /* not 8505/9540 */
+#define AB8500_INT_CHCURLIMNOHSCHIRP    109
+#define AB8500_INT_CHCURLIMHSCHIRP      110
+#define AB8500_INT_XTAL32K_KO           111
 
+/* Definitions for AB9540 */
+/* ab8500_irq_regoffset[14] -> IT[Source|Latch|Mask]13 */
+#define AB9540_INT_GPIO50R              113
+#define AB9540_INT_GPIO51R              114 /* not 8505 */
+#define AB9540_INT_GPIO52R              115
+#define AB9540_INT_GPIO53R              116
+#define AB9540_INT_GPIO54R              117 /* not 8505 */
+#define AB9540_INT_IEXT_CH_RF_BFN_R     118
+#define AB9540_INT_IEXT_CH_RF_BFN_F     119
+/* ab8500_irq_regoffset[15] -> IT[Source|Latch|Mask]14 */
+#define AB9540_INT_GPIO50F              121
+#define AB9540_INT_GPIO51F              122 /* not 8505 */
+#define AB9540_INT_GPIO52F              123
+#define AB9540_INT_GPIO53F              124
+#define AB9540_INT_GPIO54F              125 /* not 8505 */
+
+/*
+ * AB8500_AB9540_NR_IRQS is used when configuring the IRQ numbers for the
+ * entire platform. This is a "compile time" constant so this must be set to
+ * the largest possible value that may be encountered with different AB SOCs.
+ * Of the currently supported AB devices, AB8500 and AB9540, it is the AB9540
+ * which is larger.
+ */
 #define AB8500_NR_IRQS                  112
+#define AB8505_NR_IRQS                  128
+#define AB9540_NR_IRQS                  128
+/* This is set to the roof of any AB8500 chip variant IRQ counts */
+#define AB8500_MAX_NR_IRQS              AB9540_NR_IRQS
+
 #define AB8500_NUM_IRQ_REGS             14
+#define AB9540_NUM_IRQ_REGS             17
 
 /**
  * struct ab8500 - ab8500 internal structure
@@ -145,13 +217,18 @@
  * @lock: read/write operations lock
  * @irq_lock: genirq bus lock
  * @irq: irq line
+ * @version: chip version id (e.g. ab8500 or ab9540)
  * @chip_id: chip revision id
  * @write: register write
+ * @write_masked: masked register write
  * @read: register read
  * @rx_buf: rx buf for SPI
  * @tx_buf: tx buf for SPI
  * @mask: cache of IRQ regs for bus lock
  * @oldmask: cache of previous IRQ regs for bus lock
+ * @mask_size: Actual number of valid entries in mask[], oldmask[] and
+ * irq_reg_offset
+ * @irq_reg_offset: Array of offsets into IRQ registers
  */
 struct ab8500 {
         struct device   *dev;
@@ -160,16 +237,20 @@ struct ab8500 {
 
         int             irq_base;
         int             irq;
+        enum ab8500_version version;
         u8              chip_id;
 
-        int (*write) (struct ab8500 *a8500, u16 addr, u8 data);
-        int (*read) (struct ab8500 *a8500, u16 addr);
+        int (*write)(struct ab8500 *ab8500, u16 addr, u8 data);
+        int (*write_masked)(struct ab8500 *ab8500, u16 addr, u8 mask, u8 data);
+        int (*read)(struct ab8500 *ab8500, u16 addr);
 
         unsigned long   tx_buf[4];
         unsigned long   rx_buf[4];
 
-        u8 mask[AB8500_NUM_IRQ_REGS];
-        u8 oldmask[AB8500_NUM_IRQ_REGS];
+        u8 *mask;
+        u8 *oldmask;
+        int mask_size;
+        const int *irq_reg_offset;
 };
 
 struct regulator_reg_init;
@@ -195,7 +276,52 @@ struct ab8500_platform_data {
         struct ab8500_gpio_platform_data *gpio;
 };
 
-extern int __devinit ab8500_init(struct ab8500 *ab8500);
+extern int __devinit ab8500_init(struct ab8500 *ab8500,
+                                 enum ab8500_version version);
 extern int __devexit ab8500_exit(struct ab8500 *ab8500);
 
+static inline int is_ab8500(struct ab8500 *ab)
+{
+        return ab->version == AB8500_VERSION_AB8500;
+}
+
+static inline int is_ab8505(struct ab8500 *ab)
+{
+        return ab->version == AB8500_VERSION_AB8505;
+}
+
+static inline int is_ab9540(struct ab8500 *ab)
+{
+        return ab->version == AB8500_VERSION_AB9540;
+}
+
+static inline int is_ab8540(struct ab8500 *ab)
+{
+        return ab->version == AB8500_VERSION_AB8540;
+}
+
+/* exclude also ab8505, ab9540... */
+static inline int is_ab8500_1p0_or_earlier(struct ab8500 *ab)
+{
+        return (is_ab8500(ab) && (ab->chip_id <= AB8500_CUT1P0));
+}
+
+/* exclude also ab8505, ab9540... */
+static inline int is_ab8500_1p1_or_earlier(struct ab8500 *ab)
+{
+        return (is_ab8500(ab) && (ab->chip_id <= AB8500_CUT1P1));
+}
+
+/* exclude also ab8505, ab9540... */
+static inline int is_ab8500_2p0_or_earlier(struct ab8500 *ab)
+{
+        return (is_ab8500(ab) && (ab->chip_id <= AB8500_CUT2P0));
+}
+
+/* exclude also ab8505, ab9540... */
+static inline int is_ab8500_2p0(struct ab8500 *ab)
+{
+        return (is_ab8500(ab) && (ab->chip_id == AB8500_CUT2P0));
+}
+
 #endif /* MFD_AB8500_H */
diff --git a/include/linux/mfd/anatop.h b/include/linux/mfd/anatop.h
new file mode 100644
index 000000000000..22c1007d3ec5
--- /dev/null
+++ b/include/linux/mfd/anatop.h
@@ -0,0 +1,40 @@
+/*
+ * anatop.h - Anatop MFD driver
+ *
+ *  Copyright (C) 2012 Ying-Chun Liu (PaulLiu) <paul.liu@linaro.org>
+ *  Copyright (C) 2012 Linaro
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef __LINUX_MFD_ANATOP_H
+#define __LINUX_MFD_ANATOP_H
+
+#include <linux/spinlock.h>
+
+/**
+ * anatop - MFD data
+ * @ioreg: ioremap register
+ * @reglock: spinlock for register read/write
+ */
+struct anatop {
+        void *ioreg;
+        spinlock_t reglock;
+};
+
+extern u32 anatop_get_bits(struct anatop *, u32, int, int);
+extern void anatop_set_bits(struct anatop *, u32, int, int, u32);
+
+#endif /*  __LINUX_MFD_ANATOP_H */
diff --git a/include/linux/mfd/da9052/da9052.h b/include/linux/mfd/da9052/da9052.h
index 5702d1be13b4..7ffbd6e9e7fc 100644
--- a/include/linux/mfd/da9052/da9052.h
+++ b/include/linux/mfd/da9052/da9052.h
@@ -76,8 +76,6 @@ enum da9052_chip_id {
 struct da9052_pdata;
 
 struct da9052 {
-        struct mutex io_lock;
-
         struct device *dev;
         struct regmap *regmap;
 
diff --git a/include/linux/mfd/db8500-prcmu.h b/include/linux/mfd/db8500-prcmu.h
index 60d27f7bfc1f..b3a43b1263fe 100644
--- a/include/linux/mfd/db8500-prcmu.h
+++ b/include/linux/mfd/db8500-prcmu.h
@@ -11,6 +11,24 @@
 #define __MFD_DB8500_PRCMU_H
 
 #include <linux/interrupt.h>
+#include <linux/bitops.h>
+
+/*
+ * Registers
+ */
+#define DB8500_PRCM_GPIOCR 0x138
+#define DB8500_PRCM_GPIOCR_DBG_UARTMOD_CMD0     BIT(0)
+#define DB8500_PRCM_GPIOCR_DBG_STM_APE_CMD      BIT(9)
+#define DB8500_PRCM_GPIOCR_DBG_STM_MOD_CMD1     BIT(11)
+#define DB8500_PRCM_GPIOCR_SPI2_SELECT          BIT(23)
+
+#define DB8500_PRCM_LINE_VALUE 0x170
+#define DB8500_PRCM_LINE_VALUE_HSI_CAWAKE0      BIT(3)
+
+#define DB8500_PRCM_DSI_SW_RESET 0x324
+#define DB8500_PRCM_DSI_SW_RESET_DSI0_SW_RESETN BIT(0)
+#define DB8500_PRCM_DSI_SW_RESET_DSI1_SW_RESETN BIT(1)
+#define DB8500_PRCM_DSI_SW_RESET_DSI2_SW_RESETN BIT(2)
 
 /* This portion previously known as <mach/prcmu-fw-defs_v1.h> */
 
@@ -421,40 +439,22 @@ enum auto_enable {
 /* End of file previously known as prcmu-fw-defs_v1.h */
 
 /**
- * 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.
+ * enum prcmu_power_status - results from set_power_state
+ * @PRCMU_SLEEP_OK: Sleep went ok
+ * @PRCMU_DEEP_SLEEP_OK: DeepSleep went ok
+ * @PRCMU_IDLE_OK: Idle went ok
+ * @PRCMU_DEEPIDLE_OK: DeepIdle went ok
+ * @PRCMU_PRCMU2ARMPENDINGIT_ER: Pending interrupt detected
+ * @PRCMU_ARMPENDINGIT_ER: Pending interrupt detected
  *
- * 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
+enum prcmu_power_status {
+        PRCMU_SLEEP_OK                  = 0xf3,
+        PRCMU_DEEP_SLEEP_OK             = 0xf6,
+        PRCMU_IDLE_OK                   = 0xf0,
+        PRCMU_DEEPIDLE_OK               = 0xe3,
+        PRCMU_PRCMU2ARMPENDINGIT_ER     = 0x91,
+        PRCMU_ARMPENDINGIT_ER           = 0x93,
 };
 
 /*
@@ -493,6 +493,20 @@ struct prcmu_auto_pm_config {
         u8 sva_policy;
 };
 
+#define PRCMU_FW_PROJECT_U8500          2
+#define PRCMU_FW_PROJECT_U9500          4
+#define PRCMU_FW_PROJECT_U8500_C2       7
+#define PRCMU_FW_PROJECT_U9500_C2       11
+#define PRCMU_FW_PROJECT_U8520          13
+#define PRCMU_FW_PROJECT_U8420          14
+
+struct prcmu_fw_version {
+        u8 project;
+        u8 api_version;
+        u8 func_version;
+        u8 errata;
+};
+
 #ifdef CONFIG_MFD_DB8500_PRCMU
 
 void db8500_prcmu_early_init(void);
@@ -500,42 +514,41 @@ 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);
 bool prcmu_has_arm_maxopp(void);
-bool prcmu_is_u8400(void);
-int prcmu_set_ape_opp(u8 opp);
-int prcmu_get_ape_opp(void);
+struct prcmu_fw_version *prcmu_get_fw_version(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);
-/* NOTE! Use regulator framework instead */
-int prcmu_set_hwacc(u16 hw_acc_dev, u8 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_set_clock_divider(u8 clock, u8 divider);
-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 db8500_prcmu_config_hotdog(u8 threshold);
+int db8500_prcmu_config_hotmon(u8 low, u8 high);
+int db8500_prcmu_start_temp_sense(u16 cycles32k);
+int db8500_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_modem_reset(void);
-void prcmu_enable_spi2(void);
-void prcmu_disable_spi2(void);
+void db8500_prcmu_modem_reset(void);
 
-int prcmu_config_a9wdog(u8 num, bool sleep_auto_off);
-int prcmu_enable_a9wdog(u8 id);
-int prcmu_disable_a9wdog(u8 id);
-int prcmu_kick_a9wdog(u8 id);
-int prcmu_load_a9wdog(u8 id, u32 val);
+int db8500_prcmu_config_a9wdog(u8 num, bool sleep_auto_off);
+int db8500_prcmu_enable_a9wdog(u8 id);
+int db8500_prcmu_disable_a9wdog(u8 id);
+int db8500_prcmu_kick_a9wdog(u8 id);
+int db8500_prcmu_load_a9wdog(u8 id, u32 val);
 
 void db8500_prcmu_system_reset(u16 reset_code);
 int db8500_prcmu_set_power_state(u8 state, bool keep_ulp_clk, bool keep_ap_pll);
+u8 db8500_prcmu_get_power_state_result(void);
+int db8500_prcmu_gic_decouple(void);
+int db8500_prcmu_gic_recouple(void);
+int db8500_prcmu_copy_gic_settings(void);
+bool db8500_prcmu_gic_pending_irq(void);
+bool db8500_prcmu_pending_irq(void);
+bool db8500_prcmu_is_cpu_in_wfi(int cpu);
 void db8500_prcmu_enable_wakeups(u32 wakeups);
 int db8500_prcmu_set_epod(u16 epod_id, u8 epod_state);
 int db8500_prcmu_request_clock(u8 clock, bool enable);
@@ -549,6 +562,14 @@ u16 db8500_prcmu_get_reset_code(void);
 bool db8500_prcmu_is_ac_wake_requested(void);
 int db8500_prcmu_set_arm_opp(u8 opp);
 int db8500_prcmu_get_arm_opp(void);
+int db8500_prcmu_set_ape_opp(u8 opp);
+int db8500_prcmu_get_ape_opp(void);
+int db8500_prcmu_set_ddr_opp(u8 opp);
+int db8500_prcmu_get_ddr_opp(void);
+
+u32 db8500_prcmu_read(unsigned int reg);
+void db8500_prcmu_write(unsigned int reg, u32 value);
+void db8500_prcmu_write_masked(unsigned int reg, u32 mask, u32 value);
 
 #else /* !CONFIG_MFD_DB8500_PRCMU */
 
@@ -574,17 +595,17 @@ static inline bool prcmu_has_arm_maxopp(void)
         return false;
 }
 
-static inline bool prcmu_is_u8400(void)
+static inline struct prcmu_fw_version *prcmu_get_fw_version(void)
 {
-        return false;
+        return NULL;
 }
 
-static inline int prcmu_set_ape_opp(u8 opp)
+static inline int db8500_prcmu_set_ape_opp(u8 opp)
 {
         return 0;
 }
 
-static inline int prcmu_get_ape_opp(void)
+static inline int db8500_prcmu_get_ape_opp(void)
 {
         return APE_100_OPP;
 }
@@ -599,21 +620,16 @@ static inline int prcmu_release_usb_wakeup_state(void)
         return 0;
 }
 
-static inline int prcmu_set_ddr_opp(u8 opp)
+static inline int db8500_prcmu_set_ddr_opp(u8 opp)
 {
         return 0;
 }
 
-static inline int prcmu_get_ddr_opp(void)
+static inline int db8500_prcmu_get_ddr_opp(void)
 {
         return DDR_100_OPP;
 }
 
-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)
 {
@@ -634,22 +650,22 @@ static inline int prcmu_set_clock_divider(u8 clock, u8 divider)
         return 0;
 }
 
-static inline int prcmu_config_hotdog(u8 threshold)
+static inline int db8500_prcmu_config_hotdog(u8 threshold)
 {
         return 0;
 }
 
-static inline int prcmu_config_hotmon(u8 low, u8 high)
+static inline int db8500_prcmu_config_hotmon(u8 low, u8 high)
 {
         return 0;
 }
 
-static inline int prcmu_start_temp_sense(u16 cycles32k)
+static inline int db8500_prcmu_start_temp_sense(u16 cycles32k)
 {
         return 0;
 }
 
-static inline int prcmu_stop_temp_sense(void)
+static inline int db8500_prcmu_stop_temp_sense(void)
 {
         return 0;
 }
@@ -668,22 +684,17 @@ static inline void prcmu_ac_wake_req(void) {}
 
 static inline void prcmu_ac_sleep_req(void) {}
 
-static inline void prcmu_modem_reset(void) {}
+static inline void db8500_prcmu_modem_reset(void) {}
 
-static inline int prcmu_enable_spi2(void)
-{
-        return 0;
-}
+static inline void db8500_prcmu_system_reset(u16 reset_code) {}
 
-static inline int prcmu_disable_spi2(void)
+static inline int db8500_prcmu_set_power_state(u8 state, bool keep_ulp_clk,
+        bool keep_ap_pll)
 {
         return 0;
 }
 
-static inline void db8500_prcmu_system_reset(u16 reset_code) {}
-
-static inline int db8500_prcmu_set_power_state(u8 state, bool keep_ulp_clk,
-        bool keep_ap_pll)
+static inline u8 db8500_prcmu_get_power_state_result(void)
 {
         return 0;
 }
@@ -729,27 +740,27 @@ static inline u16 db8500_prcmu_get_reset_code(void)
         return 0;
 }
 
-static inline int prcmu_config_a9wdog(u8 num, bool sleep_auto_off)
+static inline int db8500_prcmu_config_a9wdog(u8 num, bool sleep_auto_off)
 {
         return 0;
 }
 
-static inline int prcmu_enable_a9wdog(u8 id)
+static inline int db8500_prcmu_enable_a9wdog(u8 id)
 {
         return 0;
 }
 
-static inline int prcmu_disable_a9wdog(u8 id)
+static inline int db8500_prcmu_disable_a9wdog(u8 id)
 {
         return 0;
 }
 
-static inline int prcmu_kick_a9wdog(u8 id)
+static inline int db8500_prcmu_kick_a9wdog(u8 id)
 {
         return 0;
 }
 
-static inline int prcmu_load_a9wdog(u8 id, u32 val)
+static inline int db8500_prcmu_load_a9wdog(u8 id, u32 val)
 {
         return 0;
 }
@@ -769,6 +780,16 @@ static inline int db8500_prcmu_get_arm_opp(void)
         return 0;
 }
 
+static inline u32 db8500_prcmu_read(unsigned int reg)
+{
+        return 0;
+}
+
+static inline void db8500_prcmu_write(unsigned int reg, u32 value) {}
+
+static inline void db8500_prcmu_write_masked(unsigned int reg, u32 mask,
+        u32 value) {}
+
 #endif /* !CONFIG_MFD_DB8500_PRCMU */
 
 #endif /* __MFD_DB8500_PRCMU_H */
diff --git a/include/linux/mfd/dbx500-prcmu.h b/include/linux/mfd/dbx500-prcmu.h
index bac942f959c1..d7674eb7305f 100644
--- a/include/linux/mfd/dbx500-prcmu.h
+++ b/include/linux/mfd/dbx500-prcmu.h
@@ -10,7 +10,7 @@
 
 #include <linux/interrupt.h>
 #include <linux/notifier.h>
-#include <asm/mach-types.h>
+#include <linux/err.h>
 
 /* PRCMU Wakeup defines */
 enum prcmu_wakeup_index {
@@ -80,6 +80,29 @@ enum prcmu_wakeup_index {
 #define EPOD_STATE_ON_CLK_OFF   0x03
 #define EPOD_STATE_ON           0x04
 
+/* DB5500 CLKOUT IDs */
+enum {
+        DB5500_CLKOUT0 = 0,
+        DB5500_CLKOUT1,
+};
+
+/* DB5500 CLKOUTx sources */
+enum {
+        DB5500_CLKOUT_REF_CLK_SEL0,
+        DB5500_CLKOUT_RTC_CLK0_SEL0,
+        DB5500_CLKOUT_ULP_CLK_SEL0,
+        DB5500_CLKOUT_STATIC0,
+        DB5500_CLKOUT_REFCLK,
+        DB5500_CLKOUT_ULPCLK,
+        DB5500_CLKOUT_ARMCLK,
+        DB5500_CLKOUT_SYSACC0CLK,
+        DB5500_CLKOUT_SOC0PLLCLK,
+        DB5500_CLKOUT_SOC1PLLCLK,
+        DB5500_CLKOUT_DDRPLLCLK,
+        DB5500_CLKOUT_TVCLK,
+        DB5500_CLKOUT_IRDACLK,
+};
+
 /*
  * CLKOUT sources
  */
@@ -111,6 +134,7 @@ enum prcmu_clock {
         PRCMU_MSP1CLK,
         PRCMU_I2CCLK,
         PRCMU_SDMMCCLK,
+        PRCMU_SPARE1CLK,
         PRCMU_SLIMCLK,
         PRCMU_PER1CLK,
         PRCMU_PER2CLK,
@@ -139,12 +163,20 @@ enum prcmu_clock {
         PRCMU_IRRCCLK,
         PRCMU_SIACLK,
         PRCMU_SVACLK,
+        PRCMU_ACLK,
         PRCMU_NUM_REG_CLOCKS,
         PRCMU_SYSCLK = PRCMU_NUM_REG_CLOCKS,
+        PRCMU_CDCLK,
         PRCMU_TIMCLK,
         PRCMU_PLLSOC0,
         PRCMU_PLLSOC1,
         PRCMU_PLLDDR,
+        PRCMU_PLLDSI,
+        PRCMU_DSI0CLK,
+        PRCMU_DSI1CLK,
+        PRCMU_DSI0ESCCLK,
+        PRCMU_DSI1ESCCLK,
+        PRCMU_DSI2ESCCLK,
 };
 
 /**
@@ -153,12 +185,14 @@ enum prcmu_clock {
  * @APE_NO_CHANGE: The APE operating point is unchanged
  * @APE_100_OPP: The new APE operating point is ape100opp
  * @APE_50_OPP: 50%
+ * @APE_50_PARTLY_25_OPP: 50%, except some clocks at 25%.
  */
 enum ape_opp {
         APE_OPP_INIT = 0x00,
         APE_NO_CHANGE = 0x01,
         APE_100_OPP = 0x02,
-        APE_50_OPP = 0x03
+        APE_50_OPP = 0x03,
+        APE_50_PARTLY_25_OPP = 0xFF,
 };
 
 /**
@@ -218,9 +252,11 @@ enum ddr_pwrst {
 
 #if defined(CONFIG_UX500_SOC_DB8500) || defined(CONFIG_UX500_SOC_DB5500)
 
+#include <mach/id.h>
+
 static inline void __init prcmu_early_init(void)
 {
-        if (machine_is_u5500())
+        if (cpu_is_u5500())
                 return db5500_prcmu_early_init();
         else
                 return db8500_prcmu_early_init();
@@ -229,7 +265,7 @@ static inline void __init prcmu_early_init(void)
 static inline int prcmu_set_power_state(u8 state, bool keep_ulp_clk,
                 bool keep_ap_pll)
 {
-        if (machine_is_u5500())
+        if (cpu_is_u5500())
                 return db5500_prcmu_set_power_state(state, keep_ulp_clk,
                         keep_ap_pll);
         else
@@ -237,9 +273,65 @@ static inline int prcmu_set_power_state(u8 state, bool keep_ulp_clk,
                         keep_ap_pll);
 }
 
+static inline u8 prcmu_get_power_state_result(void)
+{
+        if (cpu_is_u5500())
+                return -EINVAL;
+        else
+                return db8500_prcmu_get_power_state_result();
+}
+
+static inline int prcmu_gic_decouple(void)
+{
+        if (cpu_is_u5500())
+                return -EINVAL;
+        else
+                return db8500_prcmu_gic_decouple();
+}
+
+static inline int prcmu_gic_recouple(void)
+{
+        if (cpu_is_u5500())
+                return -EINVAL;
+        else
+                return db8500_prcmu_gic_recouple();
+}
+
+static inline bool prcmu_gic_pending_irq(void)
+{
+        if (cpu_is_u5500())
+                return -EINVAL;
+        else
+                return db8500_prcmu_gic_pending_irq();
+}
+
+static inline bool prcmu_is_cpu_in_wfi(int cpu)
+{
+        if (cpu_is_u5500())
+                return -EINVAL;
+        else
+                return db8500_prcmu_is_cpu_in_wfi(cpu);
+}
+
+static inline int prcmu_copy_gic_settings(void)
+{
+        if (cpu_is_u5500())
+                return -EINVAL;
+        else
+                return db8500_prcmu_copy_gic_settings();
+}
+
+static inline bool prcmu_pending_irq(void)
+{
+        if (cpu_is_u5500())
+                return -EINVAL;
+        else
+                return db8500_prcmu_pending_irq();
+}
+
 static inline int prcmu_set_epod(u16 epod_id, u8 epod_state)
 {
-        if (machine_is_u5500())
+        if (cpu_is_u5500())
                 return -EINVAL;
         else
                 return db8500_prcmu_set_epod(epod_id, epod_state);
@@ -247,7 +339,7 @@ static inline int prcmu_set_epod(u16 epod_id, u8 epod_state)
 
 static inline void prcmu_enable_wakeups(u32 wakeups)
 {
-        if (machine_is_u5500())
+        if (cpu_is_u5500())
                 db5500_prcmu_enable_wakeups(wakeups);
         else
                 db8500_prcmu_enable_wakeups(wakeups);
@@ -260,7 +352,7 @@ static inline void prcmu_disable_wakeups(void)
 
 static inline void prcmu_config_abb_event_readout(u32 abb_events)
 {
-        if (machine_is_u5500())
+        if (cpu_is_u5500())
                 db5500_prcmu_config_abb_event_readout(abb_events);
         else
                 db8500_prcmu_config_abb_event_readout(abb_events);
@@ -268,7 +360,7 @@ static inline void prcmu_config_abb_event_readout(u32 abb_events)
 
 static inline void prcmu_get_abb_event_buffer(void __iomem **buf)
 {
-        if (machine_is_u5500())
+        if (cpu_is_u5500())
                 db5500_prcmu_get_abb_event_buffer(buf);
         else
                 db8500_prcmu_get_abb_event_buffer(buf);
@@ -276,25 +368,40 @@ static inline void prcmu_get_abb_event_buffer(void __iomem **buf)
 
 int prcmu_abb_read(u8 slave, u8 reg, u8 *value, u8 size);
 int prcmu_abb_write(u8 slave, u8 reg, u8 *value, u8 size);
+int prcmu_abb_write_masked(u8 slave, u8 reg, u8 *value, u8 *mask, u8 size);
 
 int prcmu_config_clkout(u8 clkout, u8 source, u8 div);
 
 static inline int prcmu_request_clock(u8 clock, bool enable)
 {
-        if (machine_is_u5500())
+        if (cpu_is_u5500())
                 return db5500_prcmu_request_clock(clock, enable);
         else
                 return db8500_prcmu_request_clock(clock, enable);
 }
 
-int prcmu_set_ape_opp(u8 opp);
-int prcmu_get_ape_opp(void);
-int prcmu_set_ddr_opp(u8 opp);
-int prcmu_get_ddr_opp(void);
+unsigned long prcmu_clock_rate(u8 clock);
+long prcmu_round_clock_rate(u8 clock, unsigned long rate);
+int prcmu_set_clock_rate(u8 clock, unsigned long rate);
+
+static inline int prcmu_set_ddr_opp(u8 opp)
+{
+        if (cpu_is_u5500())
+                return -EINVAL;
+        else
+                return db8500_prcmu_set_ddr_opp(opp);
+}
+static inline int prcmu_get_ddr_opp(void)
+{
+        if (cpu_is_u5500())
+                return -EINVAL;
+        else
+                return db8500_prcmu_get_ddr_opp();
+}
 
 static inline int prcmu_set_arm_opp(u8 opp)
 {
-        if (machine_is_u5500())
+        if (cpu_is_u5500())
                 return -EINVAL;
         else
                 return db8500_prcmu_set_arm_opp(opp);
@@ -302,15 +409,31 @@ static inline int prcmu_set_arm_opp(u8 opp)
 
 static inline int prcmu_get_arm_opp(void)
 {
-        if (machine_is_u5500())
+        if (cpu_is_u5500())
                 return -EINVAL;
         else
                 return db8500_prcmu_get_arm_opp();
 }
 
+static inline int prcmu_set_ape_opp(u8 opp)
+{
+        if (cpu_is_u5500())
+                return -EINVAL;
+        else
+                return db8500_prcmu_set_ape_opp(opp);
+}
+
+static inline int prcmu_get_ape_opp(void)
+{
+        if (cpu_is_u5500())
+                return -EINVAL;
+        else
+                return db8500_prcmu_get_ape_opp();
+}
+
 static inline void prcmu_system_reset(u16 reset_code)
 {
-        if (machine_is_u5500())
+        if (cpu_is_u5500())
                 return db5500_prcmu_system_reset(reset_code);
         else
                 return db8500_prcmu_system_reset(reset_code);
@@ -318,7 +441,7 @@ static inline void prcmu_system_reset(u16 reset_code)
 
 static inline u16 prcmu_get_reset_code(void)
 {
-        if (machine_is_u5500())
+        if (cpu_is_u5500())
                 return db5500_prcmu_get_reset_code();
         else
                 return db8500_prcmu_get_reset_code();
@@ -326,10 +449,17 @@ static inline u16 prcmu_get_reset_code(void)
 
 void prcmu_ac_wake_req(void);
 void prcmu_ac_sleep_req(void);
-void prcmu_modem_reset(void);
+static inline void prcmu_modem_reset(void)
+{
+        if (cpu_is_u5500())
+                return;
+        else
+                return db8500_prcmu_modem_reset();
+}
+
 static inline bool prcmu_is_ac_wake_requested(void)
 {
-        if (machine_is_u5500())
+        if (cpu_is_u5500())
                 return db5500_prcmu_is_ac_wake_requested();
         else
                 return db8500_prcmu_is_ac_wake_requested();
@@ -337,7 +467,7 @@ static inline bool prcmu_is_ac_wake_requested(void)
 
 static inline int prcmu_set_display_clocks(void)
 {
-        if (machine_is_u5500())
+        if (cpu_is_u5500())
                 return db5500_prcmu_set_display_clocks();
         else
                 return db8500_prcmu_set_display_clocks();
@@ -345,7 +475,7 @@ static inline int prcmu_set_display_clocks(void)
 
 static inline int prcmu_disable_dsipll(void)
 {
-        if (machine_is_u5500())
+        if (cpu_is_u5500())
                 return db5500_prcmu_disable_dsipll();
         else
                 return db8500_prcmu_disable_dsipll();
@@ -353,7 +483,7 @@ static inline int prcmu_disable_dsipll(void)
 
 static inline int prcmu_enable_dsipll(void)
 {
-        if (machine_is_u5500())
+        if (cpu_is_u5500())
                 return db5500_prcmu_enable_dsipll();
         else
                 return db8500_prcmu_enable_dsipll();
@@ -361,11 +491,107 @@ static inline int prcmu_enable_dsipll(void)
 
 static inline int prcmu_config_esram0_deep_sleep(u8 state)
 {
-        if (machine_is_u5500())
+        if (cpu_is_u5500())
                 return -EINVAL;
         else
                 return db8500_prcmu_config_esram0_deep_sleep(state);
 }
+
+static inline int prcmu_config_hotdog(u8 threshold)
+{
+        if (cpu_is_u5500())
+                return -EINVAL;
+        else
+                return db8500_prcmu_config_hotdog(threshold);
+}
+
+static inline int prcmu_config_hotmon(u8 low, u8 high)
+{
+        if (cpu_is_u5500())
+                return -EINVAL;
+        else
+                return db8500_prcmu_config_hotmon(low, high);
+}
+
+static inline int prcmu_start_temp_sense(u16 cycles32k)
+{
+        if (cpu_is_u5500())
+                return  -EINVAL;
+        else
+                return  db8500_prcmu_start_temp_sense(cycles32k);
+}
+
+static inline int prcmu_stop_temp_sense(void)
+{
+        if (cpu_is_u5500())
+                return  -EINVAL;
+        else
+                return  db8500_prcmu_stop_temp_sense();
+}
+
+static inline u32 prcmu_read(unsigned int reg)
+{
+        if (cpu_is_u5500())
+                return -EINVAL;
+        else
+                return db8500_prcmu_read(reg);
+}
+
+static inline void prcmu_write(unsigned int reg, u32 value)
+{
+        if (cpu_is_u5500())
+                return;
+        else
+                db8500_prcmu_write(reg, value);
+}
+
+static inline void prcmu_write_masked(unsigned int reg, u32 mask, u32 value)
+{
+        if (cpu_is_u5500())
+                return;
+        else
+                db8500_prcmu_write_masked(reg, mask, value);
+}
+
+static inline int prcmu_enable_a9wdog(u8 id)
+{
+        if (cpu_is_u5500())
+                return -EINVAL;
+        else
+                return db8500_prcmu_enable_a9wdog(id);
+}
+
+static inline int prcmu_disable_a9wdog(u8 id)
+{
+        if (cpu_is_u5500())
+                return -EINVAL;
+        else
+                return db8500_prcmu_disable_a9wdog(id);
+}
+
+static inline int prcmu_kick_a9wdog(u8 id)
+{
+        if (cpu_is_u5500())
+                return -EINVAL;
+        else
+                return db8500_prcmu_kick_a9wdog(id);
+}
+
+static inline int prcmu_load_a9wdog(u8 id, u32 timeout)
+{
+        if (cpu_is_u5500())
+                return -EINVAL;
+        else
+                return db8500_prcmu_load_a9wdog(id, timeout);
+}
+
+static inline int prcmu_config_a9wdog(u8 num, bool sleep_auto_off)
+{
+        if (cpu_is_u5500())
+                return -EINVAL;
+        else
+                return db8500_prcmu_config_a9wdog(num, sleep_auto_off);
+}
 #else
 
 static inline void __init prcmu_early_init(void) {}
@@ -395,6 +621,12 @@ static inline int prcmu_abb_write(u8 slave, u8 reg, u8 *value, u8 size)
         return -ENOSYS;
 }
 
+static inline int prcmu_abb_write_masked(u8 slave, u8 reg, u8 *value, u8 *mask,
+        u8 size)
+{
+        return -ENOSYS;
+}
+
 static inline int prcmu_config_clkout(u8 clkout, u8 source, u8 div)
 {
         return 0;
@@ -405,6 +637,21 @@ static inline int prcmu_request_clock(u8 clock, bool enable)
         return 0;
 }
 
+static inline long prcmu_round_clock_rate(u8 clock, unsigned long rate)
+{
+        return 0;
+}
+
+static inline int prcmu_set_clock_rate(u8 clock, unsigned long rate)
+{
+        return 0;
+}
+
+static inline unsigned long prcmu_clock_rate(u8 clock)
+{
+        return 0;
+}
+
 static inline int prcmu_set_ape_opp(u8 opp)
 {
         return 0;
@@ -480,14 +727,133 @@ static inline void prcmu_get_abb_event_buffer(void __iomem **buf)
         *buf = NULL;
 }
 
+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 u32 prcmu_read(unsigned int reg)
+{
+        return 0;
+}
+
+static inline void prcmu_write(unsigned int reg, u32 value) {}
+
+static inline void prcmu_write_masked(unsigned int reg, u32 mask, u32 value) {}
+
+#endif
+
+static inline void prcmu_set(unsigned int reg, u32 bits)
+{
+        prcmu_write_masked(reg, bits, bits);
+}
+
+static inline void prcmu_clear(unsigned int reg, u32 bits)
+{
+        prcmu_write_masked(reg, bits, 0);
+}
+
+#if defined(CONFIG_UX500_SOC_DB8500) || defined(CONFIG_UX500_SOC_DB5500)
+
+/**
+ * prcmu_enable_spi2 - Enables pin muxing for SPI2 on OtherAlternateC1.
+ */
+static inline void prcmu_enable_spi2(void)
+{
+        if (cpu_is_u8500())
+                prcmu_set(DB8500_PRCM_GPIOCR, DB8500_PRCM_GPIOCR_SPI2_SELECT);
+}
+
+/**
+ * prcmu_disable_spi2 - Disables pin muxing for SPI2 on OtherAlternateC1.
+ */
+static inline void prcmu_disable_spi2(void)
+{
+        if (cpu_is_u8500())
+                prcmu_clear(DB8500_PRCM_GPIOCR, DB8500_PRCM_GPIOCR_SPI2_SELECT);
+}
+
+/**
+ * prcmu_enable_stm_mod_uart - Enables pin muxing for STMMOD
+ * and UARTMOD on OtherAlternateC3.
+ */
+static inline void prcmu_enable_stm_mod_uart(void)
+{
+        if (cpu_is_u8500()) {
+                prcmu_set(DB8500_PRCM_GPIOCR,
+                        (DB8500_PRCM_GPIOCR_DBG_STM_MOD_CMD1 |
+                         DB8500_PRCM_GPIOCR_DBG_UARTMOD_CMD0));
+        }
+}
+
+/**
+ * prcmu_disable_stm_mod_uart - Disables pin muxing for STMMOD
+ * and UARTMOD on OtherAlternateC3.
+ */
+static inline void prcmu_disable_stm_mod_uart(void)
+{
+        if (cpu_is_u8500()) {
+                prcmu_clear(DB8500_PRCM_GPIOCR,
+                        (DB8500_PRCM_GPIOCR_DBG_STM_MOD_CMD1 |
+                         DB8500_PRCM_GPIOCR_DBG_UARTMOD_CMD0));
+        }
+}
+
+/**
+ * prcmu_enable_stm_ape - Enables pin muxing for STM APE on OtherAlternateC1.
+ */
+static inline void prcmu_enable_stm_ape(void)
+{
+        if (cpu_is_u8500()) {
+                prcmu_set(DB8500_PRCM_GPIOCR,
+                        DB8500_PRCM_GPIOCR_DBG_STM_APE_CMD);
+        }
+}
+
+/**
+ * prcmu_disable_stm_ape - Disables pin muxing for STM APE on OtherAlternateC1.
+ */
+static inline void prcmu_disable_stm_ape(void)
+{
+        if (cpu_is_u8500()) {
+                prcmu_clear(DB8500_PRCM_GPIOCR,
+                        DB8500_PRCM_GPIOCR_DBG_STM_APE_CMD);
+        }
+}
+
+#else
+
+static inline void prcmu_enable_spi2(void) {}
+static inline void prcmu_disable_spi2(void) {}
+static inline void prcmu_enable_stm_mod_uart(void) {}
+static inline void prcmu_disable_stm_mod_uart(void) {}
+static inline void prcmu_enable_stm_ape(void) {}
+static inline void prcmu_disable_stm_ape(void) {}
+
 #endif
 
 /* PRCMU QoS APE OPP class */
 #define PRCMU_QOS_APE_OPP 1
 #define PRCMU_QOS_DDR_OPP 2
+#define PRCMU_QOS_ARM_OPP 3
 #define PRCMU_QOS_DEFAULT_VALUE -1
 
-#ifdef CONFIG_UX500_PRCMU_QOS_POWER
+#ifdef CONFIG_DBX500_PRCMU_QOS_POWER
 
 unsigned long prcmu_qos_get_cpufreq_opp_delay(void);
 void prcmu_qos_set_cpufreq_opp_delay(unsigned long);
diff --git a/include/linux/mfd/max8997.h b/include/linux/mfd/max8997.h
index fff590521e50..28726dd540f2 100644
--- a/include/linux/mfd/max8997.h
+++ b/include/linux/mfd/max8997.h
@@ -131,6 +131,55 @@ struct max8997_muic_platform_data {
         int num_init_data;
 };
 
+enum max8997_haptic_motor_type {
+        MAX8997_HAPTIC_ERM,
+        MAX8997_HAPTIC_LRA,
+};
+
+enum max8997_haptic_pulse_mode {
+        MAX8997_EXTERNAL_MODE,
+        MAX8997_INTERNAL_MODE,
+};
+
+enum max8997_haptic_pwm_divisor {
+        MAX8997_PWM_DIVISOR_32,
+        MAX8997_PWM_DIVISOR_64,
+        MAX8997_PWM_DIVISOR_128,
+        MAX8997_PWM_DIVISOR_256,
+};
+
+/**
+ * max8997_haptic_platform_data
+ * @pwm_channel_id: channel number of PWM device
+ *                  valid for MAX8997_EXTERNAL_MODE
+ * @pwm_period: period in nano second for PWM device
+ *              valid for MAX8997_EXTERNAL_MODE
+ * @type: motor type
+ * @mode: pulse mode
+ *     MAX8997_EXTERNAL_MODE: external PWM device is used to control motor
+ *     MAX8997_INTERNAL_MODE: internal pulse generator is used to control motor
+ * @pwm_divisor: divisor for external PWM device
+ * @internal_mode_pattern: internal mode pattern for internal mode
+ *     [0 - 3]: valid pattern number
+ * @pattern_cycle: the number of cycles of the waveform
+ *                 for the internal mode pattern
+ *     [0 - 15]: available cycles
+ * @pattern_signal_period: period of the waveform for the internal mode pattern
+ *     [0 - 255]: available period
+ */
+struct max8997_haptic_platform_data {
+        unsigned int pwm_channel_id;
+        unsigned int pwm_period;
+
+        enum max8997_haptic_motor_type type;
+        enum max8997_haptic_pulse_mode mode;
+        enum max8997_haptic_pwm_divisor pwm_divisor;
+
+        unsigned int internal_mode_pattern;
+        unsigned int pattern_cycle;
+        unsigned int pattern_signal_period;
+};
+
 enum max8997_led_mode {
         MAX8997_NONE,
         MAX8997_FLASH_MODE,
@@ -192,7 +241,9 @@ struct max8997_platform_data {
         /* ---- MUIC ---- */
         struct max8997_muic_platform_data *muic_pdata;
 
-        /* HAPTIC: Not implemented */
+        /* ---- HAPTIC ---- */
+        struct max8997_haptic_platform_data *haptic_pdata;
+
         /* RTC: Not implemented */
         /* ---- LED ---- */
         struct max8997_led_platform_data *led_pdata;
diff --git a/include/linux/mfd/mc13xxx.h b/include/linux/mfd/mc13xxx.h
index b86ee45c8b03..10e038bac8dd 100644
--- a/include/linux/mfd/mc13xxx.h
+++ b/include/linux/mfd/mc13xxx.h
@@ -38,7 +38,8 @@ int mc13xxx_irq_ack(struct mc13xxx *mc13xxx, int irq);
 int mc13xxx_get_flags(struct mc13xxx *mc13xxx);
 
 int mc13xxx_adc_do_conversion(struct mc13xxx *mc13xxx,
-                unsigned int mode, unsigned int channel, unsigned int *sample);
+                unsigned int mode, unsigned int channel,
+                u8 ato, bool atox, unsigned int *sample);
 
 #define MC13XXX_IRQ_ADCDONE     0
 #define MC13XXX_IRQ_ADCBISDONE  1
@@ -157,6 +158,18 @@ struct mc13xxx_buttons_platform_data {
         unsigned short b3on_key;
 };
 
+struct mc13xxx_ts_platform_data {
+        /* Delay between Touchscreen polarization and ADC Conversion.
+         * Given in clock ticks of a 32 kHz clock which gives a granularity of
+         * about 30.5ms */
+        u8 ato;
+
+#define MC13783_TS_ATO_FIRST false
+#define MC13783_TS_ATO_EACH  true
+        /* Use the ATO delay only for the first conversion or for each one */
+        bool atox;
+};
+
 struct mc13xxx_platform_data {
 #define MC13XXX_USE_TOUCHSCREEN (1 << 0)
 #define MC13XXX_USE_CODEC       (1 << 1)
@@ -167,6 +180,7 @@ struct mc13xxx_platform_data {
         struct mc13xxx_regulator_platform_data regulators;
         struct mc13xxx_leds_platform_data *leds;
         struct mc13xxx_buttons_platform_data *buttons;
+        struct mc13xxx_ts_platform_data touch;
 };
 
 #define MC13XXX_ADC_MODE_TS             1
diff --git a/include/linux/mfd/mcp.h b/include/linux/mfd/mcp.h
index f88c1cc0cb0f..a9e8bd157673 100644
--- a/include/linux/mfd/mcp.h
+++ b/include/linux/mfd/mcp.h
@@ -10,8 +10,6 @@
 #ifndef MCP_H
 #define MCP_H
 
-#include <mach/dma.h>
-
 struct mcp_ops;
 
 struct mcp {
@@ -21,12 +19,7 @@ struct mcp {
         int             use_count;
         unsigned int    sclk_rate;
         unsigned int    rw_timeout;
-        dma_device_t    dma_audio_rd;
-        dma_device_t    dma_audio_wr;
-        dma_device_t    dma_telco_rd;
-        dma_device_t    dma_telco_wr;
         struct device   attached_device;
-        int             gpio_base;
 };
 
 struct mcp_ops {
@@ -47,15 +40,14 @@ void mcp_disable(struct mcp *);
 #define mcp_get_sclk_rate(mcp)  ((mcp)->sclk_rate)
 
 struct mcp *mcp_host_alloc(struct device *, size_t);
-int mcp_host_register(struct mcp *);
-void mcp_host_unregister(struct mcp *);
+int mcp_host_add(struct mcp *, void *);
+void mcp_host_del(struct mcp *);
+void mcp_host_free(struct mcp *);
 
 struct mcp_driver {
         struct device_driver drv;
         int (*probe)(struct mcp *);
         void (*remove)(struct mcp *);
-        int (*suspend)(struct mcp *, pm_message_t);
-        int (*resume)(struct mcp *);
 };
 
 int mcp_driver_register(struct mcp_driver *);
diff --git a/include/linux/mfd/pm8xxx/pm8921.h b/include/linux/mfd/pm8xxx/pm8921.h
index d5517fd32d1b..00fa3de7659d 100644
--- a/include/linux/mfd/pm8xxx/pm8921.h
+++ b/include/linux/mfd/pm8xxx/pm8921.h
@@ -18,7 +18,6 @@
 #ifndef __MFD_PM8921_H
 #define __MFD_PM8921_H
 
-#include <linux/device.h>
 #include <linux/mfd/pm8xxx/irq.h>
 
 #define PM8921_NR_IRQS          256
diff --git a/include/linux/mfd/rc5t583.h b/include/linux/mfd/rc5t583.h
new file mode 100644
index 000000000000..a2c61609d21d
--- /dev/null
+++ b/include/linux/mfd/rc5t583.h
@@ -0,0 +1,295 @@
+/*
+ * Core driver interface to access RICOH_RC5T583 power management chip.
+ *
+ * Copyright (c) 2011-2012, NVIDIA CORPORATION.  All rights reserved.
+ * Author: Laxman dewangan <ldewangan@nvidia.com>
+ *
+ * Based on code
+ *      Copyright (C) 2011 RICOH COMPANY,LTD
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef __LINUX_MFD_RC5T583_H
+#define __LINUX_MFD_RC5T583_H
+
+#include <linux/mutex.h>
+#include <linux/types.h>
+
+#define RC5T583_MAX_REGS                0xF8
+
+/* Maximum number of main interrupts */
+#define MAX_MAIN_INTERRUPT              5
+#define RC5T583_MAX_GPEDGE_REG          2
+#define RC5T583_MAX_INTERRUPT_MASK_REGS 9
+
+/* Interrupt enable register */
+#define RC5T583_INT_EN_SYS1     0x19
+#define RC5T583_INT_EN_SYS2     0x1D
+#define RC5T583_INT_EN_DCDC     0x41
+#define RC5T583_INT_EN_RTC      0xED
+#define RC5T583_INT_EN_ADC1     0x90
+#define RC5T583_INT_EN_ADC2     0x91
+#define RC5T583_INT_EN_ADC3     0x92
+
+/* Interrupt status registers (monitor regs in Ricoh)*/
+#define RC5T583_INTC_INTPOL     0xAD
+#define RC5T583_INTC_INTEN      0xAE
+#define RC5T583_INTC_INTMON     0xAF
+
+#define RC5T583_INT_MON_GRP     0xAF
+#define RC5T583_INT_MON_SYS1    0x1B
+#define RC5T583_INT_MON_SYS2    0x1F
+#define RC5T583_INT_MON_DCDC    0x43
+#define RC5T583_INT_MON_RTC     0xEE
+
+/* Interrupt clearing registers */
+#define RC5T583_INT_IR_SYS1     0x1A
+#define RC5T583_INT_IR_SYS2     0x1E
+#define RC5T583_INT_IR_DCDC     0x42
+#define RC5T583_INT_IR_RTC      0xEE
+#define RC5T583_INT_IR_ADCL     0x94
+#define RC5T583_INT_IR_ADCH     0x95
+#define RC5T583_INT_IR_ADCEND   0x96
+#define RC5T583_INT_IR_GPIOR    0xA9
+#define RC5T583_INT_IR_GPIOF    0xAA
+
+/* Sleep sequence registers */
+#define RC5T583_SLPSEQ1         0x21
+#define RC5T583_SLPSEQ2         0x22
+#define RC5T583_SLPSEQ3         0x23
+#define RC5T583_SLPSEQ4         0x24
+#define RC5T583_SLPSEQ5         0x25
+#define RC5T583_SLPSEQ6         0x26
+#define RC5T583_SLPSEQ7         0x27
+#define RC5T583_SLPSEQ8         0x28
+#define RC5T583_SLPSEQ9         0x29
+#define RC5T583_SLPSEQ10        0x2A
+#define RC5T583_SLPSEQ11        0x2B
+
+/* Regulator registers */
+#define RC5T583_REG_DC0CTL      0x30
+#define RC5T583_REG_DC0DAC      0x31
+#define RC5T583_REG_DC0LATCTL   0x32
+#define RC5T583_REG_SR0CTL      0x33
+
+#define RC5T583_REG_DC1CTL      0x34
+#define RC5T583_REG_DC1DAC      0x35
+#define RC5T583_REG_DC1LATCTL   0x36
+#define RC5T583_REG_SR1CTL      0x37
+
+#define RC5T583_REG_DC2CTL      0x38
+#define RC5T583_REG_DC2DAC      0x39
+#define RC5T583_REG_DC2LATCTL   0x3A
+#define RC5T583_REG_SR2CTL      0x3B
+
+#define RC5T583_REG_DC3CTL      0x3C
+#define RC5T583_REG_DC3DAC      0x3D
+#define RC5T583_REG_DC3LATCTL   0x3E
+#define RC5T583_REG_SR3CTL      0x3F
+
+
+#define RC5T583_REG_LDOEN1      0x50
+#define RC5T583_REG_LDOEN2      0x51
+#define RC5T583_REG_LDODIS1     0x52
+#define RC5T583_REG_LDODIS2     0x53
+
+#define RC5T583_REG_LDO0DAC     0x54
+#define RC5T583_REG_LDO1DAC     0x55
+#define RC5T583_REG_LDO2DAC     0x56
+#define RC5T583_REG_LDO3DAC     0x57
+#define RC5T583_REG_LDO4DAC     0x58
+#define RC5T583_REG_LDO5DAC     0x59
+#define RC5T583_REG_LDO6DAC     0x5A
+#define RC5T583_REG_LDO7DAC     0x5B
+#define RC5T583_REG_LDO8DAC     0x5C
+#define RC5T583_REG_LDO9DAC     0x5D
+
+#define RC5T583_REG_DC0DAC_DS   0x60
+#define RC5T583_REG_DC1DAC_DS   0x61
+#define RC5T583_REG_DC2DAC_DS   0x62
+#define RC5T583_REG_DC3DAC_DS   0x63
+
+#define RC5T583_REG_LDO0DAC_DS  0x64
+#define RC5T583_REG_LDO1DAC_DS  0x65
+#define RC5T583_REG_LDO2DAC_DS  0x66
+#define RC5T583_REG_LDO3DAC_DS  0x67
+#define RC5T583_REG_LDO4DAC_DS  0x68
+#define RC5T583_REG_LDO5DAC_DS  0x69
+#define RC5T583_REG_LDO6DAC_DS  0x6A
+#define RC5T583_REG_LDO7DAC_DS  0x6B
+#define RC5T583_REG_LDO8DAC_DS  0x6C
+#define RC5T583_REG_LDO9DAC_DS  0x6D
+
+/* GPIO register base address */
+#define RC5T583_GPIO_IOSEL      0xA0
+#define RC5T583_GPIO_PDEN       0xA1
+#define RC5T583_GPIO_IOOUT      0xA2
+#define RC5T583_GPIO_PGSEL      0xA3
+#define RC5T583_GPIO_GPINV      0xA4
+#define RC5T583_GPIO_GPDEB      0xA5
+#define RC5T583_GPIO_GPEDGE1    0xA6
+#define RC5T583_GPIO_GPEDGE2    0xA7
+#define RC5T583_GPIO_EN_INT     0xA8
+#define RC5T583_GPIO_MON_IOIN   0xAB
+#define RC5T583_GPIO_GPOFUNC    0xAC
+
+/* RICOH_RC5T583 IRQ definitions */
+enum {
+        RC5T583_IRQ_ONKEY,
+        RC5T583_IRQ_ACOK,
+        RC5T583_IRQ_LIDOPEN,
+        RC5T583_IRQ_PREOT,
+        RC5T583_IRQ_CLKSTP,
+        RC5T583_IRQ_ONKEY_OFF,
+        RC5T583_IRQ_WD,
+        RC5T583_IRQ_EN_PWRREQ1,
+        RC5T583_IRQ_EN_PWRREQ2,
+        RC5T583_IRQ_PRE_VINDET,
+
+        RC5T583_IRQ_DC0LIM,
+        RC5T583_IRQ_DC1LIM,
+        RC5T583_IRQ_DC2LIM,
+        RC5T583_IRQ_DC3LIM,
+
+        RC5T583_IRQ_CTC,
+        RC5T583_IRQ_YALE,
+        RC5T583_IRQ_DALE,
+        RC5T583_IRQ_WALE,
+
+        RC5T583_IRQ_AIN1L,
+        RC5T583_IRQ_AIN2L,
+        RC5T583_IRQ_AIN3L,
+        RC5T583_IRQ_VBATL,
+        RC5T583_IRQ_VIN3L,
+        RC5T583_IRQ_VIN8L,
+        RC5T583_IRQ_AIN1H,
+        RC5T583_IRQ_AIN2H,
+        RC5T583_IRQ_AIN3H,
+        RC5T583_IRQ_VBATH,
+        RC5T583_IRQ_VIN3H,
+        RC5T583_IRQ_VIN8H,
+        RC5T583_IRQ_ADCEND,
+
+        RC5T583_IRQ_GPIO0,
+        RC5T583_IRQ_GPIO1,
+        RC5T583_IRQ_GPIO2,
+        RC5T583_IRQ_GPIO3,
+        RC5T583_IRQ_GPIO4,
+        RC5T583_IRQ_GPIO5,
+        RC5T583_IRQ_GPIO6,
+        RC5T583_IRQ_GPIO7,
+
+        /* Should be last entry */
+        RC5T583_MAX_IRQS,
+};
+
+/* Ricoh583 gpio definitions */
+enum {
+        RC5T583_GPIO0,
+        RC5T583_GPIO1,
+        RC5T583_GPIO2,
+        RC5T583_GPIO3,
+        RC5T583_GPIO4,
+        RC5T583_GPIO5,
+        RC5T583_GPIO6,
+        RC5T583_GPIO7,
+
+        /* Should be last entry */
+        RC5T583_MAX_GPIO,
+};
+
+enum {
+        RC5T583_DS_NONE,
+        RC5T583_DS_DC0,
+        RC5T583_DS_DC1,
+        RC5T583_DS_DC2,
+        RC5T583_DS_DC3,
+        RC5T583_DS_LDO0,
+        RC5T583_DS_LDO1,
+        RC5T583_DS_LDO2,
+        RC5T583_DS_LDO3,
+        RC5T583_DS_LDO4,
+        RC5T583_DS_LDO5,
+        RC5T583_DS_LDO6,
+        RC5T583_DS_LDO7,
+        RC5T583_DS_LDO8,
+        RC5T583_DS_LDO9,
+        RC5T583_DS_PSO0,
+        RC5T583_DS_PSO1,
+        RC5T583_DS_PSO2,
+        RC5T583_DS_PSO3,
+        RC5T583_DS_PSO4,
+        RC5T583_DS_PSO5,
+        RC5T583_DS_PSO6,
+        RC5T583_DS_PSO7,
+
+        /* Should be last entry */
+        RC5T583_DS_MAX,
+};
+
+/*
+ * Ricoh pmic RC5T583 supports sleep through two external controls.
+ * The output of gpios and regulator can be enable/disable through
+ * this external signals.
+ */
+enum {
+        RC5T583_EXT_PWRREQ1_CONTROL = 0x1,
+        RC5T583_EXT_PWRREQ2_CONTROL = 0x2,
+};
+
+struct rc5t583 {
+        struct device   *dev;
+        struct regmap   *regmap;
+        int             chip_irq;
+        int             irq_base;
+        struct mutex    irq_lock;
+        unsigned long   group_irq_en[MAX_MAIN_INTERRUPT];
+
+        /* For main interrupt bits in INTC */
+        uint8_t         intc_inten_reg;
+
+        /* For group interrupt bits and address */
+        uint8_t         irq_en_reg[RC5T583_MAX_INTERRUPT_MASK_REGS];
+
+        /* For gpio edge */
+        uint8_t         gpedge_reg[RC5T583_MAX_GPEDGE_REG];
+};
+
+/*
+ * rc5t583_platform_data: Platform data for ricoh rc5t583 pmu.
+ * The board specific data is provided through this structure.
+ * @irq_base: Irq base number on which this device registers their interrupts.
+ * @enable_shutdown: Enable shutdown through the input pin "shutdown".
+ */
+
+struct rc5t583_platform_data {
+        int             irq_base;
+        bool            enable_shutdown;
+};
+
+int rc5t583_write(struct device *dev, u8 reg, uint8_t val);
+int rc5t583_read(struct device *dev, uint8_t reg, uint8_t *val);
+int rc5t583_set_bits(struct device *dev, unsigned int reg,
+                unsigned int bit_mask);
+int rc5t583_clear_bits(struct device *dev, unsigned int reg,
+                unsigned int bit_mask);
+int rc5t583_update(struct device *dev, unsigned int reg,
+                unsigned int val, unsigned int mask);
+int rc5t583_ext_power_req_config(struct device *dev, int deepsleep_id,
+        int ext_pwr_req, int deepsleep_slot_nr);
+int rc5t583_irq_init(struct rc5t583 *rc5t583, int irq, int irq_base);
+int rc5t583_irq_exit(struct rc5t583 *rc5t583);
+
+#endif
diff --git a/include/linux/mfd/stmpe.h b/include/linux/mfd/stmpe.h
index ca1d7a347600..8516fd1eaabc 100644
--- a/include/linux/mfd/stmpe.h
+++ b/include/linux/mfd/stmpe.h
@@ -8,7 +8,9 @@
 #ifndef __LINUX_MFD_STMPE_H
 #define __LINUX_MFD_STMPE_H
 
-#include <linux/device.h>
+#include <linux/mutex.h>
+
+struct device;
 
 enum stmpe_block {
         STMPE_BLOCK_GPIO        = 1 << 0,
@@ -26,6 +28,7 @@ enum stmpe_partnum {
         STMPE1601,
         STMPE2401,
         STMPE2403,
+        STMPE_NBR_PARTS
 };
 
 /*
diff --git a/include/linux/mfd/tc3589x.h b/include/linux/mfd/tc3589x.h
index 16c76e124f9c..3acb3a8e3af5 100644
--- a/include/linux/mfd/tc3589x.h
+++ b/include/linux/mfd/tc3589x.h
@@ -7,7 +7,7 @@
 #ifndef __LINUX_MFD_TC3589x_H
 #define __LINUX_MFD_TC3589x_H
 
-#include <linux/device.h>
+struct device;
 
 enum tx3589x_block {
         TC3589x_BLOCK_GPIO        = 1 << 0,
diff --git a/include/linux/mfd/tps65090.h b/include/linux/mfd/tps65090.h
new file mode 100644
index 000000000000..38e31c55adbb
--- /dev/null
+++ b/include/linux/mfd/tps65090.h
@@ -0,0 +1,46 @@
+/*
+ * Core driver interface for TI TPS65090 PMIC family
+ *
+ * Copyright (C) 2012 NVIDIA Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#ifndef __LINUX_MFD_TPS65090_H
+#define __LINUX_MFD_TPS65090_H
+
+struct tps65090_subdev_info {
+        int             id;
+        const char      *name;
+        void            *platform_data;
+};
+
+struct tps65090_platform_data {
+        int irq_base;
+        int num_subdevs;
+        struct tps65090_subdev_info *subdevs;
+};
+
+/*
+ * NOTE: the functions below are not intended for use outside
+ * of the TPS65090 sub-device drivers
+ */
+extern int tps65090_write(struct device *dev, int reg, uint8_t val);
+extern int tps65090_read(struct device *dev, int reg, uint8_t *val);
+extern int tps65090_set_bits(struct device *dev, int reg, uint8_t bit_num);
+extern int tps65090_clr_bits(struct device *dev, int reg, uint8_t bit_num);
+
+#endif /*__LINUX_MFD_TPS65090_H */
diff --git a/include/linux/mfd/tps65217.h b/include/linux/mfd/tps65217.h
new file mode 100644
index 000000000000..e030ef9a64ee
--- /dev/null
+++ b/include/linux/mfd/tps65217.h
@@ -0,0 +1,283 @@
+/*
+ * linux/mfd/tps65217.h
+ *
+ * Functions to access TPS65217 power management chip.
+ *
+ * Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation version 2.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef __LINUX_MFD_TPS65217_H
+#define __LINUX_MFD_TPS65217_H
+
+#include <linux/i2c.h>
+#include <linux/regulator/driver.h>
+#include <linux/regulator/machine.h>
+
+/* I2C ID for TPS65217 part */
+#define TPS65217_I2C_ID                 0x24
+
+/* All register addresses */
+#define TPS65217_REG_CHIPID             0X00
+#define TPS65217_REG_PPATH              0X01
+#define TPS65217_REG_INT                0X02
+#define TPS65217_REG_CHGCONFIG0         0X03
+#define TPS65217_REG_CHGCONFIG1         0X04
+#define TPS65217_REG_CHGCONFIG2         0X05
+#define TPS65217_REG_CHGCONFIG3         0X06
+#define TPS65217_REG_WLEDCTRL1          0X07
+#define TPS65217_REG_WLEDCTRL2          0X08
+#define TPS65217_REG_MUXCTRL            0X09
+#define TPS65217_REG_STATUS             0X0A
+#define TPS65217_REG_PASSWORD           0X0B
+#define TPS65217_REG_PGOOD              0X0C
+#define TPS65217_REG_DEFPG              0X0D
+#define TPS65217_REG_DEFDCDC1           0X0E
+#define TPS65217_REG_DEFDCDC2           0X0F
+#define TPS65217_REG_DEFDCDC3           0X10
+#define TPS65217_REG_DEFSLEW            0X11
+#define TPS65217_REG_DEFLDO1            0X12
+#define TPS65217_REG_DEFLDO2            0X13
+#define TPS65217_REG_DEFLS1             0X14
+#define TPS65217_REG_DEFLS2             0X15
+#define TPS65217_REG_ENABLE             0X16
+#define TPS65217_REG_DEFUVLO            0X18
+#define TPS65217_REG_SEQ1               0X19
+#define TPS65217_REG_SEQ2               0X1A
+#define TPS65217_REG_SEQ3               0X1B
+#define TPS65217_REG_SEQ4               0X1C
+#define TPS65217_REG_SEQ5               0X1D
+#define TPS65217_REG_SEQ6               0X1E
+
+/* Register field definitions */
+#define TPS65217_CHIPID_CHIP_MASK       0xF0
+#define TPS65217_CHIPID_REV_MASK        0x0F
+
+#define TPS65217_PPATH_ACSINK_ENABLE    BIT(7)
+#define TPS65217_PPATH_USBSINK_ENABLE   BIT(6)
+#define TPS65217_PPATH_AC_PW_ENABLE     BIT(5)
+#define TPS65217_PPATH_USB_PW_ENABLE    BIT(4)
+#define TPS65217_PPATH_AC_CURRENT_MASK  0x0C
+#define TPS65217_PPATH_USB_CURRENT_MASK 0x03
+
+#define TPS65217_INT_PBM                BIT(6)
+#define TPS65217_INT_ACM                BIT(5)
+#define TPS65217_INT_USBM               BIT(4)
+#define TPS65217_INT_PBI                BIT(2)
+#define TPS65217_INT_ACI                BIT(1)
+#define TPS65217_INT_USBI               BIT(0)
+
+#define TPS65217_CHGCONFIG0_TREG        BIT(7)
+#define TPS65217_CHGCONFIG0_DPPM        BIT(6)
+#define TPS65217_CHGCONFIG0_TSUSP       BIT(5)
+#define TPS65217_CHGCONFIG0_TERMI       BIT(4)
+#define TPS65217_CHGCONFIG0_ACTIVE      BIT(3)
+#define TPS65217_CHGCONFIG0_CHGTOUT     BIT(2)
+#define TPS65217_CHGCONFIG0_PCHGTOUT    BIT(1)
+#define TPS65217_CHGCONFIG0_BATTEMP     BIT(0)
+
+#define TPS65217_CHGCONFIG1_TMR_MASK    0xC0
+#define TPS65217_CHGCONFIG1_TMR_ENABLE  BIT(5)
+#define TPS65217_CHGCONFIG1_NTC_TYPE    BIT(4)
+#define TPS65217_CHGCONFIG1_RESET       BIT(3)
+#define TPS65217_CHGCONFIG1_TERM        BIT(2)
+#define TPS65217_CHGCONFIG1_SUSP        BIT(1)
+#define TPS65217_CHGCONFIG1_CHG_EN      BIT(0)
+
+#define TPS65217_CHGCONFIG2_DYNTMR      BIT(7)
+#define TPS65217_CHGCONFIG2_VPREGHG     BIT(6)
+#define TPS65217_CHGCONFIG2_VOREG_MASK  0x30
+
+#define TPS65217_CHGCONFIG3_ICHRG_MASK  0xC0
+#define TPS65217_CHGCONFIG3_DPPMTH_MASK 0x30
+#define TPS65217_CHGCONFIG2_PCHRGT      BIT(3)
+#define TPS65217_CHGCONFIG2_TERMIF      0x06
+#define TPS65217_CHGCONFIG2_TRANGE      BIT(0)
+
+#define TPS65217_WLEDCTRL1_ISINK_ENABLE BIT(3)
+#define TPS65217_WLEDCTRL1_ISEL         BIT(2)
+#define TPS65217_WLEDCTRL1_FDIM_MASK    0x03
+
+#define TPS65217_WLEDCTRL2_DUTY_MASK    0x7F
+
+#define TPS65217_MUXCTRL_MUX_MASK       0x07
+
+#define TPS65217_STATUS_OFF             BIT(7)
+#define TPS65217_STATUS_ACPWR           BIT(3)
+#define TPS65217_STATUS_USBPWR          BIT(2)
+#define TPS65217_STATUS_PB              BIT(0)
+
+#define TPS65217_PASSWORD_REGS_UNLOCK   0x7D
+
+#define TPS65217_PGOOD_LDO3_PG          BIT(6)
+#define TPS65217_PGOOD_LDO4_PG          BIT(5)
+#define TPS65217_PGOOD_DC1_PG           BIT(4)
+#define TPS65217_PGOOD_DC2_PG           BIT(3)
+#define TPS65217_PGOOD_DC3_PG           BIT(2)
+#define TPS65217_PGOOD_LDO1_PG          BIT(1)
+#define TPS65217_PGOOD_LDO2_PG          BIT(0)
+
+#define TPS65217_DEFPG_LDO1PGM          BIT(3)
+#define TPS65217_DEFPG_LDO2PGM          BIT(2)
+#define TPS65217_DEFPG_PGDLY_MASK       0x03
+
+#define TPS65217_DEFDCDCX_XADJX         BIT(7)
+#define TPS65217_DEFDCDCX_DCDC_MASK     0x3F
+
+#define TPS65217_DEFSLEW_GO             BIT(7)
+#define TPS65217_DEFSLEW_GODSBL         BIT(6)
+#define TPS65217_DEFSLEW_PFM_EN1        BIT(5)
+#define TPS65217_DEFSLEW_PFM_EN2        BIT(4)
+#define TPS65217_DEFSLEW_PFM_EN3        BIT(3)
+#define TPS65217_DEFSLEW_SLEW_MASK      0x07
+
+#define TPS65217_DEFLDO1_LDO1_MASK      0x0F
+
+#define TPS65217_DEFLDO2_TRACK          BIT(6)
+#define TPS65217_DEFLDO2_LDO2_MASK      0x3F
+
+#define TPS65217_DEFLDO3_LDO3_EN        BIT(5)
+#define TPS65217_DEFLDO3_LDO3_MASK      0x1F
+
+#define TPS65217_DEFLDO4_LDO4_EN        BIT(5)
+#define TPS65217_DEFLDO4_LDO4_MASK      0x1F
+
+#define TPS65217_ENABLE_LS1_EN          BIT(6)
+#define TPS65217_ENABLE_LS2_EN          BIT(5)
+#define TPS65217_ENABLE_DC1_EN          BIT(4)
+#define TPS65217_ENABLE_DC2_EN          BIT(3)
+#define TPS65217_ENABLE_DC3_EN          BIT(2)
+#define TPS65217_ENABLE_LDO1_EN         BIT(1)
+#define TPS65217_ENABLE_LDO2_EN         BIT(0)
+
+#define TPS65217_DEFUVLO_UVLOHYS        BIT(2)
+#define TPS65217_DEFUVLO_UVLO_MASK      0x03
+
+#define TPS65217_SEQ1_DC1_SEQ_MASK      0xF0
+#define TPS65217_SEQ1_DC2_SEQ_MASK      0x0F
+
+#define TPS65217_SEQ2_DC3_SEQ_MASK      0xF0
+#define TPS65217_SEQ2_LDO1_SEQ_MASK     0x0F
+
+#define TPS65217_SEQ3_LDO2_SEQ_MASK     0xF0
+#define TPS65217_SEQ3_LDO3_SEQ_MASK     0x0F
+
+#define TPS65217_SEQ4_LDO4_SEQ_MASK     0xF0
+
+#define TPS65217_SEQ5_DLY1_MASK         0xC0
+#define TPS65217_SEQ5_DLY2_MASK         0x30
+#define TPS65217_SEQ5_DLY3_MASK         0x0C
+#define TPS65217_SEQ5_DLY4_MASK         0x03
+
+#define TPS65217_SEQ6_DLY5_MASK         0xC0
+#define TPS65217_SEQ6_DLY6_MASK         0x30
+#define TPS65217_SEQ6_SEQUP             BIT(2)
+#define TPS65217_SEQ6_SEQDWN            BIT(1)
+#define TPS65217_SEQ6_INSTDWN           BIT(0)
+
+#define TPS65217_MAX_REGISTER           0x1E
+#define TPS65217_PROTECT_NONE           0
+#define TPS65217_PROTECT_L1             1
+#define TPS65217_PROTECT_L2             2
+
+
+enum tps65217_regulator_id {
+        /* DCDC's */
+        TPS65217_DCDC_1,
+        TPS65217_DCDC_2,
+        TPS65217_DCDC_3,
+        /* LDOs */
+        TPS65217_LDO_1,
+        TPS65217_LDO_2,
+        TPS65217_LDO_3,
+        TPS65217_LDO_4,
+};
+
+#define TPS65217_MAX_REG_ID             TPS65217_LDO_4
+
+/* Number of step-down converters available */
+#define TPS65217_NUM_DCDC               3
+/* Number of LDO voltage regulators available */
+#define TPS65217_NUM_LDO                4
+/* Number of total regulators available */
+#define TPS65217_NUM_REGULATOR          (TPS65217_NUM_DCDC + TPS65217_NUM_LDO)
+
+/**
+ * struct tps65217_board - packages regulator init data
+ * @tps65217_regulator_data: regulator initialization values
+ *
+ * Board data may be used to initialize regulator.
+ */
+struct tps65217_board {
+        struct regulator_init_data *tps65217_init_data;
+};
+
+/**
+ * struct tps_info - packages regulator constraints
+ * @name:               Voltage regulator name
+ * @min_uV:             minimum micro volts
+ * @max_uV:             minimum micro volts
+ * @vsel_to_uv:         Function pointer to get voltage from selector
+ * @uv_to_vsel:         Function pointer to get selector from voltage
+ * @table:              Table for non-uniform voltage step-size
+ * @table_len:          Length of the voltage table
+ * @enable_mask:        Regulator enable mask bits
+ * @set_vout_reg:       Regulator output voltage set register
+ * @set_vout_mask:      Regulator output voltage set mask
+ *
+ * This data is used to check the regualtor voltage limits while setting.
+ */
+struct tps_info {
+        const char *name;
+        int min_uV;
+        int max_uV;
+        int (*vsel_to_uv)(unsigned int vsel);
+        int (*uv_to_vsel)(int uV, unsigned int *vsel);
+        const int *table;
+        unsigned int table_len;
+        unsigned int enable_mask;
+        unsigned int set_vout_reg;
+        unsigned int set_vout_mask;
+};
+
+/**
+ * struct tps65217 - tps65217 sub-driver chip access routines
+ *
+ * Device data may be used to access the TPS65217 chip
+ */
+
+struct tps65217 {
+        struct device *dev;
+        struct tps65217_board *pdata;
+        struct regulator_desc desc[TPS65217_NUM_REGULATOR];
+        struct regulator_dev *rdev[TPS65217_NUM_REGULATOR];
+        struct tps_info *info[TPS65217_NUM_REGULATOR];
+        struct regmap *regmap;
+
+        /* Client devices */
+        struct platform_device *regulator_pdev[TPS65217_NUM_REGULATOR];
+};
+
+static inline struct tps65217 *dev_to_tps65217(struct device *dev)
+{
+        return dev_get_drvdata(dev);
+}
+
+int tps65217_reg_read(struct tps65217 *tps, unsigned int reg,
+                                        unsigned int *val);
+int tps65217_reg_write(struct tps65217 *tps, unsigned int reg,
+                        unsigned int val, unsigned int level);
+int tps65217_set_bits(struct tps65217 *tps, unsigned int reg,
+                unsigned int mask, unsigned int val, unsigned int level);
+int tps65217_clear_bits(struct tps65217 *tps, unsigned int reg,
+                unsigned int mask, unsigned int level);
+
+#endif /*  __LINUX_MFD_TPS65217_H */
diff --git a/include/linux/mfd/tps65910.h b/include/linux/mfd/tps65910.h
index d0cb12eba402..1c6c2860d1a6 100644
--- a/include/linux/mfd/tps65910.h
+++ b/include/linux/mfd/tps65910.h
@@ -17,6 +17,8 @@
 #ifndef __LINUX_MFD_TPS65910_H
 #define __LINUX_MFD_TPS65910_H
 
+#include <linux/gpio.h>
+
 /* TPS chip id list */
 #define TPS65910                        0
 #define TPS65911                        1
@@ -657,6 +659,8 @@
 
 
 /*Register GPIO  (0x80) register.RegisterDescription */
+#define GPIO_SLEEP_MASK                         0x80
+#define GPIO_SLEEP_SHIFT                        7
 #define GPIO_DEB_MASK                           0x10
 #define GPIO_DEB_SHIFT                          4
 #define GPIO_PUEN_MASK                          0x08
@@ -740,6 +744,11 @@
 #define TPS65910_GPIO_STS                               BIT(1)
 #define TPS65910_GPIO_SET                               BIT(0)
 
+/* Max number of TPS65910/11 GPIOs */
+#define TPS65910_NUM_GPIO                               6
+#define TPS65911_NUM_GPIO                               9
+#define TPS6591X_MAX_NUM_GPIO                           9
+
 /* Regulator Index Definitions */
 #define TPS65910_REG_VRTC                               0
 #define TPS65910_REG_VIO                                1
@@ -768,6 +777,12 @@
 /* Max number of TPS65910/11 regulators */
 #define TPS65910_NUM_REGS                               13
 
+/* External sleep controls through EN1/EN2/EN3/SLEEP inputs */
+#define TPS65910_SLEEP_CONTROL_EXT_INPUT_EN1            0x1
+#define TPS65910_SLEEP_CONTROL_EXT_INPUT_EN2            0x2
+#define TPS65910_SLEEP_CONTROL_EXT_INPUT_EN3            0x4
+#define TPS65911_SLEEP_CONTROL_EXT_INPUT_SLEEP          0x8
+
 /**
  * struct tps65910_board
  * Board platform data may be used to initialize regulators.
@@ -779,6 +794,8 @@ struct tps65910_board {
         int irq_base;
         int vmbch_threshold;
         int vmbch2_threshold;
+        bool en_gpio_sleep[TPS6591X_MAX_NUM_GPIO];
+        unsigned long regulator_ext_sleep_control[TPS65910_NUM_REGS];
         struct regulator_init_data *tps65910_pmic_init_data[TPS65910_NUM_REGS];
 };
 
@@ -789,6 +806,7 @@ struct tps65910_board {
 struct tps65910 {
         struct device *dev;
         struct i2c_client *i2c_client;
+        struct regmap *regmap;
         struct mutex io_mutex;
         unsigned int id;
         int (*read)(struct tps65910 *tps65910, u8 reg, int size, void *dest);
diff --git a/include/linux/mfd/ucb1x00.h b/include/linux/mfd/ucb1x00.h
index 4321f044d1e4..28af41756360 100644
--- a/include/linux/mfd/ucb1x00.h
+++ b/include/linux/mfd/ucb1x00.h
@@ -12,7 +12,7 @@
 
 #include <linux/mfd/mcp.h>
 #include <linux/gpio.h>
-#include <linux/semaphore.h>
+#include <linux/mutex.h>
 
 #define UCB_IO_DATA     0x00
 #define UCB_IO_DIR      0x01
@@ -104,17 +104,27 @@
 #define UCB_MODE_DYN_VFLAG_ENA  (1 << 12)
 #define UCB_MODE_AUD_OFF_CAN    (1 << 13)
 
+enum ucb1x00_reset {
+        UCB_RST_PROBE,
+        UCB_RST_RESUME,
+        UCB_RST_SUSPEND,
+        UCB_RST_REMOVE,
+        UCB_RST_PROBE_FAIL,
+};
 
-struct ucb1x00_irq {
-        void *devid;
-        void (*fn)(int, void *);
+struct ucb1x00_plat_data {
+        void                    (*reset)(enum ucb1x00_reset);
+        unsigned                irq_base;
+        int                     gpio_base;
+        unsigned                can_wakeup;
 };
 
 struct ucb1x00 {
-        spinlock_t              lock;
+        raw_spinlock_t          irq_lock;
         struct mcp              *mcp;
         unsigned int            irq;
-        struct semaphore        adc_sem;
+        int                     irq_base;
+        struct mutex            adc_mutex;
         spinlock_t              io_lock;
         u16                     id;
         u16                     io_dir;
@@ -122,7 +132,8 @@ struct ucb1x00 {
         u16                     adc_cr;
         u16                     irq_fal_enbl;
         u16                     irq_ris_enbl;
-        struct ucb1x00_irq      irq_handler[16];
+        u16                     irq_mask;
+        u16                     irq_wake;
         struct device           dev;
         struct list_head        node;
         struct list_head        devs;
@@ -144,7 +155,7 @@ struct ucb1x00_driver {
         struct list_head        devs;
         int     (*add)(struct ucb1x00_dev *dev);
         void    (*remove)(struct ucb1x00_dev *dev);
-        int     (*suspend)(struct ucb1x00_dev *dev, pm_message_t state);
+        int     (*suspend)(struct ucb1x00_dev *dev);
         int     (*resume)(struct ucb1x00_dev *dev);
 };
 
@@ -245,15 +256,4 @@ unsigned int ucb1x00_adc_read(struct ucb1x00 *ucb, int adc_channel, int sync);
 void ucb1x00_adc_enable(struct ucb1x00 *ucb);
 void ucb1x00_adc_disable(struct ucb1x00 *ucb);
 
-/*
- * Which edges of the IRQ do you want to control today?
- */
-#define UCB_RISING      (1 << 0)
-#define UCB_FALLING     (1 << 1)
-
-int ucb1x00_hook_irq(struct ucb1x00 *ucb, unsigned int idx, void (*fn)(int, void *), void *devid);
-void ucb1x00_enable_irq(struct ucb1x00 *ucb, unsigned int idx, int edges);
-void ucb1x00_disable_irq(struct ucb1x00 *ucb, unsigned int idx, int edges);
-int ucb1x00_free_irq(struct ucb1x00 *ucb, unsigned int idx, void *devid);
-
 #endif
diff --git a/include/linux/mfd/wm8994/pdata.h b/include/linux/mfd/wm8994/pdata.h
index 3fb1f407d5e6..893267bb6229 100644
--- a/include/linux/mfd/wm8994/pdata.h
+++ b/include/linux/mfd/wm8994/pdata.h
@@ -22,7 +22,6 @@ struct wm8994_ldo_pdata {
         /** GPIOs to enable regulator, 0 or less if not available */
         int enable;
 
-        const char *supply;
         const struct regulator_init_data *init_data;
 };
 
@@ -185,6 +184,9 @@ struct wm8994_pdata {
         unsigned int jd_scthr:2;
         unsigned int jd_thr:2;
 
+        /* Configure WM1811 jack detection for use with external capacitor */
+        unsigned int jd_ext_cap:1;
+
         /* WM8958 microphone bias configuration */
         int micbias[2];
 
diff --git a/include/linux/migrate.h b/include/linux/migrate.h
index 05ed2828a553..855c337b20c3 100644
--- a/include/linux/migrate.h
+++ b/include/linux/migrate.h
@@ -8,7 +8,6 @@
 typedef struct page *new_page_t(struct page *, unsigned long private, int **);
 
 #ifdef CONFIG_MIGRATION
-#define PAGE_MIGRATION 1
 
 extern void putback_lru_pages(struct list_head *l);
 extern int migrate_page(struct address_space *,
@@ -32,7 +31,6 @@ extern void migrate_page_copy(struct page *newpage, struct page *page);
 extern int migrate_huge_page_move_mapping(struct address_space *mapping,
                                   struct page *newpage, struct page *page);
 #else
-#define PAGE_MIGRATION 0
 
 static inline void putback_lru_pages(struct list_head *l) {}
 static inline int migrate_pages(struct list_head *l, new_page_t x,
diff --git a/include/linux/mlx4/device.h b/include/linux/mlx4/device.h
index aea61905499b..834c96c5d879 100644
--- a/include/linux/mlx4/device.h
+++ b/include/linux/mlx4/device.h
@@ -101,10 +101,6 @@ enum {
 #define MLX4_ATTR_EXTENDED_PORT_INFO    cpu_to_be16(0xff90)
 
 enum {
-        MLX_EXT_PORT_CAP_FLAG_EXTENDED_PORT_INFO        = 1 <<  0
-};
-
-enum {
         MLX4_BMME_FLAG_LOCAL_INV        = 1 <<  6,
         MLX4_BMME_FLAG_REMOTE_INV       = 1 <<  7,
         MLX4_BMME_FLAG_TYPE_2_WIN       = 1 <<  9,
@@ -133,6 +129,7 @@ enum mlx4_event {
         MLX4_EVENT_TYPE_CMD                = 0x0a,
         MLX4_EVENT_TYPE_VEP_UPDATE         = 0x19,
         MLX4_EVENT_TYPE_COMM_CHANNEL       = 0x18,
+        MLX4_EVENT_TYPE_FATAL_WARNING      = 0x1b,
         MLX4_EVENT_TYPE_FLR_EVENT          = 0x1c,
         MLX4_EVENT_TYPE_NONE               = 0xff,
 };
@@ -143,6 +140,10 @@ enum {
 };
 
 enum {
+        MLX4_FATAL_WARNING_SUBTYPE_WARMING = 0,
+};
+
+enum {
         MLX4_PERM_LOCAL_READ    = 1 << 10,
         MLX4_PERM_LOCAL_WRITE   = 1 << 11,
         MLX4_PERM_REMOTE_READ   = 1 << 12,
@@ -273,6 +274,7 @@ struct mlx4_caps {
         int                     num_comp_vectors;
         int                     comp_pool;
         int                     num_mpts;
+        int                     max_fmr_maps;
         int                     num_mtts;
         int                     fmr_reserved_mtts;
         int                     reserved_mtts;
@@ -308,7 +310,7 @@ struct mlx4_caps {
         u32                     port_mask[MLX4_MAX_PORTS + 1];
         enum mlx4_port_type     possible_type[MLX4_MAX_PORTS + 1];
         u32                     max_counters;
-        u8                      ext_port_cap[MLX4_MAX_PORTS + 1];
+        u8                      port_ib_mtu[MLX4_MAX_PORTS + 1];
 };
 
 struct mlx4_buf_list {
@@ -622,7 +624,10 @@ int mlx4_replace_mac(struct mlx4_dev *dev, u8 port, int qpn, u64 new_mac);
 int mlx4_get_eth_qp(struct mlx4_dev *dev, u8 port, u64 mac, int *qpn);
 void mlx4_put_eth_qp(struct mlx4_dev *dev, u8 port, u64 mac, int qpn);
 void mlx4_set_stats_bitmap(struct mlx4_dev *dev, u64 *stats_bitmap);
-
+int mlx4_SET_PORT_general(struct mlx4_dev *dev, u8 port, int mtu,
+                          u8 pptx, u8 pfctx, u8 pprx, u8 pfcrx);
+int mlx4_SET_PORT_qpn_calc(struct mlx4_dev *dev, u8 port, u32 base_qpn,
+                           u8 promisc);
 int mlx4_find_cached_vlan(struct mlx4_dev *dev, u8 port, u16 vid, int *idx);
 int mlx4_register_vlan(struct mlx4_dev *dev, u8 port, u16 vlan, int *index);
 void mlx4_unregister_vlan(struct mlx4_dev *dev, u8 port, int index);
diff --git a/include/linux/mlx4/driver.h b/include/linux/mlx4/driver.h
index e1eebf78caba..5f1298b1b5ef 100644
--- a/include/linux/mlx4/driver.h
+++ b/include/linux/mlx4/driver.h
@@ -33,7 +33,6 @@
 #ifndef MLX4_DRIVER_H
 #define MLX4_DRIVER_H
 
-#include <linux/device.h>
 #include <linux/mlx4/device.h>
 
 struct mlx4_dev;
diff --git a/include/linux/mlx4/qp.h b/include/linux/mlx4/qp.h
index bee8fa231276..091f9e7dc8b9 100644
--- a/include/linux/mlx4/qp.h
+++ b/include/linux/mlx4/qp.h
@@ -212,7 +212,10 @@ struct mlx4_wqe_ctrl_seg {
          * [1]   SE (solicited event)
          * [0]   FL (force loopback)
          */
-        __be32                  srcrb_flags;
+        union {
+                __be32                  srcrb_flags;
+                __be16                  srcrb_flags16[2];
+        };
         /*
          * imm is immediate data for send/RDMA write w/ immediate;
          * also invalidation key for send with invalidate; input
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 17b27cd269c4..cf7982336103 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -6,6 +6,7 @@
 #ifdef __KERNEL__
 
 #include <linux/gfp.h>
+#include <linux/bug.h>
 #include <linux/list.h>
 #include <linux/mmzone.h>
 #include <linux/rbtree.h>
@@ -111,7 +112,7 @@ extern unsigned int kobjsize(const void *objp);
 #define VM_HUGEPAGE     0x01000000      /* MADV_HUGEPAGE marked this vma */
 #endif
 #define VM_INSERTPAGE   0x02000000      /* The vma has had "vm_insert_page()" done on it */
-#define VM_ALWAYSDUMP   0x04000000      /* Always include in core dumps */
+#define VM_NODUMP       0x04000000      /* Do not include in the core dump */
 
 #define VM_CAN_NONLINEAR 0x08000000     /* Has ->fault & does nonlinear pages */
 #define VM_MIXEDMAP     0x10000000      /* Can contain "struct page" and pure PFN pages */
@@ -893,9 +894,9 @@ struct page *vm_normal_page(struct vm_area_struct *vma, unsigned long addr,
 
 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,
+void 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,
+void 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 *);
@@ -1040,6 +1041,9 @@ static inline int stack_guard_page_end(struct vm_area_struct *vma,
                 !vma_growsup(vma->vm_next, addr);
 }
 
+extern pid_t
+vm_is_stack(struct task_struct *task, struct vm_area_struct *vma, int in_group);
+
 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);
@@ -1058,19 +1062,20 @@ int __get_user_pages_fast(unsigned long start, int nr_pages, int write,
 /*
  * per-process(per-mm_struct) statistics.
  */
-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);
-#else
 static inline unsigned long get_mm_counter(struct mm_struct *mm, int member)
 {
-        return atomic_long_read(&mm->rss_stat.count[member]);
-}
+        long val = atomic_long_read(&mm->rss_stat.count[member]);
+
+#ifdef SPLIT_RSS_COUNTING
+        /*
+         * counter is updated in asynchronous manner and may go to minus.
+         * But it's never be expected number for users.
+         */
+        if (val < 0)
+                val = 0;
 #endif
+        return (unsigned long)val;
+}
 
 static inline void add_mm_counter(struct mm_struct *mm, int member, long value)
 {
@@ -1127,9 +1132,9 @@ static inline void setmax_mm_hiwater_rss(unsigned long *maxrss,
 }
 
 #if defined(SPLIT_RSS_COUNTING)
-void sync_mm_rss(struct task_struct *task, struct mm_struct *mm);
+void sync_mm_rss(struct mm_struct *mm);
 #else
-static inline void sync_mm_rss(struct task_struct *task, struct mm_struct *mm)
+static inline void sync_mm_rss(struct mm_struct *mm)
 {
 }
 #endif
@@ -1291,8 +1296,6 @@ extern void get_pfn_range_for_nid(unsigned int nid,
 extern unsigned long find_min_pfn_with_active_regions(void);
 extern void free_bootmem_with_active_regions(int nid,
                                                 unsigned long max_low_pfn);
-int add_from_early_node_map(struct range *range, int az,
-                                   int nr_range, int nid);
 extern void sparse_memory_present_with_active_regions(int nid);
 
 #endif /* CONFIG_HAVE_MEMBLOCK_NODE_MAP */
@@ -1598,9 +1601,9 @@ void vmemmap_populate_print_last(void);
 
 enum mf_flags {
         MF_COUNT_INCREASED = 1 << 0,
+        MF_ACTION_REQUIRED = 1 << 1,
 };
-extern void memory_failure(unsigned long pfn, int trapno);
-extern int __memory_failure(unsigned long pfn, int trapno, int flags);
+extern int memory_failure(unsigned long pfn, int trapno, int flags);
 extern void memory_failure_queue(unsigned long pfn, int trapno, int flags);
 extern int unpoison_memory(unsigned long pfn);
 extern int sysctl_memory_failure_early_kill;
diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
index 19a41d1737af..6faa145c81e3 100644
--- a/include/linux/mmc/card.h
+++ b/include/linux/mmc/card.h
@@ -10,6 +10,7 @@
 #ifndef LINUX_MMC_CARD_H
 #define LINUX_MMC_CARD_H
 
+#include <linux/device.h>
 #include <linux/mmc/core.h>
 #include <linux/mod_devicetable.h>
 
diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
index 87a976cc5654..2e6a681fceb2 100644
--- a/include/linux/mmc/core.h
+++ b/include/linux/mmc/core.h
@@ -9,7 +9,7 @@
 #define LINUX_MMC_CORE_H
 
 #include <linux/interrupt.h>
-#include <linux/device.h>
+#include <linux/completion.h>
 
 struct request;
 struct mmc_data;
diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h
index ee2b0363c040..91924e8c642b 100644
--- a/include/linux/mmc/host.h
+++ b/include/linux/mmc/host.h
@@ -12,6 +12,7 @@
 
 #include <linux/leds.h>
 #include <linux/sched.h>
+#include <linux/device.h>
 #include <linux/fault-inject.h>
 
 #include <linux/mmc/core.h>
diff --git a/include/linux/mmc/ioctl.h b/include/linux/mmc/ioctl.h
index 8fa5bc5f8059..1f5e68923929 100644
--- a/include/linux/mmc/ioctl.h
+++ b/include/linux/mmc/ioctl.h
@@ -1,5 +1,8 @@
 #ifndef LINUX_MMC_IOCTL_H
 #define LINUX_MMC_IOCTL_H
+
+#include <linux/types.h>
+
 struct mmc_ioc_cmd {
         /* Implies direction of data.  true = write, false = read */
         int write_flag;
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index 650ba2fb3301..dff711509661 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -365,6 +365,7 @@ struct zone {
          */
         unsigned int            compact_considered;
         unsigned int            compact_defer_shift;
+        int                     compact_order_failed;
 #endif
 
         ZONE_PADDING(_pad1_)
diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetable.h
index 83ac0713ed0a..501da4cb8a6d 100644
--- a/include/linux/mod_devicetable.h
+++ b/include/linux/mod_devicetable.h
@@ -414,6 +414,15 @@ struct hv_vmbus_device_id {
                         __attribute__((aligned(sizeof(kernel_ulong_t))));
 };
 
+/* rpmsg */
+
+#define RPMSG_NAME_SIZE                 32
+#define RPMSG_DEVICE_MODALIAS_FMT       "rpmsg:%s"
+
+struct rpmsg_device_id {
+        char name[RPMSG_NAME_SIZE];
+};
+
 /* i2c */
 
 #define I2C_NAME_SIZE   20
@@ -560,4 +569,25 @@ struct amba_id {
 #endif
 };
 
+/*
+ * Match x86 CPUs for CPU specific drivers.
+ * See documentation of "x86_match_cpu" for details.
+ */
+
+struct x86_cpu_id {
+        __u16 vendor;
+        __u16 family;
+        __u16 model;
+        __u16 feature;  /* bit index */
+        kernel_ulong_t driver_data;
+};
+
+#define X86_FEATURE_MATCH(x) \
+        { X86_VENDOR_ANY, X86_FAMILY_ANY, X86_MODEL_ANY, x }
+
+#define X86_VENDOR_ANY 0xffff
+#define X86_FAMILY_ANY 0
+#define X86_MODEL_ANY  0
+#define X86_FEATURE_ANY 0       /* Same as FPU, you can't test for that */
+
 #endif /* LINUX_MOD_DEVICETABLE_H */
diff --git a/include/linux/mtd/cfi.h b/include/linux/mtd/cfi.h
index d5d2ec6494bb..37ef6b194089 100644
--- a/include/linux/mtd/cfi.h
+++ b/include/linux/mtd/cfi.h
@@ -22,6 +22,7 @@
 
 #include <linux/delay.h>
 #include <linux/types.h>
+#include <linux/bug.h>
 #include <linux/interrupt.h>
 #include <linux/mtd/flashchip.h>
 #include <linux/mtd/map.h>
diff --git a/include/linux/net.h b/include/linux/net.h
index b29923006b11..be60c7f5e145 100644
--- a/include/linux/net.h
+++ b/include/linux/net.h
@@ -206,6 +206,7 @@ struct proto_ops {
                                       int offset, size_t size, int flags);
         ssize_t         (*splice_read)(struct socket *sock,  loff_t *ppos,
                                        struct pipe_inode_info *pipe, size_t len, unsigned int flags);
+        void            (*set_peek_off)(struct sock *sk, int val);
 };
 
 #define DECLARE_SOCKADDR(type, dst, src)        \
diff --git a/include/linux/netdev_features.h b/include/linux/netdev_features.h
index 77f5202977ce..5ac32123035a 100644
--- a/include/linux/netdev_features.h
+++ b/include/linux/netdev_features.h
@@ -54,6 +54,8 @@ enum {
         NETIF_F_RXCSUM_BIT,             /* Receive checksumming offload */
         NETIF_F_NOCACHE_COPY_BIT,       /* Use no-cache copyfromuser */
         NETIF_F_LOOPBACK_BIT,           /* Enable loopback */
+        NETIF_F_RXFCS_BIT,              /* Append FCS to skb pkt data */
+        NETIF_F_RXALL_BIT,              /* Receive errored frames too */
 
         /*
          * Add your fresh new feature above and remember to update
@@ -98,6 +100,8 @@ enum {
 #define NETIF_F_TSO             __NETIF_F(TSO)
 #define NETIF_F_UFO             __NETIF_F(UFO)
 #define NETIF_F_VLAN_CHALLENGED __NETIF_F(VLAN_CHALLENGED)
+#define NETIF_F_RXFCS           __NETIF_F(RXFCS)
+#define NETIF_F_RXALL           __NETIF_F(RXALL)
 
 /* Features valid for ethtool to change */
 /* = all defined minus driver/device-class-related */
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index 0eac07c95255..1f77540bdc95 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -33,12 +33,12 @@
 #ifdef __KERNEL__
 #include <linux/pm_qos.h>
 #include <linux/timer.h>
+#include <linux/bug.h>
 #include <linux/delay.h>
 #include <linux/atomic.h>
 #include <asm/cache.h>
 #include <asm/byteorder.h>
 
-#include <linux/device.h>
 #include <linux/percpu.h>
 #include <linux/rculist.h>
 #include <linux/dmaengine.h>
@@ -56,6 +56,7 @@
 #include <linux/netdev_features.h>
 
 struct netpoll_info;
+struct device;
 struct phy_device;
 /* 802.11 specific */
 struct wireless_dev;
@@ -214,8 +215,8 @@ enum {
 #include <linux/skbuff.h>
 
 #ifdef CONFIG_RPS
-#include <linux/jump_label.h>
-extern struct jump_label_key rps_needed;
+#include <linux/static_key.h>
+extern struct static_key rps_needed;
 #endif
 
 struct neighbour;
@@ -417,7 +418,7 @@ typedef rx_handler_result_t rx_handler_func_t(struct sk_buff **pskb);
 
 extern void __napi_schedule(struct napi_struct *n);
 
-static inline int napi_disable_pending(struct napi_struct *n)
+static inline bool napi_disable_pending(struct napi_struct *n)
 {
         return test_bit(NAPI_STATE_DISABLE, &n->state);
 }
@@ -431,7 +432,7 @@ static inline int napi_disable_pending(struct napi_struct *n)
  * insure only one NAPI poll instance runs.  We also make
  * sure there is no pending NAPI disable.
  */
-static inline int napi_schedule_prep(struct napi_struct *n)
+static inline bool napi_schedule_prep(struct napi_struct *n)
 {
         return !napi_disable_pending(n) &&
                 !test_and_set_bit(NAPI_STATE_SCHED, &n->state);
@@ -451,13 +452,13 @@ static inline void napi_schedule(struct napi_struct *n)
 }
 
 /* Try to reschedule poll. Called by dev->poll() after napi_complete().  */
-static inline int napi_reschedule(struct napi_struct *napi)
+static inline bool napi_reschedule(struct napi_struct *napi)
 {
         if (napi_schedule_prep(napi)) {
                 __napi_schedule(napi);
-                return 1;
+                return true;
         }
-        return 0;
+        return false;
 }
 
 /**
@@ -1082,7 +1083,8 @@ 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 int            priv_flags; /* Like 'flags' but invisible to userspace.
+                                             * See if.h for definitions. */
         unsigned short          gflags;
         unsigned short          padded; /* How much padding added by alloc_netdev() */
 
@@ -1867,7 +1869,7 @@ static inline void netif_tx_stop_all_queues(struct net_device *dev)
         }
 }
 
-static inline int netif_tx_queue_stopped(const struct netdev_queue *dev_queue)
+static inline bool netif_tx_queue_stopped(const struct netdev_queue *dev_queue)
 {
         return test_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state);
 }
@@ -1878,17 +1880,17 @@ static inline int netif_tx_queue_stopped(const struct netdev_queue *dev_queue)
  *
  *      Test if transmit queue on device is currently unable to send.
  */
-static inline int netif_queue_stopped(const struct net_device *dev)
+static inline bool netif_queue_stopped(const struct net_device *dev)
 {
         return netif_tx_queue_stopped(netdev_get_tx_queue(dev, 0));
 }
 
-static inline int netif_xmit_stopped(const struct netdev_queue *dev_queue)
+static inline bool netif_xmit_stopped(const struct netdev_queue *dev_queue)
 {
         return dev_queue->state & QUEUE_STATE_ANY_XOFF;
 }
 
-static inline int netif_xmit_frozen_or_stopped(const struct netdev_queue *dev_queue)
+static inline bool netif_xmit_frozen_or_stopped(const struct netdev_queue *dev_queue)
 {
         return dev_queue->state & QUEUE_STATE_ANY_XOFF_OR_FROZEN;
 }
@@ -1898,12 +1900,22 @@ static inline void netdev_tx_sent_queue(struct netdev_queue *dev_queue,
 {
 #ifdef CONFIG_BQL
         dql_queued(&dev_queue->dql, bytes);
-        if (unlikely(dql_avail(&dev_queue->dql) < 0)) {
-                set_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state);
-                if (unlikely(dql_avail(&dev_queue->dql) >= 0))
-                        clear_bit(__QUEUE_STATE_STACK_XOFF,
-                            &dev_queue->state);
-        }
+
+        if (likely(dql_avail(&dev_queue->dql) >= 0))
+                return;
+
+        set_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state);
+
+        /*
+         * The XOFF flag must be set before checking the dql_avail below,
+         * because in netdev_tx_completed_queue we update the dql_completed
+         * before checking the XOFF flag.
+         */
+        smp_mb();
+
+        /* check again in case another CPU has just made room avail */
+        if (unlikely(dql_avail(&dev_queue->dql) >= 0))
+                clear_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state);
 #endif
 }
 
@@ -1916,16 +1928,23 @@ static inline void netdev_tx_completed_queue(struct netdev_queue *dev_queue,
                                              unsigned pkts, unsigned bytes)
 {
 #ifdef CONFIG_BQL
-        if (likely(bytes)) {
-                dql_completed(&dev_queue->dql, bytes);
-                if (unlikely(test_bit(__QUEUE_STATE_STACK_XOFF,
-                    &dev_queue->state) &&
-                    dql_avail(&dev_queue->dql) >= 0)) {
-                        if (test_and_clear_bit(__QUEUE_STATE_STACK_XOFF,
-                             &dev_queue->state))
-                                netif_schedule_queue(dev_queue);
-                }
-        }
+        if (unlikely(!bytes))
+                return;
+
+        dql_completed(&dev_queue->dql, bytes);
+
+        /*
+         * Without the memory barrier there is a small possiblity that
+         * netdev_tx_sent_queue will miss the update and cause the queue to
+         * be stopped forever
+         */
+        smp_mb();
+
+        if (dql_avail(&dev_queue->dql) < 0)
+                return;
+
+        if (test_and_clear_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state))
+                netif_schedule_queue(dev_queue);
 #endif
 }
 
@@ -1938,6 +1957,7 @@ static inline void netdev_completed_queue(struct net_device *dev,
 static inline void netdev_tx_reset_queue(struct netdev_queue *q)
 {
 #ifdef CONFIG_BQL
+        clear_bit(__QUEUE_STATE_STACK_XOFF, &q->state);
         dql_reset(&q->dql);
 #endif
 }
@@ -1953,7 +1973,7 @@ static inline void netdev_reset_queue(struct net_device *dev_queue)
  *
  *      Test if the device has been brought up.
  */
-static inline int netif_running(const struct net_device *dev)
+static inline bool netif_running(const struct net_device *dev)
 {
         return test_bit(__LINK_STATE_START, &dev->state);
 }
@@ -2003,16 +2023,16 @@ static inline void netif_stop_subqueue(struct net_device *dev, u16 queue_index)
  *
  * Check individual transmit queue of a device with multiple transmit queues.
  */
-static inline int __netif_subqueue_stopped(const struct net_device *dev,
-                                         u16 queue_index)
+static inline bool __netif_subqueue_stopped(const struct net_device *dev,
+                                            u16 queue_index)
 {
         struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
 
         return netif_tx_queue_stopped(txq);
 }
 
-static inline int netif_subqueue_stopped(const struct net_device *dev,
-                                         struct sk_buff *skb)
+static inline bool netif_subqueue_stopped(const struct net_device *dev,
+                                          struct sk_buff *skb)
 {
         return __netif_subqueue_stopped(dev, skb_get_queue_mapping(skb));
 }
@@ -2051,7 +2071,7 @@ static inline u16 skb_tx_hash(const struct net_device *dev,
  *
  * Check if device has multiple transmit queues
  */
-static inline int netif_is_multiqueue(const struct net_device *dev)
+static inline bool netif_is_multiqueue(const struct net_device *dev)
 {
         return dev->num_tx_queues > 1;
 }
@@ -2121,7 +2141,7 @@ extern int netdev_rx_handler_register(struct net_device *dev,
                                       void *rx_handler_data);
 extern void netdev_rx_handler_unregister(struct net_device *dev);
 
-extern int              dev_valid_name(const char *name);
+extern bool             dev_valid_name(const char *name);
 extern int              dev_ioctl(struct net *net, unsigned int cmd, void __user *);
 extern int              dev_ethtool(struct net *net, struct ifreq *);
 extern unsigned         dev_get_flags(const struct net_device *);
@@ -2187,7 +2207,7 @@ extern void linkwatch_forget_dev(struct net_device *dev);
  *
  * Check if carrier is present on device
  */
-static inline int netif_carrier_ok(const struct net_device *dev)
+static inline bool netif_carrier_ok(const struct net_device *dev)
 {
         return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
 }
@@ -2239,7 +2259,7 @@ static inline void netif_dormant_off(struct net_device *dev)
  *
  * Check if carrier is present on device
  */
-static inline int netif_dormant(const struct net_device *dev)
+static inline bool netif_dormant(const struct net_device *dev)
 {
         return test_bit(__LINK_STATE_DORMANT, &dev->state);
 }
@@ -2251,7 +2271,7 @@ static inline int netif_dormant(const struct net_device *dev)
  *
  * Check if carrier is operational
  */
-static inline int netif_oper_up(const struct net_device *dev)
+static inline bool netif_oper_up(const struct net_device *dev)
 {
         return (dev->operstate == IF_OPER_UP ||
                 dev->operstate == IF_OPER_UNKNOWN /* backward compat */);
@@ -2263,7 +2283,7 @@ static inline int netif_oper_up(const struct net_device *dev)
  *
  * Check if device has not been removed from system.
  */
-static inline int netif_device_present(struct net_device *dev)
+static inline bool netif_device_present(struct net_device *dev)
 {
         return test_bit(__LINK_STATE_PRESENT, &dev->state);
 }
@@ -2333,9 +2353,9 @@ static inline void __netif_tx_lock_bh(struct netdev_queue *txq)
         txq->xmit_lock_owner = smp_processor_id();
 }
 
-static inline int __netif_tx_trylock(struct netdev_queue *txq)
+static inline bool __netif_tx_trylock(struct netdev_queue *txq)
 {
-        int ok = spin_trylock(&txq->_xmit_lock);
+        bool ok = spin_trylock(&txq->_xmit_lock);
         if (likely(ok))
                 txq->xmit_lock_owner = smp_processor_id();
         return ok;
@@ -2556,6 +2576,8 @@ extern void		dev_load(struct net *net, const char *name);
 extern void             dev_mcast_init(void);
 extern struct rtnl_link_stats64 *dev_get_stats(struct net_device *dev,
                                                struct rtnl_link_stats64 *storage);
+extern void netdev_stats_to_stats64(struct rtnl_link_stats64 *stats64,
+                                    const struct net_device_stats *netdev_stats);
 
 extern int              netdev_max_backlog;
 extern int              netdev_tstamp_prequeue;
@@ -2611,7 +2633,7 @@ void netif_stacked_transfer_operstate(const struct net_device *rootdev,
 
 netdev_features_t netif_skb_features(struct sk_buff *skb);
 
-static inline int net_gso_ok(netdev_features_t features, int gso_type)
+static inline bool net_gso_ok(netdev_features_t features, int gso_type)
 {
         netdev_features_t feature = gso_type << NETIF_F_GSO_SHIFT;
 
@@ -2626,17 +2648,18 @@ static inline int net_gso_ok(netdev_features_t features, int gso_type)
         return (features & feature) == feature;
 }
 
-static inline int skb_gso_ok(struct sk_buff *skb, netdev_features_t features)
+static inline bool skb_gso_ok(struct sk_buff *skb, netdev_features_t features)
 {
         return net_gso_ok(features, skb_shinfo(skb)->gso_type) &&
                (!skb_has_frag_list(skb) || (features & NETIF_F_FRAGLIST));
 }
 
-static inline int netif_needs_gso(struct sk_buff *skb,
-        netdev_features_t features)
+static inline bool netif_needs_gso(struct sk_buff *skb,
+                                   netdev_features_t features)
 {
         return skb_is_gso(skb) && (!skb_gso_ok(skb, features) ||
-                unlikely(skb->ip_summed != CHECKSUM_PARTIAL));
+                unlikely((skb->ip_summed != CHECKSUM_PARTIAL) &&
+                         (skb->ip_summed != CHECKSUM_UNNECESSARY)));
 }
 
 static inline void netif_set_gso_max_size(struct net_device *dev,
@@ -2645,11 +2668,16 @@ static inline void netif_set_gso_max_size(struct net_device *dev,
         dev->gso_max_size = size;
 }
 
-static inline int netif_is_bond_slave(struct net_device *dev)
+static inline bool netif_is_bond_slave(struct net_device *dev)
 {
         return dev->flags & IFF_SLAVE && dev->priv_flags & IFF_BONDING;
 }
 
+static inline bool netif_supports_nofcs(struct net_device *dev)
+{
+        return dev->priv_flags & IFF_SUPP_NOFCS;
+}
+
 extern struct pernet_operations __net_initdata loopback_net_ops;
 
 /* Logging, debugging and troubleshooting/diagnostic helpers. */
@@ -2687,14 +2715,14 @@ int netdev_info(const struct net_device *dev, const char *format, ...);
 #define MODULE_ALIAS_NETDEV(device) \
         MODULE_ALIAS("netdev-" device)
 
-#if defined(DEBUG)
-#define netdev_dbg(__dev, format, args...)                      \
-        netdev_printk(KERN_DEBUG, __dev, format, ##args)
-#elif defined(CONFIG_DYNAMIC_DEBUG)
+#if defined(CONFIG_DYNAMIC_DEBUG)
 #define netdev_dbg(__dev, format, args...)                      \
 do {                                                            \
         dynamic_netdev_dbg(__dev, format, ##args);              \
 } while (0)
+#elif defined(DEBUG)
+#define netdev_dbg(__dev, format, args...)                      \
+        netdev_printk(KERN_DEBUG, __dev, format, ##args)
 #else
 #define netdev_dbg(__dev, format, args...)                      \
 ({                                                              \
diff --git a/include/linux/netfilter.h b/include/linux/netfilter.h
index b809265607d0..29734be334c1 100644
--- a/include/linux/netfilter.h
+++ b/include/linux/netfilter.h
@@ -163,13 +163,13 @@ extern struct ctl_path nf_net_ipv4_netfilter_sysctl_path[];
 extern struct list_head nf_hooks[NFPROTO_NUMPROTO][NF_MAX_HOOKS];
 
 #if defined(CONFIG_JUMP_LABEL)
-#include <linux/jump_label.h>
-extern struct jump_label_key nf_hooks_needed[NFPROTO_NUMPROTO][NF_MAX_HOOKS];
+#include <linux/static_key.h>
+extern struct static_key nf_hooks_needed[NFPROTO_NUMPROTO][NF_MAX_HOOKS];
 static inline bool nf_hooks_active(u_int8_t pf, unsigned int hook)
 {
         if (__builtin_constant_p(pf) &&
             __builtin_constant_p(hook))
-                return static_branch(&nf_hooks_needed[pf][hook]);
+                return static_key_false(&nf_hooks_needed[pf][hook]);
 
         return !list_empty(&nf_hooks[pf][hook]);
 }
diff --git a/include/linux/netfilter/Kbuild b/include/linux/netfilter/Kbuild
index e144f54185c0..1697036336b6 100644
--- a/include/linux/netfilter/Kbuild
+++ b/include/linux/netfilter/Kbuild
@@ -10,6 +10,7 @@ header-y += nfnetlink.h
 header-y += nfnetlink_acct.h
 header-y += nfnetlink_compat.h
 header-y += nfnetlink_conntrack.h
+header-y += nfnetlink_cttimeout.h
 header-y += nfnetlink_log.h
 header-y += nfnetlink_queue.h
 header-y += x_tables.h
@@ -22,6 +23,7 @@ header-y += xt_CT.h
 header-y += xt_DSCP.h
 header-y += xt_IDLETIMER.h
 header-y += xt_LED.h
+header-y += xt_LOG.h
 header-y += xt_MARK.h
 header-y += xt_nfacct.h
 header-y += xt_NFLOG.h
diff --git a/include/linux/netfilter/ipset/ip_set.h b/include/linux/netfilter/ipset/ip_set.h
index 3540c6e262f7..2f8e18a23227 100644
--- a/include/linux/netfilter/ipset/ip_set.h
+++ b/include/linux/netfilter/ipset/ip_set.h
@@ -11,6 +11,8 @@
  * published by the Free Software Foundation.
  */
 
+#include <linux/types.h>
+
 /* The protocol version */
 #define IPSET_PROTOCOL          6
 
@@ -148,6 +150,7 @@ enum ipset_cmd_flags {
         IPSET_FLAG_LIST_SETNAME = (1 << IPSET_FLAG_BIT_LIST_SETNAME),
         IPSET_FLAG_BIT_LIST_HEADER = 2,
         IPSET_FLAG_LIST_HEADER  = (1 << IPSET_FLAG_BIT_LIST_HEADER),
+        IPSET_FLAG_CMD_MAX = 15,        /* Lower half */
 };
 
 /* Flags at CADT attribute level */
@@ -156,6 +159,9 @@ enum ipset_cadt_flags {
         IPSET_FLAG_BEFORE       = (1 << IPSET_FLAG_BIT_BEFORE),
         IPSET_FLAG_BIT_PHYSDEV  = 1,
         IPSET_FLAG_PHYSDEV      = (1 << IPSET_FLAG_BIT_PHYSDEV),
+        IPSET_FLAG_BIT_NOMATCH  = 2,
+        IPSET_FLAG_NOMATCH      = (1 << IPSET_FLAG_BIT_NOMATCH),
+        IPSET_FLAG_CADT_MAX     = 15,   /* Upper half */
 };
 
 /* Commands with settype-specific attributes */
@@ -168,19 +174,10 @@ enum ipset_adt {
         IPSET_CADT_MAX,
 };
 
-#ifdef __KERNEL__
-#include <linux/ip.h>
-#include <linux/ipv6.h>
-#include <linux/netlink.h>
-#include <linux/netfilter.h>
-#include <linux/netfilter/x_tables.h>
-#include <linux/vmalloc.h>
-#include <net/netlink.h>
-
 /* Sets are identified by an index in kernel space. Tweak with ip_set_id_t
  * and IPSET_INVALID_ID if you want to increase the max number of sets.
  */
-typedef u16 ip_set_id_t;
+typedef __u16 ip_set_id_t;
 
 #define IPSET_INVALID_ID                65535
 
@@ -203,6 +200,15 @@ enum ip_set_kopt {
         IPSET_DIM_THREE_SRC = (1 << IPSET_DIM_THREE),
 };
 
+#ifdef __KERNEL__
+#include <linux/ip.h>
+#include <linux/ipv6.h>
+#include <linux/netlink.h>
+#include <linux/netfilter.h>
+#include <linux/netfilter/x_tables.h>
+#include <linux/vmalloc.h>
+#include <net/netlink.h>
+
 /* Set features */
 enum ip_set_feature {
         IPSET_TYPE_IP_FLAG = 0,
@@ -288,7 +294,10 @@ struct ip_set_type {
         u8 features;
         /* Set type dimension */
         u8 dimension;
-        /* Supported family: may be AF_UNSPEC for both AF_INET/AF_INET6 */
+        /*
+         * Supported family: may be NFPROTO_UNSPEC for both
+         * NFPROTO_IPV4/NFPROTO_IPV6.
+         */
         u8 family;
         /* Type revisions */
         u8 revision_min, revision_max;
@@ -450,6 +459,8 @@ bitmap_bytes(u32 a, u32 b)
         return 4 * ((((b - a + 8) / 8) + 3) / 4);
 }
 
+#endif /* __KERNEL__ */
+
 /* Interface to iptables/ip6tables */
 
 #define SO_IP_SET               83
@@ -475,6 +486,4 @@ struct ip_set_req_version {
         unsigned version;
 };
 
-#endif  /* __KERNEL__ */
-
 #endif /*_IP_SET_H */
diff --git a/include/linux/netfilter/ipset/ip_set_ahash.h b/include/linux/netfilter/ipset/ip_set_ahash.h
index b89fb79cb44f..05a5d72680be 100644
--- a/include/linux/netfilter/ipset/ip_set_ahash.h
+++ b/include/linux/netfilter/ipset/ip_set_ahash.h
@@ -113,6 +113,12 @@ htable_bits(u32 hashsize)
 }
 
 #ifdef IP_SET_HASH_WITH_NETS
+#ifdef IP_SET_HASH_WITH_NETS_PACKED
+/* When cidr is packed with nomatch, cidr - 1 is stored in the entry */
+#define CIDR(cidr)      (cidr + 1)
+#else
+#define CIDR(cidr)      (cidr)
+#endif
 
 #define SET_HOST_MASK(family)   (family == AF_INET ? 32 : 128)
 
@@ -262,6 +268,12 @@ ip_set_hash_destroy(struct ip_set *set)
 #define type_pf_data_list       TOKEN(TYPE, PF, _data_list)
 #define type_pf_data_tlist      TOKEN(TYPE, PF, _data_tlist)
 #define type_pf_data_next       TOKEN(TYPE, PF, _data_next)
+#define type_pf_data_flags      TOKEN(TYPE, PF, _data_flags)
+#ifdef IP_SET_HASH_WITH_NETS
+#define type_pf_data_match      TOKEN(TYPE, PF, _data_match)
+#else
+#define type_pf_data_match(d)   1
+#endif
 
 #define type_pf_elem            TOKEN(TYPE, PF, _elem)
 #define type_pf_telem           TOKEN(TYPE, PF, _telem)
@@ -308,8 +320,10 @@ ip_set_hash_destroy(struct ip_set *set)
  * we spare the maintenance of the internal counters. */
 static int
 type_pf_elem_add(struct hbucket *n, const struct type_pf_elem *value,
-                 u8 ahash_max)
+                 u8 ahash_max, u32 cadt_flags)
 {
+        struct type_pf_elem *data;
+
         if (n->pos >= n->size) {
                 void *tmp;
 
@@ -330,7 +344,13 @@ type_pf_elem_add(struct hbucket *n, const struct type_pf_elem *value,
                 n->value = tmp;
                 n->size += AHASH_INIT_SIZE;
         }
-        type_pf_data_copy(ahash_data(n, n->pos++), value);
+        data = ahash_data(n, n->pos++);
+        type_pf_data_copy(data, value);
+#ifdef IP_SET_HASH_WITH_NETS
+        /* Resizing won't overwrite stored flags */
+        if (cadt_flags)
+                type_pf_data_flags(data, cadt_flags);
+#endif
         return 0;
 }
 
@@ -353,9 +373,12 @@ retry:
         htable_bits++;
         pr_debug("attempt to resize set %s from %u to %u, t %p\n",
                  set->name, orig->htable_bits, htable_bits, orig);
-        if (!htable_bits)
+        if (!htable_bits) {
                 /* In case we have plenty of memory :-) */
+                pr_warning("Cannot increase the hashsize of set %s further\n",
+                           set->name);
                 return -IPSET_ERR_HASH_FULL;
+        }
         t = ip_set_alloc(sizeof(*t)
                          + jhash_size(htable_bits) * sizeof(struct hbucket));
         if (!t)
@@ -368,7 +391,7 @@ retry:
                 for (j = 0; j < n->pos; j++) {
                         data = ahash_data(n, j);
                         m = hbucket(t, HKEY(data, h->initval, htable_bits));
-                        ret = type_pf_elem_add(m, data, AHASH_MAX(h));
+                        ret = type_pf_elem_add(m, data, AHASH_MAX(h), 0);
                         if (ret < 0) {
                                 read_unlock_bh(&set->lock);
                                 ahash_destroy(t);
@@ -406,9 +429,14 @@ type_pf_add(struct ip_set *set, void *value, u32 timeout, u32 flags)
         struct hbucket *n;
         int i, ret = 0;
         u32 key, multi = 0;
+        u32 cadt_flags = flags >> 16;
 
-        if (h->elements >= h->maxelem)
+        if (h->elements >= h->maxelem) {
+                if (net_ratelimit())
+                        pr_warning("Set %s is full, maxelem %u reached\n",
+                                   set->name, h->maxelem);
                 return -IPSET_ERR_HASH_FULL;
+        }
 
         rcu_read_lock_bh();
         t = rcu_dereference_bh(h->table);
@@ -416,11 +444,17 @@ type_pf_add(struct ip_set *set, void *value, u32 timeout, u32 flags)
         n = hbucket(t, key);
         for (i = 0; i < n->pos; i++)
                 if (type_pf_data_equal(ahash_data(n, i), d, &multi)) {
+#ifdef IP_SET_HASH_WITH_NETS
+                        if (flags & IPSET_FLAG_EXIST)
+                                /* Support overwriting just the flags */
+                                type_pf_data_flags(ahash_data(n, i),
+                                                   cadt_flags);
+#endif
                         ret = -IPSET_ERR_EXIST;
                         goto out;
                 }
         TUNE_AHASH_MAX(h, multi);
-        ret = type_pf_elem_add(n, value, AHASH_MAX(h));
+        ret = type_pf_elem_add(n, value, AHASH_MAX(h), cadt_flags);
         if (ret != 0) {
                 if (ret == -EAGAIN)
                         type_pf_data_next(h, d);
@@ -428,7 +462,7 @@ type_pf_add(struct ip_set *set, void *value, u32 timeout, u32 flags)
         }
 
 #ifdef IP_SET_HASH_WITH_NETS
-        add_cidr(h, d->cidr, HOST_MASK);
+        add_cidr(h, CIDR(d->cidr), HOST_MASK);
 #endif
         h->elements++;
 out:
@@ -463,7 +497,7 @@ type_pf_del(struct ip_set *set, void *value, u32 timeout, u32 flags)
                 n->pos--;
                 h->elements--;
 #ifdef IP_SET_HASH_WITH_NETS
-                del_cidr(h, d->cidr, HOST_MASK);
+                del_cidr(h, CIDR(d->cidr), HOST_MASK);
 #endif
                 if (n->pos + AHASH_INIT_SIZE < n->size) {
                         void *tmp = kzalloc((n->size - AHASH_INIT_SIZE)
@@ -506,7 +540,7 @@ type_pf_test_cidrs(struct ip_set *set, struct type_pf_elem *d, u32 timeout)
                 for (i = 0; i < n->pos; i++) {
                         data = ahash_data(n, i);
                         if (type_pf_data_equal(data, d, &multi))
-                                return 1;
+                                return type_pf_data_match(data);
                 }
         }
         return 0;
@@ -528,7 +562,7 @@ type_pf_test(struct ip_set *set, void *value, u32 timeout, u32 flags)
 #ifdef IP_SET_HASH_WITH_NETS
         /* If we test an IP address and not a network address,
          * try all possible network sizes */
-        if (d->cidr == SET_HOST_MASK(set->family))
+        if (CIDR(d->cidr) == SET_HOST_MASK(set->family))
                 return type_pf_test_cidrs(set, d, timeout);
 #endif
 
@@ -537,7 +571,7 @@ type_pf_test(struct ip_set *set, void *value, u32 timeout, u32 flags)
         for (i = 0; i < n->pos; i++) {
                 data = ahash_data(n, i);
                 if (type_pf_data_equal(data, d, &multi))
-                        return 1;
+                        return type_pf_data_match(data);
         }
         return 0;
 }
@@ -693,7 +727,7 @@ type_pf_data_timeout_set(struct type_pf_elem *data, u32 timeout)
 
 static int
 type_pf_elem_tadd(struct hbucket *n, const struct type_pf_elem *value,
-                  u8 ahash_max, u32 timeout)
+                  u8 ahash_max, u32 cadt_flags, u32 timeout)
 {
         struct type_pf_elem *data;
 
@@ -720,6 +754,11 @@ type_pf_elem_tadd(struct hbucket *n, const struct type_pf_elem *value,
         data = ahash_tdata(n, n->pos++);
         type_pf_data_copy(data, value);
         type_pf_data_timeout_set(data, timeout);
+#ifdef IP_SET_HASH_WITH_NETS
+        /* Resizing won't overwrite stored flags */
+        if (cadt_flags)
+                type_pf_data_flags(data, cadt_flags);
+#endif
         return 0;
 }
 
@@ -740,7 +779,7 @@ type_pf_expire(struct ip_set_hash *h)
                         if (type_pf_data_expired(data)) {
                                 pr_debug("expired %u/%u\n", i, j);
 #ifdef IP_SET_HASH_WITH_NETS
-                                del_cidr(h, data->cidr, HOST_MASK);
+                                del_cidr(h, CIDR(data->cidr), HOST_MASK);
 #endif
                                 if (j != n->pos - 1)
                                         /* Not last one */
@@ -790,9 +829,12 @@ type_pf_tresize(struct ip_set *set, bool retried)
 retry:
         ret = 0;
         htable_bits++;
-        if (!htable_bits)
+        if (!htable_bits) {
                 /* In case we have plenty of memory :-) */
+                pr_warning("Cannot increase the hashsize of set %s further\n",
+                           set->name);
                 return -IPSET_ERR_HASH_FULL;
+        }
         t = ip_set_alloc(sizeof(*t)
                          + jhash_size(htable_bits) * sizeof(struct hbucket));
         if (!t)
@@ -805,7 +847,7 @@ retry:
                 for (j = 0; j < n->pos; j++) {
                         data = ahash_tdata(n, j);
                         m = hbucket(t, HKEY(data, h->initval, htable_bits));
-                        ret = type_pf_elem_tadd(m, data, AHASH_MAX(h),
+                        ret = type_pf_elem_tadd(m, data, AHASH_MAX(h), 0,
                                                 type_pf_data_timeout(data));
                         if (ret < 0) {
                                 read_unlock_bh(&set->lock);
@@ -839,12 +881,17 @@ type_pf_tadd(struct ip_set *set, void *value, u32 timeout, u32 flags)
         int ret = 0, i, j = AHASH_MAX(h) + 1;
         bool flag_exist = flags & IPSET_FLAG_EXIST;
         u32 key, multi = 0;
+        u32 cadt_flags = flags >> 16;
 
         if (h->elements >= h->maxelem)
                 /* FIXME: when set is full, we slow down here */
                 type_pf_expire(h);
-        if (h->elements >= h->maxelem)
+        if (h->elements >= h->maxelem) {
+                if (net_ratelimit())
+                        pr_warning("Set %s is full, maxelem %u reached\n",
+                                   set->name, h->maxelem);
                 return -IPSET_ERR_HASH_FULL;
+        }
 
         rcu_read_lock_bh();
         t = rcu_dereference_bh(h->table);
@@ -854,6 +901,7 @@ type_pf_tadd(struct ip_set *set, void *value, u32 timeout, u32 flags)
                 data = ahash_tdata(n, i);
                 if (type_pf_data_equal(data, d, &multi)) {
                         if (type_pf_data_expired(data) || flag_exist)
+                                /* Just timeout value may be updated */
                                 j = i;
                         else {
                                 ret = -IPSET_ERR_EXIST;
@@ -866,15 +914,18 @@ type_pf_tadd(struct ip_set *set, void *value, u32 timeout, u32 flags)
         if (j != AHASH_MAX(h) + 1) {
                 data = ahash_tdata(n, j);
 #ifdef IP_SET_HASH_WITH_NETS
-                del_cidr(h, data->cidr, HOST_MASK);
-                add_cidr(h, d->cidr, HOST_MASK);
+                del_cidr(h, CIDR(data->cidr), HOST_MASK);
+                add_cidr(h, CIDR(d->cidr), HOST_MASK);
 #endif
                 type_pf_data_copy(data, d);
                 type_pf_data_timeout_set(data, timeout);
+#ifdef IP_SET_HASH_WITH_NETS
+                type_pf_data_flags(data, cadt_flags);
+#endif
                 goto out;
         }
         TUNE_AHASH_MAX(h, multi);
-        ret = type_pf_elem_tadd(n, d, AHASH_MAX(h), timeout);
+        ret = type_pf_elem_tadd(n, d, AHASH_MAX(h), cadt_flags, timeout);
         if (ret != 0) {
                 if (ret == -EAGAIN)
                         type_pf_data_next(h, d);
@@ -882,7 +933,7 @@ type_pf_tadd(struct ip_set *set, void *value, u32 timeout, u32 flags)
         }
 
 #ifdef IP_SET_HASH_WITH_NETS
-        add_cidr(h, d->cidr, HOST_MASK);
+        add_cidr(h, CIDR(d->cidr), HOST_MASK);
 #endif
         h->elements++;
 out:
@@ -916,7 +967,7 @@ type_pf_tdel(struct ip_set *set, void *value, u32 timeout, u32 flags)
                 n->pos--;
                 h->elements--;
 #ifdef IP_SET_HASH_WITH_NETS
-                del_cidr(h, d->cidr, HOST_MASK);
+                del_cidr(h, CIDR(d->cidr), HOST_MASK);
 #endif
                 if (n->pos + AHASH_INIT_SIZE < n->size) {
                         void *tmp = kzalloc((n->size - AHASH_INIT_SIZE)
@@ -954,8 +1005,17 @@ type_pf_ttest_cidrs(struct ip_set *set, struct type_pf_elem *d, u32 timeout)
                 n = hbucket(t, key);
                 for (i = 0; i < n->pos; i++) {
                         data = ahash_tdata(n, i);
-                        if (type_pf_data_equal(data, d, &multi))
-                                return !type_pf_data_expired(data);
+#ifdef IP_SET_HASH_WITH_MULTI
+                        if (type_pf_data_equal(data, d, &multi)) {
+                                if (!type_pf_data_expired(data))
+                                        return type_pf_data_match(data);
+                                multi = 0;
+                        }
+#else
+                        if (type_pf_data_equal(data, d, &multi) &&
+                            !type_pf_data_expired(data))
+                                return type_pf_data_match(data);
+#endif
                 }
         }
         return 0;
@@ -973,15 +1033,16 @@ type_pf_ttest(struct ip_set *set, void *value, u32 timeout, u32 flags)
         u32 key, multi = 0;
 
 #ifdef IP_SET_HASH_WITH_NETS
-        if (d->cidr == SET_HOST_MASK(set->family))
+        if (CIDR(d->cidr) == SET_HOST_MASK(set->family))
                 return type_pf_ttest_cidrs(set, d, timeout);
 #endif
         key = HKEY(d, h->initval, t->htable_bits);
         n = hbucket(t, key);
         for (i = 0; i < n->pos; i++) {
                 data = ahash_tdata(n, i);
-                if (type_pf_data_equal(data, d, &multi))
-                        return !type_pf_data_expired(data);
+                if (type_pf_data_equal(data, d, &multi) &&
+                    !type_pf_data_expired(data))
+                        return type_pf_data_match(data);
         }
         return 0;
 }
@@ -1094,14 +1155,17 @@ type_pf_gc_init(struct ip_set *set)
 #undef type_pf_data_isnull
 #undef type_pf_data_copy
 #undef type_pf_data_zero_out
+#undef type_pf_data_netmask
 #undef type_pf_data_list
 #undef type_pf_data_tlist
+#undef type_pf_data_next
+#undef type_pf_data_flags
+#undef type_pf_data_match
 
 #undef type_pf_elem
 #undef type_pf_telem
 #undef type_pf_data_timeout
 #undef type_pf_data_expired
-#undef type_pf_data_netmask
 #undef type_pf_data_timeout_set
 
 #undef type_pf_elem_add
@@ -1111,6 +1175,7 @@ type_pf_gc_init(struct ip_set *set)
 #undef type_pf_test
 
 #undef type_pf_elem_tadd
+#undef type_pf_del_telem
 #undef type_pf_expire
 #undef type_pf_tadd
 #undef type_pf_tdel
diff --git a/include/linux/netfilter/nf_conntrack_tcp.h b/include/linux/netfilter/nf_conntrack_tcp.h
index 6e135f97e59a..e59868ae12d4 100644
--- a/include/linux/netfilter/nf_conntrack_tcp.h
+++ b/include/linux/netfilter/nf_conntrack_tcp.h
@@ -18,7 +18,10 @@ enum tcp_conntrack {
         TCP_CONNTRACK_LISTEN,   /* obsolete */
 #define TCP_CONNTRACK_SYN_SENT2 TCP_CONNTRACK_LISTEN
         TCP_CONNTRACK_MAX,
-        TCP_CONNTRACK_IGNORE
+        TCP_CONNTRACK_IGNORE,
+        TCP_CONNTRACK_RETRANS,
+        TCP_CONNTRACK_UNACK,
+        TCP_CONNTRACK_TIMEOUT_MAX
 };
 
 /* Window scaling is advertised by the sender */
diff --git a/include/linux/netfilter/nfnetlink.h b/include/linux/netfilter/nfnetlink.h
index b64454c2f79f..6fd1f0d07e64 100644
--- a/include/linux/netfilter/nfnetlink.h
+++ b/include/linux/netfilter/nfnetlink.h
@@ -49,7 +49,8 @@ struct nfgenmsg {
 #define NFNL_SUBSYS_OSF                 5
 #define NFNL_SUBSYS_IPSET               6
 #define NFNL_SUBSYS_ACCT                7
-#define NFNL_SUBSYS_COUNT               8
+#define NFNL_SUBSYS_CTNETLINK_TIMEOUT   8
+#define NFNL_SUBSYS_COUNT               9
 
 #ifdef __KERNEL__
 
diff --git a/include/linux/netfilter/nfnetlink_conntrack.h b/include/linux/netfilter/nfnetlink_conntrack.h
index debf1aefd753..e58e4b93c108 100644
--- a/include/linux/netfilter/nfnetlink_conntrack.h
+++ b/include/linux/netfilter/nfnetlink_conntrack.h
@@ -43,6 +43,7 @@ enum ctattr_type {
         CTA_ZONE,
         CTA_SECCTX,
         CTA_TIMESTAMP,
+        CTA_MARK_MASK,
         __CTA_MAX
 };
 #define CTA_MAX (__CTA_MAX - 1)
@@ -172,10 +173,21 @@ enum ctattr_expect {
         CTA_EXPECT_HELP_NAME,
         CTA_EXPECT_ZONE,
         CTA_EXPECT_FLAGS,
+        CTA_EXPECT_CLASS,
+        CTA_EXPECT_NAT,
+        CTA_EXPECT_FN,
         __CTA_EXPECT_MAX
 };
 #define CTA_EXPECT_MAX (__CTA_EXPECT_MAX - 1)
 
+enum ctattr_expect_nat {
+        CTA_EXPECT_NAT_UNSPEC,
+        CTA_EXPECT_NAT_DIR,
+        CTA_EXPECT_NAT_TUPLE,
+        __CTA_EXPECT_NAT_MAX
+};
+#define CTA_EXPECT_NAT_MAX (__CTA_EXPECT_NAT_MAX - 1)
+
 enum ctattr_help {
         CTA_HELP_UNSPEC,
         CTA_HELP_NAME,
diff --git a/include/linux/netfilter/nfnetlink_cttimeout.h b/include/linux/netfilter/nfnetlink_cttimeout.h
new file mode 100644
index 000000000000..a2810a7c5e30
--- /dev/null
+++ b/include/linux/netfilter/nfnetlink_cttimeout.h
@@ -0,0 +1,114 @@
+#ifndef _CTTIMEOUT_NETLINK_H
+#define _CTTIMEOUT_NETLINK_H
+#include <linux/netfilter/nfnetlink.h>
+
+enum ctnl_timeout_msg_types {
+        IPCTNL_MSG_TIMEOUT_NEW,
+        IPCTNL_MSG_TIMEOUT_GET,
+        IPCTNL_MSG_TIMEOUT_DELETE,
+
+        IPCTNL_MSG_TIMEOUT_MAX
+};
+
+enum ctattr_timeout {
+        CTA_TIMEOUT_UNSPEC,
+        CTA_TIMEOUT_NAME,
+        CTA_TIMEOUT_L3PROTO,
+        CTA_TIMEOUT_L4PROTO,
+        CTA_TIMEOUT_DATA,
+        CTA_TIMEOUT_USE,
+        __CTA_TIMEOUT_MAX
+};
+#define CTA_TIMEOUT_MAX (__CTA_TIMEOUT_MAX - 1)
+
+enum ctattr_timeout_generic {
+        CTA_TIMEOUT_GENERIC_UNSPEC,
+        CTA_TIMEOUT_GENERIC_TIMEOUT,
+        __CTA_TIMEOUT_GENERIC_MAX
+};
+#define CTA_TIMEOUT_GENERIC_MAX (__CTA_TIMEOUT_GENERIC_MAX - 1)
+
+enum ctattr_timeout_tcp {
+        CTA_TIMEOUT_TCP_UNSPEC,
+        CTA_TIMEOUT_TCP_SYN_SENT,
+        CTA_TIMEOUT_TCP_SYN_RECV,
+        CTA_TIMEOUT_TCP_ESTABLISHED,
+        CTA_TIMEOUT_TCP_FIN_WAIT,
+        CTA_TIMEOUT_TCP_CLOSE_WAIT,
+        CTA_TIMEOUT_TCP_LAST_ACK,
+        CTA_TIMEOUT_TCP_TIME_WAIT,
+        CTA_TIMEOUT_TCP_CLOSE,
+        CTA_TIMEOUT_TCP_SYN_SENT2,
+        CTA_TIMEOUT_TCP_RETRANS,
+        CTA_TIMEOUT_TCP_UNACK,
+        __CTA_TIMEOUT_TCP_MAX
+};
+#define CTA_TIMEOUT_TCP_MAX (__CTA_TIMEOUT_TCP_MAX - 1)
+
+enum ctattr_timeout_udp {
+        CTA_TIMEOUT_UDP_UNSPEC,
+        CTA_TIMEOUT_UDP_UNREPLIED,
+        CTA_TIMEOUT_UDP_REPLIED,
+        __CTA_TIMEOUT_UDP_MAX
+};
+#define CTA_TIMEOUT_UDP_MAX (__CTA_TIMEOUT_UDP_MAX - 1)
+
+enum ctattr_timeout_udplite {
+        CTA_TIMEOUT_UDPLITE_UNSPEC,
+        CTA_TIMEOUT_UDPLITE_UNREPLIED,
+        CTA_TIMEOUT_UDPLITE_REPLIED,
+        __CTA_TIMEOUT_UDPLITE_MAX
+};
+#define CTA_TIMEOUT_UDPLITE_MAX (__CTA_TIMEOUT_UDPLITE_MAX - 1)
+
+enum ctattr_timeout_icmp {
+        CTA_TIMEOUT_ICMP_UNSPEC,
+        CTA_TIMEOUT_ICMP_TIMEOUT,
+        __CTA_TIMEOUT_ICMP_MAX
+};
+#define CTA_TIMEOUT_ICMP_MAX (__CTA_TIMEOUT_ICMP_MAX - 1)
+
+enum ctattr_timeout_dccp {
+        CTA_TIMEOUT_DCCP_UNSPEC,
+        CTA_TIMEOUT_DCCP_REQUEST,
+        CTA_TIMEOUT_DCCP_RESPOND,
+        CTA_TIMEOUT_DCCP_PARTOPEN,
+        CTA_TIMEOUT_DCCP_OPEN,
+        CTA_TIMEOUT_DCCP_CLOSEREQ,
+        CTA_TIMEOUT_DCCP_CLOSING,
+        CTA_TIMEOUT_DCCP_TIMEWAIT,
+        __CTA_TIMEOUT_DCCP_MAX
+};
+#define CTA_TIMEOUT_DCCP_MAX (__CTA_TIMEOUT_DCCP_MAX - 1)
+
+enum ctattr_timeout_sctp {
+        CTA_TIMEOUT_SCTP_UNSPEC,
+        CTA_TIMEOUT_SCTP_CLOSED,
+        CTA_TIMEOUT_SCTP_COOKIE_WAIT,
+        CTA_TIMEOUT_SCTP_COOKIE_ECHOED,
+        CTA_TIMEOUT_SCTP_ESTABLISHED,
+        CTA_TIMEOUT_SCTP_SHUTDOWN_SENT,
+        CTA_TIMEOUT_SCTP_SHUTDOWN_RECD,
+        CTA_TIMEOUT_SCTP_SHUTDOWN_ACK_SENT,
+        __CTA_TIMEOUT_SCTP_MAX
+};
+#define CTA_TIMEOUT_SCTP_MAX (__CTA_TIMEOUT_SCTP_MAX - 1)
+
+enum ctattr_timeout_icmpv6 {
+        CTA_TIMEOUT_ICMPV6_UNSPEC,
+        CTA_TIMEOUT_ICMPV6_TIMEOUT,
+        __CTA_TIMEOUT_ICMPV6_MAX
+};
+#define CTA_TIMEOUT_ICMPV6_MAX (__CTA_TIMEOUT_ICMPV6_MAX - 1)
+
+enum ctattr_timeout_gre {
+        CTA_TIMEOUT_GRE_UNSPEC,
+        CTA_TIMEOUT_GRE_UNREPLIED,
+        CTA_TIMEOUT_GRE_REPLIED,
+        __CTA_TIMEOUT_GRE_MAX
+};
+#define CTA_TIMEOUT_GRE_MAX (__CTA_TIMEOUT_GRE_MAX - 1)
+
+#define CTNL_TIMEOUT_NAME_MAX   32
+
+#endif
diff --git a/include/linux/netfilter/xt_CT.h b/include/linux/netfilter/xt_CT.h
index b56e76811c04..a064b8af360c 100644
--- a/include/linux/netfilter/xt_CT.h
+++ b/include/linux/netfilter/xt_CT.h
@@ -16,4 +16,16 @@ struct xt_ct_target_info {
         struct nf_conn  *ct __attribute__((aligned(8)));
 };
 
+struct xt_ct_target_info_v1 {
+        __u16 flags;
+        __u16 zone;
+        __u32 ct_events;
+        __u32 exp_events;
+        char helper[16];
+        char timeout[32];
+
+        /* Used internally by the kernel */
+        struct nf_conn  *ct __attribute__((aligned(8)));
+};
+
 #endif /* _XT_CT_H */
diff --git a/include/linux/netfilter/xt_LOG.h b/include/linux/netfilter/xt_LOG.h
new file mode 100644
index 000000000000..cac079095305
--- /dev/null
+++ b/include/linux/netfilter/xt_LOG.h
@@ -0,0 +1,19 @@
+#ifndef _XT_LOG_H
+#define _XT_LOG_H
+
+/* make sure not to change this without changing nf_log.h:NF_LOG_* (!) */
+#define XT_LOG_TCPSEQ           0x01    /* Log TCP sequence numbers */
+#define XT_LOG_TCPOPT           0x02    /* Log TCP options */
+#define XT_LOG_IPOPT            0x04    /* Log IP options */
+#define XT_LOG_UID              0x08    /* Log UID owning local socket */
+#define XT_LOG_NFLOG            0x10    /* Unsupported, don't reuse */
+#define XT_LOG_MACDECODE        0x20    /* Decode MAC header */
+#define XT_LOG_MASK             0x2f
+
+struct xt_log_info {
+        unsigned char level;
+        unsigned char logflags;
+        char prefix[30];
+};
+
+#endif /* _XT_LOG_H */
diff --git a/include/linux/netfilter_ipv4/Kbuild b/include/linux/netfilter_ipv4/Kbuild
index f9930c87fff3..31f8bec95650 100644
--- a/include/linux/netfilter_ipv4/Kbuild
+++ b/include/linux/netfilter_ipv4/Kbuild
@@ -4,11 +4,9 @@ header-y += ipt_CLUSTERIP.h
 header-y += ipt_ECN.h
 header-y += ipt_LOG.h
 header-y += ipt_REJECT.h
-header-y += ipt_SAME.h
 header-y += ipt_TTL.h
 header-y += ipt_ULOG.h
 header-y += ipt_addrtype.h
 header-y += ipt_ah.h
 header-y += ipt_ecn.h
-header-y += ipt_realm.h
 header-y += ipt_ttl.h
diff --git a/include/linux/netfilter_ipv4/ipt_LOG.h b/include/linux/netfilter_ipv4/ipt_LOG.h
index dcdbadf9fd4a..5d8152077d71 100644
--- a/include/linux/netfilter_ipv4/ipt_LOG.h
+++ b/include/linux/netfilter_ipv4/ipt_LOG.h
@@ -1,6 +1,8 @@
 #ifndef _IPT_LOG_H
 #define _IPT_LOG_H
 
+#warning "Please update iptables, this file will be removed soon!"
+
 /* make sure not to change this without changing netfilter.h:NF_LOG_* (!) */
 #define IPT_LOG_TCPSEQ          0x01    /* Log TCP sequence numbers */
 #define IPT_LOG_TCPOPT          0x02    /* Log TCP options */
diff --git a/include/linux/netfilter_ipv4/ipt_SAME.h b/include/linux/netfilter_ipv4/ipt_SAME.h
deleted file mode 100644
index 5bca78267afd..000000000000
--- a/include/linux/netfilter_ipv4/ipt_SAME.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#ifndef _IPT_SAME_H
-#define _IPT_SAME_H
-
-#include <linux/types.h>
-
-#define IPT_SAME_MAX_RANGE      10
-
-#define IPT_SAME_NODST          0x01
-
-struct ipt_same_info {
-        unsigned char info;
-        __u32 rangesize;
-        __u32 ipnum;
-        __u32 *iparray;
-
-        /* hangs off end. */
-        struct nf_nat_range range[IPT_SAME_MAX_RANGE];
-};
-
-#endif /*_IPT_SAME_H*/
diff --git a/include/linux/netfilter_ipv4/ipt_realm.h b/include/linux/netfilter_ipv4/ipt_realm.h
deleted file mode 100644
index b3996eaa0188..000000000000
--- a/include/linux/netfilter_ipv4/ipt_realm.h
+++ /dev/null
@@ -1,7 +0,0 @@
-#ifndef _IPT_REALM_H
-#define _IPT_REALM_H
-
-#include <linux/netfilter/xt_realm.h>
-#define ipt_realm_info xt_realm_info
-
-#endif /* _IPT_REALM_H */
diff --git a/include/linux/netfilter_ipv6/ip6t_LOG.h b/include/linux/netfilter_ipv6/ip6t_LOG.h
index 9dd5579e02ec..3dd0bc4e0735 100644
--- a/include/linux/netfilter_ipv6/ip6t_LOG.h
+++ b/include/linux/netfilter_ipv6/ip6t_LOG.h
@@ -1,6 +1,8 @@
 #ifndef _IP6T_LOG_H
 #define _IP6T_LOG_H
 
+#warning "Please update iptables, this file will be removed soon!"
+
 /* make sure not to change this without changing netfilter.h:NF_LOG_* (!) */
 #define IP6T_LOG_TCPSEQ         0x01    /* Log TCP sequence numbers */
 #define IP6T_LOG_TCPOPT         0x02    /* Log TCP options */
diff --git a/include/linux/netlink.h b/include/linux/netlink.h
index 52e48959cfa1..a2092f582a78 100644
--- a/include/linux/netlink.h
+++ b/include/linux/netlink.h
@@ -225,6 +225,7 @@ struct netlink_callback {
         int                     (*dump)(struct sk_buff * skb,
                                         struct netlink_callback *cb);
         int                     (*done)(struct netlink_callback *cb);
+        void                    *data;
         u16                     family;
         u16                     min_dump_alloc;
         unsigned int            prev_seq, seq;
@@ -237,22 +238,8 @@ struct netlink_notify {
         int protocol;
 };
 
-static __inline__ struct nlmsghdr *
-__nlmsg_put(struct sk_buff *skb, u32 pid, u32 seq, int type, int len, int flags)
-{
-        struct nlmsghdr *nlh;
-        int size = NLMSG_LENGTH(len);
-
-        nlh = (struct nlmsghdr*)skb_put(skb, NLMSG_ALIGN(size));
-        nlh->nlmsg_type = type;
-        nlh->nlmsg_len = size;
-        nlh->nlmsg_flags = flags;
-        nlh->nlmsg_pid = pid;
-        nlh->nlmsg_seq = seq;
-        if (!__builtin_constant_p(size) || NLMSG_ALIGN(size) - size != 0)
-                memset(NLMSG_DATA(nlh) + len, 0, NLMSG_ALIGN(size) - size);
-        return nlh;
-}
+struct nlmsghdr *
+__nlmsg_put(struct sk_buff *skb, u32 pid, u32 seq, int type, int len, int flags);
 
 #define NLMSG_NEW(skb, pid, seq, type, len, flags) \
 ({      if (unlikely(skb_tailroom(skb) < (int)NLMSG_SPACE(len))) \
@@ -262,11 +249,16 @@ __nlmsg_put(struct sk_buff *skb, u32 pid, u32 seq, int type, int len, int flags)
 #define NLMSG_PUT(skb, pid, seq, type, len) \
         NLMSG_NEW(skb, pid, seq, type, len, 0)
 
+struct netlink_dump_control {
+        int (*dump)(struct sk_buff *skb, struct netlink_callback *);
+        int (*done)(struct netlink_callback*);
+        void *data;
+        u16 min_dump_alloc;
+};
+
 extern int netlink_dump_start(struct sock *ssk, struct sk_buff *skb,
                               const struct nlmsghdr *nlh,
-                              int (*dump)(struct sk_buff *skb, struct netlink_callback*),
-                              int (*done)(struct netlink_callback*),
-                              u16 min_dump_alloc);
+                              struct netlink_dump_control *control);
 
 
 #define NL_NONROOT_RECV 0x1
diff --git a/include/linux/nfc.h b/include/linux/nfc.h
index 01d4e5d60325..39c1fcf089c0 100644
--- a/include/linux/nfc.h
+++ b/include/linux/nfc.h
@@ -89,6 +89,8 @@ enum nfc_commands {
  * @NFC_ATTR_TARGET_SEL_RES: NFC-A targets extra information (useful if the
  *      target is not NFC-Forum compliant)
  * @NFC_ATTR_TARGET_NFCID1: NFC-A targets identifier, max 10 bytes
+ * @NFC_ATTR_TARGET_SENSB_RES: NFC-B targets extra information, max 12 bytes
+ * @NFC_ATTR_TARGET_SENSF_RES: NFC-F targets extra information, max 18 bytes
  * @NFC_ATTR_COMM_MODE: Passive or active mode
  * @NFC_ATTR_RF_MODE: Initiator or target
  */
@@ -101,14 +103,20 @@ enum nfc_attrs {
         NFC_ATTR_TARGET_SENS_RES,
         NFC_ATTR_TARGET_SEL_RES,
         NFC_ATTR_TARGET_NFCID1,
+        NFC_ATTR_TARGET_SENSB_RES,
+        NFC_ATTR_TARGET_SENSF_RES,
         NFC_ATTR_COMM_MODE,
         NFC_ATTR_RF_MODE,
+        NFC_ATTR_DEVICE_POWERED,
 /* private: internal use only */
         __NFC_ATTR_AFTER_LAST
 };
 #define NFC_ATTR_MAX (__NFC_ATTR_AFTER_LAST - 1)
 
 #define NFC_DEVICE_NAME_MAXSIZE 8
+#define NFC_NFCID1_MAXSIZE 10
+#define NFC_SENSB_RES_MAXSIZE 12
+#define NFC_SENSF_RES_MAXSIZE 18
 
 /* NFC protocols */
 #define NFC_PROTO_JEWEL         1
diff --git a/include/linux/nfs.h b/include/linux/nfs.h
index 8c6ee44914cb..6d1fb63f5922 100644
--- a/include/linux/nfs.h
+++ b/include/linux/nfs.h
@@ -29,7 +29,7 @@
 #define NFS_MNT_VERSION         1
 #define NFS_MNT3_VERSION        3
 
-#define NFS_PIPE_DIRNAME "/nfs"
+#define NFS_PIPE_DIRNAME "nfs"
 
 /*
  * NFS stats. The good thing with these values is that NFSv3 errors are
diff --git a/include/linux/nfs4.h b/include/linux/nfs4.h
index 32345c2805c0..834df8bf08b6 100644
--- a/include/linux/nfs4.h
+++ b/include/linux/nfs4.h
@@ -183,15 +183,12 @@ struct nfs4_acl {
 
 typedef struct { char data[NFS4_VERIFIER_SIZE]; } nfs4_verifier;
 
-struct nfs41_stateid {
+struct nfs_stateid4 {
         __be32 seqid;
         char other[NFS4_STATEID_OTHER_SIZE];
 } __attribute__ ((packed));
 
-typedef union {
-        char data[NFS4_STATEID_SIZE];
-        struct nfs41_stateid stateid;
-} nfs4_stateid;
+typedef struct nfs_stateid4 nfs4_stateid;
 
 enum nfs_opnum4 {
         OP_ACCESS = 3,
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index 8c29950d2fa5..52a1bdb4ee2b 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -38,6 +38,13 @@
 
 #ifdef __KERNEL__
 
+/*
+ * Enable dprintk() debugging support for nfs client.
+ */
+#ifdef CONFIG_NFS_DEBUG
+# define NFS_DEBUG
+#endif
+
 #include <linux/in.h>
 #include <linux/mm.h>
 #include <linux/pagemap.h>
@@ -171,13 +178,9 @@ struct nfs_inode {
          */
         __be32                  cookieverf[2];
 
-        /*
-         * This is the list of dirty unwritten pages.
-         */
-        struct radix_tree_root  nfs_page_tree;
-
         unsigned long           npages;
         unsigned long           ncommit;
+        struct list_head        commit_list;
 
         /* Open contexts for shared mmap writes */
         struct list_head        open_files;
@@ -395,6 +398,29 @@ static inline void nfs_free_fhandle(const struct nfs_fh *fh)
         kfree(fh);
 }
 
+#ifdef NFS_DEBUG
+extern u32 _nfs_display_fhandle_hash(const struct nfs_fh *fh);
+static inline u32 nfs_display_fhandle_hash(const struct nfs_fh *fh)
+{
+        return _nfs_display_fhandle_hash(fh);
+}
+extern void _nfs_display_fhandle(const struct nfs_fh *fh, const char *caption);
+#define nfs_display_fhandle(fh, caption)                        \
+        do {                                                    \
+                if (unlikely(nfs_debug & NFSDBG_FACILITY))      \
+                        _nfs_display_fhandle(fh, caption);      \
+        } while (0)
+#else
+static inline u32 nfs_display_fhandle_hash(const struct nfs_fh *fh)
+{
+        return 0;
+}
+static inline void nfs_display_fhandle(const struct nfs_fh *fh,
+                                       const char *caption)
+{
+}
+#endif
+
 /*
  * linux/fs/nfs/nfsroot.c
  */
@@ -632,19 +658,13 @@ nfs_fileid_to_ino_t(u64 fileid)
 
 #ifdef __KERNEL__
 
-/*
- * Enable debugging support for nfs client.
- * Requires RPC_DEBUG.
- */
-#ifdef RPC_DEBUG
-# define NFS_DEBUG
-#endif
-
 # undef ifdebug
 # ifdef NFS_DEBUG
 #  define ifdebug(fac)          if (unlikely(nfs_debug & NFSDBG_##fac))
+#  define NFS_IFDEBUG(x)        x
 # else
 #  define ifdebug(fac)          if (0)
+#  define NFS_IFDEBUG(x)
 # endif
 #endif /* __KERNEL */
 
diff --git a/include/linux/nfs_fs_i.h b/include/linux/nfs_fs_i.h
index 861730275ba0..a5c50d97341e 100644
--- a/include/linux/nfs_fs_i.h
+++ b/include/linux/nfs_fs_i.h
@@ -1,10 +1,6 @@
 #ifndef _NFS_FS_I
 #define _NFS_FS_I
 
-#include <asm/types.h>
-#include <linux/list.h>
-#include <linux/nfs.h>
-
 struct nlm_lockowner;
 
 /*
diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h
index ba4d7656ecfd..7073fc74481c 100644
--- a/include/linux/nfs_fs_sb.h
+++ b/include/linux/nfs_fs_sb.h
@@ -3,6 +3,7 @@
 
 #include <linux/list.h>
 #include <linux/backing-dev.h>
+#include <linux/idr.h>
 #include <linux/wait.h>
 #include <linux/nfs_xdr.h>
 #include <linux/sunrpc/xprt.h>
@@ -17,6 +18,7 @@ struct nfs4_sequence_res;
 struct nfs_server;
 struct nfs4_minor_version_ops;
 struct server_scope;
+struct nfs41_impl_id;
 
 /*
  * The nfs_client identifies our client state to the server.
@@ -85,6 +87,8 @@ struct nfs_client {
 #endif
 
         struct server_scope     *server_scope;  /* from exchange_id */
+        struct nfs41_impl_id    *impl_id;       /* from exchange_id */
+        struct net              *net;
 };
 
 /*
@@ -144,15 +148,18 @@ struct nfs_server {
         u32                     acl_bitmask;    /* V4 bitmask representing the ACEs
                                                    that are supported on this
                                                    filesystem */
+        u32                     fh_expire_type; /* V4 bitmask representing file
+                                                   handle volatility type for
+                                                   this filesystem */
         struct pnfs_layoutdriver_type  *pnfs_curr_ld; /* Active layout driver */
         struct rpc_wait_queue   roc_rpcwaitq;
         void                    *pnfs_ld_data;  /* per mount point data */
 
         /* the following fields are protected by nfs_client->cl_lock */
         struct rb_root          state_owners;
-        struct rb_root          openowner_id;
-        struct rb_root          lockowner_id;
 #endif
+        struct ida              openowner_id;
+        struct ida              lockowner_id;
         struct list_head        state_owners_lru;
         struct list_head        layouts;
         struct list_head        delegations;
@@ -188,21 +195,23 @@ struct nfs_server {
 
 
 /* maximum number of slots to use */
-#define NFS4_MAX_SLOT_TABLE RPC_MAX_SLOT_TABLE
+#define NFS4_DEF_SLOT_TABLE_SIZE (16U)
+#define NFS4_MAX_SLOT_TABLE (256U)
+#define NFS4_NO_SLOT ((u32)-1)
 
 #if defined(CONFIG_NFS_V4)
 
 /* Sessions */
-#define SLOT_TABLE_SZ (NFS4_MAX_SLOT_TABLE/(8*sizeof(long)))
+#define SLOT_TABLE_SZ DIV_ROUND_UP(NFS4_MAX_SLOT_TABLE, 8*sizeof(long))
 struct nfs4_slot_table {
         struct nfs4_slot *slots;                /* seqid per slot */
         unsigned long   used_slots[SLOT_TABLE_SZ]; /* used/unused bitmap */
         spinlock_t      slot_tbl_lock;
         struct rpc_wait_queue   slot_tbl_waitq; /* allocators may wait here */
-        int             max_slots;              /* # slots in table */
-        int             highest_used_slotid;    /* sent to server on each SEQ.
+        u32             max_slots;              /* # slots in table */
+        u32             highest_used_slotid;    /* sent to server on each SEQ.
                                                  * op for dynamic resizing */
-        int             target_max_slots;       /* Set by CB_RECALL_SLOT as
+        u32             target_max_slots;       /* Set by CB_RECALL_SLOT as
                                                  * the new max_slots */
         struct completion complete;
 };
diff --git a/include/linux/nfs_idmap.h b/include/linux/nfs_idmap.h
index 308c18877018..7eed2012d288 100644
--- a/include/linux/nfs_idmap.h
+++ b/include/linux/nfs_idmap.h
@@ -69,36 +69,22 @@ struct nfs_server;
 struct nfs_fattr;
 struct nfs4_string;
 
-#ifdef CONFIG_NFS_USE_NEW_IDMAPPER
-
+#ifdef CONFIG_NFS_V4
 int nfs_idmap_init(void);
 void nfs_idmap_quit(void);
-
-static inline int nfs_idmap_new(struct nfs_client *clp)
-{
-        return 0;
-}
-
-static inline void nfs_idmap_delete(struct nfs_client *clp)
-{
-}
-
-#else /* CONFIG_NFS_USE_NEW_IDMAPPER not set */
-
+#else
 static inline int nfs_idmap_init(void)
 {
         return 0;
 }
 
 static inline void nfs_idmap_quit(void)
-{
-}
+{}
+#endif
 
 int nfs_idmap_new(struct nfs_client *);
 void nfs_idmap_delete(struct nfs_client *);
 
-#endif /* CONFIG_NFS_USE_NEW_IDMAPPER */
-
 void nfs_fattr_init_names(struct nfs_fattr *fattr,
                 struct nfs4_string *owner_name,
                 struct nfs4_string *group_name);
diff --git a/include/linux/nfs_iostat.h b/include/linux/nfs_iostat.h
index 8866bb3502ee..9dcbbe9a51fb 100644
--- a/include/linux/nfs_iostat.h
+++ b/include/linux/nfs_iostat.h
@@ -21,7 +21,7 @@
 #ifndef _LINUX_NFS_IOSTAT
 #define _LINUX_NFS_IOSTAT
 
-#define NFS_IOSTAT_VERS         "1.0"
+#define NFS_IOSTAT_VERS         "1.1"
 
 /*
  * NFS byte counters
diff --git a/include/linux/nfs_page.h b/include/linux/nfs_page.h
index ab465fe8c3d6..eac30d6bec17 100644
--- a/include/linux/nfs_page.h
+++ b/include/linux/nfs_page.h
@@ -19,12 +19,6 @@
 #include <linux/kref.h>
 
 /*
- * Valid flags for the radix tree
- */
-#define NFS_PAGE_TAG_LOCKED     0
-#define NFS_PAGE_TAG_COMMIT     1
-
-/*
  * Valid flags for a dirty buffer
  */
 enum {
@@ -33,16 +27,13 @@ enum {
         PG_CLEAN,
         PG_NEED_COMMIT,
         PG_NEED_RESCHED,
-        PG_PNFS_COMMIT,
         PG_PARTIAL_READ_FAILED,
+        PG_COMMIT_TO_DS,
 };
 
 struct nfs_inode;
 struct nfs_page {
-        union {
-                struct list_head        wb_list;        /* Defines state of page: */
-                struct pnfs_layout_segment *wb_commit_lseg; /* Used when PG_PNFS_COMMIT set */
-        };
+        struct list_head        wb_list;        /* Defines state of page: */
         struct page             *wb_page;       /* page to read in/write out */
         struct nfs_open_context *wb_context;    /* File state context info */
         struct nfs_lock_context *wb_lock_context;       /* lock context info */
@@ -90,8 +81,6 @@ extern	struct nfs_page *nfs_create_request(struct nfs_open_context *ctx,
 extern  void nfs_release_request(struct nfs_page *req);
 
 
-extern  int nfs_scan_list(struct nfs_inode *nfsi, struct list_head *dst,
-                          pgoff_t idx_start, unsigned int npages, int tag);
 extern  void nfs_pageio_init(struct nfs_pageio_descriptor *desc,
                              struct inode *inode,
                              const struct nfs_pageio_ops *pg_ops,
@@ -106,8 +95,6 @@ extern bool nfs_generic_pg_test(struct nfs_pageio_descriptor *desc,
                                 struct nfs_page *req);
 extern  int nfs_wait_on_request(struct nfs_page *);
 extern  void nfs_unlock_request(struct nfs_page *req);
-extern  int nfs_set_page_tag_locked(struct nfs_page *req);
-extern  void nfs_clear_page_tag_locked(struct nfs_page *req);
 
 /*
  * Lock the page of an asynchronous request without getting a new reference
@@ -118,6 +105,16 @@ nfs_lock_request_dontget(struct nfs_page *req)
         return !test_and_set_bit(PG_BUSY, &req->wb_flags);
 }
 
+static inline int
+nfs_lock_request(struct nfs_page *req)
+{
+        if (test_and_set_bit(PG_BUSY, &req->wb_flags))
+                return 0;
+        kref_get(&req->wb_kref);
+        return 1;
+}
+
+
 /**
  * nfs_list_add_request - Insert a request into a list
  * @req: request
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index d6ba9a12591e..bfd0d1bf6707 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -2,7 +2,6 @@
 #define _LINUX_NFS_XDR_H
 
 #include <linux/nfsacl.h>
-#include <linux/nfs3.h>
 #include <linux/sunrpc/gss_api.h>
 
 /*
@@ -89,11 +88,12 @@ struct nfs_fattr {
 #define NFS_ATTR_FATTR_PRECTIME         (1U << 16)
 #define NFS_ATTR_FATTR_CHANGE           (1U << 17)
 #define NFS_ATTR_FATTR_PRECHANGE        (1U << 18)
-#define NFS_ATTR_FATTR_V4_REFERRAL      (1U << 19)      /* NFSv4 referral */
-#define NFS_ATTR_FATTR_MOUNTPOINT       (1U << 20)      /* Treat as mountpoint */
-#define NFS_ATTR_FATTR_MOUNTED_ON_FILEID                (1U << 21)
-#define NFS_ATTR_FATTR_OWNER_NAME       (1U << 22)
-#define NFS_ATTR_FATTR_GROUP_NAME       (1U << 23)
+#define NFS_ATTR_FATTR_V4_LOCATIONS     (1U << 19)
+#define NFS_ATTR_FATTR_V4_REFERRAL      (1U << 20)
+#define NFS_ATTR_FATTR_MOUNTPOINT       (1U << 21)
+#define NFS_ATTR_FATTR_MOUNTED_ON_FILEID (1U << 22)
+#define NFS_ATTR_FATTR_OWNER_NAME       (1U << 23)
+#define NFS_ATTR_FATTR_GROUP_NAME       (1U << 24)
 
 #define NFS_ATTR_FATTR (NFS_ATTR_FATTR_TYPE \
                 | NFS_ATTR_FATTR_MODE \
@@ -182,7 +182,7 @@ struct nfs4_slot {
 
 struct nfs4_sequence_args {
         struct nfs4_session     *sa_session;
-        u8                      sa_slotid;
+        u32                     sa_slotid;
         u8                      sa_cache_this;
 };
 
@@ -977,6 +977,7 @@ struct nfs4_server_caps_res {
         u32                             acl_bitmask;
         u32                             has_links;
         u32                             has_symlinks;
+        u32                             fh_expire_type;
         struct nfs4_sequence_res        seq_res;
 };
 
@@ -1055,14 +1056,6 @@ struct nfstime4 {
 };
 
 #ifdef CONFIG_NFS_V4_1
-struct nfs_impl_id4 {
-        u32             domain_len;
-        char            *domain;
-        u32             name_len;
-        char            *name;
-        struct nfstime4 date;
-};
-
 #define NFS4_EXCHANGE_ID_LEN    (48)
 struct nfs41_exchange_id_args {
         struct nfs_client               *client;
@@ -1083,10 +1076,17 @@ struct server_scope {
         char                            server_scope[NFS4_OPAQUE_LIMIT];
 };
 
+struct nfs41_impl_id {
+        char                            domain[NFS4_OPAQUE_LIMIT + 1];
+        char                            name[NFS4_OPAQUE_LIMIT + 1];
+        struct nfstime4                 date;
+};
+
 struct nfs41_exchange_id_res {
         struct nfs_client               *client;
         u32                             flags;
         struct server_scope             *server_scope;
+        struct nfs41_impl_id            *impl_id;
 };
 
 struct nfs41_create_session_args {
@@ -1192,6 +1192,27 @@ struct nfs_write_data {
         struct page             *page_array[NFS_PAGEVEC_SIZE];
 };
 
+struct nfs_unlinkdata {
+        struct hlist_node list;
+        struct nfs_removeargs args;
+        struct nfs_removeres res;
+        struct inode *dir;
+        struct rpc_cred *cred;
+        struct nfs_fattr dir_attr;
+};
+
+struct nfs_renamedata {
+        struct nfs_renameargs   args;
+        struct nfs_renameres    res;
+        struct rpc_cred         *cred;
+        struct inode            *old_dir;
+        struct dentry           *old_dentry;
+        struct nfs_fattr        old_fattr;
+        struct inode            *new_dir;
+        struct dentry           *new_dentry;
+        struct nfs_fattr        new_fattr;
+};
+
 struct nfs_access_entry;
 struct nfs_client;
 struct rpc_timeout;
@@ -1221,10 +1242,12 @@ struct nfs_rpc_ops {
                             struct iattr *, int, struct nfs_open_context *);
         int     (*remove)  (struct inode *, struct qstr *);
         void    (*unlink_setup)  (struct rpc_message *, struct inode *dir);
+        void    (*unlink_rpc_prepare) (struct rpc_task *, struct nfs_unlinkdata *);
         int     (*unlink_done) (struct rpc_task *, struct inode *);
         int     (*rename)  (struct inode *, struct qstr *,
                             struct inode *, struct qstr *);
         void    (*rename_setup)  (struct rpc_message *msg, struct inode *dir);
+        void    (*rename_rpc_prepare)(struct rpc_task *task, struct nfs_renamedata *);
         int     (*rename_done) (struct rpc_task *task, struct inode *old_dir, struct inode *new_dir);
         int     (*link)    (struct inode *, struct inode *, struct qstr *);
         int     (*symlink) (struct inode *, struct dentry *, struct page *,
@@ -1244,8 +1267,10 @@ struct nfs_rpc_ops {
         int     (*set_capabilities)(struct nfs_server *, struct nfs_fh *);
         int     (*decode_dirent)(struct xdr_stream *, struct nfs_entry *, int);
         void    (*read_setup)   (struct nfs_read_data *, struct rpc_message *);
+        void    (*read_rpc_prepare)(struct rpc_task *, struct nfs_read_data *);
         int     (*read_done)  (struct rpc_task *, struct nfs_read_data *);
         void    (*write_setup)  (struct nfs_write_data *, struct rpc_message *);
+        void    (*write_rpc_prepare)(struct rpc_task *, struct nfs_write_data *);
         int     (*write_done)  (struct rpc_task *, struct nfs_write_data *);
         void    (*commit_setup) (struct nfs_write_data *, struct rpc_message *);
         int     (*commit_done) (struct rpc_task *, struct nfs_write_data *);
@@ -1275,11 +1300,11 @@ struct nfs_rpc_ops {
 extern const struct nfs_rpc_ops nfs_v2_clientops;
 extern const struct nfs_rpc_ops nfs_v3_clientops;
 extern const struct nfs_rpc_ops nfs_v4_clientops;
-extern struct rpc_version       nfs_version2;
-extern struct rpc_version       nfs_version3;
-extern struct rpc_version       nfs_version4;
+extern const struct rpc_version nfs_version2;
+extern const struct rpc_version nfs_version3;
+extern const struct rpc_version nfs_version4;
 
-extern struct rpc_version       nfsacl_version3;
-extern struct rpc_program       nfsacl_program;
+extern const struct rpc_version nfsacl_version3;
+extern const struct rpc_program nfsacl_program;
 
 #endif
diff --git a/include/linux/nilfs2_fs.h b/include/linux/nilfs2_fs.h
index 7454ad7451b4..89bd4a4dcfb4 100644
--- a/include/linux/nilfs2_fs.h
+++ b/include/linux/nilfs2_fs.h
@@ -41,6 +41,7 @@
 #include <linux/types.h>
 #include <linux/ioctl.h>
 #include <linux/magic.h>
+#include <linux/bug.h>
 
 
 #define NILFS_INODE_BMAP_SIZE   7
diff --git a/include/linux/nl80211.h b/include/linux/nl80211.h
index 0f5ff3739820..e474f6e780cc 100644
--- a/include/linux/nl80211.h
+++ b/include/linux/nl80211.h
@@ -156,21 +156,23 @@
  * @NL80211_CMD_DEL_KEY: delete a key identified by %NL80211_ATTR_KEY_IDX
  *      or %NL80211_ATTR_MAC.
  *
- * @NL80211_CMD_GET_BEACON: retrieve beacon information (returned in a
- *      %NL80222_CMD_NEW_BEACON message)
- * @NL80211_CMD_SET_BEACON: set the beacon on an access point interface
- *      using the %NL80211_ATTR_BEACON_INTERVAL, %NL80211_ATTR_DTIM_PERIOD,
- *      %NL80211_ATTR_BEACON_HEAD and %NL80211_ATTR_BEACON_TAIL attributes.
- *      Following attributes are provided for drivers that generate full Beacon
- *      and Probe Response frames internally: %NL80211_ATTR_SSID,
+ * @NL80211_CMD_GET_BEACON: (not used)
+ * @NL80211_CMD_SET_BEACON: change the beacon on an access point interface
+ *      using the %NL80211_ATTR_BEACON_HEAD and %NL80211_ATTR_BEACON_TAIL
+ *      attributes. For drivers that generate the beacon and probe responses
+ *      internally, the following attributes must be provided: %NL80211_ATTR_IE,
+ *      %NL80211_ATTR_IE_PROBE_RESP and %NL80211_ATTR_IE_ASSOC_RESP.
+ * @NL80211_CMD_START_AP: Start AP operation on an AP interface, parameters
+ *      are like for %NL80211_CMD_SET_BEACON, and additionally parameters that
+ *      do not change are used, these include %NL80211_ATTR_BEACON_INTERVAL,
+ *      %NL80211_ATTR_DTIM_PERIOD, %NL80211_ATTR_SSID,
  *      %NL80211_ATTR_HIDDEN_SSID, %NL80211_ATTR_CIPHERS_PAIRWISE,
  *      %NL80211_ATTR_CIPHER_GROUP, %NL80211_ATTR_WPA_VERSIONS,
  *      %NL80211_ATTR_AKM_SUITES, %NL80211_ATTR_PRIVACY,
- *      %NL80211_ATTR_AUTH_TYPE, %NL80211_ATTR_IE, %NL80211_ATTR_IE_PROBE_RESP,
- *      %NL80211_ATTR_IE_ASSOC_RESP.
- * @NL80211_CMD_NEW_BEACON: add a new beacon to an access point interface,
- *      parameters are like for %NL80211_CMD_SET_BEACON.
- * @NL80211_CMD_DEL_BEACON: remove the beacon, stop sending it
+ *      %NL80211_ATTR_AUTH_TYPE and %NL80211_ATTR_INACTIVITY_TIMEOUT.
+ * @NL80211_CMD_NEW_BEACON: old alias for %NL80211_CMD_START_AP
+ * @NL80211_CMD_STOP_AP: Stop AP operation on the given interface
+ * @NL80211_CMD_DEL_BEACON: old alias for %NL80211_CMD_STOP_AP
  *
  * @NL80211_CMD_GET_STATION: Get station attributes for station identified by
  *      %NL80211_ATTR_MAC on the interface identified by %NL80211_ATTR_IFINDEX.
@@ -367,6 +369,11 @@
  *      %NL80211_ATTR_WIPHY_FREQ, %NL80211_ATTR_CONTROL_PORT,
  *      %NL80211_ATTR_CONTROL_PORT_ETHERTYPE and
  *      %NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT.
+ *      Background scan period can optionally be
+ *      specified in %NL80211_ATTR_BG_SCAN_PERIOD,
+ *      if not specified default background scan configuration
+ *      in driver is used and if period value is 0, bg scan will be disabled.
+ *      This attribute is ignored if driver does not support roam scan.
  *      It is also sent as an event, with the BSSID and response IEs when the
  *      connection is established or failed to be established. This can be
  *      determined by the STATUS_CODE attribute.
@@ -565,8 +572,10 @@ enum nl80211_commands {
 
         NL80211_CMD_GET_BEACON,
         NL80211_CMD_SET_BEACON,
-        NL80211_CMD_NEW_BEACON,
-        NL80211_CMD_DEL_BEACON,
+        NL80211_CMD_START_AP,
+        NL80211_CMD_NEW_BEACON = NL80211_CMD_START_AP,
+        NL80211_CMD_STOP_AP,
+        NL80211_CMD_DEL_BEACON = NL80211_CMD_STOP_AP,
 
         NL80211_CMD_GET_STATION,
         NL80211_CMD_SET_STATION,
@@ -1193,6 +1202,19 @@ enum nl80211_commands {
  * @NL80211_ATTR_NOACK_MAP: This u16 bitmap contains the No Ack Policy of
  *      up to 16 TIDs.
  *
+ * @NL80211_ATTR_INACTIVITY_TIMEOUT: timeout value in seconds, this can be
+ *      used by the drivers which has MLME in firmware and does not have support
+ *      to report per station tx/rx activity to free up the staion entry from
+ *      the list. This needs to be used when the driver advertises the
+ *      capability to timeout the stations.
+ *
+ * @NL80211_ATTR_RX_SIGNAL_DBM: signal strength in dBm (as a 32-bit int);
+ *      this attribute is (depending on the driver capabilities) added to
+ *      received frames indicated with %NL80211_CMD_FRAME.
+ *
+ * @NL80211_ATTR_BG_SCAN_PERIOD: Background scan period in seconds
+ *      or 0 to disable background scan.
+ *
  * @NL80211_ATTR_MAX: highest attribute number currently defined
  * @__NL80211_ATTR_AFTER_LAST: internal use
  */
@@ -1438,6 +1460,12 @@ enum nl80211_attrs {
 
         NL80211_ATTR_NOACK_MAP,
 
+        NL80211_ATTR_INACTIVITY_TIMEOUT,
+
+        NL80211_ATTR_RX_SIGNAL_DBM,
+
+        NL80211_ATTR_BG_SCAN_PERIOD,
+
         /* add attributes here, update the policy in nl80211.c */
 
         __NL80211_ATTR_AFTER_LAST,
@@ -1475,6 +1503,7 @@ enum nl80211_attrs {
 #define NL80211_ATTR_FEATURE_FLAGS NL80211_ATTR_FEATURE_FLAGS
 
 #define NL80211_MAX_SUPP_RATES                  32
+#define NL80211_MAX_SUPP_HT_RATES               77
 #define NL80211_MAX_SUPP_REG_RULES              32
 #define NL80211_TKIP_DATA_OFFSET_ENCR_KEY       0
 #define NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY     16
@@ -2104,6 +2133,13 @@ enum nl80211_mntr_flags {
  * TUs) during which a mesh STA can send only one Action frame containing a
  * PERR element.
  *
+ * @NL80211_MESHCONF_FORWARDING: set Mesh STA as forwarding or non-forwarding
+ * or forwarding entity (default is TRUE - forwarding entity)
+ *
+ * @NL80211_MESHCONF_RSSI_THRESHOLD: RSSI threshold in dBm. This specifies the
+ * threshold for average signal strength of candidate station to establish
+ * a peer link.
+ *
  * @NL80211_MESHCONF_ATTR_MAX: highest possible mesh configuration attribute
  *
  * @__NL80211_MESHCONF_ATTR_AFTER_LAST: internal use
@@ -2128,6 +2164,8 @@ enum nl80211_meshconf_params {
         NL80211_MESHCONF_HWMP_RANN_INTERVAL,
         NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
         NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
+        NL80211_MESHCONF_FORWARDING,
+        NL80211_MESHCONF_RSSI_THRESHOLD,
 
         /* keep last */
         __NL80211_MESHCONF_ATTR_AFTER_LAST,
@@ -2401,12 +2439,15 @@ enum nl80211_key_attributes {
  *      in an array of rates as defined in IEEE 802.11 7.3.2.2 (u8 values with
  *      1 = 500 kbps) but without the IE length restriction (at most
  *      %NL80211_MAX_SUPP_RATES in a single array).
+ * @NL80211_TXRATE_MCS: HT (MCS) rates allowed for TX rate selection
+ *      in an array of MCS numbers.
  * @__NL80211_TXRATE_AFTER_LAST: internal
  * @NL80211_TXRATE_MAX: highest TX rate attribute
  */
 enum nl80211_tx_rate_attributes {
         __NL80211_TXRATE_INVALID,
         NL80211_TXRATE_LEGACY,
+        NL80211_TXRATE_MCS,
 
         /* keep last */
         __NL80211_TXRATE_AFTER_LAST,
@@ -2792,10 +2833,13 @@ enum nl80211_ap_sme_features {
  *      TX status to the socket error queue when requested with the
  *      socket option.
  * @NL80211_FEATURE_HT_IBSS: This driver supports IBSS with HT datarates.
+ * @NL80211_FEATURE_INACTIVITY_TIMER: This driver takes care of freeing up
+ *      the connected inactive stations in AP mode.
  */
 enum nl80211_feature_flags {
         NL80211_FEATURE_SK_TX_STATUS    = 1 << 0,
         NL80211_FEATURE_HT_IBSS         = 1 << 1,
+        NL80211_FEATURE_INACTIVITY_TIMER = 1 << 2,
 };
 
 /**
diff --git a/include/linux/nmi.h b/include/linux/nmi.h
index 2d304efc89df..db50840e6355 100644
--- a/include/linux/nmi.h
+++ b/include/linux/nmi.h
@@ -14,7 +14,7 @@
  * may be used to reset the timeout - for code which intentionally
  * disables interrupts for a long time. This call is stateless.
  */
-#if defined(ARCH_HAS_NMI_WATCHDOG) || defined(CONFIG_HARDLOCKUP_DETECTOR)
+#if defined(CONFIG_HAVE_NMI_WATCHDOG) || defined(CONFIG_HARDLOCKUP_DETECTOR)
 #include <asm/nmi.h>
 extern void touch_nmi_watchdog(void);
 #else
diff --git a/include/linux/of.h b/include/linux/of.h
index 92cf6ad35e0e..ba5d8494f2e1 100644
--- a/include/linux/of.h
+++ b/include/linux/of.h
@@ -58,6 +58,9 @@ struct device_node {
         struct  kref kref;
         unsigned long _flags;
         void    *data;
+#if defined(CONFIG_EEH)
+        struct eeh_dev *edev;
+#endif
 #if defined(CONFIG_SPARC)
         char    *path_component_name;
         unsigned int unique_id;
@@ -72,19 +75,24 @@ struct of_phandle_args {
         uint32_t args[MAX_PHANDLE_ARGS];
 };
 
-#if defined(CONFIG_SPARC) || !defined(CONFIG_OF)
+#if defined(CONFIG_EEH)
+static inline struct eeh_dev *of_node_to_eeh_dev(struct device_node *dn)
+{
+        return dn->edev;
+}
+#endif
+
+#ifdef CONFIG_OF_DYNAMIC
+extern struct device_node *of_node_get(struct device_node *node);
+extern void of_node_put(struct device_node *node);
+#else /* CONFIG_OF_DYNAMIC */
 /* Dummy ref counting routines - to be implemented later */
 static inline struct device_node *of_node_get(struct device_node *node)
 {
         return node;
 }
-static inline void of_node_put(struct device_node *node)
-{
-}
-#else
-extern struct device_node *of_node_get(struct device_node *node);
-extern void of_node_put(struct device_node *node);
-#endif
+static inline void of_node_put(struct device_node *node) { }
+#endif /* !CONFIG_OF_DYNAMIC */
 
 #ifdef CONFIG_OF
 
@@ -217,6 +225,9 @@ extern int of_property_read_string(struct device_node *np,
 extern int of_property_read_string_index(struct device_node *np,
                                          const char *propname,
                                          int index, const char **output);
+extern int of_property_match_string(struct device_node *np,
+                                    const char *propname,
+                                    const char *string);
 extern int of_property_count_strings(struct device_node *np,
                                      const char *propname);
 extern int of_device_is_compatible(const struct device_node *device,
@@ -350,6 +361,22 @@ static inline int of_machine_is_compatible(const char *compat)
 #define of_match_node(_matches, _node)  NULL
 #endif /* CONFIG_OF */
 
+/**
+ * of_property_read_bool - Findfrom a property
+ * @np:         device node from which the property value is to be read.
+ * @propname:   name of the property to be searched.
+ *
+ * Search for a property in a device node.
+ * Returns true if the property exist false otherwise.
+ */
+static inline bool of_property_read_bool(const struct device_node *np,
+                                         const char *propname)
+{
+        struct property *prop = of_find_property(np, propname, NULL);
+
+        return prop ? true : false;
+}
+
 static inline int of_property_read_u32(const struct device_node *np,
                                        const char *propname,
                                        u32 *out_value)
diff --git a/include/linux/of_address.h b/include/linux/of_address.h
index 3118623c2c1f..01b925ad8d78 100644
--- a/include/linux/of_address.h
+++ b/include/linux/of_address.h
@@ -4,6 +4,7 @@
 #include <linux/errno.h>
 #include <linux/of.h>
 
+#ifdef CONFIG_OF_ADDRESS
 extern u64 of_translate_address(struct device_node *np, const __be32 *addr);
 extern int of_address_to_resource(struct device_node *dev, int index,
                                   struct resource *r);
@@ -25,12 +26,37 @@ static inline unsigned long pci_address_to_pio(phys_addr_t addr) { return -1; }
 #define pci_address_to_pio pci_address_to_pio
 #endif
 
-#ifdef CONFIG_PCI
+#else /* CONFIG_OF_ADDRESS */
+static inline int of_address_to_resource(struct device_node *dev, int index,
+                                         struct resource *r)
+{
+        return -EINVAL;
+}
+static inline struct device_node *of_find_matching_node_by_address(
+                                        struct device_node *from,
+                                        const struct of_device_id *matches,
+                                        u64 base_address)
+{
+        return NULL;
+}
+static inline void __iomem *of_iomap(struct device_node *device, int index)
+{
+        return NULL;
+}
+static inline const u32 *of_get_address(struct device_node *dev, int index,
+                                        u64 *size, unsigned int *flags)
+{
+        return NULL;
+}
+#endif /* CONFIG_OF_ADDRESS */
+
+
+#if defined(CONFIG_OF_ADDRESS) && defined(CONFIG_PCI)
 extern const __be32 *of_get_pci_address(struct device_node *dev, int bar_no,
                                u64 *size, unsigned int *flags);
 extern int of_pci_address_to_resource(struct device_node *dev, int bar,
                                       struct resource *r);
-#else /* CONFIG_PCI */
+#else /* CONFIG_OF_ADDRESS && CONFIG_PCI */
 static inline int of_pci_address_to_resource(struct device_node *dev, int bar,
                                              struct resource *r)
 {
@@ -42,8 +68,7 @@ static inline const __be32 *of_get_pci_address(struct device_node *dev,
 {
         return NULL;
 }
-#endif /* CONFIG_PCI */
-
+#endif /* CONFIG_OF_ADDRESS && CONFIG_PCI */
 
 #endif /* __OF_ADDRESS_H */
 
diff --git a/include/linux/of_device.h b/include/linux/of_device.h
index ae5638480ef2..901b7435e890 100644
--- a/include/linux/of_device.h
+++ b/include/linux/of_device.h
@@ -5,10 +5,11 @@
 #include <linux/of_platform.h> /* temporary until merge */
 
 #ifdef CONFIG_OF_DEVICE
-#include <linux/device.h>
 #include <linux/of.h>
 #include <linux/mod_devicetable.h>
 
+struct device;
+
 extern const struct of_device_id *of_match_device(
         const struct of_device_id *matches, const struct device *dev);
 extern void of_device_make_bus_id(struct device *dev);
@@ -34,7 +35,8 @@ extern void of_device_unregister(struct platform_device *ofdev);
 extern ssize_t of_device_get_modalias(struct device *dev,
                                         char *str, ssize_t len);
 
-extern int of_device_uevent(struct device *dev, struct kobj_uevent_env *env);
+extern void of_device_uevent(struct device *dev, struct kobj_uevent_env *env);
+extern int of_device_uevent_modalias(struct device *dev, struct kobj_uevent_env *env);
 
 static inline void of_device_node_put(struct device *dev)
 {
@@ -49,7 +51,10 @@ static inline int of_driver_match_device(struct device *dev,
         return 0;
 }
 
-static inline int of_device_uevent(struct device *dev,
+static inline void of_device_uevent(struct device *dev,
+                        struct kobj_uevent_env *env) { }
+
+static inline int of_device_uevent_modalias(struct device *dev,
                                    struct kobj_uevent_env *env)
 {
         return -ENODEV;
diff --git a/include/linux/of_gpio.h b/include/linux/of_gpio.h
index b254052a49d7..81733d12cbea 100644
--- a/include/linux/of_gpio.h
+++ b/include/linux/of_gpio.h
@@ -50,7 +50,8 @@ static inline struct of_mm_gpio_chip *to_of_mm_gpio_chip(struct gpio_chip *gc)
 extern int of_get_named_gpio_flags(struct device_node *np,
                 const char *list_name, int index, enum of_gpio_flags *flags);
 
-extern unsigned int of_gpio_count(struct device_node *np);
+extern unsigned int of_gpio_named_count(struct device_node *np,
+                                        const char* propname);
 
 extern int of_mm_gpiochip_add(struct device_node *np,
                               struct of_mm_gpio_chip *mm_gc);
@@ -71,7 +72,8 @@ static inline int of_get_named_gpio_flags(struct device_node *np,
         return -ENOSYS;
 }
 
-static inline unsigned int of_gpio_count(struct device_node *np)
+static inline unsigned int of_gpio_named_count(struct device_node *np,
+                                        const char* propname)
 {
         return 0;
 }
@@ -89,6 +91,27 @@ static inline void of_gpiochip_remove(struct gpio_chip *gc) { }
 #endif /* CONFIG_OF_GPIO */
 
 /**
+ * of_gpio_count - Count GPIOs for a device
+ * @np:         device node to count GPIOs for
+ *
+ * The function returns the count of GPIOs specified for a node.
+ *
+ * Note that the empty GPIO specifiers counts too. For example,
+ *
+ * gpios = <0
+ *          &pio1 1 2
+ *          0
+ *          &pio2 3 4>;
+ *
+ * defines four GPIOs (so this function will return 4), two of which
+ * are not specified.
+ */
+static inline unsigned int of_gpio_count(struct device_node *np)
+{
+        return of_gpio_named_count(np, "gpios");
+}
+
+/**
  * of_get_gpio_flags() - Get a GPIO number and flags to use with GPIO API
  * @np:         device node to get GPIO from
  * @index:      index of the GPIO
diff --git a/include/linux/of_irq.h b/include/linux/of_irq.h
index d0307eed20c9..d229ad3edee0 100644
--- a/include/linux/of_irq.h
+++ b/include/linux/of_irq.h
@@ -6,6 +6,7 @@ struct of_irq;
 #include <linux/types.h>
 #include <linux/errno.h>
 #include <linux/irq.h>
+#include <linux/irqdomain.h>
 #include <linux/ioport.h>
 #include <linux/of.h>
 
@@ -65,9 +66,6 @@ extern int of_irq_map_one(struct device_node *device, int index,
 extern unsigned int irq_create_of_mapping(struct device_node *controller,
                                           const u32 *intspec,
                                           unsigned int intsize);
-#ifdef CONFIG_IRQ_DOMAIN
-extern void irq_dispose_mapping(unsigned int irq);
-#endif
 extern int of_irq_to_resource(struct device_node *dev, int index,
                               struct resource *r);
 extern int of_irq_count(struct device_node *dev);
diff --git a/include/linux/of_mtd.h b/include/linux/of_mtd.h
new file mode 100644
index 000000000000..bae1b6094c63
--- /dev/null
+++ b/include/linux/of_mtd.h
@@ -0,0 +1,19 @@
+/*
+ * Copyright 2012 Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+ *
+ * OF helpers for mtd.
+ *
+ * This file is released under the GPLv2
+ */
+
+#ifndef __LINUX_OF_MTD_H
+#define __LINUX_OF_NET_H
+
+#ifdef CONFIG_OF_MTD
+#include <linux/of.h>
+extern const int of_get_nand_ecc_mode(struct device_node *np);
+int of_get_nand_bus_width(struct device_node *np);
+bool of_get_nand_on_flash_bbt(struct device_node *np);
+#endif
+
+#endif /* __LINUX_OF_MTD_H */
diff --git a/include/linux/of_platform.h b/include/linux/of_platform.h
index 040ce2f6e8de..b47d2040c9f2 100644
--- a/include/linux/of_platform.h
+++ b/include/linux/of_platform.h
@@ -81,7 +81,7 @@ extern struct platform_device *of_device_alloc(struct device_node *np,
                                          struct device *parent);
 extern struct platform_device *of_find_device_by_node(struct device_node *np);
 
-#if !defined(CONFIG_SPARC) /* SPARC has its own device registration method */
+#ifdef CONFIG_OF_ADDRESS /* device reg helpers depend on OF_ADDRESS */
 /* Platform devices and busses creation */
 extern struct platform_device *of_platform_device_create(struct device_node *np,
                                                    const char *bus_id,
@@ -94,8 +94,19 @@ extern int of_platform_populate(struct device_node *root,
                                 const struct of_device_id *matches,
                                 const struct of_dev_auxdata *lookup,
                                 struct device *parent);
-#endif /* !CONFIG_SPARC */
+#endif /* CONFIG_OF_ADDRESS */
 
 #endif /* CONFIG_OF_DEVICE */
 
+#if !defined(CONFIG_OF_ADDRESS)
+struct of_dev_auxdata;
+static inline int of_platform_populate(struct device_node *root,
+                                        const struct of_device_id *matches,
+                                        const struct of_dev_auxdata *lookup,
+                                        struct device *parent)
+{
+        return -ENODEV;
+}
+#endif /* !CONFIG_OF_ADDRESS */
+
 #endif  /* _LINUX_OF_PLATFORM_H */
diff --git a/include/linux/omapfb.h b/include/linux/omapfb.h
index c0b018790f07..4ff57e81051d 100644
--- a/include/linux/omapfb.h
+++ b/include/linux/omapfb.h
@@ -222,41 +222,11 @@ struct omapfb_display_info {
 
 #include <plat/board.h>
 
-#ifdef CONFIG_ARCH_OMAP1
-#define OMAPFB_PLANE_NUM                1
-#else
-#define OMAPFB_PLANE_NUM                3
-#endif
-
-struct omapfb_mem_region {
-        u32             paddr;
-        void __iomem    *vaddr;
-        unsigned long   size;
-        u8              type;           /* OMAPFB_PLANE_MEM_* */
-        enum omapfb_color_format format;/* OMAPFB_COLOR_* */
-        unsigned        format_used:1;  /* Must be set when format is set.
-                                         * Needed b/c of the badly chosen 0
-                                         * base for OMAPFB_COLOR_* values
-                                         */
-        unsigned        alloc:1;        /* allocated by the driver */
-        unsigned        map:1;          /* kernel mapped by the driver */
-};
-
-struct omapfb_mem_desc {
-        int                             region_cnt;
-        struct omapfb_mem_region        region[OMAPFB_PLANE_NUM];
-};
-
 struct omapfb_platform_data {
         struct omap_lcd_config          lcd;
-        struct omapfb_mem_desc          mem_desc;
-        void                            *ctrl_platform_data;
 };
 
-/* in arch/arm/plat-omap/fb.c */
-extern void omapfb_set_platform_data(struct omapfb_platform_data *data);
-extern void omapfb_set_ctrl_platform_data(void *pdata);
-extern void omapfb_reserve_sdram_memblock(void);
+void __init omapfb_set_lcd_config(const struct omap_lcd_config *config);
 
 #endif
 
diff --git a/include/linux/oom.h b/include/linux/oom.h
index 552fba9c7d5a..3d7647536b03 100644
--- a/include/linux/oom.h
+++ b/include/linux/oom.h
@@ -49,7 +49,7 @@ extern int try_set_zonelist_oom(struct zonelist *zonelist, gfp_t gfp_flags);
 extern void clear_zonelist_oom(struct zonelist *zonelist, gfp_t gfp_flags);
 
 extern void out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask,
-                int order, nodemask_t *mask);
+                int order, nodemask_t *mask, bool force_kill);
 extern int register_oom_notifier(struct notifier_block *nb);
 extern int unregister_oom_notifier(struct notifier_block *nb);
 
diff --git a/include/linux/opp.h b/include/linux/opp.h
index ee94b33080c2..2a4e5faee904 100644
--- a/include/linux/opp.h
+++ b/include/linux/opp.h
@@ -19,6 +19,7 @@
 #include <linux/notifier.h>
 
 struct opp;
+struct device;
 
 enum opp_event {
         OPP_EVENT_ADD, OPP_EVENT_ENABLE, OPP_EVENT_DISABLE,
diff --git a/include/linux/padata.h b/include/linux/padata.h
index 4633b2f726b6..86292beebfe2 100644
--- a/include/linux/padata.h
+++ b/include/linux/padata.h
@@ -46,7 +46,6 @@ struct padata_priv {
         struct list_head        list;
         struct parallel_data    *pd;
         int                     cb_cpu;
-        int                     seq_nr;
         int                     info;
         void                    (*parallel)(struct padata_priv *padata);
         void                    (*serial)(struct padata_priv *padata);
@@ -116,7 +115,6 @@ struct padata_cpumask {
  * @pinst: padata instance.
  * @pqueue: percpu padata queues used for parallelization.
  * @squeue: percpu padata queues used for serialuzation.
- * @seq_nr: The sequence number that will be attached to the next object.
  * @reorder_objects: Number of objects waiting in the reorder queues.
  * @refcnt: Number of objects holding a reference on this parallel_data.
  * @max_seq_nr:  Maximal used sequence number.
@@ -129,12 +127,12 @@ struct parallel_data {
         struct padata_instance          *pinst;
         struct padata_parallel_queue    __percpu *pqueue;
         struct padata_serial_queue      __percpu *squeue;
-        atomic_t                        seq_nr;
         atomic_t                        reorder_objects;
         atomic_t                        refcnt;
-        unsigned int                    max_seq_nr;
         struct padata_cpumask           cpumask;
         spinlock_t                      lock ____cacheline_aligned;
+        spinlock_t                      seq_lock;
+        unsigned int                    seq_nr;
         unsigned int                    processed;
         struct timer_list               timer;
 };
diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h
index e90a673be67e..c88d2a9451af 100644
--- a/include/linux/page-flags.h
+++ b/include/linux/page-flags.h
@@ -6,6 +6,7 @@
 #define PAGE_FLAGS_H
 
 #include <linux/types.h>
+#include <linux/bug.h>
 #ifndef __GENERATING_BOUNDS_H
 #include <linux/mm_types.h>
 #include <generated/bounds.h>
@@ -414,11 +415,26 @@ static inline int PageTransHuge(struct page *page)
         return PageHead(page);
 }
 
+/*
+ * PageTransCompound returns true for both transparent huge pages
+ * and hugetlbfs pages, so it should only be called when it's known
+ * that hugetlbfs pages aren't involved.
+ */
 static inline int PageTransCompound(struct page *page)
 {
         return PageCompound(page);
 }
 
+/*
+ * PageTransTail returns true for both transparent huge pages
+ * and hugetlbfs pages, so it should only be called when it's known
+ * that hugetlbfs pages aren't involved.
+ */
+static inline int PageTransTail(struct page *page)
+{
+        return PageTail(page);
+}
+
 #else
 
 static inline int PageTransHuge(struct page *page)
@@ -430,6 +446,11 @@ static inline int PageTransCompound(struct page *page)
 {
         return 0;
 }
+
+static inline int PageTransTail(struct page *page)
+{
+        return 0;
+}
 #endif
 
 #ifdef CONFIG_MMU
diff --git a/include/linux/page_cgroup.h b/include/linux/page_cgroup.h
index a2d11771c84b..a88cdba27809 100644
--- a/include/linux/page_cgroup.h
+++ b/include/linux/page_cgroup.h
@@ -4,12 +4,8 @@
 enum {
         /* flags for mem_cgroup */
         PCG_LOCK,  /* Lock for pc->mem_cgroup and following bits. */
-        PCG_CACHE, /* charged as cache */
         PCG_USED, /* this object is in use. */
         PCG_MIGRATION, /* under page migration */
-        /* flags for mem_cgroup and file and I/O status */
-        PCG_MOVE_LOCK, /* For race between move_account v.s. following bits */
-        PCG_FILE_MAPPED, /* page is accounted as "mapped" */
         __NR_PCG_FLAGS,
 };
 
@@ -64,19 +60,10 @@ static inline void ClearPageCgroup##uname(struct page_cgroup *pc)	\
 static inline int TestClearPageCgroup##uname(struct page_cgroup *pc)    \
         { return test_and_clear_bit(PCG_##lname, &pc->flags);  }
 
-/* Cache flag is set only once (at allocation) */
-TESTPCGFLAG(Cache, CACHE)
-CLEARPCGFLAG(Cache, CACHE)
-SETPCGFLAG(Cache, CACHE)
-
 TESTPCGFLAG(Used, USED)
 CLEARPCGFLAG(Used, USED)
 SETPCGFLAG(Used, USED)
 
-SETPCGFLAG(FileMapped, FILE_MAPPED)
-CLEARPCGFLAG(FileMapped, FILE_MAPPED)
-TESTPCGFLAG(FileMapped, FILE_MAPPED)
-
 SETPCGFLAG(Migration, MIGRATION)
 CLEARPCGFLAG(Migration, MIGRATION)
 TESTPCGFLAG(Migration, MIGRATION)
@@ -85,7 +72,7 @@ static inline void lock_page_cgroup(struct page_cgroup *pc)
 {
         /*
          * Don't take this lock in IRQ context.
-         * This lock is for pc->mem_cgroup, USED, CACHE, MIGRATION
+         * This lock is for pc->mem_cgroup, USED, MIGRATION
          */
         bit_spin_lock(PCG_LOCK, &pc->flags);
 }
@@ -95,24 +82,6 @@ static inline void unlock_page_cgroup(struct page_cgroup *pc)
         bit_spin_unlock(PCG_LOCK, &pc->flags);
 }
 
-static inline void move_lock_page_cgroup(struct page_cgroup *pc,
-        unsigned long *flags)
-{
-        /*
-         * We know updates to pc->flags of page cache's stats are from both of
-         * usual context or IRQ context. Disable IRQ to avoid deadlock.
-         */
-        local_irq_save(*flags);
-        bit_spin_lock(PCG_MOVE_LOCK, &pc->flags);
-}
-
-static inline void move_unlock_page_cgroup(struct page_cgroup *pc,
-        unsigned long *flags)
-{
-        bit_spin_unlock(PCG_MOVE_LOCK, &pc->flags);
-        local_irq_restore(*flags);
-}
-
 #else /* CONFIG_CGROUP_MEM_RES_CTLR */
 struct page_cgroup;
 
diff --git a/include/linux/pci.h b/include/linux/pci.h
index a16b1df3deff..e444f5b49118 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -299,7 +299,6 @@ struct pci_dev {
          */
         unsigned int    irq;
         struct resource resource[DEVICE_COUNT_RESOURCE]; /* I/O and memory regions + expansion ROMs */
-        resource_size_t fw_addr[DEVICE_COUNT_RESOURCE]; /* FW-assigned addr */
 
         /* These fields are used by common fixups */
         unsigned int    transparent:1;  /* Transparent PCI bridge */
@@ -369,24 +368,17 @@ static inline int pci_channel_offline(struct pci_dev *pdev)
         return (pdev->error_state != pci_channel_io_normal);
 }
 
-static inline struct pci_cap_saved_state *pci_find_saved_cap(
-        struct pci_dev *pci_dev, char cap)
-{
-        struct pci_cap_saved_state *tmp;
-        struct hlist_node *pos;
-
-        hlist_for_each_entry(tmp, pos, &pci_dev->saved_cap_space, next) {
-                if (tmp->cap.cap_nr == cap)
-                        return tmp;
-        }
-        return NULL;
-}
+struct pci_host_bridge_window {
+        struct list_head list;
+        struct resource *res;           /* host bridge aperture (CPU address) */
+        resource_size_t offset;         /* bus address + offset = CPU address */
+};
 
-static inline void pci_add_saved_cap(struct pci_dev *pci_dev,
-        struct pci_cap_saved_state *new_cap)
-{
-        hlist_add_head(&new_cap->next, &pci_dev->saved_cap_space);
-}
+struct pci_host_bridge {
+        struct list_head list;
+        struct pci_bus *bus;            /* root bus */
+        struct list_head windows;       /* pci_host_bridge_windows */
+};
 
 /*
  * The first PCI_BRIDGE_RESOURCE_NUM PCI bus resources (those that correspond
@@ -656,6 +648,10 @@ void pci_fixup_cardbus(struct pci_bus *);
 
 /* Generic PCI functions used internally */
 
+void pcibios_resource_to_bus(struct pci_dev *dev, struct pci_bus_region *region,
+                             struct resource *res);
+void pcibios_bus_to_resource(struct pci_dev *dev, struct resource *res,
+                             struct pci_bus_region *region);
 void pcibios_scan_specific_bus(int busn);
 extern struct pci_bus *pci_find_bus(int domain, int busnr);
 void pci_bus_add_devices(const struct pci_bus *bus);
@@ -690,7 +686,8 @@ u8 pci_common_swizzle(struct pci_dev *dev, u8 *pinp);
 extern struct pci_dev *pci_dev_get(struct pci_dev *dev);
 extern void pci_dev_put(struct pci_dev *dev);
 extern void pci_remove_bus(struct pci_bus *b);
-extern void pci_remove_bus_device(struct pci_dev *dev);
+extern void __pci_remove_bus_device(struct pci_dev *dev);
+extern void pci_stop_and_remove_bus_device(struct pci_dev *dev);
 extern void pci_stop_bus_device(struct pci_dev *dev);
 void pci_setup_cardbus(struct pci_bus *bus);
 extern void pci_sort_breadthfirst(void);
@@ -746,28 +743,28 @@ int pci_bus_write_config_dword(struct pci_bus *bus, unsigned int devfn,
                                int where, u32 val);
 struct pci_ops *pci_bus_set_ops(struct pci_bus *bus, struct pci_ops *ops);
 
-static inline int pci_read_config_byte(struct pci_dev *dev, int where, u8 *val)
+static inline int pci_read_config_byte(const struct pci_dev *dev, int where, u8 *val)
 {
         return pci_bus_read_config_byte(dev->bus, dev->devfn, where, val);
 }
-static inline int pci_read_config_word(struct pci_dev *dev, int where, u16 *val)
+static inline int pci_read_config_word(const struct pci_dev *dev, int where, u16 *val)
 {
         return pci_bus_read_config_word(dev->bus, dev->devfn, where, val);
 }
-static inline int pci_read_config_dword(struct pci_dev *dev, int where,
+static inline int pci_read_config_dword(const struct pci_dev *dev, int where,
                                         u32 *val)
 {
         return pci_bus_read_config_dword(dev->bus, dev->devfn, where, val);
 }
-static inline int pci_write_config_byte(struct pci_dev *dev, int where, u8 val)
+static inline int pci_write_config_byte(const struct pci_dev *dev, int where, u8 val)
 {
         return pci_bus_write_config_byte(dev->bus, dev->devfn, where, val);
 }
-static inline int pci_write_config_word(struct pci_dev *dev, int where, u16 val)
+static inline int pci_write_config_word(const struct pci_dev *dev, int where, u16 val)
 {
         return pci_bus_write_config_word(dev->bus, dev->devfn, where, val);
 }
-static inline int pci_write_config_dword(struct pci_dev *dev, int where,
+static inline int pci_write_config_dword(const struct pci_dev *dev, int where,
                                          u32 val)
 {
         return pci_bus_write_config_dword(dev->bus, dev->devfn, where, val);
@@ -817,6 +814,7 @@ int pcie_set_readrq(struct pci_dev *dev, int rq);
 int pcie_get_mps(struct pci_dev *dev);
 int pcie_set_mps(struct pci_dev *dev, int mps);
 int __pci_reset_function(struct pci_dev *dev);
+int __pci_reset_function_locked(struct pci_dev *dev);
 int pci_reset_function(struct pci_dev *dev);
 void pci_update_resource(struct pci_dev *dev, int resno);
 int __must_check pci_assign_resource(struct pci_dev *dev, int i);
@@ -882,6 +880,7 @@ void set_pcie_hotplug_bridge(struct pci_dev *pdev);
 /* Functions for PCI Hotplug drivers to use */
 int pci_bus_find_capability(struct pci_bus *bus, unsigned int devfn, int cap);
 #ifdef CONFIG_HOTPLUG
+unsigned int pci_rescan_bus_bridge_resize(struct pci_dev *bridge);
 unsigned int pci_rescan_bus(struct pci_bus *bus);
 #endif
 
@@ -891,13 +890,13 @@ ssize_t pci_write_vpd(struct pci_dev *dev, loff_t pos, size_t count, const void
 int pci_vpd_truncate(struct pci_dev *dev, size_t size);
 
 /* Helper functions for low-level code (drivers/pci/setup-[bus,res].c) */
+resource_size_t pcibios_retrieve_fw_addr(struct pci_dev *dev, int idx);
 void pci_bus_assign_resources(const struct pci_bus *bus);
 void pci_bus_size_bridges(struct pci_bus *bus);
 int pci_claim_resource(struct pci_dev *, int);
 void pci_assign_unassigned_resources(void);
 void pci_assign_unassigned_bridge_resources(struct pci_dev *bridge);
 void pdev_enable_device(struct pci_dev *);
-void pdev_sort_resources(struct pci_dev *, struct resource_list *);
 int pci_enable_resources(struct pci_dev *, int mask);
 void pci_fixup_irqs(u8 (*)(struct pci_dev *, u8 *),
                     int (*)(const struct pci_dev *, u8, u8));
@@ -914,6 +913,8 @@ void pci_release_selected_regions(struct pci_dev *, int);
 
 /* drivers/pci/bus.c */
 void pci_add_resource(struct list_head *resources, struct resource *res);
+void pci_add_resource_offset(struct list_head *resources, struct resource *res,
+                             resource_size_t offset);
 void pci_free_resource_list(struct list_head *resources);
 void pci_bus_add_resource(struct pci_bus *bus, struct resource *res, unsigned int flags);
 struct resource *pci_bus_resource_n(const struct pci_bus *bus, int n);
@@ -946,7 +947,20 @@ int __must_check __pci_register_driver(struct pci_driver *, struct module *,
         __pci_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)
 
 void pci_unregister_driver(struct pci_driver *dev);
-void pci_remove_behind_bridge(struct pci_dev *dev);
+
+/**
+ * module_pci_driver() - Helper macro for registering a PCI driver
+ * @__pci_driver: pci_driver struct
+ *
+ * Helper macro for PCI drivers which do not do anything special in module
+ * init/exit. This eliminates a lot of boilerplate. Each module may only
+ * use this macro once, and calling it replaces module_init() and module_exit()
+ */
+#define module_pci_driver(__pci_driver) \
+        module_driver(__pci_driver, pci_register_driver, \
+                       pci_unregister_driver)
+
+void pci_stop_and_remove_behind_bridge(struct pci_dev *dev);
 struct pci_driver *pci_dev_driver(const struct pci_dev *dev);
 int pci_add_dynid(struct pci_driver *drv,
                   unsigned int vendor, unsigned int device,
@@ -1382,7 +1396,10 @@ static inline void pci_resource_to_user(const struct pci_dev *dev, int bar,
  */
 
 struct pci_fixup {
-        u16 vendor, device;     /* You can use PCI_ANY_ID here of course */
+        u16 vendor;             /* You can use PCI_ANY_ID here of course */
+        u16 device;             /* You can use PCI_ANY_ID here of course */
+        u32 class;              /* You can use PCI_ANY_ID here too */
+        unsigned int class_shift;       /* should be 0, 8, 16 */
         void (*hook)(struct pci_dev *dev);
 };
 
@@ -1397,30 +1414,68 @@ enum pci_fixup_pass {
 };
 
 /* Anonymous variables would be nice... */
-#define DECLARE_PCI_FIXUP_SECTION(section, name, vendor, device, hook)  \
-        static const struct pci_fixup __pci_fixup_##name __used         \
-        __attribute__((__section__(#section))) = { vendor, device, hook };
+#define DECLARE_PCI_FIXUP_SECTION(section, name, vendor, device, class, \
+                                  class_shift, hook)                    \
+        static const struct pci_fixup const __pci_fixup_##name __used   \
+        __attribute__((__section__(#section), aligned((sizeof(void *)))))    \
+                = { vendor, device, class, class_shift, hook };
+
+#define DECLARE_PCI_FIXUP_CLASS_EARLY(vendor, device, class,            \
+                                         class_shift, hook)             \
+        DECLARE_PCI_FIXUP_SECTION(.pci_fixup_early,                     \
+                vendor##device##hook, vendor, device, class, class_shift, hook)
+#define DECLARE_PCI_FIXUP_CLASS_HEADER(vendor, device, class,           \
+                                         class_shift, hook)             \
+        DECLARE_PCI_FIXUP_SECTION(.pci_fixup_header,                    \
+                vendor##device##hook, vendor, device, class, class_shift, hook)
+#define DECLARE_PCI_FIXUP_CLASS_FINAL(vendor, device, class,            \
+                                         class_shift, hook)             \
+        DECLARE_PCI_FIXUP_SECTION(.pci_fixup_final,                     \
+                vendor##device##hook, vendor, device, class, class_shift, hook)
+#define DECLARE_PCI_FIXUP_CLASS_ENABLE(vendor, device, class,           \
+                                         class_shift, hook)             \
+        DECLARE_PCI_FIXUP_SECTION(.pci_fixup_enable,                    \
+                vendor##device##hook, vendor, device, class, class_shift, hook)
+#define DECLARE_PCI_FIXUP_CLASS_RESUME(vendor, device, class,           \
+                                         class_shift, hook)             \
+        DECLARE_PCI_FIXUP_SECTION(.pci_fixup_resume,                    \
+                resume##vendor##device##hook, vendor, device, class,    \
+                class_shift, hook)
+#define DECLARE_PCI_FIXUP_CLASS_RESUME_EARLY(vendor, device, class,     \
+                                         class_shift, hook)             \
+        DECLARE_PCI_FIXUP_SECTION(.pci_fixup_resume_early,              \
+                resume_early##vendor##device##hook, vendor, device,     \
+                class, class_shift, hook)
+#define DECLARE_PCI_FIXUP_CLASS_SUSPEND(vendor, device, class,          \
+                                         class_shift, hook)             \
+        DECLARE_PCI_FIXUP_SECTION(.pci_fixup_suspend,                   \
+                suspend##vendor##device##hook, vendor, device, class,   \
+                class_shift, hook)
+
 #define DECLARE_PCI_FIXUP_EARLY(vendor, device, hook)                   \
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_early,                     \
-                        vendor##device##hook, vendor, device, hook)
+                vendor##device##hook, vendor, device, PCI_ANY_ID, 0, hook)
 #define DECLARE_PCI_FIXUP_HEADER(vendor, device, hook)                  \
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_header,                    \
-                        vendor##device##hook, vendor, device, hook)
+                vendor##device##hook, vendor, device, PCI_ANY_ID, 0, hook)
 #define DECLARE_PCI_FIXUP_FINAL(vendor, device, hook)                   \
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_final,                     \
-                        vendor##device##hook, vendor, device, hook)
+                vendor##device##hook, vendor, device, PCI_ANY_ID, 0, hook)
 #define DECLARE_PCI_FIXUP_ENABLE(vendor, device, hook)                  \
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_enable,                    \
-                        vendor##device##hook, vendor, device, hook)
+                vendor##device##hook, vendor, device, PCI_ANY_ID, 0, hook)
 #define DECLARE_PCI_FIXUP_RESUME(vendor, device, hook)                  \
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_resume,                    \
-                        resume##vendor##device##hook, vendor, device, hook)
+                resume##vendor##device##hook, vendor, device,           \
+                PCI_ANY_ID, 0, hook)
 #define DECLARE_PCI_FIXUP_RESUME_EARLY(vendor, device, hook)            \
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_resume_early,              \
-                        resume_early##vendor##device##hook, vendor, device, hook)
+                resume_early##vendor##device##hook, vendor, device,     \
+                PCI_ANY_ID, 0, hook)
 #define DECLARE_PCI_FIXUP_SUSPEND(vendor, device, hook)                 \
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_suspend,                   \
-                        suspend##vendor##device##hook, vendor, device, hook)
+                suspend##vendor##device##hook, vendor, device,          \
+                PCI_ANY_ID, 0, hook)
 
 #ifdef CONFIG_PCI_QUIRKS
 void pci_fixup_device(enum pci_fixup_pass pass, struct pci_dev *dev);
@@ -1647,6 +1702,13 @@ static inline void pci_set_bus_of_node(struct pci_bus *bus) { }
 static inline void pci_release_bus_of_node(struct pci_bus *bus) { }
 #endif  /* CONFIG_OF */
 
+#ifdef CONFIG_EEH
+static inline struct eeh_dev *pci_dev_to_eeh_dev(struct pci_dev *pdev)
+{
+        return pdev->dev.archdata.edev;
+}
+#endif
+
 /**
  * pci_find_upstream_pcie_bridge - find upstream PCIe-to-PCI bridge of a device
  * @pdev: the PCI device
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 31d77af2ef42..3329965ed63f 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -2105,6 +2105,7 @@
 #define PCI_DEVICE_ID_NX2_57711E        0x1650
 #define PCI_DEVICE_ID_TIGON3_5705       0x1653
 #define PCI_DEVICE_ID_TIGON3_5705_2     0x1654
+#define PCI_DEVICE_ID_TIGON3_5719       0x1657
 #define PCI_DEVICE_ID_TIGON3_5721       0x1659
 #define PCI_DEVICE_ID_TIGON3_5722       0x165a
 #define PCI_DEVICE_ID_TIGON3_5723       0x165b
diff --git a/include/linux/pci_regs.h b/include/linux/pci_regs.h
index e41a10f5ae83..4b608f543412 100644
--- a/include/linux/pci_regs.h
+++ b/include/linux/pci_regs.h
@@ -391,6 +391,7 @@
 #define  PCI_EXP_TYPE_UPSTREAM  0x5     /* Upstream Port */
 #define  PCI_EXP_TYPE_DOWNSTREAM 0x6    /* Downstream Port */
 #define  PCI_EXP_TYPE_PCI_BRIDGE 0x7    /* PCI/PCI-X Bridge */
+#define  PCI_EXP_TYPE_PCIE_BRIDGE 0x8   /* PCI/PCI-X to PCIE Bridge */
 #define  PCI_EXP_TYPE_RC_END    0x9     /* Root Complex Integrated Endpoint */
 #define  PCI_EXP_TYPE_RC_EC     0xa     /* Root Complex Event Collector */
 #define PCI_EXP_FLAGS_SLOT      0x0100  /* Slot implemented */
diff --git a/include/linux/perf_event.h b/include/linux/perf_event.h
index abb2776be1ba..bd9f55a5958d 100644
--- a/include/linux/perf_event.h
+++ b/include/linux/perf_event.h
@@ -129,11 +129,40 @@ enum perf_event_sample_format {
         PERF_SAMPLE_PERIOD                      = 1U << 8,
         PERF_SAMPLE_STREAM_ID                   = 1U << 9,
         PERF_SAMPLE_RAW                         = 1U << 10,
+        PERF_SAMPLE_BRANCH_STACK                = 1U << 11,
 
-        PERF_SAMPLE_MAX = 1U << 11,             /* non-ABI */
+        PERF_SAMPLE_MAX = 1U << 12,             /* non-ABI */
 };
 
 /*
+ * values to program into branch_sample_type when PERF_SAMPLE_BRANCH is set
+ *
+ * If the user does not pass priv level information via branch_sample_type,
+ * the kernel uses the event's priv level. Branch and event priv levels do
+ * not have to match. Branch priv level is checked for permissions.
+ *
+ * The branch types can be combined, however BRANCH_ANY covers all types
+ * of branches and therefore it supersedes all the other types.
+ */
+enum perf_branch_sample_type {
+        PERF_SAMPLE_BRANCH_USER         = 1U << 0, /* user branches */
+        PERF_SAMPLE_BRANCH_KERNEL       = 1U << 1, /* kernel branches */
+        PERF_SAMPLE_BRANCH_HV           = 1U << 2, /* hypervisor branches */
+
+        PERF_SAMPLE_BRANCH_ANY          = 1U << 3, /* any branch types */
+        PERF_SAMPLE_BRANCH_ANY_CALL     = 1U << 4, /* any call branch */
+        PERF_SAMPLE_BRANCH_ANY_RETURN   = 1U << 5, /* any return branch */
+        PERF_SAMPLE_BRANCH_IND_CALL     = 1U << 6, /* indirect calls */
+
+        PERF_SAMPLE_BRANCH_MAX          = 1U << 7, /* non-ABI */
+};
+
+#define PERF_SAMPLE_BRANCH_PLM_ALL \
+        (PERF_SAMPLE_BRANCH_USER|\
+         PERF_SAMPLE_BRANCH_KERNEL|\
+         PERF_SAMPLE_BRANCH_HV)
+
+/*
  * The format of the data returned by read() on a perf event fd,
  * as specified by attr.read_format:
  *
@@ -163,6 +192,8 @@ enum perf_event_read_format {
 };
 
 #define PERF_ATTR_SIZE_VER0     64      /* sizeof first published struct */
+#define PERF_ATTR_SIZE_VER1     72      /* add: config2 */
+#define PERF_ATTR_SIZE_VER2     80      /* add: branch_sample_type */
 
 /*
  * Hardware event_id to monitor via a performance monitoring event:
@@ -240,6 +271,7 @@ struct perf_event_attr {
                 __u64           bp_len;
                 __u64           config2; /* extension of config1 */
         };
+        __u64   branch_sample_type; /* enum branch_sample_type */
 };
 
 /*
@@ -291,12 +323,14 @@ struct perf_event_mmap_page {
         __s64   offset;                 /* add to hardware event value */
         __u64   time_enabled;           /* time event active */
         __u64   time_running;           /* time event on cpu */
+        __u32   time_mult, time_shift;
+        __u64   time_offset;
 
                 /*
                  * Hole for extension of the self monitor capabilities
                  */
 
-        __u64   __reserved[123];        /* align to 1k */
+        __u64   __reserved[121];        /* align to 1k */
 
         /*
          * Control data for the mmap() data buffer.
@@ -456,6 +490,8 @@ enum perf_event_type {
          *
          *      { u32                   size;
          *        char                  data[size];}&& PERF_SAMPLE_RAW
+         *
+         *      { u64 from, to, flags } lbr[nr];} && PERF_SAMPLE_BRANCH_STACK
          * };
          */
         PERF_RECORD_SAMPLE                      = 9,
@@ -512,7 +548,7 @@ struct perf_guest_info_callbacks {
 #include <linux/ftrace.h>
 #include <linux/cpu.h>
 #include <linux/irq_work.h>
-#include <linux/jump_label.h>
+#include <linux/static_key.h>
 #include <linux/atomic.h>
 #include <asm/local.h>
 
@@ -528,12 +564,34 @@ struct perf_raw_record {
         void                            *data;
 };
 
+/*
+ * single taken branch record layout:
+ *
+ *      from: source instruction (may not always be a branch insn)
+ *        to: branch target
+ *   mispred: branch target was mispredicted
+ * predicted: branch target was predicted
+ *
+ * support for mispred, predicted is optional. In case it
+ * is not supported mispred = predicted = 0.
+ */
 struct perf_branch_entry {
-        __u64                           from;
-        __u64                           to;
-        __u64                           flags;
+        __u64   from;
+        __u64   to;
+        __u64   mispred:1,  /* target mispredicted */
+                predicted:1,/* target predicted */
+                reserved:62;
 };
 
+/*
+ * branch stack layout:
+ *  nr: number of taken branches stored in entries[]
+ *
+ * Note that nr can vary from sample to sample
+ * branches (to, from) are stored from most recent
+ * to least recent, i.e., entries[0] contains the most
+ * recent branch.
+ */
 struct perf_branch_stack {
         __u64                           nr;
         struct perf_branch_entry        entries[0];
@@ -564,7 +622,9 @@ struct hw_perf_event {
                         unsigned long   event_base;
                         int             idx;
                         int             last_cpu;
+
                         struct hw_perf_event_extra extra_reg;
+                        struct hw_perf_event_extra branch_reg;
                 };
                 struct { /* software */
                         struct hrtimer  hrtimer;
@@ -616,6 +676,7 @@ struct pmu {
         struct list_head                entry;
 
         struct device                   *dev;
+        const struct attribute_group    **attr_groups;
         char                            *name;
         int                             type;
 
@@ -681,6 +742,17 @@ struct pmu {
          * for each successful ->add() during the transaction.
          */
         void (*cancel_txn)              (struct pmu *pmu); /* optional */
+
+        /*
+         * Will return the value for perf_event_mmap_page::index for this event,
+         * if no implementation is provided it will default to: event->hw.idx + 1.
+         */
+        int (*event_idx)                (struct perf_event *event); /*optional */
+
+        /*
+         * flush branch stack on context-switches (needed in cpu-wide mode)
+         */
+        void (*flush_branch_stack)      (void);
 };
 
 /**
@@ -850,6 +922,9 @@ struct perf_event {
 #ifdef CONFIG_EVENT_TRACING
         struct ftrace_event_call        *tp_event;
         struct event_filter             *filter;
+#ifdef CONFIG_FUNCTION_TRACER
+        struct ftrace_ops               ftrace_ops;
+#endif
 #endif
 
 #ifdef CONFIG_CGROUP_PERF
@@ -911,7 +986,8 @@ struct perf_event_context {
         u64                             parent_gen;
         u64                             generation;
         int                             pin_count;
-        int                             nr_cgroups; /* cgroup events present */
+        int                             nr_cgroups;      /* cgroup evts */
+        int                             nr_branch_stack; /* branch_stack evt */
         struct rcu_head                 rcu_head;
 };
 
@@ -976,6 +1052,7 @@ perf_event_create_kernel_counter(struct perf_event_attr *attr,
 extern u64 perf_event_read_value(struct perf_event *event,
                                  u64 *enabled, u64 *running);
 
+
 struct perf_sample_data {
         u64                             type;
 
@@ -995,12 +1072,14 @@ struct perf_sample_data {
         u64                             period;
         struct perf_callchain_entry     *callchain;
         struct perf_raw_record          *raw;
+        struct perf_branch_stack        *br_stack;
 };
 
 static inline void perf_sample_data_init(struct perf_sample_data *data, u64 addr)
 {
         data->addr = addr;
         data->raw  = NULL;
+        data->br_stack = NULL;
 }
 
 extern void perf_output_sample(struct perf_output_handle *handle,
@@ -1029,7 +1108,7 @@ static inline int is_software_event(struct perf_event *event)
         return event->pmu->task_ctx_nr == perf_sw_context;
 }
 
-extern struct jump_label_key perf_swevent_enabled[PERF_COUNT_SW_MAX];
+extern struct static_key perf_swevent_enabled[PERF_COUNT_SW_MAX];
 
 extern void __perf_sw_event(u32, u64, struct pt_regs *, u64);
 
@@ -1057,7 +1136,7 @@ perf_sw_event(u32 event_id, u64 nr, struct pt_regs *regs, u64 addr)
 {
         struct pt_regs hot_regs;
 
-        if (static_branch(&perf_swevent_enabled[event_id])) {
+        if (static_key_false(&perf_swevent_enabled[event_id])) {
                 if (!regs) {
                         perf_fetch_caller_regs(&hot_regs);
                         regs = &hot_regs;
@@ -1066,12 +1145,12 @@ perf_sw_event(u32 event_id, u64 nr, struct pt_regs *regs, u64 addr)
         }
 }
 
-extern struct jump_label_key_deferred perf_sched_events;
+extern struct static_key_deferred perf_sched_events;
 
 static inline void perf_event_task_sched_in(struct task_struct *prev,
                                             struct task_struct *task)
 {
-        if (static_branch(&perf_sched_events.key))
+        if (static_key_false(&perf_sched_events.key))
                 __perf_event_task_sched_in(prev, task);
 }
 
@@ -1080,7 +1159,7 @@ static inline void perf_event_task_sched_out(struct task_struct *prev,
 {
         perf_sw_event(PERF_COUNT_SW_CONTEXT_SWITCHES, 1, NULL, 0);
 
-        if (static_branch(&perf_sched_events.key))
+        if (static_key_false(&perf_sched_events.key))
                 __perf_event_task_sched_out(prev, next);
 }
 
@@ -1139,6 +1218,11 @@ extern void perf_bp_event(struct perf_event *event, void *data);
 # define perf_instruction_pointer(regs) instruction_pointer(regs)
 #endif
 
+static inline bool has_branch_stack(struct perf_event *event)
+{
+        return event->attr.sample_type & PERF_SAMPLE_BRANCH_STACK;
+}
+
 extern int perf_output_begin(struct perf_output_handle *handle,
                              struct perf_event *event, unsigned int size);
 extern void perf_output_end(struct perf_output_handle *handle);
diff --git a/include/linux/phy.h b/include/linux/phy.h
index c599f7eca1e7..6fe0a37d4abf 100644
--- a/include/linux/phy.h
+++ b/include/linux/phy.h
@@ -19,7 +19,6 @@
 #define __PHY_H
 
 #include <linux/spinlock.h>
-#include <linux/device.h>
 #include <linux/ethtool.h>
 #include <linux/mii.h>
 #include <linux/timer.h>
@@ -88,6 +87,9 @@ typedef enum {
    IEEE 802.3ae clause 45 addressing mode used by 10GIGE phy chips. */
 #define MII_ADDR_C45 (1<<30)
 
+struct device;
+struct sk_buff;
+
 /*
  * The Bus class for PHYs.  Devices which provide access to
  * PHYs should register using this structure
@@ -241,7 +243,6 @@ enum phy_state {
         PHY_RESUMING
 };
 
-struct sk_buff;
 
 /* phy_device: An instance of a PHY
  *
diff --git a/include/linux/pid_namespace.h b/include/linux/pid_namespace.h
index e7cf6669ac34..f5bd679be46b 100644
--- a/include/linux/pid_namespace.h
+++ b/include/linux/pid_namespace.h
@@ -2,6 +2,7 @@
 #define _LINUX_PID_NS_H
 
 #include <linux/sched.h>
+#include <linux/bug.h>
 #include <linux/mm.h>
 #include <linux/threads.h>
 #include <linux/nsproxy.h>
diff --git a/include/linux/pinctrl/consumer.h b/include/linux/pinctrl/consumer.h
new file mode 100644
index 000000000000..191e72688481
--- /dev/null
+++ b/include/linux/pinctrl/consumer.h
@@ -0,0 +1,159 @@
+/*
+ * Consumer interface the pin control subsystem
+ *
+ * Copyright (C) 2012 ST-Ericsson SA
+ * Written on behalf of Linaro for ST-Ericsson
+ * Based on bits of regulator core, gpio core and clk core
+ *
+ * Author: Linus Walleij <linus.walleij@linaro.org>
+ *
+ * License terms: GNU General Public License (GPL) version 2
+ */
+#ifndef __LINUX_PINCTRL_CONSUMER_H
+#define __LINUX_PINCTRL_CONSUMER_H
+
+#include <linux/err.h>
+#include <linux/list.h>
+#include <linux/seq_file.h>
+#include "pinctrl-state.h"
+
+/* This struct is private to the core and should be regarded as a cookie */
+struct pinctrl;
+struct pinctrl_state;
+
+#ifdef CONFIG_PINCTRL
+
+/* External interface to pin control */
+extern int pinctrl_request_gpio(unsigned gpio);
+extern void pinctrl_free_gpio(unsigned gpio);
+extern int pinctrl_gpio_direction_input(unsigned gpio);
+extern int pinctrl_gpio_direction_output(unsigned gpio);
+
+extern struct pinctrl * __must_check pinctrl_get(struct device *dev);
+extern void pinctrl_put(struct pinctrl *p);
+extern struct pinctrl_state * __must_check pinctrl_lookup_state(
+                                                        struct pinctrl *p,
+                                                        const char *name);
+extern int pinctrl_select_state(struct pinctrl *p, struct pinctrl_state *s);
+
+#else /* !CONFIG_PINCTRL */
+
+static inline int pinctrl_request_gpio(unsigned gpio)
+{
+        return 0;
+}
+
+static inline void pinctrl_free_gpio(unsigned gpio)
+{
+}
+
+static inline int pinctrl_gpio_direction_input(unsigned gpio)
+{
+        return 0;
+}
+
+static inline int pinctrl_gpio_direction_output(unsigned gpio)
+{
+        return 0;
+}
+
+static inline struct pinctrl * __must_check pinctrl_get(struct device *dev)
+{
+        return NULL;
+}
+
+static inline void pinctrl_put(struct pinctrl *p)
+{
+}
+
+static inline struct pinctrl_state * __must_check pinctrl_lookup_state(
+                                                        struct pinctrl *p,
+                                                        const char *name)
+{
+        return NULL;
+}
+
+static inline int pinctrl_select_state(struct pinctrl *p,
+                                       struct pinctrl_state *s)
+{
+        return 0;
+}
+
+#endif /* CONFIG_PINCTRL */
+
+static inline struct pinctrl * __must_check pinctrl_get_select(
+                                        struct device *dev, const char *name)
+{
+        struct pinctrl *p;
+        struct pinctrl_state *s;
+        int ret;
+
+        p = pinctrl_get(dev);
+        if (IS_ERR(p))
+                return p;
+
+        s = pinctrl_lookup_state(p, name);
+        if (IS_ERR(s)) {
+                pinctrl_put(p);
+                return ERR_PTR(PTR_ERR(s));
+        }
+
+        ret = pinctrl_select_state(p, s);
+        if (ret < 0) {
+                pinctrl_put(p);
+                return ERR_PTR(ret);
+        }
+
+        return p;
+}
+
+static inline struct pinctrl * __must_check pinctrl_get_select_default(
+                                        struct device *dev)
+{
+        return pinctrl_get_select(dev, PINCTRL_STATE_DEFAULT);
+}
+
+#ifdef CONFIG_PINCONF
+
+extern int pin_config_get(const char *dev_name, const char *name,
+                          unsigned long *config);
+extern int pin_config_set(const char *dev_name, const char *name,
+                          unsigned long config);
+extern int pin_config_group_get(const char *dev_name,
+                                const char *pin_group,
+                                unsigned long *config);
+extern int pin_config_group_set(const char *dev_name,
+                                const char *pin_group,
+                                unsigned long config);
+
+#else
+
+static inline int pin_config_get(const char *dev_name, const char *name,
+                                 unsigned long *config)
+{
+        return 0;
+}
+
+static inline int pin_config_set(const char *dev_name, const char *name,
+                                 unsigned long config)
+{
+        return 0;
+}
+
+static inline int pin_config_group_get(const char *dev_name,
+                                       const char *pin_group,
+                                       unsigned long *config)
+{
+        return 0;
+}
+
+static inline int pin_config_group_set(const char *dev_name,
+                                       const char *pin_group,
+                                       unsigned long config)
+{
+        return 0;
+}
+
+#endif
+
+#endif /* __LINUX_PINCTRL_CONSUMER_H */
diff --git a/include/linux/pinctrl/machine.h b/include/linux/pinctrl/machine.h
index d0aecb7f6fb9..fee4349364f7 100644
--- a/include/linux/pinctrl/machine.h
+++ b/include/linux/pinctrl/machine.h
@@ -9,87 +9,153 @@
  *
  * License terms: GNU General Public License (GPL) version 2
  */
-#ifndef __LINUX_PINMUX_MACHINE_H
-#define __LINUX_PINMUX_MACHINE_H
+#ifndef __LINUX_PINCTRL_MACHINE_H
+#define __LINUX_PINCTRL_MACHINE_H
+
+#include "pinctrl-state.h"
+
+enum pinctrl_map_type {
+        PIN_MAP_TYPE_INVALID,
+        PIN_MAP_TYPE_DUMMY_STATE,
+        PIN_MAP_TYPE_MUX_GROUP,
+        PIN_MAP_TYPE_CONFIGS_PIN,
+        PIN_MAP_TYPE_CONFIGS_GROUP,
+};
+
+/**
+ * struct pinctrl_map_mux - mapping table content for MAP_TYPE_MUX_GROUP
+ * @group: the name of the group whose mux function is to be configured. This
+ *      field may be left NULL, and the first applicable group for the function
+ *      will be used.
+ * @function: the mux function to select for the group
+ */
+struct pinctrl_map_mux {
+        const char *group;
+        const char *function;
+};
 
 /**
- * struct pinmux_map - boards/machines shall provide this map for devices
+ * struct pinctrl_map_configs - mapping table content for MAP_TYPE_CONFIGS_*
+ * @group_or_pin: the name of the pin or group whose configuration parameters
+ *      are to be configured.
+ * @configs: a pointer to an array of config parameters/values to program into
+ *      hardware. Each individual pin controller defines the format and meaning
+ *      of config parameters.
+ * @num_configs: the number of entries in array @configs
+ */
+struct pinctrl_map_configs {
+        const char *group_or_pin;
+        unsigned long *configs;
+        unsigned num_configs;
+};
+
+/**
+ * struct pinctrl_map - boards/machines shall provide this map for devices
+ * @dev_name: the name of the device using this specific mapping, the name
+ *      must be the same as in your struct device*. If this name is set to the
+ *      same name as the pin controllers own dev_name(), the map entry will be
+ *      hogged by the driver itself upon registration
  * @name: the name of this specific map entry for the particular machine.
- *      This is the second parameter passed to pinmux_get() when you want
- *      to have several mappings to the same device
- * @ctrl_dev: the pin control device to be used by this mapping, may be NULL
- *      if you provide .ctrl_dev_name instead (this is more common)
+ *      This is the parameter passed to pinmux_lookup_state()
+ * @type: the type of mapping table entry
  * @ctrl_dev_name: the name of the device controlling this specific mapping,
- *      the name must be the same as in your struct device*, may be NULL if
- *      you provide .ctrl_dev instead
- * @function: a function in the driver to use for this mapping, the driver
- *      will lookup the function referenced by this ID on the specified
- *      pin control device
- * @group: sometimes a function can map to different pin groups, so this
- *      selects a certain specific pin group to activate for the function, if
- *      left as NULL, the first applicable group will be used
- * @dev: the device using this specific mapping, may be NULL if you provide
- *      .dev_name instead (this is more common)
- * @dev_name: the name of the device using this specific mapping, the name
- *      must be the same as in your struct device*, may be NULL if you
- *      provide .dev instead
- * @hog_on_boot: if this is set to true, the pin control subsystem will itself
- *      hog the mappings as the pinmux device drivers are attached, so this is
- *      typically used with system maps (mux mappings without an assigned
- *      device) that you want to get hogged and enabled by default as soon as
- *      a pinmux device supporting it is registered. These maps will not be
- *      disabled and put until the system shuts down.
+ *      the name must be the same as in your struct device*. This field is not
+ *      used for PIN_MAP_TYPE_DUMMY_STATE
+ * @data: Data specific to the mapping type
  */
-struct pinmux_map {
+struct pinctrl_map {
+        const char *dev_name;
         const char *name;
-        struct device *ctrl_dev;
+        enum pinctrl_map_type type;
         const char *ctrl_dev_name;
-        const char *function;
-        const char *group;
-        struct device *dev;
-        const char *dev_name;
-        bool hog_on_boot;
+        union {
+                struct pinctrl_map_mux mux;
+                struct pinctrl_map_configs configs;
+        } data;
 };
 
-/*
- * Convenience macro to set a simple map from a certain pin controller and a
- * certain function to a named device
- */
-#define PINMUX_MAP(a, b, c, d) \
-        { .name = a, .ctrl_dev_name = b, .function = c, .dev_name = d }
+/* Convenience macros to create mapping table entries */
 
-/*
- * Convenience macro to map a system function onto a certain pinctrl device.
- * System functions are not assigned to a particular device.
- */
-#define PINMUX_MAP_SYS(a, b, c) \
-        { .name = a, .ctrl_dev_name = b, .function = c }
+#define PIN_MAP_DUMMY_STATE(dev, state) \
+        {                                                               \
+                .dev_name = dev,                                        \
+                .name = state,                                          \
+                .type = PIN_MAP_TYPE_DUMMY_STATE,                       \
+        }
 
-/*
- * Convenience macro to map a system function onto a certain pinctrl device,
- * to be hogged by the pinmux core until the system shuts down.
- */
-#define PINMUX_MAP_SYS_HOG(a, b, c) \
-        { .name = a, .ctrl_dev_name = b, .function = c, \
-          .hog_on_boot = true }
+#define PIN_MAP_MUX_GROUP(dev, state, pinctrl, grp, func)               \
+        {                                                               \
+                .dev_name = dev,                                        \
+                .name = state,                                          \
+                .type = PIN_MAP_TYPE_MUX_GROUP,                         \
+                .ctrl_dev_name = pinctrl,                               \
+                .data.mux = {                                           \
+                        .group = grp,                                   \
+                        .function = func,                               \
+                },                                                      \
+        }
 
-/*
- * Convenience macro to map a system function onto a certain pinctrl device
- * using a specified group, to be hogged by the pinmux core until the system
- * shuts down.
- */
-#define PINMUX_MAP_SYS_HOG_GROUP(a, b, c, d)            \
-        { .name = a, .ctrl_dev_name = b, .function = c, .group = d, \
-          .hog_on_boot = true }
+#define PIN_MAP_MUX_GROUP_DEFAULT(dev, pinctrl, grp, func)              \
+        PIN_MAP_MUX_GROUP(dev, PINCTRL_STATE_DEFAULT, pinctrl, grp, func)
+
+#define PIN_MAP_MUX_GROUP_HOG(dev, state, grp, func)                    \
+        PIN_MAP_MUX_GROUP(dev, state, dev, grp, func)
+
+#define PIN_MAP_MUX_GROUP_HOG_DEFAULT(dev, grp, func)                   \
+        PIN_MAP_MUX_GROUP(dev, PINCTRL_STATE_DEFAULT, dev, grp, func)
+
+#define PIN_MAP_CONFIGS_PIN(dev, state, pinctrl, pin, cfgs)             \
+        {                                                               \
+                .dev_name = dev,                                        \
+                .name = state,                                          \
+                .type = PIN_MAP_TYPE_CONFIGS_PIN,                       \
+                .ctrl_dev_name = pinctrl,                               \
+                .data.configs = {                                       \
+                        .group_or_pin = pin,                            \
+                        .configs = cfgs,                                \
+                        .num_configs = ARRAY_SIZE(cfgs),                \
+                },                                                      \
+        }
+
+#define PIN_MAP_CONFIGS_PIN_DEFAULT(dev, pinctrl, pin, cfgs)            \
+        PIN_MAP_CONFIGS_PIN(dev, PINCTRL_STATE_DEFAULT, pinctrl, pin, cfgs)
+
+#define PIN_MAP_CONFIGS_PIN_HOG(dev, state, pin, cfgs)                  \
+        PIN_MAP_CONFIGS_PIN(dev, state, dev, pin, cfgs)
+
+#define PIN_MAP_CONFIGS_PIN_HOG_DEFAULT(dev, pin, cfgs)                 \
+        PIN_MAP_CONFIGS_PIN(dev, PINCTRL_STATE_DEFAULT, dev, pin, cfgs)
+
+#define PIN_MAP_CONFIGS_GROUP(dev, state, pinctrl, grp, cfgs)           \
+        {                                                               \
+                .dev_name = dev,                                        \
+                .name = state,                                          \
+                .type = PIN_MAP_TYPE_CONFIGS_GROUP,                     \
+                .ctrl_dev_name = pinctrl,                               \
+                .data.configs = {                                       \
+                        .group_or_pin = grp,                            \
+                        .configs = cfgs,                                \
+                        .num_configs = ARRAY_SIZE(cfgs),                \
+                },                                                      \
+        }
+
+#define PIN_MAP_CONFIGS_GROUP_DEFAULT(dev, pinctrl, grp, cfgs)          \
+        PIN_MAP_CONFIGS_GROUP(dev, PINCTRL_STATE_DEFAULT, pinctrl, grp, cfgs)
+
+#define PIN_MAP_CONFIGS_GROUP_HOG(dev, state, grp, cfgs)                \
+        PIN_MAP_CONFIGS_GROUP(dev, state, dev, grp, cfgs)
+
+#define PIN_MAP_CONFIGS_GROUP_HOG_DEFAULT(dev, grp, cfgs)               \
+        PIN_MAP_CONFIGS_GROUP(dev, PINCTRL_STATE_DEFAULT, dev, grp, cfgs)
 
 #ifdef CONFIG_PINMUX
 
-extern int pinmux_register_mappings(struct pinmux_map const *map,
+extern int pinctrl_register_mappings(struct pinctrl_map const *map,
                                 unsigned num_maps);
 
 #else
 
-static inline int pinmux_register_mappings(struct pinmux_map const *map,
+static inline int pinctrl_register_mappings(struct pinctrl_map const *map,
                                            unsigned num_maps)
 {
         return 0;
diff --git a/include/linux/pinctrl/pinconf-generic.h b/include/linux/pinctrl/pinconf-generic.h
new file mode 100644
index 000000000000..4f0abb9f1c09
--- /dev/null
+++ b/include/linux/pinctrl/pinconf-generic.h
@@ -0,0 +1,114 @@
+/*
+ * Interface the generic pinconfig portions of the pinctrl subsystem
+ *
+ * Copyright (C) 2011 ST-Ericsson SA
+ * Written on behalf of Linaro for ST-Ericsson
+ * This interface is used in the core to keep track of pins.
+ *
+ * Author: Linus Walleij <linus.walleij@linaro.org>
+ *
+ * License terms: GNU General Public License (GPL) version 2
+ */
+#ifndef __LINUX_PINCTRL_PINCONF_GENERIC_H
+#define __LINUX_PINCTRL_PINCONF_GENERIC_H
+
+/*
+ * You shouldn't even be able to compile with these enums etc unless you're
+ * using generic pin config. That is why this is defined out.
+ */
+#ifdef CONFIG_GENERIC_PINCONF
+
+/**
+ * enum pin_config_param - possible pin configuration parameters
+ * @PIN_CONFIG_BIAS_DISABLE: disable any pin bias on the pin, a
+ *      transition from say pull-up to pull-down implies that you disable
+ *      pull-up in the process, this setting disables all biasing.
+ * @PIN_CONFIG_BIAS_HIGH_IMPEDANCE: the pin will be set to a high impedance
+ *      mode, also know as "third-state" (tristate) or "high-Z" or "floating".
+ *      On output pins this effectively disconnects the pin, which is useful
+ *      if for example some other pin is going to drive the signal connected
+ *      to it for a while. Pins used for input are usually always high
+ *      impedance.
+ * @PIN_CONFIG_BIAS_PULL_UP: the pin will be pulled up (usually with high
+ *      impedance to VDD). If the argument is != 0 pull-up is enabled,
+ *      if it is 0, pull-up is disabled.
+ * @PIN_CONFIG_BIAS_PULL_DOWN: the pin will be pulled down (usually with high
+ *      impedance to GROUND). If the argument is != 0 pull-down is enabled,
+ *      if it is 0, pull-down is disabled.
+ * @PIN_CONFIG_DRIVE_PUSH_PULL: the pin will be driven actively high and
+ *      low, this is the most typical case and is typically achieved with two
+ *      active transistors on the output. Sending this config will enabale
+ *      push-pull mode, the argument is ignored.
+ * @PIN_CONFIG_DRIVE_OPEN_DRAIN: the pin will be driven with open drain (open
+ *      collector) which means it is usually wired with other output ports
+ *      which are then pulled up with an external resistor. Sending this
+ *      config will enabale open drain mode, the argument is ignored.
+ * @PIN_CONFIG_DRIVE_OPEN_SOURCE: the pin will be driven with open source
+ *      (open emitter). Sending this config will enabale open drain mode, the
+ *      argument is ignored.
+ * @PIN_CONFIG_INPUT_SCHMITT: this will configure an input pin to run in
+ *      schmitt-trigger mode. If the schmitt-trigger has adjustable hysteresis,
+ *      the threshold value is given on a custom format as argument when
+ *      setting pins to this mode. The argument zero turns the schmitt trigger
+ *      off.
+ * @PIN_CONFIG_INPUT_DEBOUNCE: this will configure the pin to debounce mode,
+ *      which means it will wait for signals to settle when reading inputs. The
+ *      argument gives the debounce time on a custom format. Setting the
+ *      argument to zero turns debouncing off.
+ * @PIN_CONFIG_POWER_SOURCE: if the pin can select between different power
+ *      supplies, the argument to this parameter (on a custom format) tells
+ *      the driver which alternative power source to use.
+ * @PIN_CONFIG_LOW_POWER_MODE: this will configure the pin for low power
+ *      operation, if several modes of operation are supported these can be
+ *      passed in the argument on a custom form, else just use argument 1
+ *      to indicate low power mode, argument 0 turns low power mode off.
+ * @PIN_CONFIG_END: this is the last enumerator for pin configurations, if
+ *      you need to pass in custom configurations to the pin controller, use
+ *      PIN_CONFIG_END+1 as the base offset.
+ */
+enum pin_config_param {
+        PIN_CONFIG_BIAS_DISABLE,
+        PIN_CONFIG_BIAS_HIGH_IMPEDANCE,
+        PIN_CONFIG_BIAS_PULL_UP,
+        PIN_CONFIG_BIAS_PULL_DOWN,
+        PIN_CONFIG_DRIVE_PUSH_PULL,
+        PIN_CONFIG_DRIVE_OPEN_DRAIN,
+        PIN_CONFIG_DRIVE_OPEN_SOURCE,
+        PIN_CONFIG_INPUT_SCHMITT,
+        PIN_CONFIG_INPUT_DEBOUNCE,
+        PIN_CONFIG_POWER_SOURCE,
+        PIN_CONFIG_LOW_POWER_MODE,
+        PIN_CONFIG_END = 0x7FFF,
+};
+
+/*
+ * Helpful configuration macro to be used in tables etc.
+ */
+#define PIN_CONF_PACKED(p, a) ((a << 16) | ((unsigned long) p & 0xffffUL))
+
+/*
+ * The following inlines stuffs a configuration parameter and data value
+ * into and out of an unsigned long argument, as used by the generic pin config
+ * system. We put the parameter in the lower 16 bits and the argument in the
+ * upper 16 bits.
+ */
+
+static inline enum pin_config_param pinconf_to_config_param(unsigned long config)
+{
+        return (enum pin_config_param) (config & 0xffffUL);
+}
+
+static inline u16 pinconf_to_config_argument(unsigned long config)
+{
+        return (enum pin_config_param) ((config >> 16) & 0xffffUL);
+}
+
+static inline unsigned long pinconf_to_config_packed(enum pin_config_param param,
+                                                     u16 argument)
+{
+        return PIN_CONF_PACKED(param, argument);
+}
+
+#endif /* CONFIG_GENERIC_PINCONF */
+
+#endif /* __LINUX_PINCTRL_PINCONF_GENERIC_H */
diff --git a/include/linux/pinctrl/pinconf.h b/include/linux/pinctrl/pinconf.h
index 477922cf043a..ec431f03362d 100644
--- a/include/linux/pinctrl/pinconf.h
+++ b/include/linux/pinctrl/pinconf.h
@@ -20,6 +20,8 @@ struct seq_file;
 /**
  * struct pinconf_ops - pin config operations, to be implemented by
  * pin configuration capable drivers.
+ * @is_generic: for pin controllers that want to use the generic interface,
+ *      this flag tells the framework that it's generic.
  * @pin_config_get: get the config of a certain pin, if the requested config
  *      is not available on this controller this should return -ENOTSUPP
  *      and if it is available but disabled it should return -EINVAL
@@ -33,6 +35,9 @@ struct seq_file;
  *      per-device info for a certain group in debugfs
  */
 struct pinconf_ops {
+#ifdef CONFIG_GENERIC_PINCONF
+        bool is_generic;
+#endif
         int (*pin_config_get) (struct pinctrl_dev *pctldev,
                                unsigned pin,
                                unsigned long *config);
@@ -53,45 +58,6 @@ struct pinconf_ops {
                                            unsigned selector);
 };
 
-extern int pin_config_get(const char *dev_name, const char *name,
-                          unsigned long *config);
-extern int pin_config_set(const char *dev_name, const char *name,
-                          unsigned long config);
-extern int pin_config_group_get(const char *dev_name,
-                                const char *pin_group,
-                                unsigned long *config);
-extern int pin_config_group_set(const char *dev_name,
-                                const char *pin_group,
-                                unsigned long config);
-
-#else
-
-static inline int pin_config_get(const char *dev_name, const char *name,
-                                 unsigned long *config)
-{
-        return 0;
-}
-
-static inline int pin_config_set(const char *dev_name, const char *name,
-                                 unsigned long config)
-{
-        return 0;
-}
-
-static inline int pin_config_group_get(const char *dev_name,
-                                       const char *pin_group,
-                                       unsigned long *config)
-{
-        return 0;
-}
-
-static inline int pin_config_group_set(const char *dev_name,
-                                       const char *pin_group,
-                                       unsigned long config)
-{
-        return 0;
-}
-
 #endif
 
 #endif /* __LINUX_PINCTRL_PINCONF_H */
diff --git a/include/linux/pinctrl/pinctrl-state.h b/include/linux/pinctrl/pinctrl-state.h
new file mode 100644
index 000000000000..3920e28b4da7
--- /dev/null
+++ b/include/linux/pinctrl/pinctrl-state.h
@@ -0,0 +1,6 @@
+/*
+ * Standard pin control state definitions
+ */
+
+#define PINCTRL_STATE_DEFAULT "default"
+#define PINCTRL_STATE_IDLE "idle"
diff --git a/include/linux/pinctrl/pinctrl.h b/include/linux/pinctrl/pinctrl.h
index 8bd22ee7aa09..4e9f0788c221 100644
--- a/include/linux/pinctrl/pinctrl.h
+++ b/include/linux/pinctrl/pinctrl.h
@@ -15,10 +15,11 @@
 #ifdef CONFIG_PINCTRL
 
 #include <linux/radix-tree.h>
-#include <linux/spinlock.h>
 #include <linux/list.h>
 #include <linux/seq_file.h>
+#include "pinctrl-state.h"
 
+struct device;
 struct pinctrl_dev;
 struct pinmux_ops;
 struct pinconf_ops;
diff --git a/include/linux/pinctrl/pinmux.h b/include/linux/pinctrl/pinmux.h
index 937b3e2fa36f..47e9237edd47 100644
--- a/include/linux/pinctrl/pinmux.h
+++ b/include/linux/pinctrl/pinmux.h
@@ -16,9 +16,6 @@
 #include <linux/seq_file.h>
 #include "pinctrl.h"
 
-/* This struct is private to the core and should be regarded as a cookie */
-struct pinmux;
-
 #ifdef CONFIG_PINMUX
 
 struct pinctrl_dev;
@@ -88,55 +85,6 @@ struct pinmux_ops {
                                    bool input);
 };
 
-/* External interface to pinmux */
-extern int pinmux_request_gpio(unsigned gpio);
-extern void pinmux_free_gpio(unsigned gpio);
-extern int pinmux_gpio_direction_input(unsigned gpio);
-extern int pinmux_gpio_direction_output(unsigned gpio);
-extern struct pinmux * __must_check pinmux_get(struct device *dev, const char *name);
-extern void pinmux_put(struct pinmux *pmx);
-extern int pinmux_enable(struct pinmux *pmx);
-extern void pinmux_disable(struct pinmux *pmx);
-
-#else /* !CONFIG_PINMUX */
-
-static inline int pinmux_request_gpio(unsigned gpio)
-{
-        return 0;
-}
-
-static inline void pinmux_free_gpio(unsigned gpio)
-{
-}
-
-static inline int pinmux_gpio_direction_input(unsigned gpio)
-{
-        return 0;
-}
-
-static inline int pinmux_gpio_direction_output(unsigned gpio)
-{
-        return 0;
-}
-
-static inline struct pinmux * __must_check pinmux_get(struct device *dev, const char *name)
-{
-        return NULL;
-}
-
-static inline void pinmux_put(struct pinmux *pmx)
-{
-}
-
-static inline int pinmux_enable(struct pinmux *pmx)
-{
-        return 0;
-}
-
-static inline void pinmux_disable(struct pinmux *pmx)
-{
-}
-
 #endif /* CONFIG_PINMUX */
 
 #endif /* __LINUX_PINCTRL_PINMUX_H */
diff --git a/include/linux/pipe_fs_i.h b/include/linux/pipe_fs_i.h
index 77257c92155a..6d626ff0cfd0 100644
--- a/include/linux/pipe_fs_i.h
+++ b/include/linux/pipe_fs_i.h
@@ -1,8 +1,6 @@
 #ifndef _LINUX_PIPE_FS_I_H
 #define _LINUX_PIPE_FS_I_H
 
-#define PIPEFS_MAGIC 0x50495045
-
 #define PIPE_DEF_BUFFERS        16
 
 #define PIPE_BUF_FLAG_LRU       0x01    /* page is on the LRU */
diff --git a/include/linux/pkt_sched.h b/include/linux/pkt_sched.h
index 0d5b79365d03..410b33d014d2 100644
--- a/include/linux/pkt_sched.h
+++ b/include/linux/pkt_sched.h
@@ -127,6 +127,27 @@ struct tc_multiq_qopt {
         __u16   max_bands;              /* Maximum number of queues */
 };
 
+/* PLUG section */
+
+#define TCQ_PLUG_BUFFER                0
+#define TCQ_PLUG_RELEASE_ONE           1
+#define TCQ_PLUG_RELEASE_INDEFINITE    2
+#define TCQ_PLUG_LIMIT                 3
+
+struct tc_plug_qopt {
+        /* TCQ_PLUG_BUFFER: Inset a plug into the queue and
+         *  buffer any incoming packets
+         * TCQ_PLUG_RELEASE_ONE: Dequeue packets from queue head
+         *   to beginning of the next plug.
+         * TCQ_PLUG_RELEASE_INDEFINITE: Dequeue all packets from queue.
+         *   Stop buffering packets until the next TCQ_PLUG_BUFFER
+         *   command is received (just act as a pass-thru queue).
+         * TCQ_PLUG_LIMIT: Increase/decrease queue size
+         */
+        int             action;
+        __u32           limit;
+};
+
 /* TBF section */
 
 struct tc_tbf_qopt {
diff --git a/include/linux/platform_data/atmel.h b/include/linux/platform_data/atmel.h
new file mode 100644
index 000000000000..d056263545b1
--- /dev/null
+++ b/include/linux/platform_data/atmel.h
@@ -0,0 +1,27 @@
+/*
+ * atmel platform data
+ *
+ * GPL v2 Only
+ */
+
+#ifndef __ATMEL_NAND_H__
+#define __ATMEL_NAND_H__
+
+#include <linux/mtd/nand.h>
+
+ /* NAND / SmartMedia */
+struct atmel_nand_data {
+        int             enable_pin;             /* chip enable */
+        int             det_pin;                /* card detect */
+        int             rdy_pin;                /* ready/busy */
+        u8              rdy_pin_active_low;     /* rdy_pin value is inverted */
+        u8              ale;                    /* address line number connected to ALE */
+        u8              cle;                    /* address line number connected to CLE */
+        u8              bus_width_16;           /* buswidth is 16 bit */
+        u8              ecc_mode;               /* ecc mode */
+        u8              on_flash_bbt;           /* bbt on flash */
+        struct mtd_partition *parts;
+        unsigned int    num_parts;
+};
+
+#endif /* __ATMEL_NAND_H__ */
diff --git a/include/linux/platform_data/cpsw.h b/include/linux/platform_data/cpsw.h
new file mode 100644
index 000000000000..c4e23d029498
--- /dev/null
+++ b/include/linux/platform_data/cpsw.h
@@ -0,0 +1,55 @@
+/*
+ * Texas Instruments Ethernet Switch Driver
+ *
+ * Copyright (C) 2012 Texas Instruments
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation version 2.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#ifndef __CPSW_H__
+#define __CPSW_H__
+
+#include <linux/if_ether.h>
+
+struct cpsw_slave_data {
+        u32             slave_reg_ofs;
+        u32             sliver_reg_ofs;
+        const char      *phy_id;
+        int             phy_if;
+        u8              mac_addr[ETH_ALEN];
+};
+
+struct cpsw_platform_data {
+        u32     ss_reg_ofs;     /* Subsystem control register offset */
+        u32     channels;       /* number of cpdma channels (symmetric) */
+        u32     cpdma_reg_ofs;  /* cpdma register offset */
+        u32     cpdma_sram_ofs; /* cpdma sram offset */
+
+        u32     slaves;         /* number of slave cpgmac ports */
+        struct cpsw_slave_data  *slave_data;
+
+        u32     ale_reg_ofs;    /* address lookup engine reg offset */
+        u32     ale_entries;    /* ale table size */
+
+        u32     host_port_reg_ofs; /* cpsw cpdma host port registers */
+        u32     host_port_num; /* The port number for the host port */
+
+        u32     hw_stats_reg_ofs;  /* cpsw hardware statistics counters */
+
+        u32     bd_ram_ofs;   /* embedded buffer descriptor RAM offset*/
+        u32     bd_ram_size;  /*buffer descriptor ram size */
+        u32     hw_ram_addr; /*if the HW address for BD RAM is different */
+        bool    no_bd_ram; /* no embedded BD ram*/
+
+        u32     rx_descs;       /* Number of Rx Descriptios */
+
+        u32     mac_control;    /* Mac control register */
+};
+
+#endif /* __CPSW_H__ */
diff --git a/include/linux/platform_data/dwc3-exynos.h b/include/linux/platform_data/dwc3-exynos.h
new file mode 100644
index 000000000000..5eb7da9b3772
--- /dev/null
+++ b/include/linux/platform_data/dwc3-exynos.h
@@ -0,0 +1,24 @@
+/**
+ * dwc3-exynos.h - Samsung EXYNOS DWC3 Specific Glue layer, header.
+ *
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd.
+ *              http://www.samsung.com
+ *
+ * Author: Anton Tikhomirov <av.tikhomirov@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#ifndef _DWC3_EXYNOS_H_
+#define _DWC3_EXYNOS_H_
+
+struct dwc3_exynos_data {
+        int phy_type;
+        int (*phy_init)(struct platform_device *pdev, int type);
+        int (*phy_exit)(struct platform_device *pdev, int type);
+};
+
+#endif /* _DWC3_EXYNOS_H_ */
diff --git a/include/linux/platform_data/efm32-uart.h b/include/linux/platform_data/efm32-uart.h
new file mode 100644
index 000000000000..ed0e975b3c54
--- /dev/null
+++ b/include/linux/platform_data/efm32-uart.h
@@ -0,0 +1,18 @@
+/*
+ *
+ *
+ */
+#ifndef __LINUX_PLATFORM_DATA_EFM32_UART_H__
+#define __LINUX_PLATFORM_DATA_EFM32_UART_H__
+
+#include <linux/types.h>
+
+/**
+ * struct efm32_uart_pdata
+ * @location: pinmux location for the I/O pins (to be written to the ROUTE
+ *      register)
+ */
+struct efm32_uart_pdata {
+        u8 location;
+};
+#endif /* ifndef __LINUX_PLATFORM_DATA_EFM32_UART_H__ */
diff --git a/include/linux/platform_data/omap-abe-twl6040.h b/include/linux/platform_data/omap-abe-twl6040.h
new file mode 100644
index 000000000000..5d298ac10fc2
--- /dev/null
+++ b/include/linux/platform_data/omap-abe-twl6040.h
@@ -0,0 +1,49 @@
+/**
+ * omap-abe-twl6040.h - ASoC machine driver OMAP4+ devices, header.
+ *
+ * Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com
+ * All rights reserved.
+ *
+ * Author: Peter Ujfalusi <peter.ujfalusi@ti.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ */
+
+#ifndef _OMAP_ABE_TWL6040_H_
+#define _OMAP_ABE_TWL6040_H_
+
+/* To select if only one channel is connected in a stereo port */
+#define ABE_TWL6040_LEFT        (1 << 0)
+#define ABE_TWL6040_RIGHT       (1 << 1)
+
+struct omap_abe_twl6040_data {
+        char *card_name;
+        /* Feature flags for connected audio pins */
+        u8      has_hs;
+        u8      has_hf;
+        bool    has_ep;
+        u8      has_aux;
+        u8      has_vibra;
+        bool    has_dmic;
+        bool    has_hsmic;
+        bool    has_mainmic;
+        bool    has_submic;
+        u8      has_afm;
+        /* Other features */
+        bool    jack_detection; /* board can detect jack events */
+        int     mclk_freq;      /* MCLK frequency speed for twl6040 */
+};
+
+#endif /* _OMAP_ABE_TWL6040_H_ */
diff --git a/include/linux/platform_data/omap4-keypad.h b/include/linux/platform_data/omap4-keypad.h
new file mode 100644
index 000000000000..4eef5fb05a17
--- /dev/null
+++ b/include/linux/platform_data/omap4-keypad.h
@@ -0,0 +1,13 @@
+#ifndef __LINUX_INPUT_OMAP4_KEYPAD_H
+#define __LINUX_INPUT_OMAP4_KEYPAD_H
+
+#include <linux/input/matrix_keypad.h>
+
+struct omap4_keypad_platform_data {
+        const struct matrix_keymap_data *keymap_data;
+
+        u8 rows;
+        u8 cols;
+};
+
+#endif /* __LINUX_INPUT_OMAP4_KEYPAD_H */
diff --git a/include/linux/platform_data/tegra_emc.h b/include/linux/platform_data/tegra_emc.h
new file mode 100644
index 000000000000..df67505e98f8
--- /dev/null
+++ b/include/linux/platform_data/tegra_emc.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2011 Google, Inc.
+ *
+ * Author:
+ *      Colin Cross <ccross@android.com>
+ *      Olof Johansson <olof@lixom.net>
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef __TEGRA_EMC_H_
+#define __TEGRA_EMC_H_
+
+#define TEGRA_EMC_NUM_REGS 46
+
+struct tegra_emc_table {
+        unsigned long rate;
+        u32 regs[TEGRA_EMC_NUM_REGS];
+};
+
+struct tegra_emc_pdata {
+        int num_tables;
+        struct tegra_emc_table *tables;
+};
+
+#endif
diff --git a/include/linux/pm.h b/include/linux/pm.h
index e4982ac3fbbc..715305e05123 100644
--- a/include/linux/pm.h
+++ b/include/linux/pm.h
@@ -110,6 +110,10 @@ typedef struct pm_message {
  *      Subsystem-level @suspend() is executed for all devices after invoking
  *      subsystem-level @prepare() for all of them.
  *
+ * @suspend_late: Continue operations started by @suspend().  For a number of
+ *      devices @suspend_late() may point to the same callback routine as the
+ *      runtime suspend callback.
+ *
  * @resume: Executed after waking the system up from a sleep state in which the
  *      contents of main memory were preserved.  The exact action to perform
  *      depends on the device's subsystem, but generally the driver is expected
@@ -122,6 +126,10 @@ typedef struct pm_message {
  *      Subsystem-level @resume() is executed for all devices after invoking
  *      subsystem-level @resume_noirq() for all of them.
  *
+ * @resume_early: Prepare to execute @resume().  For a number of devices
+ *      @resume_early() may point to the same callback routine as the runtime
+ *      resume callback.
+ *
  * @freeze: Hibernation-specific, executed before creating a hibernation image.
  *      Analogous to @suspend(), but it should not enable the device to signal
  *      wakeup events or change its power state.  The majority of subsystems
@@ -131,6 +139,10 @@ typedef struct pm_message {
  *      Subsystem-level @freeze() is executed for all devices after invoking
  *      subsystem-level @prepare() for all of them.
  *
+ * @freeze_late: Continue operations started by @freeze().  Analogous to
+ *      @suspend_late(), but it should not enable the device to signal wakeup
+ *      events or change its power state.
+ *
  * @thaw: Hibernation-specific, executed after creating a hibernation image OR
  *      if the creation of an image has failed.  Also executed after a failing
  *      attempt to restore the contents of main memory from such an image.
@@ -140,15 +152,23 @@ typedef struct pm_message {
  *      subsystem-level @thaw_noirq() for all of them.  It also may be executed
  *      directly after @freeze() in case of a transition error.
  *
+ * @thaw_early: Prepare to execute @thaw().  Undo the changes made by the
+ *      preceding @freeze_late().
+ *
  * @poweroff: Hibernation-specific, executed after saving a hibernation image.
  *      Analogous to @suspend(), but it need not save the device's settings in
  *      memory.
  *      Subsystem-level @poweroff() is executed for all devices after invoking
  *      subsystem-level @prepare() for all of them.
  *
+ * @poweroff_late: Continue operations started by @poweroff().  Analogous to
+ *      @suspend_late(), but it need not save the device's settings in memory.
+ *
  * @restore: Hibernation-specific, executed after restoring the contents of main
  *      memory from a hibernation image, analogous to @resume().
  *
+ * @restore_early: Prepare to execute @restore(), analogous to @resume_early().
+ *
  * @suspend_noirq: Complete the actions started by @suspend().  Carry out any
  *      additional operations required for suspending the device that might be
  *      racing with its driver's interrupt handler, which is guaranteed not to
@@ -158,9 +178,10 @@ typedef struct pm_message {
  *      @suspend_noirq() has returned successfully.  If the device can generate
  *      system wakeup signals and is enabled to wake up the system, it should be
  *      configured to do so at that time.  However, depending on the platform
- *      and device's subsystem, @suspend() may be allowed to put the device into
- *      the low-power state and configure it to generate wakeup signals, in
- *      which case it generally is not necessary to define @suspend_noirq().
+ *      and device's subsystem, @suspend() or @suspend_late() may be allowed to
+ *      put the device into the low-power state and configure it to generate
+ *      wakeup signals, in which case it generally is not necessary to define
+ *      @suspend_noirq().
  *
  * @resume_noirq: Prepare for the execution of @resume() by carrying out any
  *      operations required for resuming the device that might be racing with
@@ -171,9 +192,9 @@ typedef struct pm_message {
  *      additional operations required for freezing the device that might be
  *      racing with its driver's interrupt handler, which is guaranteed not to
  *      run while @freeze_noirq() is being executed.
- *      The power state of the device should not be changed by either @freeze()
- *      or @freeze_noirq() and it should not be configured to signal system
- *      wakeup by any of these callbacks.
+ *      The power state of the device should not be changed by either @freeze(),
+ *      or @freeze_late(), or @freeze_noirq() and it should not be configured to
+ *      signal system wakeup by any of these callbacks.
  *
  * @thaw_noirq: Prepare for the execution of @thaw() by carrying out any
  *      operations required for thawing the device that might be racing with its
@@ -249,6 +270,12 @@ struct dev_pm_ops {
         int (*thaw)(struct device *dev);
         int (*poweroff)(struct device *dev);
         int (*restore)(struct device *dev);
+        int (*suspend_late)(struct device *dev);
+        int (*resume_early)(struct device *dev);
+        int (*freeze_late)(struct device *dev);
+        int (*thaw_early)(struct device *dev);
+        int (*poweroff_late)(struct device *dev);
+        int (*restore_early)(struct device *dev);
         int (*suspend_noirq)(struct device *dev);
         int (*resume_noirq)(struct device *dev);
         int (*freeze_noirq)(struct device *dev);
@@ -293,6 +320,15 @@ const struct dev_pm_ops name = { \
 /*
  * Use this for defining a set of PM operations to be used in all situations
  * (sustem suspend, hibernation or runtime PM).
+ * NOTE: In general, system suspend callbacks, .suspend() and .resume(), should
+ * be different from the corresponding runtime PM callbacks, .runtime_suspend(),
+ * and .runtime_resume(), because .runtime_suspend() always works on an already
+ * quiescent device, while .suspend() should assume that the device may be doing
+ * something when it is called (it should ensure that the device will be
+ * quiescent after it has returned).  Therefore it's better to point the "late"
+ * suspend and "early" resume callback pointers, .suspend_late() and
+ * .resume_early(), to the same routines as .runtime_suspend() and
+ * .runtime_resume(), respectively (and analogously for hibernation).
  */
 #define UNIVERSAL_DEV_PM_OPS(name, suspend_fn, resume_fn, idle_fn) \
 const struct dev_pm_ops name = { \
@@ -510,6 +546,7 @@ struct dev_pm_info {
         unsigned long           accounting_timestamp;
         ktime_t                 suspend_time;
         s64                     max_time_suspended_ns;
+        struct dev_pm_qos_request *pq_req;
 #endif
         struct pm_subsys_data   *subsys_data;  /* Owned by the subsystem. */
         struct pm_qos_constraints *constraints;
@@ -584,13 +621,13 @@ struct dev_pm_domain {
 
 #ifdef CONFIG_PM_SLEEP
 extern void device_pm_lock(void);
-extern void dpm_resume_noirq(pm_message_t state);
+extern void dpm_resume_start(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_end(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);
@@ -605,17 +642,23 @@ extern void __suspend_report_result(const char *function, void *fn, int ret);
 extern int device_pm_wait_for_dev(struct device *sub, struct device *dev);
 
 extern int pm_generic_prepare(struct device *dev);
+extern int pm_generic_suspend_late(struct device *dev);
 extern int pm_generic_suspend_noirq(struct device *dev);
 extern int pm_generic_suspend(struct device *dev);
+extern int pm_generic_resume_early(struct device *dev);
 extern int pm_generic_resume_noirq(struct device *dev);
 extern int pm_generic_resume(struct device *dev);
 extern int pm_generic_freeze_noirq(struct device *dev);
+extern int pm_generic_freeze_late(struct device *dev);
 extern int pm_generic_freeze(struct device *dev);
 extern int pm_generic_thaw_noirq(struct device *dev);
+extern int pm_generic_thaw_early(struct device *dev);
 extern int pm_generic_thaw(struct device *dev);
 extern int pm_generic_restore_noirq(struct device *dev);
+extern int pm_generic_restore_early(struct device *dev);
 extern int pm_generic_restore(struct device *dev);
 extern int pm_generic_poweroff_noirq(struct device *dev);
+extern int pm_generic_poweroff_late(struct device *dev);
 extern int pm_generic_poweroff(struct device *dev);
 extern void pm_generic_complete(struct device *dev);
 
diff --git a/include/linux/pm_domain.h b/include/linux/pm_domain.h
index a03a0ad998b8..91f8286106ea 100644
--- a/include/linux/pm_domain.h
+++ b/include/linux/pm_domain.h
@@ -10,7 +10,10 @@
 #define _LINUX_PM_DOMAIN_H
 
 #include <linux/device.h>
+#include <linux/mutex.h>
+#include <linux/pm.h>
 #include <linux/err.h>
+#include <linux/of.h>
 
 enum gpd_status {
         GPD_STATE_ACTIVE = 0,   /* PM domain is active */
@@ -70,6 +73,7 @@ struct generic_pm_domain {
         s64 break_even_ns;      /* Power break even for the entire domain. */
         s64 max_off_time_ns;    /* Maximum allowed "suspended" time. */
         ktime_t power_off_time;
+        struct device_node *of_node; /* Node in device tree */
 };
 
 static inline struct generic_pm_domain *pd_to_genpd(struct dev_pm_domain *pd)
@@ -97,14 +101,15 @@ struct generic_pm_domain_data {
         struct gpd_dev_ops ops;
         struct gpd_timing_data td;
         bool need_restore;
+        bool always_on;
 };
 
+#ifdef CONFIG_PM_GENERIC_DOMAINS
 static inline struct generic_pm_domain_data *to_gpd_data(struct pm_domain_data *pdd)
 {
         return container_of(pdd, struct generic_pm_domain_data, base);
 }
 
-#ifdef CONFIG_PM_GENERIC_DOMAINS
 static inline struct generic_pm_domain_data *dev_gpd_data(struct device *dev)
 {
         return to_gpd_data(dev->power.subsys_data->domain_data);
@@ -117,14 +122,25 @@ extern int __pm_genpd_add_device(struct generic_pm_domain *genpd,
                                  struct device *dev,
                                  struct gpd_timing_data *td);
 
+extern int __pm_genpd_of_add_device(struct device_node *genpd_node,
+                                    struct device *dev,
+                                    struct gpd_timing_data *td);
+
 static inline int pm_genpd_add_device(struct generic_pm_domain *genpd,
                                       struct device *dev)
 {
         return __pm_genpd_add_device(genpd, dev, NULL);
 }
 
+static inline int pm_genpd_of_add_device(struct device_node *genpd_node,
+                                         struct device *dev)
+{
+        return __pm_genpd_of_add_device(genpd_node, dev, NULL);
+}
+
 extern int pm_genpd_remove_device(struct generic_pm_domain *genpd,
                                   struct device *dev);
+extern void pm_genpd_dev_always_on(struct device *dev, bool val);
 extern int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
                                   struct generic_pm_domain *new_subdomain);
 extern int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
@@ -143,6 +159,10 @@ extern bool default_stop_ok(struct device *dev);
 extern struct dev_power_governor pm_domain_always_on_gov;
 #else
 
+static inline struct generic_pm_domain_data *dev_gpd_data(struct device *dev)
+{
+        return ERR_PTR(-ENOSYS);
+}
 static inline struct generic_pm_domain *dev_to_genpd(struct device *dev)
 {
         return ERR_PTR(-ENOSYS);
@@ -163,6 +183,7 @@ static inline int pm_genpd_remove_device(struct generic_pm_domain *genpd,
 {
         return -ENOSYS;
 }
+static inline void pm_genpd_dev_always_on(struct device *dev, bool val) {}
 static inline int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
                                          struct generic_pm_domain *new_sd)
 {
@@ -183,7 +204,8 @@ static inline int __pm_genpd_remove_callbacks(struct device *dev, bool clear_td)
 {
         return -ENOSYS;
 }
-static inline void pm_genpd_init(struct generic_pm_domain *genpd, bool is_off)
+static inline void pm_genpd_init(struct generic_pm_domain *genpd,
+                                 struct dev_power_governor *gov, bool is_off)
 {
 }
 static inline int pm_genpd_poweron(struct generic_pm_domain *genpd)
@@ -194,6 +216,7 @@ static inline bool default_stop_ok(struct device *dev)
 {
         return false;
 }
+#define simple_qos_governor NULL
 #define pm_domain_always_on_gov NULL
 #endif
 
diff --git a/include/linux/pm_qos.h b/include/linux/pm_qos.h
index 4d99e4e6ef83..2e9191a712f3 100644
--- a/include/linux/pm_qos.h
+++ b/include/linux/pm_qos.h
@@ -9,12 +9,16 @@
 #include <linux/miscdevice.h>
 #include <linux/device.h>
 
-#define PM_QOS_RESERVED 0
-#define PM_QOS_CPU_DMA_LATENCY 1
-#define PM_QOS_NETWORK_LATENCY 2
-#define PM_QOS_NETWORK_THROUGHPUT 3
+enum {
+        PM_QOS_RESERVED = 0,
+        PM_QOS_CPU_DMA_LATENCY,
+        PM_QOS_NETWORK_LATENCY,
+        PM_QOS_NETWORK_THROUGHPUT,
+
+        /* insert new class ID */
+        PM_QOS_NUM_CLASSES,
+};
 
-#define PM_QOS_NUM_CLASSES 4
 #define PM_QOS_DEFAULT_VALUE -1
 
 #define PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE        (2000 * USEC_PER_SEC)
@@ -63,7 +67,6 @@ static inline int dev_pm_qos_request_active(struct dev_pm_qos_request *req)
         return req->dev != 0;
 }
 
-#ifdef CONFIG_PM
 int pm_qos_update_target(struct pm_qos_constraints *c, struct plist_node *node,
                          enum pm_qos_req_action action, int value);
 void pm_qos_add_request(struct pm_qos_request *req, int pm_qos_class,
@@ -78,6 +81,7 @@ int pm_qos_remove_notifier(int pm_qos_class, struct notifier_block *notifier);
 int pm_qos_request_active(struct pm_qos_request *req);
 s32 pm_qos_read_value(struct pm_qos_constraints *c);
 
+#ifdef CONFIG_PM
 s32 __dev_pm_qos_read_value(struct device *dev);
 s32 dev_pm_qos_read_value(struct device *dev);
 int dev_pm_qos_add_request(struct device *dev, struct dev_pm_qos_request *req,
@@ -95,45 +99,6 @@ void dev_pm_qos_constraints_destroy(struct device *dev);
 int dev_pm_qos_add_ancestor_request(struct device *dev,
                                     struct dev_pm_qos_request *req, s32 value);
 #else
-static inline int pm_qos_update_target(struct pm_qos_constraints *c,
-                                       struct plist_node *node,
-                                       enum pm_qos_req_action action,
-                                       int value)
-                        { return 0; }
-static inline void pm_qos_add_request(struct pm_qos_request *req,
-                                      int pm_qos_class, s32 value)
-                        { return; }
-static inline void pm_qos_update_request(struct pm_qos_request *req,
-                                         s32 new_value)
-                        { return; }
-static inline void pm_qos_remove_request(struct pm_qos_request *req)
-                        { return; }
-
-static inline int pm_qos_request(int pm_qos_class)
-{
-        switch (pm_qos_class) {
-        case PM_QOS_CPU_DMA_LATENCY:
-                return PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE;
-        case PM_QOS_NETWORK_LATENCY:
-                return PM_QOS_NETWORK_LAT_DEFAULT_VALUE;
-        case PM_QOS_NETWORK_THROUGHPUT:
-                return PM_QOS_NETWORK_THROUGHPUT_DEFAULT_VALUE;
-        default:
-                return PM_QOS_DEFAULT_VALUE;
-        }
-}
-
-static inline int pm_qos_add_notifier(int pm_qos_class,
-                                      struct notifier_block *notifier)
-                        { return 0; }
-static inline int pm_qos_remove_notifier(int pm_qos_class,
-                                         struct notifier_block *notifier)
-                        { return 0; }
-static inline int pm_qos_request_active(struct pm_qos_request *req)
-                        { return 0; }
-static inline s32 pm_qos_read_value(struct pm_qos_constraints *c)
-                        { return 0; }
-
 static inline s32 __dev_pm_qos_read_value(struct device *dev)
                         { return 0; }
 static inline s32 dev_pm_qos_read_value(struct device *dev)
@@ -172,4 +137,13 @@ static inline int dev_pm_qos_add_ancestor_request(struct device *dev,
                         { return 0; }
 #endif
 
+#ifdef CONFIG_PM_RUNTIME
+int dev_pm_qos_expose_latency_limit(struct device *dev, s32 value);
+void dev_pm_qos_hide_latency_limit(struct device *dev);
+#else
+static inline int dev_pm_qos_expose_latency_limit(struct device *dev, s32 value)
+                        { return 0; }
+static inline void dev_pm_qos_hide_latency_limit(struct device *dev) {}
+#endif
+
 #endif
diff --git a/include/linux/pm_wakeup.h b/include/linux/pm_wakeup.h
index a32da962d693..d9f05113e5fb 100644
--- a/include/linux/pm_wakeup.h
+++ b/include/linux/pm_wakeup.h
@@ -41,7 +41,7 @@
  * @active: Status of the wakeup source.
  */
 struct wakeup_source {
-        char                    *name;
+        const char              *name;
         struct list_head        entry;
         spinlock_t              lock;
         struct timer_list       timer;
@@ -73,7 +73,9 @@ static inline bool device_may_wakeup(struct device *dev)
 }
 
 /* drivers/base/power/wakeup.c */
+extern void wakeup_source_prepare(struct wakeup_source *ws, const char *name);
 extern struct wakeup_source *wakeup_source_create(const char *name);
+extern void wakeup_source_drop(struct wakeup_source *ws);
 extern void wakeup_source_destroy(struct wakeup_source *ws);
 extern void wakeup_source_add(struct wakeup_source *ws);
 extern void wakeup_source_remove(struct wakeup_source *ws);
@@ -103,11 +105,16 @@ static inline bool device_can_wakeup(struct device *dev)
         return dev->power.can_wakeup;
 }
 
+static inline void wakeup_source_prepare(struct wakeup_source *ws,
+                                         const char *name) {}
+
 static inline struct wakeup_source *wakeup_source_create(const char *name)
 {
         return NULL;
 }
 
+static inline void wakeup_source_drop(struct wakeup_source *ws) {}
+
 static inline void wakeup_source_destroy(struct wakeup_source *ws) {}
 
 static inline void wakeup_source_add(struct wakeup_source *ws) {}
@@ -165,4 +172,17 @@ static inline void pm_wakeup_event(struct device *dev, unsigned int msec) {}
 
 #endif /* !CONFIG_PM_SLEEP */
 
+static inline void wakeup_source_init(struct wakeup_source *ws,
+                                      const char *name)
+{
+        wakeup_source_prepare(ws, name);
+        wakeup_source_add(ws);
+}
+
+static inline void wakeup_source_trash(struct wakeup_source *ws)
+{
+        wakeup_source_remove(ws);
+        wakeup_source_drop(ws);
+}
+
 #endif /* _LINUX_PM_WAKEUP_H */
diff --git a/include/linux/poll.h b/include/linux/poll.h
index cf40010ce0cd..48fe8bc398d1 100644
--- a/include/linux/poll.h
+++ b/include/linux/poll.h
@@ -32,21 +32,46 @@ struct poll_table_struct;
  */
 typedef void (*poll_queue_proc)(struct file *, wait_queue_head_t *, struct poll_table_struct *);
 
+/*
+ * Do not touch the structure directly, use the access functions
+ * poll_does_not_wait() and poll_requested_events() instead.
+ */
 typedef struct poll_table_struct {
-        poll_queue_proc qproc;
-        unsigned long key;
+        poll_queue_proc _qproc;
+        unsigned long _key;
 } poll_table;
 
 static inline void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)
 {
-        if (p && wait_address)
-                p->qproc(filp, wait_address, p);
+        if (p && p->_qproc && wait_address)
+                p->_qproc(filp, wait_address, p);
+}
+
+/*
+ * Return true if it is guaranteed that poll will not wait. This is the case
+ * if the poll() of another file descriptor in the set got an event, so there
+ * is no need for waiting.
+ */
+static inline bool poll_does_not_wait(const poll_table *p)
+{
+        return p == NULL || p->_qproc == NULL;
+}
+
+/*
+ * Return the set of events that the application wants to poll for.
+ * This is useful for drivers that need to know whether a DMA transfer has
+ * to be started implicitly on poll(). You typically only want to do that
+ * if the application is actually polling for POLLIN and/or POLLOUT.
+ */
+static inline unsigned long poll_requested_events(const poll_table *p)
+{
+        return p ? p->_key : ~0UL;
 }
 
 static inline void init_poll_funcptr(poll_table *pt, poll_queue_proc qproc)
 {
-        pt->qproc = qproc;
-        pt->key   = ~0UL; /* all events enabled */
+        pt->_qproc = qproc;
+        pt->_key   = ~0UL; /* all events enabled */
 }
 
 struct poll_table_entry {
diff --git a/include/linux/posix_acl.h b/include/linux/posix_acl.h
index b7681102a4b9..11bad91c4433 100644
--- a/include/linux/posix_acl.h
+++ b/include/linux/posix_acl.h
@@ -8,6 +8,7 @@
 #ifndef __LINUX_POSIX_ACL_H
 #define __LINUX_POSIX_ACL_H
 
+#include <linux/bug.h>
 #include <linux/slab.h>
 #include <linux/rcupdate.h>
 
diff --git a/include/linux/power_supply.h b/include/linux/power_supply.h
index fa9b962aec12..c38c13db8832 100644
--- a/include/linux/power_supply.h
+++ b/include/linux/power_supply.h
@@ -13,10 +13,11 @@
 #ifndef __LINUX_POWER_SUPPLY_H__
 #define __LINUX_POWER_SUPPLY_H__
 
-#include <linux/device.h>
 #include <linux/workqueue.h>
 #include <linux/leds.h>
 
+struct device;
+
 /*
  * All voltages, currents, charges, energies, time and temperatures in uV,
  * µA, µAh, µWh, seconds and tenths of degree Celsius unless otherwise
diff --git a/include/linux/ppp-comp.h b/include/linux/ppp-comp.h
index b8d4ddd22736..e53ff65935dd 100644
--- a/include/linux/ppp-comp.h
+++ b/include/linux/ppp-comp.h
@@ -1,42 +1,12 @@
 /*
  * ppp-comp.h - Definitions for doing PPP packet compression.
  *
- * Copyright (c) 1994 The Australian National University.
- * All rights reserved.
+ * Copyright 1994-1998 Paul Mackerras.
  *
- * Permission to use, copy, modify, and distribute this software and its
- * documentation is hereby granted, provided that the above copyright
- * notice appears in all copies.  This software is provided without any
- * warranty, express or implied. The Australian National University
- * makes no representations about the suitability of this software for
- * any purpose.
- *
- * IN NO EVENT SHALL THE AUSTRALIAN NATIONAL UNIVERSITY BE LIABLE TO ANY
- * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
- * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
- * THE AUSTRALIAN NATIONAL UNIVERSITY HAVE BEEN ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- *
- * THE AUSTRALIAN NATIONAL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
- * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
- * ON AN "AS IS" BASIS, AND THE AUSTRALIAN NATIONAL UNIVERSITY HAS NO
- * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS,
- * OR MODIFICATIONS.
+ *  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.
  */
-
-/*
- *  ==FILEVERSION 980319==
- *
- *  NOTE TO MAINTAINERS:
- *     If you modify this file at all, please set the above date.
- *     ppp-comp.h is shipped with a PPP distribution as well as with the kernel;
- *     if everyone increases the FILEVERSION number above, then scripts
- *     can do the right thing when deciding whether to install a new ppp-comp.h
- *     file.  Don't change the format of that line otherwise, so the
- *     installation script can recognize it.
- */
-
 #ifndef _NET_PPP_COMP_H
 #define _NET_PPP_COMP_H
 
diff --git a/include/linux/ppp-ioctl.h b/include/linux/ppp-ioctl.h
new file mode 100644
index 000000000000..2d9a8859550a
--- /dev/null
+++ b/include/linux/ppp-ioctl.h
@@ -0,0 +1,119 @@
+/*
+ * ppp-ioctl.h - PPP ioctl definitions.
+ *
+ * Copyright 1999-2002 Paul Mackerras.
+ *
+ *  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 _PPP_IOCTL_H
+#define _PPP_IOCTL_H
+
+#include <linux/types.h>
+#include <linux/compiler.h>
+
+/*
+ * Bit definitions for flags argument to PPPIOCGFLAGS/PPPIOCSFLAGS.
+ */
+#define SC_COMP_PROT    0x00000001      /* protocol compression (output) */
+#define SC_COMP_AC      0x00000002      /* header compression (output) */
+#define SC_COMP_TCP     0x00000004      /* TCP (VJ) compression (output) */
+#define SC_NO_TCP_CCID  0x00000008      /* disable VJ connection-id comp. */
+#define SC_REJ_COMP_AC  0x00000010      /* reject adrs/ctrl comp. on input */
+#define SC_REJ_COMP_TCP 0x00000020      /* reject TCP (VJ) comp. on input */
+#define SC_CCP_OPEN     0x00000040      /* Look at CCP packets */
+#define SC_CCP_UP       0x00000080      /* May send/recv compressed packets */
+#define SC_ENABLE_IP    0x00000100      /* IP packets may be exchanged */
+#define SC_LOOP_TRAFFIC 0x00000200      /* send traffic to pppd */
+#define SC_MULTILINK    0x00000400      /* do multilink encapsulation */
+#define SC_MP_SHORTSEQ  0x00000800      /* use short MP sequence numbers */
+#define SC_COMP_RUN     0x00001000      /* compressor has been inited */
+#define SC_DECOMP_RUN   0x00002000      /* decompressor has been inited */
+#define SC_MP_XSHORTSEQ 0x00004000      /* transmit short MP seq numbers */
+#define SC_DEBUG        0x00010000      /* enable debug messages */
+#define SC_LOG_INPKT    0x00020000      /* log contents of good pkts recvd */
+#define SC_LOG_OUTPKT   0x00040000      /* log contents of pkts sent */
+#define SC_LOG_RAWIN    0x00080000      /* log all chars received */
+#define SC_LOG_FLUSH    0x00100000      /* log all chars flushed */
+#define SC_SYNC         0x00200000      /* synchronous serial mode */
+#define SC_MUST_COMP    0x00400000      /* no uncompressed packets may be sent or received */
+#define SC_MASK         0x0f600fff      /* bits that user can change */
+
+/* state bits */
+#define SC_XMIT_BUSY    0x10000000      /* (used by isdn_ppp?) */
+#define SC_RCV_ODDP     0x08000000      /* have rcvd char with odd parity */
+#define SC_RCV_EVNP     0x04000000      /* have rcvd char with even parity */
+#define SC_RCV_B7_1     0x02000000      /* have rcvd char with bit 7 = 1 */
+#define SC_RCV_B7_0     0x01000000      /* have rcvd char with bit 7 = 0 */
+#define SC_DC_FERROR    0x00800000      /* fatal decomp error detected */
+#define SC_DC_ERROR     0x00400000      /* non-fatal decomp error detected */
+
+/* Used with PPPIOCGNPMODE/PPPIOCSNPMODE */
+struct npioctl {
+        int             protocol;       /* PPP protocol, e.g. PPP_IP */
+        enum NPmode     mode;
+};
+
+/* Structure describing a CCP configuration option, for PPPIOCSCOMPRESS */
+struct ppp_option_data {
+        __u8    __user *ptr;
+        __u32   length;
+        int     transmit;
+};
+
+/* For PPPIOCGL2TPSTATS */
+struct pppol2tp_ioc_stats {
+        __u16           tunnel_id;      /* redundant */
+        __u16           session_id;     /* if zero, get tunnel stats */
+        __u32           using_ipsec:1;  /* valid only for session_id == 0 */
+        __aligned_u64   tx_packets;
+        __aligned_u64   tx_bytes;
+        __aligned_u64   tx_errors;
+        __aligned_u64   rx_packets;
+        __aligned_u64   rx_bytes;
+        __aligned_u64   rx_seq_discards;
+        __aligned_u64   rx_oos_packets;
+        __aligned_u64   rx_errors;
+};
+
+/*
+ * Ioctl definitions.
+ */
+
+#define PPPIOCGFLAGS    _IOR('t', 90, int)      /* get configuration flags */
+#define PPPIOCSFLAGS    _IOW('t', 89, int)      /* set configuration flags */
+#define PPPIOCGASYNCMAP _IOR('t', 88, int)      /* get async map */
+#define PPPIOCSASYNCMAP _IOW('t', 87, int)      /* set async map */
+#define PPPIOCGUNIT     _IOR('t', 86, int)      /* get ppp unit number */
+#define PPPIOCGRASYNCMAP _IOR('t', 85, int)     /* get receive async map */
+#define PPPIOCSRASYNCMAP _IOW('t', 84, int)     /* set receive async map */
+#define PPPIOCGMRU      _IOR('t', 83, int)      /* get max receive unit */
+#define PPPIOCSMRU      _IOW('t', 82, int)      /* set max receive unit */
+#define PPPIOCSMAXCID   _IOW('t', 81, int)      /* set VJ max slot ID */
+#define PPPIOCGXASYNCMAP _IOR('t', 80, ext_accm) /* get extended ACCM */
+#define PPPIOCSXASYNCMAP _IOW('t', 79, ext_accm) /* set extended ACCM */
+#define PPPIOCXFERUNIT  _IO('t', 78)            /* transfer PPP unit */
+#define PPPIOCSCOMPRESS _IOW('t', 77, struct ppp_option_data)
+#define PPPIOCGNPMODE   _IOWR('t', 76, struct npioctl) /* get NP mode */
+#define PPPIOCSNPMODE   _IOW('t', 75, struct npioctl)  /* set NP mode */
+#define PPPIOCSPASS     _IOW('t', 71, struct sock_fprog) /* set pass filter */
+#define PPPIOCSACTIVE   _IOW('t', 70, struct sock_fprog) /* set active filt */
+#define PPPIOCGDEBUG    _IOR('t', 65, int)      /* Read debug level */
+#define PPPIOCSDEBUG    _IOW('t', 64, int)      /* Set debug level */
+#define PPPIOCGIDLE     _IOR('t', 63, struct ppp_idle) /* get idle time */
+#define PPPIOCNEWUNIT   _IOWR('t', 62, int)     /* create new ppp unit */
+#define PPPIOCATTACH    _IOW('t', 61, int)      /* attach to ppp unit */
+#define PPPIOCDETACH    _IOW('t', 60, int)      /* detach from ppp unit/chan */
+#define PPPIOCSMRRU     _IOW('t', 59, int)      /* set multilink MRU */
+#define PPPIOCCONNECT   _IOW('t', 58, int)      /* connect channel to unit */
+#define PPPIOCDISCONN   _IO('t', 57)            /* disconnect channel */
+#define PPPIOCATTCHAN   _IOW('t', 56, int)      /* attach to ppp channel */
+#define PPPIOCGCHAN     _IOR('t', 55, int)      /* get ppp channel number */
+#define PPPIOCGL2TPSTATS _IOR('t', 54, struct pppol2tp_ioc_stats)
+
+#define SIOCGPPPSTATS   (SIOCDEVPRIVATE + 0)
+#define SIOCGPPPVER     (SIOCDEVPRIVATE + 1)    /* NEVER change this!! */
+#define SIOCGPPPCSTATS  (SIOCDEVPRIVATE + 2)
+
+#endif /* _PPP_IOCTL_H */
diff --git a/include/linux/ppp_defs.h b/include/linux/ppp_defs.h
index 0f93ed6b4a88..ba416f67eb62 100644
--- a/include/linux/ppp_defs.h
+++ b/include/linux/ppp_defs.h
@@ -1,44 +1,14 @@
 /*
  * ppp_defs.h - PPP definitions.
  *
- * Copyright (c) 1994 The Australian National University.
- * All rights reserved.
+ * Copyright 1994-2000 Paul Mackerras.
  *
- * Permission to use, copy, modify, and distribute this software and its
- * documentation is hereby granted, provided that the above copyright
- * notice appears in all copies.  This software is provided without any
- * warranty, express or implied. The Australian National University
- * makes no representations about the suitability of this software for
- * any purpose.
- *
- * IN NO EVENT SHALL THE AUSTRALIAN NATIONAL UNIVERSITY BE LIABLE TO ANY
- * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
- * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
- * THE AUSTRALIAN NATIONAL UNIVERSITY HAVE BEEN ADVISED OF THE POSSIBILITY
- * OF SUCH DAMAGE.
- *
- * THE AUSTRALIAN NATIONAL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
- * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
- * ON AN "AS IS" BASIS, AND THE AUSTRALIAN NATIONAL UNIVERSITY HAS NO
- * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS,
- * OR MODIFICATIONS.
+ *  This program is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public License
+ *  version 2 as published by the Free Software Foundation.
  */
-
 #include <linux/types.h>
 
-/*
- *  ==FILEVERSION 20000114==
- *
- *  NOTE TO MAINTAINERS:
- *     If you modify this file at all, please set the above date.
- *     ppp_defs.h is shipped with a PPP distribution as well as with the kernel;
- *     if everyone increases the FILEVERSION number above, then scripts
- *     can do the right thing when deciding whether to install a new ppp_defs.h
- *     file.  Don't change the format of that line otherwise, so the
- *     installation script can recognize it.
- */
-
 #ifndef _PPP_DEFS_H_
 #define _PPP_DEFS_H_
 
diff --git a/include/linux/prctl.h b/include/linux/prctl.h
index 7ddc7f1b480f..e0cfec2490aa 100644
--- a/include/linux/prctl.h
+++ b/include/linux/prctl.h
@@ -114,4 +114,14 @@
 # define PR_SET_MM_START_BRK            6
 # define PR_SET_MM_BRK                  7
 
+/*
+ * Set specific pid that is allowed to ptrace the current task.
+ * A value of 0 mean "no process".
+ */
+#define PR_SET_PTRACER 0x59616d61
+# define PR_SET_PTRACER_ANY ((unsigned long)-1)
+
+#define PR_SET_CHILD_SUBREAPER 36
+#define PR_GET_CHILD_SUBREAPER 37
+
 #endif /* _LINUX_PRCTL_H */
diff --git a/include/linux/preempt.h b/include/linux/preempt.h
index 58969b2a8a82..5a710b9c578e 100644
--- a/include/linux/preempt.h
+++ b/include/linux/preempt.h
@@ -48,12 +48,14 @@ do { \
         barrier(); \
 } while (0)
 
-#define preempt_enable_no_resched() \
+#define sched_preempt_enable_no_resched() \
 do { \
         barrier(); \
         dec_preempt_count(); \
 } while (0)
 
+#define preempt_enable_no_resched()     sched_preempt_enable_no_resched()
+
 #define preempt_enable() \
 do { \
         preempt_enable_no_resched(); \
@@ -92,6 +94,7 @@ do { \
 #else /* !CONFIG_PREEMPT_COUNT */
 
 #define preempt_disable()               do { } while (0)
+#define sched_preempt_enable_no_resched()       do { } while (0)
 #define preempt_enable_no_resched()     do { } while (0)
 #define preempt_enable()                do { } while (0)
 
diff --git a/include/linux/printk.h b/include/linux/printk.h
index f0e22f75143f..0525927f203f 100644
--- a/include/linux/printk.h
+++ b/include/linux/printk.h
@@ -101,6 +101,11 @@ asmlinkage __printf(1, 2) __cold
 int printk(const char *fmt, ...);
 
 /*
+ * Special printk facility for scheduler use only, _DO_NOT_USE_ !
+ */
+__printf(1, 2) __cold int printk_sched(const char *fmt, ...);
+
+/*
  * Please don't use printk_ratelimit(), because it shares ratelimiting state
  * with all other unrelated printk_ratelimit() callsites.  Instead use
  * printk_ratelimited() or plain old __ratelimit().
@@ -127,6 +132,11 @@ int printk(const char *s, ...)
 {
         return 0;
 }
+static inline __printf(1, 2) __cold
+int printk_sched(const char *s, ...)
+{
+        return 0;
+}
 static inline int printk_ratelimit(void)
 {
         return 0;
@@ -180,13 +190,13 @@ extern void dump_stack(void) __cold;
 #endif
 
 /* If you are writing a driver, please use dev_dbg instead */
-#if defined(DEBUG)
-#define pr_debug(fmt, ...) \
-        printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
-#elif defined(CONFIG_DYNAMIC_DEBUG)
+#if defined(CONFIG_DYNAMIC_DEBUG)
 /* dynamic_pr_debug() uses pr_fmt() internally so we don't need it here */
 #define pr_debug(fmt, ...) \
         dynamic_pr_debug(fmt, ##__VA_ARGS__)
+#elif defined(DEBUG)
+#define pr_debug(fmt, ...) \
+        printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
 #else
 #define pr_debug(fmt, ...) \
         no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
diff --git a/include/linux/ptrace.h b/include/linux/ptrace.h
index c2f1f6a5fcb8..5c719627c2aa 100644
--- a/include/linux/ptrace.h
+++ b/include/linux/ptrace.h
@@ -51,20 +51,6 @@
 #define PTRACE_INTERRUPT        0x4207
 #define PTRACE_LISTEN           0x4208
 
-/* flags in @data for PTRACE_SEIZE */
-#define PTRACE_SEIZE_DEVEL      0x80000000 /* temp flag for development */
-
-/* options set using PTRACE_SETOPTIONS */
-#define PTRACE_O_TRACESYSGOOD   0x00000001
-#define PTRACE_O_TRACEFORK      0x00000002
-#define PTRACE_O_TRACEVFORK     0x00000004
-#define PTRACE_O_TRACECLONE     0x00000008
-#define PTRACE_O_TRACEEXEC      0x00000010
-#define PTRACE_O_TRACEVFORKDONE 0x00000020
-#define PTRACE_O_TRACEEXIT      0x00000040
-
-#define PTRACE_O_MASK           0x0000007f
-
 /* Wait extended result codes for the above trace options.  */
 #define PTRACE_EVENT_FORK       1
 #define PTRACE_EVENT_VFORK      2
@@ -72,7 +58,19 @@
 #define PTRACE_EVENT_EXEC       4
 #define PTRACE_EVENT_VFORK_DONE 5
 #define PTRACE_EVENT_EXIT       6
-#define PTRACE_EVENT_STOP       7
+/* Extended result codes which enabled by means other than options.  */
+#define PTRACE_EVENT_STOP       128
+
+/* Options set using PTRACE_SETOPTIONS or using PTRACE_SEIZE @data param */
+#define PTRACE_O_TRACESYSGOOD   1
+#define PTRACE_O_TRACEFORK      (1 << PTRACE_EVENT_FORK)
+#define PTRACE_O_TRACEVFORK     (1 << PTRACE_EVENT_VFORK)
+#define PTRACE_O_TRACECLONE     (1 << PTRACE_EVENT_CLONE)
+#define PTRACE_O_TRACEEXEC      (1 << PTRACE_EVENT_EXEC)
+#define PTRACE_O_TRACEVFORKDONE (1 << PTRACE_EVENT_VFORK_DONE)
+#define PTRACE_O_TRACEEXIT      (1 << PTRACE_EVENT_EXIT)
+
+#define PTRACE_O_MASK           0x0000007f
 
 #include <asm/ptrace.h>
 
@@ -88,13 +86,12 @@
 #define PT_SEIZED       0x00010000      /* SEIZE used, enable new behavior */
 #define PT_PTRACED      0x00000001
 #define PT_DTRACE       0x00000002      /* delayed trace (used on m68k, i386) */
-#define PT_TRACESYSGOOD 0x00000004
-#define PT_PTRACE_CAP   0x00000008      /* ptracer can follow suid-exec */
+#define PT_PTRACE_CAP   0x00000004      /* ptracer can follow suid-exec */
 
+#define PT_OPT_FLAG_SHIFT       3
 /* PT_TRACE_* event enable flags */
-#define PT_EVENT_FLAG_SHIFT     4
-#define PT_EVENT_FLAG(event)    (1 << (PT_EVENT_FLAG_SHIFT + (event) - 1))
-
+#define PT_EVENT_FLAG(event)    (1 << (PT_OPT_FLAG_SHIFT + (event)))
+#define PT_TRACESYSGOOD         PT_EVENT_FLAG(0)
 #define PT_TRACE_FORK           PT_EVENT_FLAG(PTRACE_EVENT_FORK)
 #define PT_TRACE_VFORK          PT_EVENT_FLAG(PTRACE_EVENT_VFORK)
 #define PT_TRACE_CLONE          PT_EVENT_FLAG(PTRACE_EVENT_CLONE)
@@ -102,8 +99,6 @@
 #define PT_TRACE_VFORK_DONE     PT_EVENT_FLAG(PTRACE_EVENT_VFORK_DONE)
 #define PT_TRACE_EXIT           PT_EVENT_FLAG(PTRACE_EVENT_EXIT)
 
-#define PT_TRACE_MASK   0x000003f4
-
 /* single stepping state bits (used on ARM and PA-RISC) */
 #define PT_SINGLESTEP_BIT       31
 #define PT_SINGLESTEP           (1<<PT_SINGLESTEP_BIT)
@@ -113,6 +108,7 @@
 #include <linux/compiler.h>             /* For unlikely.  */
 #include <linux/sched.h>                /* For struct task_struct.  */
 #include <linux/err.h>                  /* for IS_ERR_VALUE */
+#include <linux/bug.h>                  /* For BUG_ON.  */
 
 
 extern long arch_ptrace(struct task_struct *child, long request,
@@ -199,9 +195,10 @@ static inline void ptrace_event(int event, unsigned long message)
         if (unlikely(ptrace_event_enabled(current, event))) {
                 current->ptrace_message = message;
                 ptrace_notify((event << 8) | SIGTRAP);
-        } else if (event == PTRACE_EVENT_EXEC && unlikely(current->ptrace)) {
+        } else if (event == PTRACE_EVENT_EXEC) {
                 /* legacy EXEC report via SIGTRAP */
-                send_sig(SIGTRAP, current, 0);
+                if ((current->ptrace & (PT_PTRACED|PT_SEIZED)) == PT_PTRACED)
+                        send_sig(SIGTRAP, current, 0);
         }
 }
 
diff --git a/include/linux/qnx6_fs.h b/include/linux/qnx6_fs.h
new file mode 100644
index 000000000000..26049eab9010
--- /dev/null
+++ b/include/linux/qnx6_fs.h
@@ -0,0 +1,134 @@
+/*
+ *  Name                 : qnx6_fs.h
+ *  Author               : Kai Bankett
+ *  Function             : qnx6 global filesystem definitions
+ *  History              : 17-01-2012 created
+ */
+#ifndef _LINUX_QNX6_FS_H
+#define _LINUX_QNX6_FS_H
+
+#include <linux/types.h>
+#include <linux/magic.h>
+
+#define QNX6_ROOT_INO 1
+
+/* for di_status */
+#define QNX6_FILE_DIRECTORY     0x01
+#define QNX6_FILE_DELETED       0x02
+#define QNX6_FILE_NORMAL        0x03
+
+#define QNX6_SUPERBLOCK_SIZE    0x200   /* superblock always is 512 bytes */
+#define QNX6_SUPERBLOCK_AREA    0x1000  /* area reserved for superblock */
+#define QNX6_BOOTBLOCK_SIZE     0x2000  /* heading bootblock area */
+#define QNX6_DIR_ENTRY_SIZE     0x20    /* dir entry size of 32 bytes */
+#define QNX6_INODE_SIZE         0x80    /* each inode is 128 bytes */
+#define QNX6_INODE_SIZE_BITS    7       /* inode entry size shift */
+
+#define QNX6_NO_DIRECT_POINTERS 16      /* 16 blockptrs in sbl/inode */
+#define QNX6_PTR_MAX_LEVELS     5       /* maximum indirect levels */
+
+/* for filenames */
+#define QNX6_SHORT_NAME_MAX     27
+#define QNX6_LONG_NAME_MAX      510
+
+/* list of mount options */
+#define QNX6_MOUNT_MMI_FS       0x010000 /* mount as Audi MMI 3G fs */
+
+/*
+ * This is the original qnx6 inode layout on disk.
+ * Each inode is 128 byte long.
+ */
+struct qnx6_inode_entry {
+        __fs64          di_size;
+        __fs32          di_uid;
+        __fs32          di_gid;
+        __fs32          di_ftime;
+        __fs32          di_mtime;
+        __fs32          di_atime;
+        __fs32          di_ctime;
+        __fs16          di_mode;
+        __fs16          di_ext_mode;
+        __fs32          di_block_ptr[QNX6_NO_DIRECT_POINTERS];
+        __u8            di_filelevels;
+        __u8            di_status;
+        __u8            di_unknown2[2];
+        __fs32          di_zero2[6];
+};
+
+/*
+ * Each directory entry is maximum 32 bytes long.
+ * If more characters or special characters required it is stored
+ * in the longfilenames structure.
+ */
+struct qnx6_dir_entry {
+        __fs32          de_inode;
+        __u8            de_size;
+        char            de_fname[QNX6_SHORT_NAME_MAX];
+};
+
+/*
+ * Longfilename direntries have a different structure
+ */
+struct qnx6_long_dir_entry {
+        __fs32          de_inode;
+        __u8            de_size;
+        __u8            de_unknown[3];
+        __fs32          de_long_inode;
+        __fs32          de_checksum;
+};
+
+struct qnx6_long_filename {
+        __fs16          lf_size;
+        __u8            lf_fname[QNX6_LONG_NAME_MAX];
+};
+
+struct qnx6_root_node {
+        __fs64          size;
+        __fs32          ptr[QNX6_NO_DIRECT_POINTERS];
+        __u8            levels;
+        __u8            mode;
+        __u8            spare[6];
+};
+
+struct qnx6_super_block {
+        __fs32          sb_magic;
+        __fs32          sb_checksum;
+        __fs64          sb_serial;
+        __fs32          sb_ctime;       /* time the fs was created */
+        __fs32          sb_atime;       /* last access time */
+        __fs32          sb_flags;
+        __fs16          sb_version1;    /* filesystem version information */
+        __fs16          sb_version2;    /* filesystem version information */
+        __u8            sb_volumeid[16];
+        __fs32          sb_blocksize;
+        __fs32          sb_num_inodes;
+        __fs32          sb_free_inodes;
+        __fs32          sb_num_blocks;
+        __fs32          sb_free_blocks;
+        __fs32          sb_allocgroup;
+        struct qnx6_root_node Inode;
+        struct qnx6_root_node Bitmap;
+        struct qnx6_root_node Longfile;
+        struct qnx6_root_node Unknown;
+};
+
+/* Audi MMI 3G superblock layout is different to plain qnx6 */
+struct qnx6_mmi_super_block {
+        __fs32          sb_magic;
+        __fs32          sb_checksum;
+        __fs64          sb_serial;
+        __u8            sb_spare0[12];
+        __u8            sb_id[12];
+        __fs32          sb_blocksize;
+        __fs32          sb_num_inodes;
+        __fs32          sb_free_inodes;
+        __fs32          sb_num_blocks;
+        __fs32          sb_free_blocks;
+        __u8            sb_spare1[4];
+        struct qnx6_root_node Inode;
+        struct qnx6_root_node Bitmap;
+        struct qnx6_root_node Longfile;
+        struct qnx6_root_node Unknown;
+};
+
+#endif
diff --git a/include/linux/radix-tree.h b/include/linux/radix-tree.h
index 07e360b1b282..e9a48234e693 100644
--- a/include/linux/radix-tree.h
+++ b/include/linux/radix-tree.h
@@ -22,6 +22,7 @@
 
 #include <linux/preempt.h>
 #include <linux/types.h>
+#include <linux/bug.h>
 #include <linux/kernel.h>
 #include <linux/rcupdate.h>
 
diff --git a/include/linux/raid/md_p.h b/include/linux/raid/md_p.h
index 6f6df86f1ae5..8c0a3adc5df5 100644
--- a/include/linux/raid/md_p.h
+++ b/include/linux/raid/md_p.h
@@ -281,6 +281,10 @@ struct mdp_superblock_1 {
                                             * active device with same 'role'.
                                             * 'recovery_offset' is also set.
                                             */
-#define MD_FEATURE_ALL                  (1|2|4|8|16)
+#define MD_FEATURE_ALL                  (MD_FEATURE_BITMAP_OFFSET       \
+                                        |MD_FEATURE_RECOVERY_OFFSET     \
+                                        |MD_FEATURE_RESHAPE_ACTIVE      \
+                                        |MD_FEATURE_BAD_BLOCKS          \
+                                        |MD_FEATURE_REPLACEMENT)
 
 #endif 
diff --git a/include/linux/rar_register.h b/include/linux/rar_register.h
deleted file mode 100644
index 5c6118189363..000000000000
--- a/include/linux/rar_register.h
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * Copyright (C) 2010 Intel Corporation. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of version 2 of the GNU General
- * Public License as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be
- * useful, but WITHOUT ANY WARRANTY; without even the implied
- * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the GNU General Public License for more details.
- * You should have received a copy of the GNU General Public
- * License along with this program; if not, write to the Free
- * Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA  02111-1307, USA.
- * The full GNU General Public License is included in this
- * distribution in the file called COPYING.
- */
-
-
-#ifndef _RAR_REGISTER_H
-#define _RAR_REGISTER_H
-
-#include <linux/types.h>
-
-/* following are used both in drivers as well as user space apps */
-
-#define RAR_TYPE_VIDEO  0
-#define RAR_TYPE_AUDIO  1
-#define RAR_TYPE_IMAGE  2
-#define RAR_TYPE_DATA   3
-
-#ifdef __KERNEL__
-
-struct rar_device;
-
-#if defined(CONFIG_RAR_REGISTER)
-int register_rar(int num,
-                int (*callback)(unsigned long data), unsigned long data);
-void unregister_rar(int num);
-int rar_get_address(int rar_index, dma_addr_t *start, dma_addr_t *end);
-int rar_lock(int rar_index);
-#else
-extern void unregister_rar(int num)  { }
-extern int rar_lock(int rar_index) { return -EIO; }
-
-extern inline int register_rar(int num,
-                int (*callback)(unsigned long data), unsigned long data)
-{
-        return -ENODEV;
-}
-
-extern int rar_get_address(int rar_index, dma_addr_t *start, dma_addr_t *end)
-{
-        return -ENODEV;
-}
-#endif  /* RAR_REGISTER */
-
-#endif  /* __KERNEL__ */
-#endif  /* _RAR_REGISTER_H */
diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
index 81c04f4348ec..20fb776a1d4a 100644
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -42,6 +42,7 @@
 #include <linux/lockdep.h>
 #include <linux/completion.h>
 #include <linux/debugobjects.h>
+#include <linux/bug.h>
 #include <linux/compiler.h>
 
 #ifdef CONFIG_RCU_TORTURE_TEST
@@ -190,6 +191,33 @@ extern void rcu_idle_exit(void);
 extern void rcu_irq_enter(void);
 extern void rcu_irq_exit(void);
 
+/**
+ * RCU_NONIDLE - Indicate idle-loop code that needs RCU readers
+ * @a: Code that RCU needs to pay attention to.
+ *
+ * RCU, RCU-bh, and RCU-sched read-side critical sections are forbidden
+ * in the inner idle loop, that is, between the rcu_idle_enter() and
+ * the rcu_idle_exit() -- RCU will happily ignore any such read-side
+ * critical sections.  However, things like powertop need tracepoints
+ * in the inner idle loop.
+ *
+ * This macro provides the way out:  RCU_NONIDLE(do_something_with_RCU())
+ * will tell RCU that it needs to pay attending, invoke its argument
+ * (in this example, a call to the do_something_with_RCU() function),
+ * and then tell RCU to go back to ignoring this CPU.  It is permissible
+ * to nest RCU_NONIDLE() wrappers, but the nesting level is currently
+ * quite limited.  If deeper nesting is required, it will be necessary
+ * to adjust DYNTICK_TASK_NESTING_VALUE accordingly.
+ *
+ * This macro may be used from process-level code only.
+ */
+#define RCU_NONIDLE(a) \
+        do { \
+                rcu_idle_exit(); \
+                do { a; } while (0); \
+                rcu_idle_enter(); \
+        } while (0)
+
 /*
  * Infrastructure to implement the synchronize_() primitives in
  * TREE_RCU and rcu_barrier_() primitives in TINY_RCU.
@@ -226,6 +254,15 @@ static inline void destroy_rcu_head_on_stack(struct rcu_head *head)
 }
 #endif  /* #else !CONFIG_DEBUG_OBJECTS_RCU_HEAD */
 
+#if defined(CONFIG_HOTPLUG_CPU) && defined(CONFIG_PROVE_RCU)
+bool rcu_lockdep_current_cpu_online(void);
+#else /* #if defined(CONFIG_HOTPLUG_CPU) && defined(CONFIG_PROVE_RCU) */
+static inline bool rcu_lockdep_current_cpu_online(void)
+{
+        return 1;
+}
+#endif /* #else #if defined(CONFIG_HOTPLUG_CPU) && defined(CONFIG_PROVE_RCU) */
+
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 
 #ifdef CONFIG_PROVE_RCU
@@ -239,13 +276,11 @@ static inline int rcu_is_cpu_idle(void)
 
 static inline void rcu_lock_acquire(struct lockdep_map *map)
 {
-        WARN_ON_ONCE(rcu_is_cpu_idle());
         lock_acquire(map, 0, 0, 2, 1, NULL, _THIS_IP_);
 }
 
 static inline void rcu_lock_release(struct lockdep_map *map)
 {
-        WARN_ON_ONCE(rcu_is_cpu_idle());
         lock_release(map, 1, _THIS_IP_);
 }
 
@@ -270,6 +305,9 @@ extern int debug_lockdep_rcu_enabled(void);
  * occur in the same context, for example, it is illegal to invoke
  * rcu_read_unlock() in process context if the matching rcu_read_lock()
  * was invoked from within an irq handler.
+ *
+ * Note that rcu_read_lock() is disallowed if the CPU is either idle or
+ * offline from an RCU perspective, so check for those as well.
  */
 static inline int rcu_read_lock_held(void)
 {
@@ -277,6 +315,8 @@ static inline int rcu_read_lock_held(void)
                 return 1;
         if (rcu_is_cpu_idle())
                 return 0;
+        if (!rcu_lockdep_current_cpu_online())
+                return 0;
         return lock_is_held(&rcu_lock_map);
 }
 
@@ -313,6 +353,9 @@ extern int rcu_read_lock_bh_held(void);
  * notice an extended quiescent state to other CPUs that started a grace
  * period. Otherwise we would delay any grace period as long as we run in
  * the idle task.
+ *
+ * Similarly, we avoid claiming an SRCU read lock held if the current
+ * CPU is offline.
  */
 #ifdef CONFIG_PREEMPT_COUNT
 static inline int rcu_read_lock_sched_held(void)
@@ -323,6 +366,8 @@ static inline int rcu_read_lock_sched_held(void)
                 return 1;
         if (rcu_is_cpu_idle())
                 return 0;
+        if (!rcu_lockdep_current_cpu_online())
+                return 0;
         if (debug_locks)
                 lockdep_opinion = lock_is_held(&rcu_sched_lock_map);
         return lockdep_opinion || preempt_count() != 0 || irqs_disabled();
@@ -374,15 +419,29 @@ extern int rcu_my_thread_group_empty(void);
  */
 #define rcu_lockdep_assert(c, s)                                        \
         do {                                                            \
-                static bool __warned;                                   \
+                static bool __section(.data.unlikely) __warned;         \
                 if (debug_lockdep_rcu_enabled() && !__warned && !(c)) { \
                         __warned = true;                                \
                         lockdep_rcu_suspicious(__FILE__, __LINE__, s);  \
                 }                                                       \
         } while (0)
 
+#if defined(CONFIG_PROVE_RCU) && !defined(CONFIG_PREEMPT_RCU)
+static inline void rcu_preempt_sleep_check(void)
+{
+        rcu_lockdep_assert(!lock_is_held(&rcu_lock_map),
+                           "Illegal context switch in RCU read-side "
+                           "critical section");
+}
+#else /* #ifdef CONFIG_PROVE_RCU */
+static inline void rcu_preempt_sleep_check(void)
+{
+}
+#endif /* #else #ifdef CONFIG_PROVE_RCU */
+
 #define rcu_sleep_check()                                               \
         do {                                                            \
+                rcu_preempt_sleep_check();                              \
                 rcu_lockdep_assert(!lock_is_held(&rcu_bh_lock_map),     \
                                    "Illegal context switch in RCU-bh"   \
                                    " read-side critical section");      \
@@ -470,6 +529,13 @@ extern int rcu_my_thread_group_empty(void);
  * NULL.  Although rcu_access_pointer() may also be used in cases where
  * update-side locks prevent the value of the pointer from changing, you
  * should instead use rcu_dereference_protected() for this use case.
+ *
+ * It is also permissible to use rcu_access_pointer() when read-side
+ * access to the pointer was removed at least one grace period ago, as
+ * is the case in the context of the RCU callback that is freeing up
+ * the data, or after a synchronize_rcu() returns.  This can be useful
+ * when tearing down multi-linked structures after a grace period
+ * has elapsed.
  */
 #define rcu_access_pointer(p) __rcu_access_pointer((p), __rcu)
 
@@ -659,6 +725,8 @@ static inline void rcu_read_lock(void)
         __rcu_read_lock();
         __acquire(RCU);
         rcu_lock_acquire(&rcu_lock_map);
+        rcu_lockdep_assert(!rcu_is_cpu_idle(),
+                           "rcu_read_lock() used illegally while idle");
 }
 
 /*
@@ -678,6 +746,8 @@ static inline void rcu_read_lock(void)
  */
 static inline void rcu_read_unlock(void)
 {
+        rcu_lockdep_assert(!rcu_is_cpu_idle(),
+                           "rcu_read_unlock() used illegally while idle");
         rcu_lock_release(&rcu_lock_map);
         __release(RCU);
         __rcu_read_unlock();
@@ -705,6 +775,8 @@ static inline void rcu_read_lock_bh(void)
         local_bh_disable();
         __acquire(RCU_BH);
         rcu_lock_acquire(&rcu_bh_lock_map);
+        rcu_lockdep_assert(!rcu_is_cpu_idle(),
+                           "rcu_read_lock_bh() used illegally while idle");
 }
 
 /*
@@ -714,6 +786,8 @@ static inline void rcu_read_lock_bh(void)
  */
 static inline void rcu_read_unlock_bh(void)
 {
+        rcu_lockdep_assert(!rcu_is_cpu_idle(),
+                           "rcu_read_unlock_bh() used illegally while idle");
         rcu_lock_release(&rcu_bh_lock_map);
         __release(RCU_BH);
         local_bh_enable();
@@ -737,6 +811,8 @@ static inline void rcu_read_lock_sched(void)
         preempt_disable();
         __acquire(RCU_SCHED);
         rcu_lock_acquire(&rcu_sched_lock_map);
+        rcu_lockdep_assert(!rcu_is_cpu_idle(),
+                           "rcu_read_lock_sched() used illegally while idle");
 }
 
 /* Used by lockdep and tracing: cannot be traced, cannot call lockdep. */
@@ -753,6 +829,8 @@ static inline notrace void rcu_read_lock_sched_notrace(void)
  */
 static inline void rcu_read_unlock_sched(void)
 {
+        rcu_lockdep_assert(!rcu_is_cpu_idle(),
+                           "rcu_read_unlock_sched() used illegally while idle");
         rcu_lock_release(&rcu_sched_lock_map);
         __release(RCU_SCHED);
         preempt_enable();
@@ -841,7 +919,7 @@ void __kfree_rcu(struct rcu_head *head, unsigned long offset)
         /* See the kfree_rcu() header comment. */
         BUILD_BUG_ON(!__is_kfree_rcu_offset(offset));
 
-        call_rcu(head, (rcu_callback)offset);
+        kfree_call_rcu(head, (rcu_callback)offset);
 }
 
 /**
diff --git a/include/linux/rcutiny.h b/include/linux/rcutiny.h
index 00b7a5e493d2..e93df77176d1 100644
--- a/include/linux/rcutiny.h
+++ b/include/linux/rcutiny.h
@@ -27,13 +27,9 @@
 
 #include <linux/cache.h>
 
-#ifdef CONFIG_RCU_BOOST
 static inline void rcu_init(void)
 {
 }
-#else /* #ifdef CONFIG_RCU_BOOST */
-void rcu_init(void);
-#endif /* #else #ifdef CONFIG_RCU_BOOST */
 
 static inline void rcu_barrier_bh(void)
 {
@@ -83,6 +79,12 @@ static inline void synchronize_sched_expedited(void)
         synchronize_sched();
 }
 
+static inline void kfree_call_rcu(struct rcu_head *head,
+                                  void (*func)(struct rcu_head *rcu))
+{
+        call_rcu(head, func);
+}
+
 #ifdef CONFIG_TINY_RCU
 
 static inline void rcu_preempt_note_context_switch(void)
diff --git a/include/linux/rcutree.h b/include/linux/rcutree.h
index 67458468f1a8..e8ee5dd0854c 100644
--- a/include/linux/rcutree.h
+++ b/include/linux/rcutree.h
@@ -61,6 +61,24 @@ extern void synchronize_rcu_bh(void);
 extern void synchronize_sched_expedited(void);
 extern void synchronize_rcu_expedited(void);
 
+void kfree_call_rcu(struct rcu_head *head, void (*func)(struct rcu_head *rcu));
+
+/**
+ * synchronize_rcu_bh_expedited - Brute-force RCU-bh grace period
+ *
+ * Wait for an RCU-bh grace period to elapse, but use a "big hammer"
+ * approach to force the grace period to end quickly.  This consumes
+ * significant time on all CPUs and is unfriendly to real-time workloads,
+ * so is thus not recommended for any sort of common-case code.  In fact,
+ * if you are using synchronize_rcu_bh_expedited() in a loop, please
+ * restructure your code to batch your updates, and then use a single
+ * synchronize_rcu_bh() instead.
+ *
+ * Note that it is illegal to call this function while holding any lock
+ * that is acquired by a CPU-hotplug notifier.  And yes, it is also illegal
+ * to call this function from a CPU-hotplug notifier.  Failing to observe
+ * these restriction will result in deadlock.
+ */
 static inline void synchronize_rcu_bh_expedited(void)
 {
         synchronize_sched_expedited();
@@ -83,6 +101,7 @@ extern void rcu_sched_force_quiescent_state(void);
 /* A context switch is a grace period for RCU-sched and RCU-bh. */
 static inline int rcu_blocking_is_gp(void)
 {
+        might_sleep();  /* Check for RCU read-side critical section. */
         return num_online_cpus() == 1;
 }
 
diff --git a/include/linux/regmap.h b/include/linux/regmap.h
index eb93921cdd30..a90abb6bfa64 100644
--- a/include/linux/regmap.h
+++ b/include/linux/regmap.h
@@ -13,12 +13,13 @@
  * published by the Free Software Foundation.
  */
 
-#include <linux/device.h>
 #include <linux/list.h>
 
 struct module;
+struct device;
 struct i2c_client;
 struct spi_device;
+struct regmap;
 
 /* An enum of all the supported cache types */
 enum regcache_type {
@@ -40,10 +41,13 @@ struct reg_default {
         unsigned int def;
 };
 
+#ifdef CONFIG_REGMAP
+
 /**
  * Configuration for the register map of a device.
  *
  * @reg_bits: Number of bits in a register address, mandatory.
+ * @pad_bits: Number of bits of padding between register and value.
  * @val_bits: Number of bits in a register value, mandatory.
  *
  * @writeable_reg: Optional callback returning true if the register
@@ -74,6 +78,7 @@ struct reg_default {
  */
 struct regmap_config {
         int reg_bits;
+        int pad_bits;
         int val_bits;
 
         bool (*writeable_reg)(struct device *dev, unsigned int reg);
@@ -127,12 +132,22 @@ struct regmap *regmap_init_i2c(struct i2c_client *i2c,
 struct regmap *regmap_init_spi(struct spi_device *dev,
                                const struct regmap_config *config);
 
+struct regmap *devm_regmap_init(struct device *dev,
+                                const struct regmap_bus *bus,
+                                const struct regmap_config *config);
+struct regmap *devm_regmap_init_i2c(struct i2c_client *i2c,
+                                    const struct regmap_config *config);
+struct regmap *devm_regmap_init_spi(struct spi_device *dev,
+                                    const struct regmap_config *config);
+
 void regmap_exit(struct regmap *map);
 int regmap_reinit_cache(struct regmap *map,
                         const struct regmap_config *config);
 int regmap_write(struct regmap *map, unsigned int reg, unsigned int val);
 int regmap_raw_write(struct regmap *map, unsigned int reg,
                      const void *val, size_t val_len);
+int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
+                        size_t val_count);
 int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val);
 int regmap_raw_read(struct regmap *map, unsigned int reg,
                     void *val, size_t val_len);
@@ -143,12 +158,18 @@ int regmap_update_bits(struct regmap *map, unsigned int reg,
 int regmap_update_bits_check(struct regmap *map, unsigned int reg,
                              unsigned int mask, unsigned int val,
                              bool *change);
+int regmap_get_val_bytes(struct regmap *map);
 
 int regcache_sync(struct regmap *map);
+int regcache_sync_region(struct regmap *map, unsigned int min,
+                         unsigned int max);
 void regcache_cache_only(struct regmap *map, bool enable);
 void regcache_cache_bypass(struct regmap *map, bool enable);
 void regcache_mark_dirty(struct regmap *map);
 
+int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
+                          int num_regs);
+
 /**
  * Description of an IRQ for the generic regmap irq_chip.
  *
@@ -197,4 +218,115 @@ int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
 void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *data);
 int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data);
 
+#else
+
+/*
+ * These stubs should only ever be called by generic code which has
+ * regmap based facilities, if they ever get called at runtime
+ * something is going wrong and something probably needs to select
+ * REGMAP.
+ */
+
+static inline int regmap_write(struct regmap *map, unsigned int reg,
+                               unsigned int val)
+{
+        WARN_ONCE(1, "regmap API is disabled");
+        return -EINVAL;
+}
+
+static inline int regmap_raw_write(struct regmap *map, unsigned int reg,
+                                   const void *val, size_t val_len)
+{
+        WARN_ONCE(1, "regmap API is disabled");
+        return -EINVAL;
+}
+
+static inline int regmap_bulk_write(struct regmap *map, unsigned int reg,
+                                    const void *val, size_t val_count)
+{
+        WARN_ONCE(1, "regmap API is disabled");
+        return -EINVAL;
+}
+
+static inline int regmap_read(struct regmap *map, unsigned int reg,
+                              unsigned int *val)
+{
+        WARN_ONCE(1, "regmap API is disabled");
+        return -EINVAL;
+}
+
+static inline int regmap_raw_read(struct regmap *map, unsigned int reg,
+                                  void *val, size_t val_len)
+{
+        WARN_ONCE(1, "regmap API is disabled");
+        return -EINVAL;
+}
+
+static inline int regmap_bulk_read(struct regmap *map, unsigned int reg,
+                                   void *val, size_t val_count)
+{
+        WARN_ONCE(1, "regmap API is disabled");
+        return -EINVAL;
+}
+
+static inline int regmap_update_bits(struct regmap *map, unsigned int reg,
+                                     unsigned int mask, unsigned int val)
+{
+        WARN_ONCE(1, "regmap API is disabled");
+        return -EINVAL;
+}
+
+static inline int regmap_update_bits_check(struct regmap *map,
+                                           unsigned int reg,
+                                           unsigned int mask, unsigned int val,
+                                           bool *change)
+{
+        WARN_ONCE(1, "regmap API is disabled");
+        return -EINVAL;
+}
+
+static inline int regmap_get_val_bytes(struct regmap *map)
+{
+        WARN_ONCE(1, "regmap API is disabled");
+        return -EINVAL;
+}
+
+static inline int regcache_sync(struct regmap *map)
+{
+        WARN_ONCE(1, "regmap API is disabled");
+        return -EINVAL;
+}
+
+static inline int regcache_sync_region(struct regmap *map, unsigned int min,
+                                       unsigned int max)
+{
+        WARN_ONCE(1, "regmap API is disabled");
+        return -EINVAL;
+}
+
+static inline void regcache_cache_only(struct regmap *map, bool enable)
+{
+        WARN_ONCE(1, "regmap API is disabled");
+}
+
+static inline void regcache_cache_bypass(struct regmap *map, bool enable)
+{
+        WARN_ONCE(1, "regmap API is disabled");
+}
+
+static inline void regcache_mark_dirty(struct regmap *map)
+{
+        WARN_ONCE(1, "regmap API is disabled");
+}
+
+static inline int regmap_register_patch(struct regmap *map,
+                                        const struct reg_default *regs,
+                                        int num_regs)
+{
+        WARN_ONCE(1, "regmap API is disabled");
+        return -EINVAL;
+}
+
+#endif
+
 #endif
diff --git a/include/linux/regset.h b/include/linux/regset.h
index 686f37327a49..8e0c9febf495 100644
--- a/include/linux/regset.h
+++ b/include/linux/regset.h
@@ -15,6 +15,7 @@
 
 #include <linux/compiler.h>
 #include <linux/types.h>
+#include <linux/bug.h>
 #include <linux/uaccess.h>
 struct task_struct;
 struct user_regset;
diff --git a/include/linux/regulator/ab8500.h b/include/linux/regulator/ab8500.h
index 76579f964a29..7bd73bbdfd1b 100644
--- a/include/linux/regulator/ab8500.h
+++ b/include/linux/regulator/ab8500.h
@@ -26,7 +26,26 @@ enum ab8500_regulator_id {
         AB8500_NUM_REGULATORS,
 };
 
-/* AB8500 register initialization */
+/* AB9450 regulators */
+enum ab9540_regulator_id {
+        AB9540_LDO_AUX1,
+        AB9540_LDO_AUX2,
+        AB9540_LDO_AUX3,
+        AB9540_LDO_AUX4,
+        AB9540_LDO_INTCORE,
+        AB9540_LDO_TVOUT,
+        AB9540_LDO_USB,
+        AB9540_LDO_AUDIO,
+        AB9540_LDO_ANAMIC1,
+        AB9540_LDO_ANAMIC2,
+        AB9540_LDO_DMIC,
+        AB9540_LDO_ANA,
+        AB9540_SYSCLKREQ_2,
+        AB9540_SYSCLKREQ_4,
+        AB9540_NUM_REGULATORS,
+};
+
+/* AB8500 and AB9540 register initialization */
 struct ab8500_regulator_reg_init {
         int id;
         u8 value;
@@ -71,4 +90,53 @@ enum ab8500_regulator_reg {
         AB8500_NUM_REGULATOR_REGISTERS,
 };
 
+
+/* AB9540 registers */
+enum ab9540_regulator_reg {
+        AB9540_REGUREQUESTCTRL1,
+        AB9540_REGUREQUESTCTRL2,
+        AB9540_REGUREQUESTCTRL3,
+        AB9540_REGUREQUESTCTRL4,
+        AB9540_REGUSYSCLKREQ1HPVALID1,
+        AB9540_REGUSYSCLKREQ1HPVALID2,
+        AB9540_REGUHWHPREQ1VALID1,
+        AB9540_REGUHWHPREQ1VALID2,
+        AB9540_REGUHWHPREQ2VALID1,
+        AB9540_REGUHWHPREQ2VALID2,
+        AB9540_REGUSWHPREQVALID1,
+        AB9540_REGUSWHPREQVALID2,
+        AB9540_REGUSYSCLKREQVALID1,
+        AB9540_REGUSYSCLKREQVALID2,
+        AB9540_REGUVAUX4REQVALID,
+        AB9540_REGUMISC1,
+        AB9540_VAUDIOSUPPLY,
+        AB9540_REGUCTRL1VAMIC,
+        AB9540_VSMPS1REGU,
+        AB9540_VSMPS2REGU,
+        AB9540_VSMPS3REGU, /* NOTE! PRCMU register */
+        AB9540_VPLLVANAREGU,
+        AB9540_EXTSUPPLYREGU,
+        AB9540_VAUX12REGU,
+        AB9540_VRF1VAUX3REGU,
+        AB9540_VSMPS1SEL1,
+        AB9540_VSMPS1SEL2,
+        AB9540_VSMPS1SEL3,
+        AB9540_VSMPS2SEL1,
+        AB9540_VSMPS2SEL2,
+        AB9540_VSMPS2SEL3,
+        AB9540_VSMPS3SEL1, /* NOTE! PRCMU register */
+        AB9540_VSMPS3SEL2, /* NOTE! PRCMU register */
+        AB9540_VAUX1SEL,
+        AB9540_VAUX2SEL,
+        AB9540_VRF1VAUX3SEL,
+        AB9540_REGUCTRL2SPARE,
+        AB9540_VAUX4REQCTRL,
+        AB9540_VAUX4REGU,
+        AB9540_VAUX4SEL,
+        AB9540_REGUCTRLDISCH,
+        AB9540_REGUCTRLDISCH2,
+        AB9540_REGUCTRLDISCH3,
+        AB9540_NUM_REGULATOR_REGISTERS,
+};
+
 #endif
diff --git a/include/linux/regulator/bq24022.h b/include/linux/regulator/bq24022.h
deleted file mode 100644
index a6d014005d49..000000000000
--- a/include/linux/regulator/bq24022.h
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * Support for TI bq24022 (bqTINY-II) Dual Input (USB/AC Adpater)
- * 1-Cell Li-Ion Charger connected via GPIOs.
- *
- * Copyright (c) 2008 Philipp Zabel
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- */
-
-struct regulator_init_data;
-
-/**
- * bq24022_mach_info - platform data for bq24022
- * @gpio_nce: GPIO line connected to the nCE pin, used to enable / disable charging
- * @gpio_iset2: GPIO line connected to the ISET2 pin, used to limit charging current to 100 mA / 500 mA
- */
-struct bq24022_mach_info {
-        int gpio_nce;
-        int gpio_iset2;
-        struct regulator_init_data *init_data;
-};
diff --git a/include/linux/regulator/consumer.h b/include/linux/regulator/consumer.h
index f2698a0edfc4..4ed1b30ac5fc 100644
--- a/include/linux/regulator/consumer.h
+++ b/include/linux/regulator/consumer.h
@@ -35,7 +35,8 @@
 #ifndef __LINUX_REGULATOR_CONSUMER_H_
 #define __LINUX_REGULATOR_CONSUMER_H_
 
-#include <linux/device.h>
+struct device;
+struct notifier_block;
 
 /*
  * Regulator operating modes.
@@ -132,9 +133,12 @@ struct regulator_bulk_data {
 /* regulator get and put */
 struct regulator *__must_check regulator_get(struct device *dev,
                                              const char *id);
+struct regulator *__must_check devm_regulator_get(struct device *dev,
+                                             const char *id);
 struct regulator *__must_check regulator_get_exclusive(struct device *dev,
                                                        const char *id);
 void regulator_put(struct regulator *regulator);
+void devm_regulator_put(struct regulator *regulator);
 
 /* regulator output control and status */
 int regulator_enable(struct regulator *regulator);
@@ -145,6 +149,8 @@ int regulator_disable_deferred(struct regulator *regulator, int ms);
 
 int regulator_bulk_get(struct device *dev, int num_consumers,
                        struct regulator_bulk_data *consumers);
+int devm_regulator_bulk_get(struct device *dev, int num_consumers,
+                            struct regulator_bulk_data *consumers);
 int regulator_bulk_enable(int num_consumers,
                           struct regulator_bulk_data *consumers);
 int regulator_bulk_disable(int num_consumers,
@@ -200,10 +206,21 @@ static inline struct regulator *__must_check regulator_get(struct device *dev,
          */
         return NULL;
 }
+
+static inline struct regulator *__must_check
+devm_regulator_get(struct device *dev, const char *id)
+{
+        return NULL;
+}
+
 static inline void regulator_put(struct regulator *regulator)
 {
 }
 
+static inline void devm_regulator_put(struct regulator *regulator)
+{
+}
+
 static inline int regulator_enable(struct regulator *regulator)
 {
         return 0;
@@ -237,6 +254,12 @@ static inline int regulator_bulk_get(struct device *dev,
         return 0;
 }
 
+static inline int devm_regulator_bulk_get(struct device *dev, int num_consumers,
+                                          struct regulator_bulk_data *consumers)
+{
+        return 0;
+}
+
 static inline int regulator_bulk_enable(int num_consumers,
                                         struct regulator_bulk_data *consumers)
 {
diff --git a/include/linux/regulator/driver.h b/include/linux/regulator/driver.h
index 4214b9a9d1c9..fa8b55b8191c 100644
--- a/include/linux/regulator/driver.h
+++ b/include/linux/regulator/driver.h
@@ -104,7 +104,7 @@ struct regulator_ops {
         int (*disable) (struct regulator_dev *);
         int (*is_enabled) (struct regulator_dev *);
 
-        /* get/set regulator operating mode (defined in regulator.h) */
+        /* get/set regulator operating mode (defined in consumer.h) */
         int (*set_mode) (struct regulator_dev *, unsigned int mode);
         unsigned int (*get_mode) (struct regulator_dev *);
 
@@ -135,7 +135,7 @@ struct regulator_ops {
         int (*set_suspend_enable) (struct regulator_dev *);
         int (*set_suspend_disable) (struct regulator_dev *);
 
-        /* set regulator suspend operating mode (defined in regulator.h) */
+        /* set regulator suspend operating mode (defined in consumer.h) */
         int (*set_suspend_mode) (struct regulator_dev *, unsigned int mode);
 };
 
@@ -207,9 +207,7 @@ struct regulator_dev {
 
         void *reg_data;         /* regulator_dev data */
 
-#ifdef CONFIG_DEBUG_FS
         struct dentry *debugfs;
-#endif
 };
 
 struct regulator_dev *regulator_register(struct regulator_desc *regulator_desc,
diff --git a/include/linux/regulator/fixed.h b/include/linux/regulator/fixed.h
index ffd7d508e726..936a7d8c11a9 100644
--- a/include/linux/regulator/fixed.h
+++ b/include/linux/regulator/fixed.h
@@ -48,4 +48,17 @@ struct fixed_voltage_config {
         struct regulator_init_data *init_data;
 };
 
+struct regulator_consumer_supply;
+
+#if IS_ENABLED(CONFIG_REGULATOR)
+struct platform_device *regulator_register_fixed(int id,
+                struct regulator_consumer_supply *supplies, int num_supplies);
+#else
+static inline struct platform_device *regulator_register_fixed(int id,
+                struct regulator_consumer_supply *supplies, int num_supplies)
+{
+        return NULL;
+}
+#endif
+
 #endif
diff --git a/include/linux/regulator/machine.h b/include/linux/regulator/machine.h
index f3f13fd5868f..7abb16093312 100644
--- a/include/linux/regulator/machine.h
+++ b/include/linux/regulator/machine.h
@@ -139,12 +139,10 @@ struct regulation_constraints {
  * make struct device available late such as I2C and is the preferred
  * form.
  *
- * @dev: Device structure for the consumer.
  * @dev_name: Result of dev_name() for the consumer.
  * @supply: Name for the supply.
  */
 struct regulator_consumer_supply {
-        struct device *dev;     /* consumer */
         const char *dev_name;   /* dev_name() for consumer */
         const char *supply;     /* consumer supply - e.g. "vcc" */
 };
diff --git a/include/linux/regulator/tps62360.h b/include/linux/regulator/tps62360.h
new file mode 100644
index 000000000000..6a5c1b2c751e
--- /dev/null
+++ b/include/linux/regulator/tps62360.h
@@ -0,0 +1,57 @@
+/*
+ * tps62360.h -- TI tps62360
+ *
+ * Interface for regulator driver for TI TPS62360 Processor core supply
+ *
+ * Copyright (C) 2012 NVIDIA Corporation
+
+ * Author: Laxman Dewangan <ldewangan@nvidia.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#ifndef __LINUX_REGULATOR_TPS62360_H
+#define __LINUX_REGULATOR_TPS62360_H
+
+#include <linux/regulator/machine.h>
+
+/*
+ * struct tps62360_regulator_platform_data - tps62360 regulator platform data.
+ *
+ * @reg_init_data: The regulator init data.
+ * @en_force_pwm: Enable force pwm or not.
+ * @en_discharge: Enable discharge the output capacitor via internal
+ *                register.
+ * @en_internal_pulldn: internal pull down enable or not.
+ * @vsel0_gpio: Gpio number for vsel0. It should be -1 if this is tied with
+ *              fixed logic.
+ * @vsel1_gpio: Gpio number for vsel1. It should be -1 if this is tied with
+ *              fixed logic.
+ * @vsel0_def_state: Default state of vsel0. 1 if it is high else 0.
+ * @vsel1_def_state: Default state of vsel1. 1 if it is high else 0.
+ */
+struct tps62360_regulator_platform_data {
+        struct regulator_init_data reg_init_data;
+        bool en_force_pwm;
+        bool en_discharge;
+        bool en_internal_pulldn;
+        int vsel0_gpio;
+        int vsel1_gpio;
+        int vsel0_def_state;
+        int vsel1_def_state;
+};
+
+#endif /* __LINUX_REGULATOR_TPS62360_H */
diff --git a/include/linux/reiserfs_acl.h b/include/linux/reiserfs_acl.h
deleted file mode 100644
index f096b80e73d8..000000000000
--- a/include/linux/reiserfs_acl.h
+++ /dev/null
@@ -1,76 +0,0 @@
-#include <linux/init.h>
-#include <linux/posix_acl.h>
-
-#define REISERFS_ACL_VERSION    0x0001
-
-typedef struct {
-        __le16 e_tag;
-        __le16 e_perm;
-        __le32 e_id;
-} reiserfs_acl_entry;
-
-typedef struct {
-        __le16 e_tag;
-        __le16 e_perm;
-} reiserfs_acl_entry_short;
-
-typedef struct {
-        __le32 a_version;
-} reiserfs_acl_header;
-
-static inline size_t reiserfs_acl_size(int count)
-{
-        if (count <= 4) {
-                return sizeof(reiserfs_acl_header) +
-                    count * sizeof(reiserfs_acl_entry_short);
-        } else {
-                return sizeof(reiserfs_acl_header) +
-                    4 * sizeof(reiserfs_acl_entry_short) +
-                    (count - 4) * sizeof(reiserfs_acl_entry);
-        }
-}
-
-static inline int reiserfs_acl_count(size_t size)
-{
-        ssize_t s;
-        size -= sizeof(reiserfs_acl_header);
-        s = size - 4 * sizeof(reiserfs_acl_entry_short);
-        if (s < 0) {
-                if (size % sizeof(reiserfs_acl_entry_short))
-                        return -1;
-                return size / sizeof(reiserfs_acl_entry_short);
-        } else {
-                if (s % sizeof(reiserfs_acl_entry))
-                        return -1;
-                return s / sizeof(reiserfs_acl_entry) + 4;
-        }
-}
-
-#ifdef CONFIG_REISERFS_FS_POSIX_ACL
-struct posix_acl *reiserfs_get_acl(struct inode *inode, int type);
-int reiserfs_acl_chmod(struct inode *inode);
-int reiserfs_inherit_default_acl(struct reiserfs_transaction_handle *th,
-                                 struct inode *dir, struct dentry *dentry,
-                                 struct inode *inode);
-int reiserfs_cache_default_acl(struct inode *dir);
-extern const struct xattr_handler reiserfs_posix_acl_default_handler;
-extern const struct xattr_handler reiserfs_posix_acl_access_handler;
-
-#else
-
-#define reiserfs_cache_default_acl(inode) 0
-#define reiserfs_get_acl NULL
-
-static inline int reiserfs_acl_chmod(struct inode *inode)
-{
-        return 0;
-}
-
-static inline int
-reiserfs_inherit_default_acl(struct reiserfs_transaction_handle *th,
-                             const struct inode *dir, struct dentry *dentry,
-                             struct inode *inode)
-{
-        return 0;
-}
-#endif
diff --git a/include/linux/reiserfs_fs.h b/include/linux/reiserfs_fs.h
index 2213ddcce20c..ea3700cd7367 100644
--- a/include/linux/reiserfs_fs.h
+++ b/include/linux/reiserfs_fs.h
@@ -1,32 +1,12 @@
 /*
  * Copyright 1996, 1997, 1998 Hans Reiser, see reiserfs/README for licensing and copyright details
  */
-
-                                /* this file has an amazingly stupid
-                                   name, yura please fix it to be
-                                   reiserfs.h, and merge all the rest
-                                   of our .h files that are in this
-                                   directory into it.  */
-
 #ifndef _LINUX_REISER_FS_H
 #define _LINUX_REISER_FS_H
 
 #include <linux/types.h>
 #include <linux/magic.h>
 
-#ifdef __KERNEL__
-#include <linux/slab.h>
-#include <linux/interrupt.h>
-#include <linux/sched.h>
-#include <linux/workqueue.h>
-#include <asm/unaligned.h>
-#include <linux/bitops.h>
-#include <linux/proc_fs.h>
-#include <linux/buffer_head.h>
-#include <linux/reiserfs_fs_i.h>
-#include <linux/reiserfs_fs_sb.h>
-#endif
-
 /*
  *  include/linux/reiser_fs.h
  *
@@ -43,2318 +23,4 @@
 #define REISERFS_IOC_GETVERSION         FS_IOC_GETVERSION
 #define REISERFS_IOC_SETVERSION         FS_IOC_SETVERSION
 
-#ifdef __KERNEL__
-/* the 32 bit compat definitions with int argument */
-#define REISERFS_IOC32_UNPACK           _IOW(0xCD, 1, int)
-#define REISERFS_IOC32_GETFLAGS         FS_IOC32_GETFLAGS
-#define REISERFS_IOC32_SETFLAGS         FS_IOC32_SETFLAGS
-#define REISERFS_IOC32_GETVERSION       FS_IOC32_GETVERSION
-#define REISERFS_IOC32_SETVERSION       FS_IOC32_SETVERSION
-
-/*
- * Locking primitives. The write lock is a per superblock
- * special mutex that has properties close to the Big Kernel Lock
- * which was used in the previous locking scheme.
- */
-void reiserfs_write_lock(struct super_block *s);
-void reiserfs_write_unlock(struct super_block *s);
-int reiserfs_write_lock_once(struct super_block *s);
-void reiserfs_write_unlock_once(struct super_block *s, int lock_depth);
-
-#ifdef CONFIG_REISERFS_CHECK
-void reiserfs_lock_check_recursive(struct super_block *s);
-#else
-static inline void reiserfs_lock_check_recursive(struct super_block *s) { }
-#endif
-
-/*
- * Several mutexes depend on the write lock.
- * However sometimes we want to relax the write lock while we hold
- * these mutexes, according to the release/reacquire on schedule()
- * properties of the Bkl that were used.
- * Reiserfs performances and locking were based on this scheme.
- * Now that the write lock is a mutex and not the bkl anymore, doing so
- * may result in a deadlock:
- *
- * A acquire write_lock
- * A acquire j_commit_mutex
- * A release write_lock and wait for something
- * B acquire write_lock
- * B can't acquire j_commit_mutex and sleep
- * A can't acquire write lock anymore
- * deadlock
- *
- * What we do here is avoiding such deadlock by playing the same game
- * than the Bkl: if we can't acquire a mutex that depends on the write lock,
- * we release the write lock, wait a bit and then retry.
- *
- * The mutexes concerned by this hack are:
- * - The commit mutex of a journal list
- * - The flush mutex
- * - The journal lock
- * - The inode mutex
- */
-static inline void reiserfs_mutex_lock_safe(struct mutex *m,
-                               struct super_block *s)
-{
-        reiserfs_lock_check_recursive(s);
-        reiserfs_write_unlock(s);
-        mutex_lock(m);
-        reiserfs_write_lock(s);
-}
-
-static inline void
-reiserfs_mutex_lock_nested_safe(struct mutex *m, unsigned int subclass,
-                               struct super_block *s)
-{
-        reiserfs_lock_check_recursive(s);
-        reiserfs_write_unlock(s);
-        mutex_lock_nested(m, subclass);
-        reiserfs_write_lock(s);
-}
-
-static inline void
-reiserfs_down_read_safe(struct rw_semaphore *sem, struct super_block *s)
-{
-        reiserfs_lock_check_recursive(s);
-        reiserfs_write_unlock(s);
-        down_read(sem);
-        reiserfs_write_lock(s);
-}
-
-/*
- * When we schedule, we usually want to also release the write lock,
- * according to the previous bkl based locking scheme of reiserfs.
- */
-static inline void reiserfs_cond_resched(struct super_block *s)
-{
-        if (need_resched()) {
-                reiserfs_write_unlock(s);
-                schedule();
-                reiserfs_write_lock(s);
-        }
-}
-
-struct fid;
-
-/* in reading the #defines, it may help to understand that they employ
-   the following abbreviations:
-
-   B = Buffer
-   I = Item header
-   H = Height within the tree (should be changed to LEV)
-   N = Number of the item in the node
-   STAT = stat data
-   DEH = Directory Entry Header
-   EC = Entry Count
-   E = Entry number
-   UL = Unsigned Long
-   BLKH = BLocK Header
-   UNFM = UNForMatted node
-   DC = Disk Child
-   P = Path
-
-   These #defines are named by concatenating these abbreviations,
-   where first comes the arguments, and last comes the return value,
-   of the macro.
-
-*/
-
-#define USE_INODE_GENERATION_COUNTER
-
-#define REISERFS_PREALLOCATE
-#define DISPLACE_NEW_PACKING_LOCALITIES
-#define PREALLOCATION_SIZE 9
-
-/* n must be power of 2 */
-#define _ROUND_UP(x,n) (((x)+(n)-1u) & ~((n)-1u))
-
-// to be ok for alpha and others we have to align structures to 8 byte
-// boundary.
-// FIXME: do not change 4 by anything else: there is code which relies on that
-#define ROUND_UP(x) _ROUND_UP(x,8LL)
-
-/* debug levels.  Right now, CONFIG_REISERFS_CHECK means print all debug
-** messages.
-*/
-#define REISERFS_DEBUG_CODE 5   /* extra messages to help find/debug errors */
-
-void __reiserfs_warning(struct super_block *s, const char *id,
-                         const char *func, const char *fmt, ...);
-#define reiserfs_warning(s, id, fmt, args...) \
-         __reiserfs_warning(s, id, __func__, fmt, ##args)
-/* assertions handling */
-
-/** always check a condition and panic if it's false. */
-#define __RASSERT(cond, scond, format, args...)                 \
-do {                                                                    \
-        if (!(cond))                                                    \
-                reiserfs_panic(NULL, "assertion failure", "(" #cond ") at " \
-                               __FILE__ ":%i:%s: " format "\n",         \
-                               in_interrupt() ? -1 : task_pid_nr(current), \
-                               __LINE__, __func__ , ##args);            \
-} while (0)
-
-#define RASSERT(cond, format, args...) __RASSERT(cond, #cond, format, ##args)
-
-#if defined( CONFIG_REISERFS_CHECK )
-#define RFALSE(cond, format, args...) __RASSERT(!(cond), "!(" #cond ")", format, ##args)
-#else
-#define RFALSE( cond, format, args... ) do {;} while( 0 )
-#endif
-
-#define CONSTF __attribute_const__
-/*
- * Disk Data Structures
- */
-
-/***************************************************************************/
-/*                             SUPER BLOCK                                 */
-/***************************************************************************/
-
-/*
- * Structure of super block on disk, a version of which in RAM is often accessed as REISERFS_SB(s)->s_rs
- * the version in RAM is part of a larger structure containing fields never written to disk.
- */
-#define UNSET_HASH 0            // read_super will guess about, what hash names
-                     // in directories were sorted with
-#define TEA_HASH  1
-#define YURA_HASH 2
-#define R5_HASH   3
-#define DEFAULT_HASH R5_HASH
-
-struct journal_params {
-        __le32 jp_journal_1st_block;    /* where does journal start from on its
-                                         * device */
-        __le32 jp_journal_dev;  /* journal device st_rdev */
-        __le32 jp_journal_size; /* size of the journal */
-        __le32 jp_journal_trans_max;    /* max number of blocks in a transaction. */
-        __le32 jp_journal_magic;        /* random value made on fs creation (this
-                                         * was sb_journal_block_count) */
-        __le32 jp_journal_max_batch;    /* max number of blocks to batch into a
-                                         * trans */
-        __le32 jp_journal_max_commit_age;       /* in seconds, how old can an async
-                                                 * commit be */
-        __le32 jp_journal_max_trans_age;        /* in seconds, how old can a transaction
-                                                 * be */
-};
-
-/* this is the super from 3.5.X, where X >= 10 */
-struct reiserfs_super_block_v1 {
-        __le32 s_block_count;   /* blocks count         */
-        __le32 s_free_blocks;   /* free blocks count    */
-        __le32 s_root_block;    /* root block number    */
-        struct journal_params s_journal;
-        __le16 s_blocksize;     /* block size */
-        __le16 s_oid_maxsize;   /* max size of object id array, see
-                                 * get_objectid() commentary  */
-        __le16 s_oid_cursize;   /* current size of object id array */
-        __le16 s_umount_state;  /* this is set to 1 when filesystem was
-                                 * umounted, to 2 - when not */
-        char s_magic[10];       /* reiserfs magic string indicates that
-                                 * file system is reiserfs:
-                                 * "ReIsErFs" or "ReIsEr2Fs" or "ReIsEr3Fs" */
-        __le16 s_fs_state;      /* it is set to used by fsck to mark which
-                                 * phase of rebuilding is done */
-        __le32 s_hash_function_code;    /* indicate, what hash function is being use
-                                         * to sort names in a directory*/
-        __le16 s_tree_height;   /* height of disk tree */
-        __le16 s_bmap_nr;       /* amount of bitmap blocks needed to address
-                                 * each block of file system */
-        __le16 s_version;       /* this field is only reliable on filesystem
-                                 * with non-standard journal */
-        __le16 s_reserved_for_journal;  /* size in blocks of journal area on main
-                                         * device, we need to keep after
-                                         * making fs with non-standard journal */
-} __attribute__ ((__packed__));
-
-#define SB_SIZE_V1 (sizeof(struct reiserfs_super_block_v1))
-
-/* this is the on disk super block */
-struct reiserfs_super_block {
-        struct reiserfs_super_block_v1 s_v1;
-        __le32 s_inode_generation;
-        __le32 s_flags;         /* Right now used only by inode-attributes, if enabled */
-        unsigned char s_uuid[16];       /* filesystem unique identifier */
-        unsigned char s_label[16];      /* filesystem volume label */
-        __le16 s_mnt_count;             /* Count of mounts since last fsck */
-        __le16 s_max_mnt_count;         /* Maximum mounts before check */
-        __le32 s_lastcheck;             /* Timestamp of last fsck */
-        __le32 s_check_interval;        /* Interval between checks */
-        char s_unused[76];      /* zero filled by mkreiserfs and
-                                 * reiserfs_convert_objectid_map_v1()
-                                 * so any additions must be updated
-                                 * there as well. */
-} __attribute__ ((__packed__));
-
-#define SB_SIZE (sizeof(struct reiserfs_super_block))
-
-#define REISERFS_VERSION_1 0
-#define REISERFS_VERSION_2 2
-
-// on-disk super block fields converted to cpu form
-#define SB_DISK_SUPER_BLOCK(s) (REISERFS_SB(s)->s_rs)
-#define SB_V1_DISK_SUPER_BLOCK(s) (&(SB_DISK_SUPER_BLOCK(s)->s_v1))
-#define SB_BLOCKSIZE(s) \
-        le32_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_blocksize))
-#define SB_BLOCK_COUNT(s) \
-        le32_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_block_count))
-#define SB_FREE_BLOCKS(s) \
-        le32_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_free_blocks))
-#define SB_REISERFS_MAGIC(s) \
-        (SB_V1_DISK_SUPER_BLOCK(s)->s_magic)
-#define SB_ROOT_BLOCK(s) \
-        le32_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_root_block))
-#define SB_TREE_HEIGHT(s) \
-        le16_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_tree_height))
-#define SB_REISERFS_STATE(s) \
-        le16_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_umount_state))
-#define SB_VERSION(s) le16_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_version))
-#define SB_BMAP_NR(s) le16_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_bmap_nr))
-
-#define PUT_SB_BLOCK_COUNT(s, val) \
-   do { SB_V1_DISK_SUPER_BLOCK(s)->s_block_count = cpu_to_le32(val); } while (0)
-#define PUT_SB_FREE_BLOCKS(s, val) \
-   do { SB_V1_DISK_SUPER_BLOCK(s)->s_free_blocks = cpu_to_le32(val); } while (0)
-#define PUT_SB_ROOT_BLOCK(s, val) \
-   do { SB_V1_DISK_SUPER_BLOCK(s)->s_root_block = cpu_to_le32(val); } while (0)
-#define PUT_SB_TREE_HEIGHT(s, val) \
-   do { SB_V1_DISK_SUPER_BLOCK(s)->s_tree_height = cpu_to_le16(val); } while (0)
-#define PUT_SB_REISERFS_STATE(s, val) \
-   do { SB_V1_DISK_SUPER_BLOCK(s)->s_umount_state = cpu_to_le16(val); } while (0)
-#define PUT_SB_VERSION(s, val) \
-   do { SB_V1_DISK_SUPER_BLOCK(s)->s_version = cpu_to_le16(val); } while (0)
-#define PUT_SB_BMAP_NR(s, val) \
-   do { SB_V1_DISK_SUPER_BLOCK(s)->s_bmap_nr = cpu_to_le16 (val); } while (0)
-
-#define SB_ONDISK_JP(s) (&SB_V1_DISK_SUPER_BLOCK(s)->s_journal)
-#define SB_ONDISK_JOURNAL_SIZE(s) \
-         le32_to_cpu ((SB_ONDISK_JP(s)->jp_journal_size))
-#define SB_ONDISK_JOURNAL_1st_BLOCK(s) \
-         le32_to_cpu ((SB_ONDISK_JP(s)->jp_journal_1st_block))
-#define SB_ONDISK_JOURNAL_DEVICE(s) \
-         le32_to_cpu ((SB_ONDISK_JP(s)->jp_journal_dev))
-#define SB_ONDISK_RESERVED_FOR_JOURNAL(s) \
-         le16_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_reserved_for_journal))
-
-#define is_block_in_log_or_reserved_area(s, block) \
-         block >= SB_JOURNAL_1st_RESERVED_BLOCK(s) \
-         && block < SB_JOURNAL_1st_RESERVED_BLOCK(s) +  \
-         ((!is_reiserfs_jr(SB_DISK_SUPER_BLOCK(s)) ? \
-         SB_ONDISK_JOURNAL_SIZE(s) + 1 : SB_ONDISK_RESERVED_FOR_JOURNAL(s)))
-
-int is_reiserfs_3_5(struct reiserfs_super_block *rs);
-int is_reiserfs_3_6(struct reiserfs_super_block *rs);
-int is_reiserfs_jr(struct reiserfs_super_block *rs);
-
-/* ReiserFS leaves the first 64k unused, so that partition labels have
-   enough space.  If someone wants to write a fancy bootloader that
-   needs more than 64k, let us know, and this will be increased in size.
-   This number must be larger than than the largest block size on any
-   platform, or code will break.  -Hans */
-#define REISERFS_DISK_OFFSET_IN_BYTES (64 * 1024)
-#define REISERFS_FIRST_BLOCK unused_define
-#define REISERFS_JOURNAL_OFFSET_IN_BYTES REISERFS_DISK_OFFSET_IN_BYTES
-
-/* the spot for the super in versions 3.5 - 3.5.10 (inclusive) */
-#define REISERFS_OLD_DISK_OFFSET_IN_BYTES (8 * 1024)
-
-/* reiserfs internal error code (used by search_by_key and fix_nodes)) */
-#define CARRY_ON      0
-#define REPEAT_SEARCH -1
-#define IO_ERROR      -2
-#define NO_DISK_SPACE -3
-#define NO_BALANCING_NEEDED  (-4)
-#define NO_MORE_UNUSED_CONTIGUOUS_BLOCKS (-5)
-#define QUOTA_EXCEEDED -6
-
-typedef __u32 b_blocknr_t;
-typedef __le32 unp_t;
-
-struct unfm_nodeinfo {
-        unp_t unfm_nodenum;
-        unsigned short unfm_freespace;
-};
-
-/* there are two formats of keys: 3.5 and 3.6
- */
-#define KEY_FORMAT_3_5 0
-#define KEY_FORMAT_3_6 1
-
-/* there are two stat datas */
-#define STAT_DATA_V1 0
-#define STAT_DATA_V2 1
-
-static inline struct reiserfs_inode_info *REISERFS_I(const struct inode *inode)
-{
-        return container_of(inode, struct reiserfs_inode_info, vfs_inode);
-}
-
-static inline struct reiserfs_sb_info *REISERFS_SB(const struct super_block *sb)
-{
-        return sb->s_fs_info;
-}
-
-/* Don't trust REISERFS_SB(sb)->s_bmap_nr, it's a u16
- * which overflows on large file systems. */
-static inline __u32 reiserfs_bmap_count(struct super_block *sb)
-{
-        return (SB_BLOCK_COUNT(sb) - 1) / (sb->s_blocksize * 8) + 1;
-}
-
-static inline int bmap_would_wrap(unsigned bmap_nr)
-{
-        return bmap_nr > ((1LL << 16) - 1);
-}
-
-/** this says about version of key of all items (but stat data) the
-    object consists of */
-#define get_inode_item_key_version( inode )                                    \
-    ((REISERFS_I(inode)->i_flags & i_item_key_version_mask) ? KEY_FORMAT_3_6 : KEY_FORMAT_3_5)
-
-#define set_inode_item_key_version( inode, version )                           \
-         ({ if((version)==KEY_FORMAT_3_6)                                      \
-                REISERFS_I(inode)->i_flags |= i_item_key_version_mask;      \
-            else                                                               \
-                REISERFS_I(inode)->i_flags &= ~i_item_key_version_mask; })
-
-#define get_inode_sd_version(inode)                                            \
-    ((REISERFS_I(inode)->i_flags & i_stat_data_version_mask) ? STAT_DATA_V2 : STAT_DATA_V1)
-
-#define set_inode_sd_version(inode, version)                                   \
-         ({ if((version)==STAT_DATA_V2)                                        \
-                REISERFS_I(inode)->i_flags |= i_stat_data_version_mask;     \
-            else                                                               \
-                REISERFS_I(inode)->i_flags &= ~i_stat_data_version_mask; })
-
-/* This is an aggressive tail suppression policy, I am hoping it
-   improves our benchmarks. The principle behind it is that percentage
-   space saving is what matters, not absolute space saving.  This is
-   non-intuitive, but it helps to understand it if you consider that the
-   cost to access 4 blocks is not much more than the cost to access 1
-   block, if you have to do a seek and rotate.  A tail risks a
-   non-linear disk access that is significant as a percentage of total
-   time cost for a 4 block file and saves an amount of space that is
-   less significant as a percentage of space, or so goes the hypothesis.
-   -Hans */
-#define STORE_TAIL_IN_UNFM_S1(n_file_size,n_tail_size,n_block_size) \
-(\
-  (!(n_tail_size)) || \
-  (((n_tail_size) > MAX_DIRECT_ITEM_LEN(n_block_size)) || \
-   ( (n_file_size) >= (n_block_size) * 4 ) || \
-   ( ( (n_file_size) >= (n_block_size) * 3 ) && \
-     ( (n_tail_size) >=   (MAX_DIRECT_ITEM_LEN(n_block_size))/4) ) || \
-   ( ( (n_file_size) >= (n_block_size) * 2 ) && \
-     ( (n_tail_size) >=   (MAX_DIRECT_ITEM_LEN(n_block_size))/2) ) || \
-   ( ( (n_file_size) >= (n_block_size) ) && \
-     ( (n_tail_size) >=   (MAX_DIRECT_ITEM_LEN(n_block_size) * 3)/4) ) ) \
-)
-
-/* Another strategy for tails, this one means only create a tail if all the
-   file would fit into one DIRECT item.
-   Primary intention for this one is to increase performance by decreasing
-   seeking.
-*/
-#define STORE_TAIL_IN_UNFM_S2(n_file_size,n_tail_size,n_block_size) \
-(\
-  (!(n_tail_size)) || \
-  (((n_file_size) > MAX_DIRECT_ITEM_LEN(n_block_size)) ) \
-)
-
-/*
- * values for s_umount_state field
- */
-#define REISERFS_VALID_FS    1
-#define REISERFS_ERROR_FS    2
-
-//
-// there are 5 item types currently
-//
-#define TYPE_STAT_DATA 0
-#define TYPE_INDIRECT 1
-#define TYPE_DIRECT 2
-#define TYPE_DIRENTRY 3
-#define TYPE_MAXTYPE 3
-#define TYPE_ANY 15             // FIXME: comment is required
-
-/***************************************************************************/
-/*                       KEY & ITEM HEAD                                   */
-/***************************************************************************/
-
-//
-// directories use this key as well as old files
-//
-struct offset_v1 {
-        __le32 k_offset;
-        __le32 k_uniqueness;
-} __attribute__ ((__packed__));
-
-struct offset_v2 {
-        __le64 v;
-} __attribute__ ((__packed__));
-
-static inline __u16 offset_v2_k_type(const struct offset_v2 *v2)
-{
-        __u8 type = le64_to_cpu(v2->v) >> 60;
-        return (type <= TYPE_MAXTYPE) ? type : TYPE_ANY;
-}
-
-static inline void set_offset_v2_k_type(struct offset_v2 *v2, int type)
-{
-        v2->v =
-            (v2->v & cpu_to_le64(~0ULL >> 4)) | cpu_to_le64((__u64) type << 60);
-}
-
-static inline loff_t offset_v2_k_offset(const struct offset_v2 *v2)
-{
-        return le64_to_cpu(v2->v) & (~0ULL >> 4);
-}
-
-static inline void set_offset_v2_k_offset(struct offset_v2 *v2, loff_t offset)
-{
-        offset &= (~0ULL >> 4);
-        v2->v = (v2->v & cpu_to_le64(15ULL << 60)) | cpu_to_le64(offset);
-}
-
-/* Key of an item determines its location in the S+tree, and
-   is composed of 4 components */
-struct reiserfs_key {
-        __le32 k_dir_id;        /* packing locality: by default parent
-                                   directory object id */
-        __le32 k_objectid;      /* object identifier */
-        union {
-                struct offset_v1 k_offset_v1;
-                struct offset_v2 k_offset_v2;
-        } __attribute__ ((__packed__)) u;
-} __attribute__ ((__packed__));
-
-struct in_core_key {
-        __u32 k_dir_id;         /* packing locality: by default parent
-                                   directory object id */
-        __u32 k_objectid;       /* object identifier */
-        __u64 k_offset;
-        __u8 k_type;
-};
-
-struct cpu_key {
-        struct in_core_key on_disk_key;
-        int version;
-        int key_length;         /* 3 in all cases but direct2indirect and
-                                   indirect2direct conversion */
-};
-
-/* Our function for comparing keys can compare keys of different
-   lengths.  It takes as a parameter the length of the keys it is to
-   compare.  These defines are used in determining what is to be passed
-   to it as that parameter. */
-#define REISERFS_FULL_KEY_LEN     4
-#define REISERFS_SHORT_KEY_LEN    2
-
-/* The result of the key compare */
-#define FIRST_GREATER 1
-#define SECOND_GREATER -1
-#define KEYS_IDENTICAL 0
-#define KEY_FOUND 1
-#define KEY_NOT_FOUND 0
-
-#define KEY_SIZE (sizeof(struct reiserfs_key))
-#define SHORT_KEY_SIZE (sizeof (__u32) + sizeof (__u32))
-
-/* return values for search_by_key and clones */
-#define ITEM_FOUND 1
-#define ITEM_NOT_FOUND 0
-#define ENTRY_FOUND 1
-#define ENTRY_NOT_FOUND 0
-#define DIRECTORY_NOT_FOUND -1
-#define REGULAR_FILE_FOUND -2
-#define DIRECTORY_FOUND -3
-#define BYTE_FOUND 1
-#define BYTE_NOT_FOUND 0
-#define FILE_NOT_FOUND -1
-
-#define POSITION_FOUND 1
-#define POSITION_NOT_FOUND 0
-
-// return values for reiserfs_find_entry and search_by_entry_key
-#define NAME_FOUND 1
-#define NAME_NOT_FOUND 0
-#define GOTO_PREVIOUS_ITEM 2
-#define NAME_FOUND_INVISIBLE 3
-
-/*  Everything in the filesystem is stored as a set of items.  The
-    item head contains the key of the item, its free space (for
-    indirect items) and specifies the location of the item itself
-    within the block.  */
-
-struct item_head {
-        /* Everything in the tree is found by searching for it based on
-         * its key.*/
-        struct reiserfs_key ih_key;
-        union {
-                /* The free space in the last unformatted node of an
-                   indirect item if this is an indirect item.  This
-                   equals 0xFFFF iff this is a direct item or stat data
-                   item. Note that the key, not this field, is used to
-                   determine the item type, and thus which field this
-                   union contains. */
-                __le16 ih_free_space_reserved;
-                /* Iff this is a directory item, this field equals the
-                   number of directory entries in the directory item. */
-                __le16 ih_entry_count;
-        } __attribute__ ((__packed__)) u;
-        __le16 ih_item_len;     /* total size of the item body */
-        __le16 ih_item_location;        /* an offset to the item body
-                                         * within the block */
-        __le16 ih_version;      /* 0 for all old items, 2 for new
-                                   ones. Highest bit is set by fsck
-                                   temporary, cleaned after all
-                                   done */
-} __attribute__ ((__packed__));
-/* size of item header     */
-#define IH_SIZE (sizeof(struct item_head))
-
-#define ih_free_space(ih)            le16_to_cpu((ih)->u.ih_free_space_reserved)
-#define ih_version(ih)               le16_to_cpu((ih)->ih_version)
-#define ih_entry_count(ih)           le16_to_cpu((ih)->u.ih_entry_count)
-#define ih_location(ih)              le16_to_cpu((ih)->ih_item_location)
-#define ih_item_len(ih)              le16_to_cpu((ih)->ih_item_len)
-
-#define put_ih_free_space(ih, val)   do { (ih)->u.ih_free_space_reserved = cpu_to_le16(val); } while(0)
-#define put_ih_version(ih, val)      do { (ih)->ih_version = cpu_to_le16(val); } while (0)
-#define put_ih_entry_count(ih, val)  do { (ih)->u.ih_entry_count = cpu_to_le16(val); } while (0)
-#define put_ih_location(ih, val)     do { (ih)->ih_item_location = cpu_to_le16(val); } while (0)
-#define put_ih_item_len(ih, val)     do { (ih)->ih_item_len = cpu_to_le16(val); } while (0)
-
-#define unreachable_item(ih) (ih_version(ih) & (1 << 15))
-
-#define get_ih_free_space(ih) (ih_version (ih) == KEY_FORMAT_3_6 ? 0 : ih_free_space (ih))
-#define set_ih_free_space(ih,val) put_ih_free_space((ih), ((ih_version(ih) == KEY_FORMAT_3_6) ? 0 : (val)))
-
-/* these operate on indirect items, where you've got an array of ints
-** at a possibly unaligned location.  These are a noop on ia32
-** 
-** p is the array of __u32, i is the index into the array, v is the value
-** to store there.
-*/
-#define get_block_num(p, i) get_unaligned_le32((p) + (i))
-#define put_block_num(p, i, v) put_unaligned_le32((v), (p) + (i))
-
-//
-// in old version uniqueness field shows key type
-//
-#define V1_SD_UNIQUENESS 0
-#define V1_INDIRECT_UNIQUENESS 0xfffffffe
-#define V1_DIRECT_UNIQUENESS 0xffffffff
-#define V1_DIRENTRY_UNIQUENESS 500
-#define V1_ANY_UNIQUENESS 555   // FIXME: comment is required
-
-//
-// here are conversion routines
-//
-static inline int uniqueness2type(__u32 uniqueness) CONSTF;
-static inline int uniqueness2type(__u32 uniqueness)
-{
-        switch ((int)uniqueness) {
-        case V1_SD_UNIQUENESS:
-                return TYPE_STAT_DATA;
-        case V1_INDIRECT_UNIQUENESS:
-                return TYPE_INDIRECT;
-        case V1_DIRECT_UNIQUENESS:
-                return TYPE_DIRECT;
-        case V1_DIRENTRY_UNIQUENESS:
-                return TYPE_DIRENTRY;
-        case V1_ANY_UNIQUENESS:
-        default:
-                return TYPE_ANY;
-        }
-}
-
-static inline __u32 type2uniqueness(int type) CONSTF;
-static inline __u32 type2uniqueness(int type)
-{
-        switch (type) {
-        case TYPE_STAT_DATA:
-                return V1_SD_UNIQUENESS;
-        case TYPE_INDIRECT:
-                return V1_INDIRECT_UNIQUENESS;
-        case TYPE_DIRECT:
-                return V1_DIRECT_UNIQUENESS;
-        case TYPE_DIRENTRY:
-                return V1_DIRENTRY_UNIQUENESS;
-        case TYPE_ANY:
-        default:
-                return V1_ANY_UNIQUENESS;
-        }
-}
-
-//
-// key is pointer to on disk key which is stored in le, result is cpu,
-// there is no way to get version of object from key, so, provide
-// version to these defines
-//
-static inline loff_t le_key_k_offset(int version,
-                                     const struct reiserfs_key *key)
-{
-        return (version == KEY_FORMAT_3_5) ?
-            le32_to_cpu(key->u.k_offset_v1.k_offset) :
-            offset_v2_k_offset(&(key->u.k_offset_v2));
-}
-
-static inline loff_t le_ih_k_offset(const struct item_head *ih)
-{
-        return le_key_k_offset(ih_version(ih), &(ih->ih_key));
-}
-
-static inline loff_t le_key_k_type(int version, const struct reiserfs_key *key)
-{
-        return (version == KEY_FORMAT_3_5) ?
-            uniqueness2type(le32_to_cpu(key->u.k_offset_v1.k_uniqueness)) :
-            offset_v2_k_type(&(key->u.k_offset_v2));
-}
-
-static inline loff_t le_ih_k_type(const struct item_head *ih)
-{
-        return le_key_k_type(ih_version(ih), &(ih->ih_key));
-}
-
-static inline void set_le_key_k_offset(int version, struct reiserfs_key *key,
-                                       loff_t offset)
-{
-        (version == KEY_FORMAT_3_5) ? (void)(key->u.k_offset_v1.k_offset = cpu_to_le32(offset)) :       /* jdm check */
-            (void)(set_offset_v2_k_offset(&(key->u.k_offset_v2), offset));
-}
-
-static inline void set_le_ih_k_offset(struct item_head *ih, loff_t offset)
-{
-        set_le_key_k_offset(ih_version(ih), &(ih->ih_key), offset);
-}
-
-static inline void set_le_key_k_type(int version, struct reiserfs_key *key,
-                                     int type)
-{
-        (version == KEY_FORMAT_3_5) ?
-            (void)(key->u.k_offset_v1.k_uniqueness =
-                   cpu_to_le32(type2uniqueness(type)))
-            : (void)(set_offset_v2_k_type(&(key->u.k_offset_v2), type));
-}
-
-static inline void set_le_ih_k_type(struct item_head *ih, int type)
-{
-        set_le_key_k_type(ih_version(ih), &(ih->ih_key), type);
-}
-
-static inline int is_direntry_le_key(int version, struct reiserfs_key *key)
-{
-        return le_key_k_type(version, key) == TYPE_DIRENTRY;
-}
-
-static inline int is_direct_le_key(int version, struct reiserfs_key *key)
-{
-        return le_key_k_type(version, key) == TYPE_DIRECT;
-}
-
-static inline int is_indirect_le_key(int version, struct reiserfs_key *key)
-{
-        return le_key_k_type(version, key) == TYPE_INDIRECT;
-}
-
-static inline int is_statdata_le_key(int version, struct reiserfs_key *key)
-{
-        return le_key_k_type(version, key) == TYPE_STAT_DATA;
-}
-
-//
-// item header has version.
-//
-static inline int is_direntry_le_ih(struct item_head *ih)
-{
-        return is_direntry_le_key(ih_version(ih), &ih->ih_key);
-}
-
-static inline int is_direct_le_ih(struct item_head *ih)
-{
-        return is_direct_le_key(ih_version(ih), &ih->ih_key);
-}
-
-static inline int is_indirect_le_ih(struct item_head *ih)
-{
-        return is_indirect_le_key(ih_version(ih), &ih->ih_key);
-}
-
-static inline int is_statdata_le_ih(struct item_head *ih)
-{
-        return is_statdata_le_key(ih_version(ih), &ih->ih_key);
-}
-
-//
-// key is pointer to cpu key, result is cpu
-//
-static inline loff_t cpu_key_k_offset(const struct cpu_key *key)
-{
-        return key->on_disk_key.k_offset;
-}
-
-static inline loff_t cpu_key_k_type(const struct cpu_key *key)
-{
-        return key->on_disk_key.k_type;
-}
-
-static inline void set_cpu_key_k_offset(struct cpu_key *key, loff_t offset)
-{
-        key->on_disk_key.k_offset = offset;
-}
-
-static inline void set_cpu_key_k_type(struct cpu_key *key, int type)
-{
-        key->on_disk_key.k_type = type;
-}
-
-static inline void cpu_key_k_offset_dec(struct cpu_key *key)
-{
-        key->on_disk_key.k_offset--;
-}
-
-#define is_direntry_cpu_key(key) (cpu_key_k_type (key) == TYPE_DIRENTRY)
-#define is_direct_cpu_key(key) (cpu_key_k_type (key) == TYPE_DIRECT)
-#define is_indirect_cpu_key(key) (cpu_key_k_type (key) == TYPE_INDIRECT)
-#define is_statdata_cpu_key(key) (cpu_key_k_type (key) == TYPE_STAT_DATA)
-
-/* are these used ? */
-#define is_direntry_cpu_ih(ih) (is_direntry_cpu_key (&((ih)->ih_key)))
-#define is_direct_cpu_ih(ih) (is_direct_cpu_key (&((ih)->ih_key)))
-#define is_indirect_cpu_ih(ih) (is_indirect_cpu_key (&((ih)->ih_key)))
-#define is_statdata_cpu_ih(ih) (is_statdata_cpu_key (&((ih)->ih_key)))
-
-#define I_K_KEY_IN_ITEM(ih, key, n_blocksize) \
-    (!COMP_SHORT_KEYS(ih, key) && \
-          I_OFF_BYTE_IN_ITEM(ih, k_offset(key), n_blocksize))
-
-/* maximal length of item */
-#define MAX_ITEM_LEN(block_size) (block_size - BLKH_SIZE - IH_SIZE)
-#define MIN_ITEM_LEN 1
-
-/* object identifier for root dir */
-#define REISERFS_ROOT_OBJECTID 2
-#define REISERFS_ROOT_PARENT_OBJECTID 1
-
-extern struct reiserfs_key root_key;
-
-/* 
- * Picture represents a leaf of the S+tree
- *  ______________________________________________________
- * |      |  Array of     |                   |           |
- * |Block |  Object-Item  |      F r e e      |  Objects- |
- * | head |  Headers      |     S p a c e     |   Items   |
- * |______|_______________|___________________|___________|
- */
-
-/* Header of a disk block.  More precisely, header of a formatted leaf
-   or internal node, and not the header of an unformatted node. */
-struct block_head {
-        __le16 blk_level;       /* Level of a block in the tree. */
-        __le16 blk_nr_item;     /* Number of keys/items in a block. */
-        __le16 blk_free_space;  /* Block free space in bytes. */
-        __le16 blk_reserved;
-        /* dump this in v4/planA */
-        struct reiserfs_key blk_right_delim_key;        /* kept only for compatibility */
-};
-
-#define BLKH_SIZE                     (sizeof(struct block_head))
-#define blkh_level(p_blkh)            (le16_to_cpu((p_blkh)->blk_level))
-#define blkh_nr_item(p_blkh)          (le16_to_cpu((p_blkh)->blk_nr_item))
-#define blkh_free_space(p_blkh)       (le16_to_cpu((p_blkh)->blk_free_space))
-#define blkh_reserved(p_blkh)         (le16_to_cpu((p_blkh)->blk_reserved))
-#define set_blkh_level(p_blkh,val)    ((p_blkh)->blk_level = cpu_to_le16(val))
-#define set_blkh_nr_item(p_blkh,val)  ((p_blkh)->blk_nr_item = cpu_to_le16(val))
-#define set_blkh_free_space(p_blkh,val) ((p_blkh)->blk_free_space = cpu_to_le16(val))
-#define set_blkh_reserved(p_blkh,val) ((p_blkh)->blk_reserved = cpu_to_le16(val))
-#define blkh_right_delim_key(p_blkh)  ((p_blkh)->blk_right_delim_key)
-#define set_blkh_right_delim_key(p_blkh,val)  ((p_blkh)->blk_right_delim_key = val)
-
-/*
- * values for blk_level field of the struct block_head
- */
-
-#define FREE_LEVEL 0            /* when node gets removed from the tree its
-                                   blk_level is set to FREE_LEVEL. It is then
-                                   used to see whether the node is still in the
-                                   tree */
-
-#define DISK_LEAF_NODE_LEVEL  1 /* Leaf node level. */
-
-/* Given the buffer head of a formatted node, resolve to the block head of that node. */
-#define B_BLK_HEAD(bh)                  ((struct block_head *)((bh)->b_data))
-/* Number of items that are in buffer. */
-#define B_NR_ITEMS(bh)                  (blkh_nr_item(B_BLK_HEAD(bh)))
-#define B_LEVEL(bh)                     (blkh_level(B_BLK_HEAD(bh)))
-#define B_FREE_SPACE(bh)                (blkh_free_space(B_BLK_HEAD(bh)))
-
-#define PUT_B_NR_ITEMS(bh, val)         do { set_blkh_nr_item(B_BLK_HEAD(bh), val); } while (0)
-#define PUT_B_LEVEL(bh, val)            do { set_blkh_level(B_BLK_HEAD(bh), val); } while (0)
-#define PUT_B_FREE_SPACE(bh, val)       do { set_blkh_free_space(B_BLK_HEAD(bh), val); } while (0)
-
-/* Get right delimiting key. -- little endian */
-#define B_PRIGHT_DELIM_KEY(bh)          (&(blk_right_delim_key(B_BLK_HEAD(bh))))
-
-/* Does the buffer contain a disk leaf. */
-#define B_IS_ITEMS_LEVEL(bh)            (B_LEVEL(bh) == DISK_LEAF_NODE_LEVEL)
-
-/* Does the buffer contain a disk internal node */
-#define B_IS_KEYS_LEVEL(bh)      (B_LEVEL(bh) > DISK_LEAF_NODE_LEVEL \
-                                            && B_LEVEL(bh) <= MAX_HEIGHT)
-
-/***************************************************************************/
-/*                             STAT DATA                                   */
-/***************************************************************************/
-
-//
-// old stat data is 32 bytes long. We are going to distinguish new one by
-// different size
-//
-struct stat_data_v1 {
-        __le16 sd_mode;         /* file type, permissions */
-        __le16 sd_nlink;        /* number of hard links */
-        __le16 sd_uid;          /* owner */
-        __le16 sd_gid;          /* group */
-        __le32 sd_size;         /* file size */
-        __le32 sd_atime;        /* time of last access */
-        __le32 sd_mtime;        /* time file was last modified  */
-        __le32 sd_ctime;        /* time inode (stat data) was last changed (except changes to sd_atime and sd_mtime) */
-        union {
-                __le32 sd_rdev;
-                __le32 sd_blocks;       /* number of blocks file uses */
-        } __attribute__ ((__packed__)) u;
-        __le32 sd_first_direct_byte;    /* first byte of file which is stored
-                                           in a direct item: except that if it
-                                           equals 1 it is a symlink and if it
-                                           equals ~(__u32)0 there is no
-                                           direct item.  The existence of this
-                                           field really grates on me. Let's
-                                           replace it with a macro based on
-                                           sd_size and our tail suppression
-                                           policy.  Someday.  -Hans */
-} __attribute__ ((__packed__));
-
-#define SD_V1_SIZE              (sizeof(struct stat_data_v1))
-#define stat_data_v1(ih)        (ih_version (ih) == KEY_FORMAT_3_5)
-#define sd_v1_mode(sdp)         (le16_to_cpu((sdp)->sd_mode))
-#define set_sd_v1_mode(sdp,v)   ((sdp)->sd_mode = cpu_to_le16(v))
-#define sd_v1_nlink(sdp)        (le16_to_cpu((sdp)->sd_nlink))
-#define set_sd_v1_nlink(sdp,v)  ((sdp)->sd_nlink = cpu_to_le16(v))
-#define sd_v1_uid(sdp)          (le16_to_cpu((sdp)->sd_uid))
-#define set_sd_v1_uid(sdp,v)    ((sdp)->sd_uid = cpu_to_le16(v))
-#define sd_v1_gid(sdp)          (le16_to_cpu((sdp)->sd_gid))
-#define set_sd_v1_gid(sdp,v)    ((sdp)->sd_gid = cpu_to_le16(v))
-#define sd_v1_size(sdp)         (le32_to_cpu((sdp)->sd_size))
-#define set_sd_v1_size(sdp,v)   ((sdp)->sd_size = cpu_to_le32(v))
-#define sd_v1_atime(sdp)        (le32_to_cpu((sdp)->sd_atime))
-#define set_sd_v1_atime(sdp,v)  ((sdp)->sd_atime = cpu_to_le32(v))
-#define sd_v1_mtime(sdp)        (le32_to_cpu((sdp)->sd_mtime))
-#define set_sd_v1_mtime(sdp,v)  ((sdp)->sd_mtime = cpu_to_le32(v))
-#define sd_v1_ctime(sdp)        (le32_to_cpu((sdp)->sd_ctime))
-#define set_sd_v1_ctime(sdp,v)  ((sdp)->sd_ctime = cpu_to_le32(v))
-#define sd_v1_rdev(sdp)         (le32_to_cpu((sdp)->u.sd_rdev))
-#define set_sd_v1_rdev(sdp,v)   ((sdp)->u.sd_rdev = cpu_to_le32(v))
-#define sd_v1_blocks(sdp)       (le32_to_cpu((sdp)->u.sd_blocks))
-#define set_sd_v1_blocks(sdp,v) ((sdp)->u.sd_blocks = cpu_to_le32(v))
-#define sd_v1_first_direct_byte(sdp) \
-                                (le32_to_cpu((sdp)->sd_first_direct_byte))
-#define set_sd_v1_first_direct_byte(sdp,v) \
-                                ((sdp)->sd_first_direct_byte = cpu_to_le32(v))
-
-/* inode flags stored in sd_attrs (nee sd_reserved) */
-
-/* we want common flags to have the same values as in ext2,
-   so chattr(1) will work without problems */
-#define REISERFS_IMMUTABLE_FL FS_IMMUTABLE_FL
-#define REISERFS_APPEND_FL    FS_APPEND_FL
-#define REISERFS_SYNC_FL      FS_SYNC_FL
-#define REISERFS_NOATIME_FL   FS_NOATIME_FL
-#define REISERFS_NODUMP_FL    FS_NODUMP_FL
-#define REISERFS_SECRM_FL     FS_SECRM_FL
-#define REISERFS_UNRM_FL      FS_UNRM_FL
-#define REISERFS_COMPR_FL     FS_COMPR_FL
-#define REISERFS_NOTAIL_FL    FS_NOTAIL_FL
-
-/* persistent flags that file inherits from the parent directory */
-#define REISERFS_INHERIT_MASK ( REISERFS_IMMUTABLE_FL | \
-                                REISERFS_SYNC_FL |      \
-                                REISERFS_NOATIME_FL |   \
-                                REISERFS_NODUMP_FL |    \
-                                REISERFS_SECRM_FL |     \
-                                REISERFS_COMPR_FL |     \
-                                REISERFS_NOTAIL_FL )
-
-/* Stat Data on disk (reiserfs version of UFS disk inode minus the
-   address blocks) */
-struct stat_data {
-        __le16 sd_mode;         /* file type, permissions */
-        __le16 sd_attrs;        /* persistent inode flags */
-        __le32 sd_nlink;        /* number of hard links */
-        __le64 sd_size;         /* file size */
-        __le32 sd_uid;          /* owner */
-        __le32 sd_gid;          /* group */
-        __le32 sd_atime;        /* time of last access */
-        __le32 sd_mtime;        /* time file was last modified  */
-        __le32 sd_ctime;        /* time inode (stat data) was last changed (except changes to sd_atime and sd_mtime) */
-        __le32 sd_blocks;
-        union {
-                __le32 sd_rdev;
-                __le32 sd_generation;
-                //__le32 sd_first_direct_byte;
-                /* first byte of file which is stored in a
-                   direct item: except that if it equals 1
-                   it is a symlink and if it equals
-                   ~(__u32)0 there is no direct item.  The
-                   existence of this field really grates
-                   on me. Let's replace it with a macro
-                   based on sd_size and our tail
-                   suppression policy? */
-        } __attribute__ ((__packed__)) u;
-} __attribute__ ((__packed__));
-//
-// this is 44 bytes long
-//
-#define SD_SIZE (sizeof(struct stat_data))
-#define SD_V2_SIZE              SD_SIZE
-#define stat_data_v2(ih)        (ih_version (ih) == KEY_FORMAT_3_6)
-#define sd_v2_mode(sdp)         (le16_to_cpu((sdp)->sd_mode))
-#define set_sd_v2_mode(sdp,v)   ((sdp)->sd_mode = cpu_to_le16(v))
-/* sd_reserved */
-/* set_sd_reserved */
-#define sd_v2_nlink(sdp)        (le32_to_cpu((sdp)->sd_nlink))
-#define set_sd_v2_nlink(sdp,v)  ((sdp)->sd_nlink = cpu_to_le32(v))
-#define sd_v2_size(sdp)         (le64_to_cpu((sdp)->sd_size))
-#define set_sd_v2_size(sdp,v)   ((sdp)->sd_size = cpu_to_le64(v))
-#define sd_v2_uid(sdp)          (le32_to_cpu((sdp)->sd_uid))
-#define set_sd_v2_uid(sdp,v)    ((sdp)->sd_uid = cpu_to_le32(v))
-#define sd_v2_gid(sdp)          (le32_to_cpu((sdp)->sd_gid))
-#define set_sd_v2_gid(sdp,v)    ((sdp)->sd_gid = cpu_to_le32(v))
-#define sd_v2_atime(sdp)        (le32_to_cpu((sdp)->sd_atime))
-#define set_sd_v2_atime(sdp,v)  ((sdp)->sd_atime = cpu_to_le32(v))
-#define sd_v2_mtime(sdp)        (le32_to_cpu((sdp)->sd_mtime))
-#define set_sd_v2_mtime(sdp,v)  ((sdp)->sd_mtime = cpu_to_le32(v))
-#define sd_v2_ctime(sdp)        (le32_to_cpu((sdp)->sd_ctime))
-#define set_sd_v2_ctime(sdp,v)  ((sdp)->sd_ctime = cpu_to_le32(v))
-#define sd_v2_blocks(sdp)       (le32_to_cpu((sdp)->sd_blocks))
-#define set_sd_v2_blocks(sdp,v) ((sdp)->sd_blocks = cpu_to_le32(v))
-#define sd_v2_rdev(sdp)         (le32_to_cpu((sdp)->u.sd_rdev))
-#define set_sd_v2_rdev(sdp,v)   ((sdp)->u.sd_rdev = cpu_to_le32(v))
-#define sd_v2_generation(sdp)   (le32_to_cpu((sdp)->u.sd_generation))
-#define set_sd_v2_generation(sdp,v) ((sdp)->u.sd_generation = cpu_to_le32(v))
-#define sd_v2_attrs(sdp)         (le16_to_cpu((sdp)->sd_attrs))
-#define set_sd_v2_attrs(sdp,v)   ((sdp)->sd_attrs = cpu_to_le16(v))
-
-/***************************************************************************/
-/*                      DIRECTORY STRUCTURE                                */
-/***************************************************************************/
-/* 
-   Picture represents the structure of directory items
-   ________________________________________________
-   |  Array of     |   |     |        |       |   |
-   | directory     |N-1| N-2 | ....   |   1st |0th|
-   | entry headers |   |     |        |       |   |
-   |_______________|___|_____|________|_______|___|
-                    <----   directory entries         ------>
-
- First directory item has k_offset component 1. We store "." and ".."
- in one item, always, we never split "." and ".." into differing
- items.  This makes, among other things, the code for removing
- directories simpler. */
-#define SD_OFFSET  0
-#define SD_UNIQUENESS 0
-#define DOT_OFFSET 1
-#define DOT_DOT_OFFSET 2
-#define DIRENTRY_UNIQUENESS 500
-
-/* */
-#define FIRST_ITEM_OFFSET 1
-
-/*
-   Q: How to get key of object pointed to by entry from entry?  
-
-   A: Each directory entry has its header. This header has deh_dir_id and deh_objectid fields, those are key
-      of object, entry points to */
-
-/* NOT IMPLEMENTED:   
-   Directory will someday contain stat data of object */
-
-struct reiserfs_de_head {
-        __le32 deh_offset;      /* third component of the directory entry key */
-        __le32 deh_dir_id;      /* objectid of the parent directory of the object, that is referenced
-                                   by directory entry */
-        __le32 deh_objectid;    /* objectid of the object, that is referenced by directory entry */
-        __le16 deh_location;    /* offset of name in the whole item */
-        __le16 deh_state;       /* whether 1) entry contains stat data (for future), and 2) whether
-                                   entry is hidden (unlinked) */
-} __attribute__ ((__packed__));
-#define DEH_SIZE                  sizeof(struct reiserfs_de_head)
-#define deh_offset(p_deh)         (le32_to_cpu((p_deh)->deh_offset))
-#define deh_dir_id(p_deh)         (le32_to_cpu((p_deh)->deh_dir_id))
-#define deh_objectid(p_deh)       (le32_to_cpu((p_deh)->deh_objectid))
-#define deh_location(p_deh)       (le16_to_cpu((p_deh)->deh_location))
-#define deh_state(p_deh)          (le16_to_cpu((p_deh)->deh_state))
-
-#define put_deh_offset(p_deh,v)   ((p_deh)->deh_offset = cpu_to_le32((v)))
-#define put_deh_dir_id(p_deh,v)   ((p_deh)->deh_dir_id = cpu_to_le32((v)))
-#define put_deh_objectid(p_deh,v) ((p_deh)->deh_objectid = cpu_to_le32((v)))
-#define put_deh_location(p_deh,v) ((p_deh)->deh_location = cpu_to_le16((v)))
-#define put_deh_state(p_deh,v)    ((p_deh)->deh_state = cpu_to_le16((v)))
-
-/* empty directory contains two entries "." and ".." and their headers */
-#define EMPTY_DIR_SIZE \
-(DEH_SIZE * 2 + ROUND_UP (strlen (".")) + ROUND_UP (strlen ("..")))
-
-/* old format directories have this size when empty */
-#define EMPTY_DIR_SIZE_V1 (DEH_SIZE * 2 + 3)
-
-#define DEH_Statdata 0          /* not used now */
-#define DEH_Visible 2
-
-/* 64 bit systems (and the S/390) need to be aligned explicitly -jdm */
-#if BITS_PER_LONG == 64 || defined(__s390__) || defined(__hppa__)
-#   define ADDR_UNALIGNED_BITS  (3)
-#endif
-
-/* These are only used to manipulate deh_state.
- * Because of this, we'll use the ext2_ bit routines,
- * since they are little endian */
-#ifdef ADDR_UNALIGNED_BITS
-
-#   define aligned_address(addr)           ((void *)((long)(addr) & ~((1UL << ADDR_UNALIGNED_BITS) - 1)))
-#   define unaligned_offset(addr)          (((int)((long)(addr) & ((1 << ADDR_UNALIGNED_BITS) - 1))) << 3)
-
-#   define set_bit_unaligned(nr, addr)  \
-        __test_and_set_bit_le((nr) + unaligned_offset(addr), aligned_address(addr))
-#   define clear_bit_unaligned(nr, addr)        \
-        __test_and_clear_bit_le((nr) + unaligned_offset(addr), aligned_address(addr))
-#   define test_bit_unaligned(nr, addr) \
-        test_bit_le((nr) + unaligned_offset(addr), aligned_address(addr))
-
-#else
-
-#   define set_bit_unaligned(nr, addr)  __test_and_set_bit_le(nr, addr)
-#   define clear_bit_unaligned(nr, addr)        __test_and_clear_bit_le(nr, addr)
-#   define test_bit_unaligned(nr, addr) test_bit_le(nr, addr)
-
-#endif
-
-#define mark_de_with_sd(deh)        set_bit_unaligned (DEH_Statdata, &((deh)->deh_state))
-#define mark_de_without_sd(deh)     clear_bit_unaligned (DEH_Statdata, &((deh)->deh_state))
-#define mark_de_visible(deh)        set_bit_unaligned (DEH_Visible, &((deh)->deh_state))
-#define mark_de_hidden(deh)         clear_bit_unaligned (DEH_Visible, &((deh)->deh_state))
-
-#define de_with_sd(deh)             test_bit_unaligned (DEH_Statdata, &((deh)->deh_state))
-#define de_visible(deh)             test_bit_unaligned (DEH_Visible, &((deh)->deh_state))
-#define de_hidden(deh)              !test_bit_unaligned (DEH_Visible, &((deh)->deh_state))
-
-extern void make_empty_dir_item_v1(char *body, __le32 dirid, __le32 objid,
-                                   __le32 par_dirid, __le32 par_objid);
-extern void make_empty_dir_item(char *body, __le32 dirid, __le32 objid,
-                                __le32 par_dirid, __le32 par_objid);
-
-/* array of the entry headers */
- /* get item body */
-#define B_I_PITEM(bh,ih) ( (bh)->b_data + ih_location(ih) )
-#define B_I_DEH(bh,ih) ((struct reiserfs_de_head *)(B_I_PITEM(bh,ih)))
-
-/* length of the directory entry in directory item. This define
-   calculates length of i-th directory entry using directory entry
-   locations from dir entry head. When it calculates length of 0-th
-   directory entry, it uses length of whole item in place of entry
-   location of the non-existent following entry in the calculation.
-   See picture above.*/
-/*
-#define I_DEH_N_ENTRY_LENGTH(ih,deh,i) \
-((i) ? (deh_location((deh)-1) - deh_location((deh))) : (ih_item_len((ih)) - deh_location((deh))))
-*/
-static inline int entry_length(const struct buffer_head *bh,
-                               const struct item_head *ih, int pos_in_item)
-{
-        struct reiserfs_de_head *deh;
-
-        deh = B_I_DEH(bh, ih) + pos_in_item;
-        if (pos_in_item)
-                return deh_location(deh - 1) - deh_location(deh);
-
-        return ih_item_len(ih) - deh_location(deh);
-}
-
-/* number of entries in the directory item, depends on ENTRY_COUNT being at the start of directory dynamic data. */
-#define I_ENTRY_COUNT(ih) (ih_entry_count((ih)))
-
-/* name by bh, ih and entry_num */
-#define B_I_E_NAME(bh,ih,entry_num) ((char *)(bh->b_data + ih_location(ih) + deh_location(B_I_DEH(bh,ih)+(entry_num))))
-
-// two entries per block (at least)
-#define REISERFS_MAX_NAME(block_size) 255
-
-/* this structure is used for operations on directory entries. It is
-   not a disk structure. */
-/* When reiserfs_find_entry or search_by_entry_key find directory
-   entry, they return filled reiserfs_dir_entry structure */
-struct reiserfs_dir_entry {
-        struct buffer_head *de_bh;
-        int de_item_num;
-        struct item_head *de_ih;
-        int de_entry_num;
-        struct reiserfs_de_head *de_deh;
-        int de_entrylen;
-        int de_namelen;
-        char *de_name;
-        unsigned long *de_gen_number_bit_string;
-
-        __u32 de_dir_id;
-        __u32 de_objectid;
-
-        struct cpu_key de_entry_key;
-};
-
-/* these defines are useful when a particular member of a reiserfs_dir_entry is needed */
-
-/* pointer to file name, stored in entry */
-#define B_I_DEH_ENTRY_FILE_NAME(bh,ih,deh) (B_I_PITEM (bh, ih) + deh_location(deh))
-
-/* length of name */
-#define I_DEH_N_ENTRY_FILE_NAME_LENGTH(ih,deh,entry_num) \
-(I_DEH_N_ENTRY_LENGTH (ih, deh, entry_num) - (de_with_sd (deh) ? SD_SIZE : 0))
-
-/* hash value occupies bits from 7 up to 30 */
-#define GET_HASH_VALUE(offset) ((offset) & 0x7fffff80LL)
-/* generation number occupies 7 bits starting from 0 up to 6 */
-#define GET_GENERATION_NUMBER(offset) ((offset) & 0x7fLL)
-#define MAX_GENERATION_NUMBER  127
-
-#define SET_GENERATION_NUMBER(offset,gen_number) (GET_HASH_VALUE(offset)|(gen_number))
-
-/*
- * Picture represents an internal node of the reiserfs tree
- *  ______________________________________________________
- * |      |  Array of     |  Array of         |  Free     |
- * |block |    keys       |  pointers         | space     |
- * | head |      N        |      N+1          |           |
- * |______|_______________|___________________|___________|
- */
-
-/***************************************************************************/
-/*                      DISK CHILD                                         */
-/***************************************************************************/
-/* Disk child pointer: The pointer from an internal node of the tree
-   to a node that is on disk. */
-struct disk_child {
-        __le32 dc_block_number; /* Disk child's block number. */
-        __le16 dc_size;         /* Disk child's used space.   */
-        __le16 dc_reserved;
-};
-
-#define DC_SIZE (sizeof(struct disk_child))
-#define dc_block_number(dc_p)   (le32_to_cpu((dc_p)->dc_block_number))
-#define dc_size(dc_p)           (le16_to_cpu((dc_p)->dc_size))
-#define put_dc_block_number(dc_p, val)   do { (dc_p)->dc_block_number = cpu_to_le32(val); } while(0)
-#define put_dc_size(dc_p, val)   do { (dc_p)->dc_size = cpu_to_le16(val); } while(0)
-
-/* Get disk child by buffer header and position in the tree node. */
-#define B_N_CHILD(bh, n_pos)  ((struct disk_child *)\
-((bh)->b_data + BLKH_SIZE + B_NR_ITEMS(bh) * KEY_SIZE + DC_SIZE * (n_pos)))
-
-/* Get disk child number by buffer header and position in the tree node. */
-#define B_N_CHILD_NUM(bh, n_pos) (dc_block_number(B_N_CHILD(bh, n_pos)))
-#define PUT_B_N_CHILD_NUM(bh, n_pos, val) \
-                                (put_dc_block_number(B_N_CHILD(bh, n_pos), val))
-
- /* maximal value of field child_size in structure disk_child */
- /* child size is the combined size of all items and their headers */
-#define MAX_CHILD_SIZE(bh) ((int)( (bh)->b_size - BLKH_SIZE ))
-
-/* amount of used space in buffer (not including block head) */
-#define B_CHILD_SIZE(cur) (MAX_CHILD_SIZE(cur)-(B_FREE_SPACE(cur)))
-
-/* max and min number of keys in internal node */
-#define MAX_NR_KEY(bh) ( (MAX_CHILD_SIZE(bh)-DC_SIZE)/(KEY_SIZE+DC_SIZE) )
-#define MIN_NR_KEY(bh)    (MAX_NR_KEY(bh)/2)
-
-/***************************************************************************/
-/*                      PATH STRUCTURES AND DEFINES                        */
-/***************************************************************************/
-
-/* Search_by_key fills up the path from the root to the leaf as it descends the tree looking for the
-   key.  It uses reiserfs_bread to try to find buffers in the cache given their block number.  If it
-   does not find them in the cache it reads them from disk.  For each node search_by_key finds using
-   reiserfs_bread it then uses bin_search to look through that node.  bin_search will find the
-   position of the block_number of the next node if it is looking through an internal node.  If it
-   is looking through a leaf node bin_search will find the position of the item which has key either
-   equal to given key, or which is the maximal key less than the given key. */
-
-struct path_element {
-        struct buffer_head *pe_buffer;  /* Pointer to the buffer at the path in the tree. */
-        int pe_position;        /* Position in the tree node which is placed in the */
-        /* buffer above.                                  */
-};
-
-#define MAX_HEIGHT 5            /* maximal height of a tree. don't change this without changing JOURNAL_PER_BALANCE_CNT */
-#define EXTENDED_MAX_HEIGHT         7   /* Must be equals MAX_HEIGHT + FIRST_PATH_ELEMENT_OFFSET */
-#define FIRST_PATH_ELEMENT_OFFSET   2   /* Must be equal to at least 2. */
-
-#define ILLEGAL_PATH_ELEMENT_OFFSET 1   /* Must be equal to FIRST_PATH_ELEMENT_OFFSET - 1 */
-#define MAX_FEB_SIZE 6          /* this MUST be MAX_HEIGHT + 1. See about FEB below */
-
-/* We need to keep track of who the ancestors of nodes are.  When we
-   perform a search we record which nodes were visited while
-   descending the tree looking for the node we searched for. This list
-   of nodes is called the path.  This information is used while
-   performing balancing.  Note that this path information may become
-   invalid, and this means we must check it when using it to see if it
-   is still valid. You'll need to read search_by_key and the comments
-   in it, especially about decrement_counters_in_path(), to understand
-   this structure.  
-
-Paths make the code so much harder to work with and debug.... An
-enormous number of bugs are due to them, and trying to write or modify
-code that uses them just makes my head hurt.  They are based on an
-excessive effort to avoid disturbing the precious VFS code.:-( The
-gods only know how we are going to SMP the code that uses them.
-znodes are the way! */
-
-#define PATH_READA      0x1     /* do read ahead */
-#define PATH_READA_BACK 0x2     /* read backwards */
-
-struct treepath {
-        int path_length;        /* Length of the array above.   */
-        int reada;
-        struct path_element path_elements[EXTENDED_MAX_HEIGHT]; /* Array of the path elements.  */
-        int pos_in_item;
-};
-
-#define pos_in_item(path) ((path)->pos_in_item)
-
-#define INITIALIZE_PATH(var) \
-struct treepath var = {.path_length = ILLEGAL_PATH_ELEMENT_OFFSET, .reada = 0,}
-
-/* Get path element by path and path position. */
-#define PATH_OFFSET_PELEMENT(path, n_offset)  ((path)->path_elements + (n_offset))
-
-/* Get buffer header at the path by path and path position. */
-#define PATH_OFFSET_PBUFFER(path, n_offset)   (PATH_OFFSET_PELEMENT(path, n_offset)->pe_buffer)
-
-/* Get position in the element at the path by path and path position. */
-#define PATH_OFFSET_POSITION(path, n_offset) (PATH_OFFSET_PELEMENT(path, n_offset)->pe_position)
-
-#define PATH_PLAST_BUFFER(path) (PATH_OFFSET_PBUFFER((path), (path)->path_length))
-                                /* you know, to the person who didn't
-                                   write this the macro name does not
-                                   at first suggest what it does.
-                                   Maybe POSITION_FROM_PATH_END? Or
-                                   maybe we should just focus on
-                                   dumping paths... -Hans */
-#define PATH_LAST_POSITION(path) (PATH_OFFSET_POSITION((path), (path)->path_length))
-
-#define PATH_PITEM_HEAD(path)    B_N_PITEM_HEAD(PATH_PLAST_BUFFER(path), PATH_LAST_POSITION(path))
-
-/* in do_balance leaf has h == 0 in contrast with path structure,
-   where root has level == 0. That is why we need these defines */
-#define PATH_H_PBUFFER(path, h) PATH_OFFSET_PBUFFER (path, path->path_length - (h))     /* tb->S[h] */
-#define PATH_H_PPARENT(path, h) PATH_H_PBUFFER (path, (h) + 1)  /* tb->F[h] or tb->S[0]->b_parent */
-#define PATH_H_POSITION(path, h) PATH_OFFSET_POSITION (path, path->path_length - (h))
-#define PATH_H_B_ITEM_ORDER(path, h) PATH_H_POSITION(path, h + 1)       /* tb->S[h]->b_item_order */
-
-#define PATH_H_PATH_OFFSET(path, n_h) ((path)->path_length - (n_h))
-
-#define get_last_bh(path) PATH_PLAST_BUFFER(path)
-#define get_ih(path) PATH_PITEM_HEAD(path)
-#define get_item_pos(path) PATH_LAST_POSITION(path)
-#define get_item(path) ((void *)B_N_PITEM(PATH_PLAST_BUFFER(path), PATH_LAST_POSITION (path)))
-#define item_moved(ih,path) comp_items(ih, path)
-#define path_changed(ih,path) comp_items (ih, path)
-
-/***************************************************************************/
-/*                       MISC                                              */
-/***************************************************************************/
-
-/* Size of pointer to the unformatted node. */
-#define UNFM_P_SIZE (sizeof(unp_t))
-#define UNFM_P_SHIFT 2
-
-// in in-core inode key is stored on le form
-#define INODE_PKEY(inode) ((struct reiserfs_key *)(REISERFS_I(inode)->i_key))
-
-#define MAX_UL_INT 0xffffffff
-#define MAX_INT    0x7ffffff
-#define MAX_US_INT 0xffff
-
-// reiserfs version 2 has max offset 60 bits. Version 1 - 32 bit offset
-#define U32_MAX (~(__u32)0)
-
-static inline loff_t max_reiserfs_offset(struct inode *inode)
-{
-        if (get_inode_item_key_version(inode) == KEY_FORMAT_3_5)
-                return (loff_t) U32_MAX;
-
-        return (loff_t) ((~(__u64) 0) >> 4);
-}
-
-/*#define MAX_KEY_UNIQUENESS    MAX_UL_INT*/
-#define MAX_KEY_OBJECTID        MAX_UL_INT
-
-#define MAX_B_NUM  MAX_UL_INT
-#define MAX_FC_NUM MAX_US_INT
-
-/* the purpose is to detect overflow of an unsigned short */
-#define REISERFS_LINK_MAX (MAX_US_INT - 1000)
-
-/* The following defines are used in reiserfs_insert_item and reiserfs_append_item  */
-#define REISERFS_KERNEL_MEM             0       /* reiserfs kernel memory mode  */
-#define REISERFS_USER_MEM               1       /* reiserfs user memory mode            */
-
-#define fs_generation(s) (REISERFS_SB(s)->s_generation_counter)
-#define get_generation(s) atomic_read (&fs_generation(s))
-#define FILESYSTEM_CHANGED_TB(tb)  (get_generation((tb)->tb_sb) != (tb)->fs_gen)
-#define __fs_changed(gen,s) (gen != get_generation (s))
-#define fs_changed(gen,s)               \
-({                                      \
-        reiserfs_cond_resched(s);       \
-        __fs_changed(gen, s);           \
-})
-
-/***************************************************************************/
-/*                  FIXATE NODES                                           */
-/***************************************************************************/
-
-#define VI_TYPE_LEFT_MERGEABLE 1
-#define VI_TYPE_RIGHT_MERGEABLE 2
-
-/* To make any changes in the tree we always first find node, that
-   contains item to be changed/deleted or place to insert a new
-   item. We call this node S. To do balancing we need to decide what
-   we will shift to left/right neighbor, or to a new node, where new
-   item will be etc. To make this analysis simpler we build virtual
-   node. Virtual node is an array of items, that will replace items of
-   node S. (For instance if we are going to delete an item, virtual
-   node does not contain it). Virtual node keeps information about
-   item sizes and types, mergeability of first and last items, sizes
-   of all entries in directory item. We use this array of items when
-   calculating what we can shift to neighbors and how many nodes we
-   have to have if we do not any shiftings, if we shift to left/right
-   neighbor or to both. */
-struct virtual_item {
-        int vi_index;           // index in the array of item operations
-        unsigned short vi_type; // left/right mergeability
-        unsigned short vi_item_len;     /* length of item that it will have after balancing */
-        struct item_head *vi_ih;
-        const char *vi_item;    // body of item (old or new)
-        const void *vi_new_data;        // 0 always but paste mode
-        void *vi_uarea;         // item specific area
-};
-
-struct virtual_node {
-        char *vn_free_ptr;      /* this is a pointer to the free space in the buffer */
-        unsigned short vn_nr_item;      /* number of items in virtual node */
-        short vn_size;          /* size of node , that node would have if it has unlimited size and no balancing is performed */
-        short vn_mode;          /* mode of balancing (paste, insert, delete, cut) */
-        short vn_affected_item_num;
-        short vn_pos_in_item;
-        struct item_head *vn_ins_ih;    /* item header of inserted item, 0 for other modes */
-        const void *vn_data;
-        struct virtual_item *vn_vi;     /* array of items (including a new one, excluding item to be deleted) */
-};
-
-/* used by directory items when creating virtual nodes */
-struct direntry_uarea {
-        int flags;
-        __u16 entry_count;
-        __u16 entry_sizes[1];
-} __attribute__ ((__packed__));
-
-/***************************************************************************/
-/*                  TREE BALANCE                                           */
-/***************************************************************************/
-
-/* This temporary structure is used in tree balance algorithms, and
-   constructed as we go to the extent that its various parts are
-   needed.  It contains arrays of nodes that can potentially be
-   involved in the balancing of node S, and parameters that define how
-   each of the nodes must be balanced.  Note that in these algorithms
-   for balancing the worst case is to need to balance the current node
-   S and the left and right neighbors and all of their parents plus
-   create a new node.  We implement S1 balancing for the leaf nodes
-   and S0 balancing for the internal nodes (S1 and S0 are defined in
-   our papers.)*/
-
-#define MAX_FREE_BLOCK 7        /* size of the array of buffers to free at end of do_balance */
-
-/* maximum number of FEB blocknrs on a single level */
-#define MAX_AMOUNT_NEEDED 2
-
-/* someday somebody will prefix every field in this struct with tb_ */
-struct tree_balance {
-        int tb_mode;
-        int need_balance_dirty;
-        struct super_block *tb_sb;
-        struct reiserfs_transaction_handle *transaction_handle;
-        struct treepath *tb_path;
-        struct buffer_head *L[MAX_HEIGHT];      /* array of left neighbors of nodes in the path */
-        struct buffer_head *R[MAX_HEIGHT];      /* array of right neighbors of nodes in the path */
-        struct buffer_head *FL[MAX_HEIGHT];     /* array of fathers of the left  neighbors      */
-        struct buffer_head *FR[MAX_HEIGHT];     /* array of fathers of the right neighbors      */
-        struct buffer_head *CFL[MAX_HEIGHT];    /* array of common parents of center node and its left neighbor  */
-        struct buffer_head *CFR[MAX_HEIGHT];    /* array of common parents of center node and its right neighbor */
-
-        struct buffer_head *FEB[MAX_FEB_SIZE];  /* array of empty buffers. Number of buffers in array equals
-                                                   cur_blknum. */
-        struct buffer_head *used[MAX_FEB_SIZE];
-        struct buffer_head *thrown[MAX_FEB_SIZE];
-        int lnum[MAX_HEIGHT];   /* array of number of items which must be
-                                   shifted to the left in order to balance the
-                                   current node; for leaves includes item that
-                                   will be partially shifted; for internal
-                                   nodes, it is the number of child pointers
-                                   rather than items. It includes the new item
-                                   being created. The code sometimes subtracts
-                                   one to get the number of wholly shifted
-                                   items for other purposes. */
-        int rnum[MAX_HEIGHT];   /* substitute right for left in comment above */
-        int lkey[MAX_HEIGHT];   /* array indexed by height h mapping the key delimiting L[h] and
-                                   S[h] to its item number within the node CFL[h] */
-        int rkey[MAX_HEIGHT];   /* substitute r for l in comment above */
-        int insert_size[MAX_HEIGHT];    /* the number of bytes by we are trying to add or remove from
-                                           S[h]. A negative value means removing.  */
-        int blknum[MAX_HEIGHT]; /* number of nodes that will replace node S[h] after
-                                   balancing on the level h of the tree.  If 0 then S is
-                                   being deleted, if 1 then S is remaining and no new nodes
-                                   are being created, if 2 or 3 then 1 or 2 new nodes is
-                                   being created */
-
-        /* fields that are used only for balancing leaves of the tree */
-        int cur_blknum;         /* number of empty blocks having been already allocated                 */
-        int s0num;              /* number of items that fall into left most  node when S[0] splits     */
-        int s1num;              /* number of items that fall into first  new node when S[0] splits     */
-        int s2num;              /* number of items that fall into second new node when S[0] splits     */
-        int lbytes;             /* number of bytes which can flow to the left neighbor from the        left    */
-        /* most liquid item that cannot be shifted from S[0] entirely         */
-        /* if -1 then nothing will be partially shifted */
-        int rbytes;             /* number of bytes which will flow to the right neighbor from the right        */
-        /* most liquid item that cannot be shifted from S[0] entirely         */
-        /* if -1 then nothing will be partially shifted                           */
-        int s1bytes;            /* number of bytes which flow to the first  new node when S[0] splits   */
-        /* note: if S[0] splits into 3 nodes, then items do not need to be cut  */
-        int s2bytes;
-        struct buffer_head *buf_to_free[MAX_FREE_BLOCK];        /* buffers which are to be freed after do_balance finishes by unfix_nodes */
-        char *vn_buf;           /* kmalloced memory. Used to create
-                                   virtual node and keep map of
-                                   dirtied bitmap blocks */
-        int vn_buf_size;        /* size of the vn_buf */
-        struct virtual_node *tb_vn;     /* VN starts after bitmap of bitmap blocks */
-
-        int fs_gen;             /* saved value of `reiserfs_generation' counter
-                                   see FILESYSTEM_CHANGED() macro in reiserfs_fs.h */
-#ifdef DISPLACE_NEW_PACKING_LOCALITIES
-        struct in_core_key key; /* key pointer, to pass to block allocator or
-                                   another low-level subsystem */
-#endif
-};
-
-/* These are modes of balancing */
-
-/* When inserting an item. */
-#define M_INSERT        'i'
-/* When inserting into (directories only) or appending onto an already
-   existent item. */
-#define M_PASTE         'p'
-/* When deleting an item. */
-#define M_DELETE        'd'
-/* When truncating an item or removing an entry from a (directory) item. */
-#define M_CUT           'c'
-
-/* used when balancing on leaf level skipped (in reiserfsck) */
-#define M_INTERNAL      'n'
-
-/* When further balancing is not needed, then do_balance does not need
-   to be called. */
-#define M_SKIP_BALANCING                's'
-#define M_CONVERT       'v'
-
-/* modes of leaf_move_items */
-#define LEAF_FROM_S_TO_L 0
-#define LEAF_FROM_S_TO_R 1
-#define LEAF_FROM_R_TO_L 2
-#define LEAF_FROM_L_TO_R 3
-#define LEAF_FROM_S_TO_SNEW 4
-
-#define FIRST_TO_LAST 0
-#define LAST_TO_FIRST 1
-
-/* used in do_balance for passing parent of node information that has
-   been gotten from tb struct */
-struct buffer_info {
-        struct tree_balance *tb;
-        struct buffer_head *bi_bh;
-        struct buffer_head *bi_parent;
-        int bi_position;
-};
-
-static inline struct super_block *sb_from_tb(struct tree_balance *tb)
-{
-        return tb ? tb->tb_sb : NULL;
-}
-
-static inline struct super_block *sb_from_bi(struct buffer_info *bi)
-{
-        return bi ? sb_from_tb(bi->tb) : NULL;
-}
-
-/* there are 4 types of items: stat data, directory item, indirect, direct.
-+-------------------+------------+--------------+------------+
-|                   |  k_offset  | k_uniqueness | mergeable? |
-+-------------------+------------+--------------+------------+
-|     stat data     |   0        |      0       |   no       |
-+-------------------+------------+--------------+------------+
-| 1st directory item| DOT_OFFSET |DIRENTRY_UNIQUENESS|   no       | 
-| non 1st directory | hash value |              |   yes      |
-|     item          |            |              |            |
-+-------------------+------------+--------------+------------+
-| indirect item     | offset + 1 |TYPE_INDIRECT |   if this is not the first indirect item of the object
-+-------------------+------------+--------------+------------+
-| direct item       | offset + 1 |TYPE_DIRECT   | if not this is not the first direct item of the object
-+-------------------+------------+--------------+------------+
-*/
-
-struct item_operations {
-        int (*bytes_number) (struct item_head * ih, int block_size);
-        void (*decrement_key) (struct cpu_key *);
-        int (*is_left_mergeable) (struct reiserfs_key * ih,
-                                  unsigned long bsize);
-        void (*print_item) (struct item_head *, char *item);
-        void (*check_item) (struct item_head *, char *item);
-
-        int (*create_vi) (struct virtual_node * vn, struct virtual_item * vi,
-                          int is_affected, int insert_size);
-        int (*check_left) (struct virtual_item * vi, int free,
-                           int start_skip, int end_skip);
-        int (*check_right) (struct virtual_item * vi, int free);
-        int (*part_size) (struct virtual_item * vi, int from, int to);
-        int (*unit_num) (struct virtual_item * vi);
-        void (*print_vi) (struct virtual_item * vi);
-};
-
-extern struct item_operations *item_ops[TYPE_ANY + 1];
-
-#define op_bytes_number(ih,bsize)                    item_ops[le_ih_k_type (ih)]->bytes_number (ih, bsize)
-#define op_is_left_mergeable(key,bsize)              item_ops[le_key_k_type (le_key_version (key), key)]->is_left_mergeable (key, bsize)
-#define op_print_item(ih,item)                       item_ops[le_ih_k_type (ih)]->print_item (ih, item)
-#define op_check_item(ih,item)                       item_ops[le_ih_k_type (ih)]->check_item (ih, item)
-#define op_create_vi(vn,vi,is_affected,insert_size)  item_ops[le_ih_k_type ((vi)->vi_ih)]->create_vi (vn,vi,is_affected,insert_size)
-#define op_check_left(vi,free,start_skip,end_skip) item_ops[(vi)->vi_index]->check_left (vi, free, start_skip, end_skip)
-#define op_check_right(vi,free)                      item_ops[(vi)->vi_index]->check_right (vi, free)
-#define op_part_size(vi,from,to)                     item_ops[(vi)->vi_index]->part_size (vi, from, to)
-#define op_unit_num(vi)                              item_ops[(vi)->vi_index]->unit_num (vi)
-#define op_print_vi(vi)                              item_ops[(vi)->vi_index]->print_vi (vi)
-
-#define COMP_SHORT_KEYS comp_short_keys
-
-/* number of blocks pointed to by the indirect item */
-#define I_UNFM_NUM(ih)  (ih_item_len(ih) / UNFM_P_SIZE)
-
-/* the used space within the unformatted node corresponding to pos within the item pointed to by ih */
-#define I_POS_UNFM_SIZE(ih,pos,size) (((pos) == I_UNFM_NUM(ih) - 1 ) ? (size) - ih_free_space(ih) : (size))
-
-/* number of bytes contained by the direct item or the unformatted nodes the indirect item points to */
-
-/* get the item header */
-#define B_N_PITEM_HEAD(bh,item_num) ( (struct item_head * )((bh)->b_data + BLKH_SIZE) + (item_num) )
-
-/* get key */
-#define B_N_PDELIM_KEY(bh,item_num) ( (struct reiserfs_key * )((bh)->b_data + BLKH_SIZE) + (item_num) )
-
-/* get the key */
-#define B_N_PKEY(bh,item_num) ( &(B_N_PITEM_HEAD(bh,item_num)->ih_key) )
-
-/* get item body */
-#define B_N_PITEM(bh,item_num) ( (bh)->b_data + ih_location(B_N_PITEM_HEAD((bh),(item_num))))
-
-/* get the stat data by the buffer header and the item order */
-#define B_N_STAT_DATA(bh,nr) \
-( (struct stat_data *)((bh)->b_data + ih_location(B_N_PITEM_HEAD((bh),(nr))) ) )
-
-    /* following defines use reiserfs buffer header and item header */
-
-/* get stat-data */
-#define B_I_STAT_DATA(bh, ih) ( (struct stat_data * )((bh)->b_data + ih_location(ih)) )
-
-// this is 3976 for size==4096
-#define MAX_DIRECT_ITEM_LEN(size) ((size) - BLKH_SIZE - 2*IH_SIZE - SD_SIZE - UNFM_P_SIZE)
-
-/* indirect items consist of entries which contain blocknrs, pos
-   indicates which entry, and B_I_POS_UNFM_POINTER resolves to the
-   blocknr contained by the entry pos points to */
-#define B_I_POS_UNFM_POINTER(bh,ih,pos) le32_to_cpu(*(((unp_t *)B_I_PITEM(bh,ih)) + (pos)))
-#define PUT_B_I_POS_UNFM_POINTER(bh,ih,pos, val) do {*(((unp_t *)B_I_PITEM(bh,ih)) + (pos)) = cpu_to_le32(val); } while (0)
-
-struct reiserfs_iget_args {
-        __u32 objectid;
-        __u32 dirid;
-};
-
-/***************************************************************************/
-/*                    FUNCTION DECLARATIONS                                */
-/***************************************************************************/
-
-#define get_journal_desc_magic(bh) (bh->b_data + bh->b_size - 12)
-
-#define journal_trans_half(blocksize) \
-        ((blocksize - sizeof (struct reiserfs_journal_desc) + sizeof (__u32) - 12) / sizeof (__u32))
-
-/* journal.c see journal.c for all the comments here */
-
-/* first block written in a commit.  */
-struct reiserfs_journal_desc {
-        __le32 j_trans_id;      /* id of commit */
-        __le32 j_len;           /* length of commit. len +1 is the commit block */
-        __le32 j_mount_id;      /* mount id of this trans */
-        __le32 j_realblock[1];  /* real locations for each block */
-};
-
-#define get_desc_trans_id(d)   le32_to_cpu((d)->j_trans_id)
-#define get_desc_trans_len(d)  le32_to_cpu((d)->j_len)
-#define get_desc_mount_id(d)   le32_to_cpu((d)->j_mount_id)
-
-#define set_desc_trans_id(d,val)       do { (d)->j_trans_id = cpu_to_le32 (val); } while (0)
-#define set_desc_trans_len(d,val)      do { (d)->j_len = cpu_to_le32 (val); } while (0)
-#define set_desc_mount_id(d,val)       do { (d)->j_mount_id = cpu_to_le32 (val); } while (0)
-
-/* last block written in a commit */
-struct reiserfs_journal_commit {
-        __le32 j_trans_id;      /* must match j_trans_id from the desc block */
-        __le32 j_len;           /* ditto */
-        __le32 j_realblock[1];  /* real locations for each block */
-};
-
-#define get_commit_trans_id(c) le32_to_cpu((c)->j_trans_id)
-#define get_commit_trans_len(c)        le32_to_cpu((c)->j_len)
-#define get_commit_mount_id(c) le32_to_cpu((c)->j_mount_id)
-
-#define set_commit_trans_id(c,val)     do { (c)->j_trans_id = cpu_to_le32 (val); } while (0)
-#define set_commit_trans_len(c,val)    do { (c)->j_len = cpu_to_le32 (val); } while (0)
-
-/* this header block gets written whenever a transaction is considered fully flushed, and is more recent than the
-** last fully flushed transaction.  fully flushed means all the log blocks and all the real blocks are on disk,
-** and this transaction does not need to be replayed.
-*/
-struct reiserfs_journal_header {
-        __le32 j_last_flush_trans_id;   /* id of last fully flushed transaction */
-        __le32 j_first_unflushed_offset;        /* offset in the log of where to start replay after a crash */
-        __le32 j_mount_id;
-        /* 12 */ struct journal_params jh_journal;
-};
-
-/* biggest tunable defines are right here */
-#define JOURNAL_BLOCK_COUNT 8192        /* number of blocks in the journal */
-#define JOURNAL_TRANS_MAX_DEFAULT 1024  /* biggest possible single transaction, don't change for now (8/3/99) */
-#define JOURNAL_TRANS_MIN_DEFAULT 256
-#define JOURNAL_MAX_BATCH_DEFAULT   900 /* max blocks to batch into one transaction, don't make this any bigger than 900 */
-#define JOURNAL_MIN_RATIO 2
-#define JOURNAL_MAX_COMMIT_AGE 30
-#define JOURNAL_MAX_TRANS_AGE 30
-#define JOURNAL_PER_BALANCE_CNT (3 * (MAX_HEIGHT-2) + 9)
-#define JOURNAL_BLOCKS_PER_OBJECT(sb)  (JOURNAL_PER_BALANCE_CNT * 3 + \
-                                         2 * (REISERFS_QUOTA_INIT_BLOCKS(sb) + \
-                                              REISERFS_QUOTA_TRANS_BLOCKS(sb)))
-
-#ifdef CONFIG_QUOTA
-#define REISERFS_QUOTA_OPTS ((1 << REISERFS_USRQUOTA) | (1 << REISERFS_GRPQUOTA))
-/* We need to update data and inode (atime) */
-#define REISERFS_QUOTA_TRANS_BLOCKS(s) (REISERFS_SB(s)->s_mount_opt & REISERFS_QUOTA_OPTS ? 2 : 0)
-/* 1 balancing, 1 bitmap, 1 data per write + stat data update */
-#define REISERFS_QUOTA_INIT_BLOCKS(s) (REISERFS_SB(s)->s_mount_opt & REISERFS_QUOTA_OPTS ? \
-(DQUOT_INIT_ALLOC*(JOURNAL_PER_BALANCE_CNT+2)+DQUOT_INIT_REWRITE+1) : 0)
-/* same as with INIT */
-#define REISERFS_QUOTA_DEL_BLOCKS(s) (REISERFS_SB(s)->s_mount_opt & REISERFS_QUOTA_OPTS ? \
-(DQUOT_DEL_ALLOC*(JOURNAL_PER_BALANCE_CNT+2)+DQUOT_DEL_REWRITE+1) : 0)
-#else
-#define REISERFS_QUOTA_TRANS_BLOCKS(s) 0
-#define REISERFS_QUOTA_INIT_BLOCKS(s) 0
-#define REISERFS_QUOTA_DEL_BLOCKS(s) 0
-#endif
-
-/* both of these can be as low as 1, or as high as you want.  The min is the
-** number of 4k bitmap nodes preallocated on mount. New nodes are allocated
-** as needed, and released when transactions are committed.  On release, if 
-** the current number of nodes is > max, the node is freed, otherwise, 
-** it is put on a free list for faster use later.
-*/
-#define REISERFS_MIN_BITMAP_NODES 10
-#define REISERFS_MAX_BITMAP_NODES 100
-
-#define JBH_HASH_SHIFT 13       /* these are based on journal hash size of 8192 */
-#define JBH_HASH_MASK 8191
-
-#define _jhashfn(sb,block)      \
-        (((unsigned long)sb>>L1_CACHE_SHIFT) ^ \
-         (((block)<<(JBH_HASH_SHIFT - 6)) ^ ((block) >> 13) ^ ((block) << (JBH_HASH_SHIFT - 12))))
-#define journal_hash(t,sb,block) ((t)[_jhashfn((sb),(block)) & JBH_HASH_MASK])
-
-// We need these to make journal.c code more readable
-#define journal_find_get_block(s, block) __find_get_block(SB_JOURNAL(s)->j_dev_bd, block, s->s_blocksize)
-#define journal_getblk(s, block) __getblk(SB_JOURNAL(s)->j_dev_bd, block, s->s_blocksize)
-#define journal_bread(s, block) __bread(SB_JOURNAL(s)->j_dev_bd, block, s->s_blocksize)
-
-enum reiserfs_bh_state_bits {
-        BH_JDirty = BH_PrivateStart,    /* buffer is in current transaction */
-        BH_JDirty_wait,
-        BH_JNew,                /* disk block was taken off free list before
-                                 * being in a finished transaction, or
-                                 * written to disk. Can be reused immed. */
-        BH_JPrepared,
-        BH_JRestore_dirty,
-        BH_JTest,               // debugging only will go away
-};
-
-BUFFER_FNS(JDirty, journaled);
-TAS_BUFFER_FNS(JDirty, journaled);
-BUFFER_FNS(JDirty_wait, journal_dirty);
-TAS_BUFFER_FNS(JDirty_wait, journal_dirty);
-BUFFER_FNS(JNew, journal_new);
-TAS_BUFFER_FNS(JNew, journal_new);
-BUFFER_FNS(JPrepared, journal_prepared);
-TAS_BUFFER_FNS(JPrepared, journal_prepared);
-BUFFER_FNS(JRestore_dirty, journal_restore_dirty);
-TAS_BUFFER_FNS(JRestore_dirty, journal_restore_dirty);
-BUFFER_FNS(JTest, journal_test);
-TAS_BUFFER_FNS(JTest, journal_test);
-
-/*
-** transaction handle which is passed around for all journal calls
-*/
-struct reiserfs_transaction_handle {
-        struct super_block *t_super;    /* super for this FS when journal_begin was
-                                           called. saves calls to reiserfs_get_super
-                                           also used by nested transactions to make
-                                           sure they are nesting on the right FS
-                                           _must_ be first in the handle
-                                         */
-        int t_refcount;
-        int t_blocks_logged;    /* number of blocks this writer has logged */
-        int t_blocks_allocated; /* number of blocks this writer allocated */
-        unsigned int t_trans_id;        /* sanity check, equals the current trans id */
-        void *t_handle_save;    /* save existing current->journal_info */
-        unsigned displace_new_blocks:1; /* if new block allocation occurres, that block
-                                           should be displaced from others */
-        struct list_head t_list;
-};
-
-/* used to keep track of ordered and tail writes, attached to the buffer
- * head through b_journal_head.
- */
-struct reiserfs_jh {
-        struct reiserfs_journal_list *jl;
-        struct buffer_head *bh;
-        struct list_head list;
-};
-
-void reiserfs_free_jh(struct buffer_head *bh);
-int reiserfs_add_tail_list(struct inode *inode, struct buffer_head *bh);
-int reiserfs_add_ordered_list(struct inode *inode, struct buffer_head *bh);
-int journal_mark_dirty(struct reiserfs_transaction_handle *,
-                       struct super_block *, struct buffer_head *bh);
-
-static inline int reiserfs_file_data_log(struct inode *inode)
-{
-        if (reiserfs_data_log(inode->i_sb) ||
-            (REISERFS_I(inode)->i_flags & i_data_log))
-                return 1;
-        return 0;
-}
-
-static inline int reiserfs_transaction_running(struct super_block *s)
-{
-        struct reiserfs_transaction_handle *th = current->journal_info;
-        if (th && th->t_super == s)
-                return 1;
-        if (th && th->t_super == NULL)
-                BUG();
-        return 0;
-}
-
-static inline int reiserfs_transaction_free_space(struct reiserfs_transaction_handle *th)
-{
-        return th->t_blocks_allocated - th->t_blocks_logged;
-}
-
-struct reiserfs_transaction_handle *reiserfs_persistent_transaction(struct
-                                                                    super_block
-                                                                    *,
-                                                                    int count);
-int reiserfs_end_persistent_transaction(struct reiserfs_transaction_handle *);
-int reiserfs_commit_page(struct inode *inode, struct page *page,
-                         unsigned from, unsigned to);
-int reiserfs_flush_old_commits(struct super_block *);
-int reiserfs_commit_for_inode(struct inode *);
-int reiserfs_inode_needs_commit(struct inode *);
-void reiserfs_update_inode_transaction(struct inode *);
-void reiserfs_wait_on_write_block(struct super_block *s);
-void reiserfs_block_writes(struct reiserfs_transaction_handle *th);
-void reiserfs_allow_writes(struct super_block *s);
-void reiserfs_check_lock_depth(struct super_block *s, char *caller);
-int reiserfs_prepare_for_journal(struct super_block *, struct buffer_head *bh,
-                                 int wait);
-void reiserfs_restore_prepared_buffer(struct super_block *,
-                                      struct buffer_head *bh);
-int journal_init(struct super_block *, const char *j_dev_name, int old_format,
-                 unsigned int);
-int journal_release(struct reiserfs_transaction_handle *, struct super_block *);
-int journal_release_error(struct reiserfs_transaction_handle *,
-                          struct super_block *);
-int journal_end(struct reiserfs_transaction_handle *, struct super_block *,
-                unsigned long);
-int journal_end_sync(struct reiserfs_transaction_handle *, struct super_block *,
-                     unsigned long);
-int journal_mark_freed(struct reiserfs_transaction_handle *,
-                       struct super_block *, b_blocknr_t blocknr);
-int journal_transaction_should_end(struct reiserfs_transaction_handle *, int);
-int reiserfs_in_journal(struct super_block *sb, unsigned int bmap_nr,
-                         int bit_nr, int searchall, b_blocknr_t *next);
-int journal_begin(struct reiserfs_transaction_handle *,
-                  struct super_block *sb, unsigned long);
-int journal_join_abort(struct reiserfs_transaction_handle *,
-                       struct super_block *sb, unsigned long);
-void reiserfs_abort_journal(struct super_block *sb, int errno);
-void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...);
-int reiserfs_allocate_list_bitmaps(struct super_block *s,
-                                   struct reiserfs_list_bitmap *, unsigned int);
-
-void add_save_link(struct reiserfs_transaction_handle *th,
-                   struct inode *inode, int truncate);
-int remove_save_link(struct inode *inode, int truncate);
-
-/* objectid.c */
-__u32 reiserfs_get_unused_objectid(struct reiserfs_transaction_handle *th);
-void reiserfs_release_objectid(struct reiserfs_transaction_handle *th,
-                               __u32 objectid_to_release);
-int reiserfs_convert_objectid_map_v1(struct super_block *);
-
-/* stree.c */
-int B_IS_IN_TREE(const struct buffer_head *);
-extern void copy_item_head(struct item_head *to,
-                           const struct item_head *from);
-
-// first key is in cpu form, second - le
-extern int comp_short_keys(const struct reiserfs_key *le_key,
-                           const struct cpu_key *cpu_key);
-extern void le_key2cpu_key(struct cpu_key *to, const struct reiserfs_key *from);
-
-// both are in le form
-extern int comp_le_keys(const struct reiserfs_key *,
-                        const struct reiserfs_key *);
-extern int comp_short_le_keys(const struct reiserfs_key *,
-                              const struct reiserfs_key *);
-
-//
-// get key version from on disk key - kludge
-//
-static inline int le_key_version(const struct reiserfs_key *key)
-{
-        int type;
-
-        type = offset_v2_k_type(&(key->u.k_offset_v2));
-        if (type != TYPE_DIRECT && type != TYPE_INDIRECT
-            && type != TYPE_DIRENTRY)
-                return KEY_FORMAT_3_5;
-
-        return KEY_FORMAT_3_6;
-
-}
-
-static inline void copy_key(struct reiserfs_key *to,
-                            const struct reiserfs_key *from)
-{
-        memcpy(to, from, KEY_SIZE);
-}
-
-int comp_items(const struct item_head *stored_ih, const struct treepath *path);
-const struct reiserfs_key *get_rkey(const struct treepath *chk_path,
-                                    const struct super_block *sb);
-int search_by_key(struct super_block *, const struct cpu_key *,
-                  struct treepath *, int);
-#define search_item(s,key,path) search_by_key (s, key, path, DISK_LEAF_NODE_LEVEL)
-int search_for_position_by_key(struct super_block *sb,
-                               const struct cpu_key *cpu_key,
-                               struct treepath *search_path);
-extern void decrement_bcount(struct buffer_head *bh);
-void decrement_counters_in_path(struct treepath *search_path);
-void pathrelse(struct treepath *search_path);
-int reiserfs_check_path(struct treepath *p);
-void pathrelse_and_restore(struct super_block *s, struct treepath *search_path);
-
-int reiserfs_insert_item(struct reiserfs_transaction_handle *th,
-                         struct treepath *path,
-                         const struct cpu_key *key,
-                         struct item_head *ih,
-                         struct inode *inode, const char *body);
-
-int reiserfs_paste_into_item(struct reiserfs_transaction_handle *th,
-                             struct treepath *path,
-                             const struct cpu_key *key,
-                             struct inode *inode,
-                             const char *body, int paste_size);
-
-int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
-                           struct treepath *path,
-                           struct cpu_key *key,
-                           struct inode *inode,
-                           struct page *page, loff_t new_file_size);
-
-int reiserfs_delete_item(struct reiserfs_transaction_handle *th,
-                         struct treepath *path,
-                         const struct cpu_key *key,
-                         struct inode *inode, struct buffer_head *un_bh);
-
-void reiserfs_delete_solid_item(struct reiserfs_transaction_handle *th,
-                                struct inode *inode, struct reiserfs_key *key);
-int reiserfs_delete_object(struct reiserfs_transaction_handle *th,
-                           struct inode *inode);
-int reiserfs_do_truncate(struct reiserfs_transaction_handle *th,
-                         struct inode *inode, struct page *,
-                         int update_timestamps);
-
-#define i_block_size(inode) ((inode)->i_sb->s_blocksize)
-#define file_size(inode) ((inode)->i_size)
-#define tail_size(inode) (file_size (inode) & (i_block_size (inode) - 1))
-
-#define tail_has_to_be_packed(inode) (have_large_tails ((inode)->i_sb)?\
-!STORE_TAIL_IN_UNFM_S1(file_size (inode), tail_size(inode), inode->i_sb->s_blocksize):have_small_tails ((inode)->i_sb)?!STORE_TAIL_IN_UNFM_S2(file_size (inode), tail_size(inode), inode->i_sb->s_blocksize):0 )
-
-void padd_item(char *item, int total_length, int length);
-
-/* inode.c */
-/* args for the create parameter of reiserfs_get_block */
-#define GET_BLOCK_NO_CREATE 0   /* don't create new blocks or convert tails */
-#define GET_BLOCK_CREATE 1      /* add anything you need to find block */
-#define GET_BLOCK_NO_HOLE 2     /* return -ENOENT for file holes */
-#define GET_BLOCK_READ_DIRECT 4 /* read the tail if indirect item not found */
-#define GET_BLOCK_NO_IMUX     8 /* i_mutex is not held, don't preallocate */
-#define GET_BLOCK_NO_DANGLE   16        /* don't leave any transactions running */
-
-void reiserfs_read_locked_inode(struct inode *inode,
-                                struct reiserfs_iget_args *args);
-int reiserfs_find_actor(struct inode *inode, void *p);
-int reiserfs_init_locked_inode(struct inode *inode, void *p);
-void reiserfs_evict_inode(struct inode *inode);
-int reiserfs_write_inode(struct inode *inode, struct writeback_control *wbc);
-int reiserfs_get_block(struct inode *inode, sector_t block,
-                       struct buffer_head *bh_result, int create);
-struct dentry *reiserfs_fh_to_dentry(struct super_block *sb, struct fid *fid,
-                                     int fh_len, int fh_type);
-struct dentry *reiserfs_fh_to_parent(struct super_block *sb, struct fid *fid,
-                                     int fh_len, int fh_type);
-int reiserfs_encode_fh(struct dentry *dentry, __u32 * data, int *lenp,
-                       int connectable);
-
-int reiserfs_truncate_file(struct inode *, int update_timestamps);
-void make_cpu_key(struct cpu_key *cpu_key, struct inode *inode, loff_t offset,
-                  int type, int key_length);
-void make_le_item_head(struct item_head *ih, const struct cpu_key *key,
-                       int version,
-                       loff_t offset, int type, int length, int entry_count);
-struct inode *reiserfs_iget(struct super_block *s, const struct cpu_key *key);
-
-struct reiserfs_security_handle;
-int reiserfs_new_inode(struct reiserfs_transaction_handle *th,
-                       struct inode *dir, umode_t mode,
-                       const char *symname, loff_t i_size,
-                       struct dentry *dentry, struct inode *inode,
-                       struct reiserfs_security_handle *security);
-
-void reiserfs_update_sd_size(struct reiserfs_transaction_handle *th,
-                             struct inode *inode, loff_t size);
-
-static inline void reiserfs_update_sd(struct reiserfs_transaction_handle *th,
-                                      struct inode *inode)
-{
-        reiserfs_update_sd_size(th, inode, inode->i_size);
-}
-
-void sd_attrs_to_i_attrs(__u16 sd_attrs, struct inode *inode);
-void i_attrs_to_sd_attrs(struct inode *inode, __u16 * sd_attrs);
-int reiserfs_setattr(struct dentry *dentry, struct iattr *attr);
-
-int __reiserfs_write_begin(struct page *page, unsigned from, unsigned len);
-
-/* namei.c */
-void set_de_name_and_namelen(struct reiserfs_dir_entry *de);
-int search_by_entry_key(struct super_block *sb, const struct cpu_key *key,
-                        struct treepath *path, struct reiserfs_dir_entry *de);
-struct dentry *reiserfs_get_parent(struct dentry *);
-
-#ifdef CONFIG_REISERFS_PROC_INFO
-int reiserfs_proc_info_init(struct super_block *sb);
-int reiserfs_proc_info_done(struct super_block *sb);
-int reiserfs_proc_info_global_init(void);
-int reiserfs_proc_info_global_done(void);
-
-#define PROC_EXP( e )   e
-
-#define __PINFO( sb ) REISERFS_SB(sb) -> s_proc_info_data
-#define PROC_INFO_MAX( sb, field, value )                                                               \
-    __PINFO( sb ).field =                                                                                               \
-        max( REISERFS_SB( sb ) -> s_proc_info_data.field, value )
-#define PROC_INFO_INC( sb, field ) ( ++ ( __PINFO( sb ).field ) )
-#define PROC_INFO_ADD( sb, field, val ) ( __PINFO( sb ).field += ( val ) )
-#define PROC_INFO_BH_STAT( sb, bh, level )                                                      \
-    PROC_INFO_INC( sb, sbk_read_at[ ( level ) ] );                                              \
-    PROC_INFO_ADD( sb, free_at[ ( level ) ], B_FREE_SPACE( bh ) );      \
-    PROC_INFO_ADD( sb, items_at[ ( level ) ], B_NR_ITEMS( bh ) )
-#else
-static inline int reiserfs_proc_info_init(struct super_block *sb)
-{
-        return 0;
-}
-
-static inline int reiserfs_proc_info_done(struct super_block *sb)
-{
-        return 0;
-}
-
-static inline int reiserfs_proc_info_global_init(void)
-{
-        return 0;
-}
-
-static inline int reiserfs_proc_info_global_done(void)
-{
-        return 0;
-}
-
-#define PROC_EXP( e )
-#define VOID_V ( ( void ) 0 )
-#define PROC_INFO_MAX( sb, field, value ) VOID_V
-#define PROC_INFO_INC( sb, field ) VOID_V
-#define PROC_INFO_ADD( sb, field, val ) VOID_V
-#define PROC_INFO_BH_STAT(sb, bh, n_node_level) VOID_V
-#endif
-
-/* dir.c */
-extern const struct inode_operations reiserfs_dir_inode_operations;
-extern const struct inode_operations reiserfs_symlink_inode_operations;
-extern const struct inode_operations reiserfs_special_inode_operations;
-extern const struct file_operations reiserfs_dir_operations;
-int reiserfs_readdir_dentry(struct dentry *, void *, filldir_t, loff_t *);
-
-/* tail_conversion.c */
-int direct2indirect(struct reiserfs_transaction_handle *, struct inode *,
-                    struct treepath *, struct buffer_head *, loff_t);
-int indirect2direct(struct reiserfs_transaction_handle *, struct inode *,
-                    struct page *, struct treepath *, const struct cpu_key *,
-                    loff_t, char *);
-void reiserfs_unmap_buffer(struct buffer_head *);
-
-/* file.c */
-extern const struct inode_operations reiserfs_file_inode_operations;
-extern const struct file_operations reiserfs_file_operations;
-extern const struct address_space_operations reiserfs_address_space_operations;
-
-/* fix_nodes.c */
-
-int fix_nodes(int n_op_mode, struct tree_balance *tb,
-              struct item_head *ins_ih, const void *);
-void unfix_nodes(struct tree_balance *);
-
-/* prints.c */
-void __reiserfs_panic(struct super_block *s, const char *id,
-                      const char *function, const char *fmt, ...)
-    __attribute__ ((noreturn));
-#define reiserfs_panic(s, id, fmt, args...) \
-        __reiserfs_panic(s, id, __func__, fmt, ##args)
-void __reiserfs_error(struct super_block *s, const char *id,
-                      const char *function, const char *fmt, ...);
-#define reiserfs_error(s, id, fmt, args...) \
-         __reiserfs_error(s, id, __func__, fmt, ##args)
-void reiserfs_info(struct super_block *s, const char *fmt, ...);
-void reiserfs_debug(struct super_block *s, int level, const char *fmt, ...);
-void print_indirect_item(struct buffer_head *bh, int item_num);
-void store_print_tb(struct tree_balance *tb);
-void print_cur_tb(char *mes);
-void print_de(struct reiserfs_dir_entry *de);
-void print_bi(struct buffer_info *bi, char *mes);
-#define PRINT_LEAF_ITEMS 1      /* print all items */
-#define PRINT_DIRECTORY_ITEMS 2 /* print directory items */
-#define PRINT_DIRECT_ITEMS 4    /* print contents of direct items */
-void print_block(struct buffer_head *bh, ...);
-void print_bmap(struct super_block *s, int silent);
-void print_bmap_block(int i, char *data, int size, int silent);
-/*void print_super_block (struct super_block * s, char * mes);*/
-void print_objectid_map(struct super_block *s);
-void print_block_head(struct buffer_head *bh, char *mes);
-void check_leaf(struct buffer_head *bh);
-void check_internal(struct buffer_head *bh);
-void print_statistics(struct super_block *s);
-char *reiserfs_hashname(int code);
-
-/* lbalance.c */
-int leaf_move_items(int shift_mode, struct tree_balance *tb, int mov_num,
-                    int mov_bytes, struct buffer_head *Snew);
-int leaf_shift_left(struct tree_balance *tb, int shift_num, int shift_bytes);
-int leaf_shift_right(struct tree_balance *tb, int shift_num, int shift_bytes);
-void leaf_delete_items(struct buffer_info *cur_bi, int last_first, int first,
-                       int del_num, int del_bytes);
-void leaf_insert_into_buf(struct buffer_info *bi, int before,
-                          struct item_head *inserted_item_ih,
-                          const char *inserted_item_body, int zeros_number);
-void leaf_paste_in_buffer(struct buffer_info *bi, int pasted_item_num,
-                          int pos_in_item, int paste_size, const char *body,
-                          int zeros_number);
-void leaf_cut_from_buffer(struct buffer_info *bi, int cut_item_num,
-                          int pos_in_item, int cut_size);
-void leaf_paste_entries(struct buffer_info *bi, int item_num, int before,
-                        int new_entry_count, struct reiserfs_de_head *new_dehs,
-                        const char *records, int paste_size);
-/* ibalance.c */
-int balance_internal(struct tree_balance *, int, int, struct item_head *,
-                     struct buffer_head **);
-
-/* do_balance.c */
-void do_balance_mark_leaf_dirty(struct tree_balance *tb,
-                                struct buffer_head *bh, int flag);
-#define do_balance_mark_internal_dirty do_balance_mark_leaf_dirty
-#define do_balance_mark_sb_dirty do_balance_mark_leaf_dirty
-
-void do_balance(struct tree_balance *tb, struct item_head *ih,
-                const char *body, int flag);
-void reiserfs_invalidate_buffer(struct tree_balance *tb,
-                                struct buffer_head *bh);
-
-int get_left_neighbor_position(struct tree_balance *tb, int h);
-int get_right_neighbor_position(struct tree_balance *tb, int h);
-void replace_key(struct tree_balance *tb, struct buffer_head *, int,
-                 struct buffer_head *, int);
-void make_empty_node(struct buffer_info *);
-struct buffer_head *get_FEB(struct tree_balance *);
-
-/* bitmap.c */
-
-/* structure contains hints for block allocator, and it is a container for
- * arguments, such as node, search path, transaction_handle, etc. */
-struct __reiserfs_blocknr_hint {
-        struct inode *inode;    /* inode passed to allocator, if we allocate unf. nodes */
-        sector_t block;         /* file offset, in blocks */
-        struct in_core_key key;
-        struct treepath *path;  /* search path, used by allocator to deternine search_start by
-                                 * various ways */
-        struct reiserfs_transaction_handle *th; /* transaction handle is needed to log super blocks and
-                                                 * bitmap blocks changes  */
-        b_blocknr_t beg, end;
-        b_blocknr_t search_start;       /* a field used to transfer search start value (block number)
-                                         * between different block allocator procedures
-                                         * (determine_search_start() and others) */
-        int prealloc_size;      /* is set in determine_prealloc_size() function, used by underlayed
-                                 * function that do actual allocation */
-
-        unsigned formatted_node:1;      /* the allocator uses different polices for getting disk space for
-                                         * formatted/unformatted blocks with/without preallocation */
-        unsigned preallocate:1;
-};
-
-typedef struct __reiserfs_blocknr_hint reiserfs_blocknr_hint_t;
-
-int reiserfs_parse_alloc_options(struct super_block *, char *);
-void reiserfs_init_alloc_options(struct super_block *s);
-
-/*
- * given a directory, this will tell you what packing locality
- * to use for a new object underneat it.  The locality is returned
- * in disk byte order (le).
- */
-__le32 reiserfs_choose_packing(struct inode *dir);
-
-int reiserfs_init_bitmap_cache(struct super_block *sb);
-void reiserfs_free_bitmap_cache(struct super_block *sb);
-void reiserfs_cache_bitmap_metadata(struct super_block *sb, struct buffer_head *bh, struct reiserfs_bitmap_info *info);
-struct buffer_head *reiserfs_read_bitmap_block(struct super_block *sb, unsigned int bitmap);
-int is_reusable(struct super_block *s, b_blocknr_t block, int bit_value);
-void reiserfs_free_block(struct reiserfs_transaction_handle *th, struct inode *,
-                         b_blocknr_t, int for_unformatted);
-int reiserfs_allocate_blocknrs(reiserfs_blocknr_hint_t *, b_blocknr_t *, int,
-                               int);
-static inline int reiserfs_new_form_blocknrs(struct tree_balance *tb,
-                                             b_blocknr_t * new_blocknrs,
-                                             int amount_needed)
-{
-        reiserfs_blocknr_hint_t hint = {
-                .th = tb->transaction_handle,
-                .path = tb->tb_path,
-                .inode = NULL,
-                .key = tb->key,
-                .block = 0,
-                .formatted_node = 1
-        };
-        return reiserfs_allocate_blocknrs(&hint, new_blocknrs, amount_needed,
-                                          0);
-}
-
-static inline int reiserfs_new_unf_blocknrs(struct reiserfs_transaction_handle
-                                            *th, struct inode *inode,
-                                            b_blocknr_t * new_blocknrs,
-                                            struct treepath *path,
-                                            sector_t block)
-{
-        reiserfs_blocknr_hint_t hint = {
-                .th = th,
-                .path = path,
-                .inode = inode,
-                .block = block,
-                .formatted_node = 0,
-                .preallocate = 0
-        };
-        return reiserfs_allocate_blocknrs(&hint, new_blocknrs, 1, 0);
-}
-
-#ifdef REISERFS_PREALLOCATE
-static inline int reiserfs_new_unf_blocknrs2(struct reiserfs_transaction_handle
-                                             *th, struct inode *inode,
-                                             b_blocknr_t * new_blocknrs,
-                                             struct treepath *path,
-                                             sector_t block)
-{
-        reiserfs_blocknr_hint_t hint = {
-                .th = th,
-                .path = path,
-                .inode = inode,
-                .block = block,
-                .formatted_node = 0,
-                .preallocate = 1
-        };
-        return reiserfs_allocate_blocknrs(&hint, new_blocknrs, 1, 0);
-}
-
-void reiserfs_discard_prealloc(struct reiserfs_transaction_handle *th,
-                               struct inode *inode);
-void reiserfs_discard_all_prealloc(struct reiserfs_transaction_handle *th);
-#endif
-
-/* hashes.c */
-__u32 keyed_hash(const signed char *msg, int len);
-__u32 yura_hash(const signed char *msg, int len);
-__u32 r5_hash(const signed char *msg, int len);
-
-#define reiserfs_set_le_bit             __set_bit_le
-#define reiserfs_test_and_set_le_bit    __test_and_set_bit_le
-#define reiserfs_clear_le_bit           __clear_bit_le
-#define reiserfs_test_and_clear_le_bit  __test_and_clear_bit_le
-#define reiserfs_test_le_bit            test_bit_le
-#define reiserfs_find_next_zero_le_bit  find_next_zero_bit_le
-
-/* sometimes reiserfs_truncate may require to allocate few new blocks
-   to perform indirect2direct conversion. People probably used to
-   think, that truncate should work without problems on a filesystem
-   without free disk space. They may complain that they can not
-   truncate due to lack of free disk space. This spare space allows us
-   to not worry about it. 500 is probably too much, but it should be
-   absolutely safe */
-#define SPARE_SPACE 500
-
-/* prototypes from ioctl.c */
-long reiserfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);
-long reiserfs_compat_ioctl(struct file *filp,
-                   unsigned int cmd, unsigned long arg);
-int reiserfs_unpack(struct inode *inode, struct file *filp);
-
-#endif /* __KERNEL__ */
-
 #endif                          /* _LINUX_REISER_FS_H */
diff --git a/include/linux/reiserfs_fs_i.h b/include/linux/reiserfs_fs_i.h
deleted file mode 100644
index 97959bdfe214..000000000000
--- a/include/linux/reiserfs_fs_i.h
+++ /dev/null
@@ -1,63 +0,0 @@
-#ifndef _REISER_FS_I
-#define _REISER_FS_I
-
-#include <linux/list.h>
-
-struct reiserfs_journal_list;
-
-/** bitmasks for i_flags field in reiserfs-specific part of inode */
-typedef enum {
-    /** this says what format of key do all items (but stat data) of
-      an object have.  If this is set, that format is 3.6 otherwise
-      - 3.5 */
-        i_item_key_version_mask = 0x0001,
-    /** If this is unset, object has 3.5 stat data, otherwise, it has
-      3.6 stat data with 64bit size, 32bit nlink etc. */
-        i_stat_data_version_mask = 0x0002,
-    /** file might need tail packing on close */
-        i_pack_on_close_mask = 0x0004,
-    /** don't pack tail of file */
-        i_nopack_mask = 0x0008,
-    /** If those is set, "safe link" was created for this file during
-      truncate or unlink. Safe link is used to avoid leakage of disk
-      space on crash with some files open, but unlinked. */
-        i_link_saved_unlink_mask = 0x0010,
-        i_link_saved_truncate_mask = 0x0020,
-        i_has_xattr_dir = 0x0040,
-        i_data_log = 0x0080,
-} reiserfs_inode_flags;
-
-struct reiserfs_inode_info {
-        __u32 i_key[4];         /* key is still 4 32 bit integers */
-    /** transient inode flags that are never stored on disk. Bitmasks
-      for this field are defined above. */
-        __u32 i_flags;
-
-        __u32 i_first_direct_byte;      // offset of first byte stored in direct item.
-
-        /* copy of persistent inode flags read from sd_attrs. */
-        __u32 i_attrs;
-
-        int i_prealloc_block;   /* first unused block of a sequence of unused blocks */
-        int i_prealloc_count;   /* length of that sequence */
-        struct list_head i_prealloc_list;       /* per-transaction list of inodes which
-                                                 * have preallocated blocks */
-
-        unsigned new_packing_locality:1;        /* new_packig_locality is created; new blocks
-                                                 * for the contents of this directory should be
-                                                 * displaced */
-
-        /* we use these for fsync or O_SYNC to decide which transaction
-         ** needs to be committed in order for this inode to be properly
-         ** flushed */
-        unsigned int i_trans_id;
-        struct reiserfs_journal_list *i_jl;
-        atomic_t openers;
-        struct mutex tailpack;
-#ifdef CONFIG_REISERFS_FS_XATTR
-        struct rw_semaphore i_xattr_sem;
-#endif
-        struct inode vfs_inode;
-};
-
-#endif
diff --git a/include/linux/reiserfs_fs_sb.h b/include/linux/reiserfs_fs_sb.h
deleted file mode 100644
index 8c9e85c64b46..000000000000
--- a/include/linux/reiserfs_fs_sb.h
+++ /dev/null
@@ -1,554 +0,0 @@
-/* Copyright 1996-2000 Hans Reiser, see reiserfs/README for licensing
- * and copyright details */
-
-#ifndef _LINUX_REISER_FS_SB
-#define _LINUX_REISER_FS_SB
-
-#ifdef __KERNEL__
-#include <linux/workqueue.h>
-#include <linux/rwsem.h>
-#include <linux/mutex.h>
-#include <linux/sched.h>
-#endif
-
-typedef enum {
-        reiserfs_attrs_cleared = 0x00000001,
-} reiserfs_super_block_flags;
-
-/* struct reiserfs_super_block accessors/mutators
- * since this is a disk structure, it will always be in
- * little endian format. */
-#define sb_block_count(sbp)         (le32_to_cpu((sbp)->s_v1.s_block_count))
-#define set_sb_block_count(sbp,v)   ((sbp)->s_v1.s_block_count = cpu_to_le32(v))
-#define sb_free_blocks(sbp)         (le32_to_cpu((sbp)->s_v1.s_free_blocks))
-#define set_sb_free_blocks(sbp,v)   ((sbp)->s_v1.s_free_blocks = cpu_to_le32(v))
-#define sb_root_block(sbp)          (le32_to_cpu((sbp)->s_v1.s_root_block))
-#define set_sb_root_block(sbp,v)    ((sbp)->s_v1.s_root_block = cpu_to_le32(v))
-
-#define sb_jp_journal_1st_block(sbp)  \
-              (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_1st_block))
-#define set_sb_jp_journal_1st_block(sbp,v) \
-              ((sbp)->s_v1.s_journal.jp_journal_1st_block = cpu_to_le32(v))
-#define sb_jp_journal_dev(sbp) \
-              (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_dev))
-#define set_sb_jp_journal_dev(sbp,v) \
-              ((sbp)->s_v1.s_journal.jp_journal_dev = cpu_to_le32(v))
-#define sb_jp_journal_size(sbp) \
-              (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_size))
-#define set_sb_jp_journal_size(sbp,v) \
-              ((sbp)->s_v1.s_journal.jp_journal_size = cpu_to_le32(v))
-#define sb_jp_journal_trans_max(sbp) \
-              (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_trans_max))
-#define set_sb_jp_journal_trans_max(sbp,v) \
-              ((sbp)->s_v1.s_journal.jp_journal_trans_max = cpu_to_le32(v))
-#define sb_jp_journal_magic(sbp) \
-              (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_magic))
-#define set_sb_jp_journal_magic(sbp,v) \
-              ((sbp)->s_v1.s_journal.jp_journal_magic = cpu_to_le32(v))
-#define sb_jp_journal_max_batch(sbp) \
-              (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_max_batch))
-#define set_sb_jp_journal_max_batch(sbp,v) \
-              ((sbp)->s_v1.s_journal.jp_journal_max_batch = cpu_to_le32(v))
-#define sb_jp_jourmal_max_commit_age(sbp) \
-              (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_max_commit_age))
-#define set_sb_jp_journal_max_commit_age(sbp,v) \
-              ((sbp)->s_v1.s_journal.jp_journal_max_commit_age = cpu_to_le32(v))
-
-#define sb_blocksize(sbp)          (le16_to_cpu((sbp)->s_v1.s_blocksize))
-#define set_sb_blocksize(sbp,v)    ((sbp)->s_v1.s_blocksize = cpu_to_le16(v))
-#define sb_oid_maxsize(sbp)        (le16_to_cpu((sbp)->s_v1.s_oid_maxsize))
-#define set_sb_oid_maxsize(sbp,v)  ((sbp)->s_v1.s_oid_maxsize = cpu_to_le16(v))
-#define sb_oid_cursize(sbp)        (le16_to_cpu((sbp)->s_v1.s_oid_cursize))
-#define set_sb_oid_cursize(sbp,v)  ((sbp)->s_v1.s_oid_cursize = cpu_to_le16(v))
-#define sb_umount_state(sbp)       (le16_to_cpu((sbp)->s_v1.s_umount_state))
-#define set_sb_umount_state(sbp,v) ((sbp)->s_v1.s_umount_state = cpu_to_le16(v))
-#define sb_fs_state(sbp)           (le16_to_cpu((sbp)->s_v1.s_fs_state))
-#define set_sb_fs_state(sbp,v)     ((sbp)->s_v1.s_fs_state = cpu_to_le16(v))
-#define sb_hash_function_code(sbp) \
-              (le32_to_cpu((sbp)->s_v1.s_hash_function_code))
-#define set_sb_hash_function_code(sbp,v) \
-              ((sbp)->s_v1.s_hash_function_code = cpu_to_le32(v))
-#define sb_tree_height(sbp)        (le16_to_cpu((sbp)->s_v1.s_tree_height))
-#define set_sb_tree_height(sbp,v)  ((sbp)->s_v1.s_tree_height = cpu_to_le16(v))
-#define sb_bmap_nr(sbp)            (le16_to_cpu((sbp)->s_v1.s_bmap_nr))
-#define set_sb_bmap_nr(sbp,v)      ((sbp)->s_v1.s_bmap_nr = cpu_to_le16(v))
-#define sb_version(sbp)            (le16_to_cpu((sbp)->s_v1.s_version))
-#define set_sb_version(sbp,v)      ((sbp)->s_v1.s_version = cpu_to_le16(v))
-
-#define sb_mnt_count(sbp)          (le16_to_cpu((sbp)->s_mnt_count))
-#define set_sb_mnt_count(sbp, v)   ((sbp)->s_mnt_count = cpu_to_le16(v))
-
-#define sb_reserved_for_journal(sbp) \
-              (le16_to_cpu((sbp)->s_v1.s_reserved_for_journal))
-#define set_sb_reserved_for_journal(sbp,v) \
-              ((sbp)->s_v1.s_reserved_for_journal = cpu_to_le16(v))
-
-/* LOGGING -- */
-
-/* These all interelate for performance.
-**
-** If the journal block count is smaller than n transactions, you lose speed.
-** I don't know what n is yet, I'm guessing 8-16.
-**
-** typical transaction size depends on the application, how often fsync is
-** called, and how many metadata blocks you dirty in a 30 second period.
-** The more small files (<16k) you use, the larger your transactions will
-** be.
-**
-** If your journal fills faster than dirty buffers get flushed to disk, it must flush them before allowing the journal
-** to wrap, which slows things down.  If you need high speed meta data updates, the journal should be big enough
-** to prevent wrapping before dirty meta blocks get to disk.
-**
-** If the batch max is smaller than the transaction max, you'll waste space at the end of the journal
-** because journal_end sets the next transaction to start at 0 if the next transaction has any chance of wrapping.
-**
-** The large the batch max age, the better the speed, and the more meta data changes you'll lose after a crash.
-**
-*/
-
-/* don't mess with these for a while */
-                                /* we have a node size define somewhere in reiserfs_fs.h. -Hans */
-#define JOURNAL_BLOCK_SIZE  4096        /* BUG gotta get rid of this */
-#define JOURNAL_MAX_CNODE   1500        /* max cnodes to allocate. */
-#define JOURNAL_HASH_SIZE 8192
-#define JOURNAL_NUM_BITMAPS 5   /* number of copies of the bitmaps to have floating.  Must be >= 2 */
-
-/* One of these for every block in every transaction
-** Each one is in two hash tables.  First, a hash of the current transaction, and after journal_end, a
-** hash of all the in memory transactions.
-** next and prev are used by the current transaction (journal_hash).
-** hnext and hprev are used by journal_list_hash.  If a block is in more than one transaction, the journal_list_hash
-** links it in multiple times.  This allows flush_journal_list to remove just the cnode belonging
-** to a given transaction.
-*/
-struct reiserfs_journal_cnode {
-        struct buffer_head *bh; /* real buffer head */
-        struct super_block *sb; /* dev of real buffer head */
-        __u32 blocknr;          /* block number of real buffer head, == 0 when buffer on disk */
-        unsigned long state;
-        struct reiserfs_journal_list *jlist;    /* journal list this cnode lives in */
-        struct reiserfs_journal_cnode *next;    /* next in transaction list */
-        struct reiserfs_journal_cnode *prev;    /* prev in transaction list */
-        struct reiserfs_journal_cnode *hprev;   /* prev in hash list */
-        struct reiserfs_journal_cnode *hnext;   /* next in hash list */
-};
-
-struct reiserfs_bitmap_node {
-        int id;
-        char *data;
-        struct list_head list;
-};
-
-struct reiserfs_list_bitmap {
-        struct reiserfs_journal_list *journal_list;
-        struct reiserfs_bitmap_node **bitmaps;
-};
-
-/*
-** one of these for each transaction.  The most important part here is the j_realblock.
-** this list of cnodes is used to hash all the blocks in all the commits, to mark all the
-** real buffer heads dirty once all the commits hit the disk,
-** and to make sure every real block in a transaction is on disk before allowing the log area
-** to be overwritten */
-struct reiserfs_journal_list {
-        unsigned long j_start;
-        unsigned long j_state;
-        unsigned long j_len;
-        atomic_t j_nonzerolen;
-        atomic_t j_commit_left;
-        atomic_t j_older_commits_done;  /* all commits older than this on disk */
-        struct mutex j_commit_mutex;
-        unsigned int j_trans_id;
-        time_t j_timestamp;
-        struct reiserfs_list_bitmap *j_list_bitmap;
-        struct buffer_head *j_commit_bh;        /* commit buffer head */
-        struct reiserfs_journal_cnode *j_realblock;
-        struct reiserfs_journal_cnode *j_freedlist;     /* list of buffers that were freed during this trans.  free each of these on flush */
-        /* time ordered list of all active transactions */
-        struct list_head j_list;
-
-        /* time ordered list of all transactions we haven't tried to flush yet */
-        struct list_head j_working_list;
-
-        /* list of tail conversion targets in need of flush before commit */
-        struct list_head j_tail_bh_list;
-        /* list of data=ordered buffers in need of flush before commit */
-        struct list_head j_bh_list;
-        int j_refcount;
-};
-
-struct reiserfs_journal {
-        struct buffer_head **j_ap_blocks;       /* journal blocks on disk */
-        struct reiserfs_journal_cnode *j_last;  /* newest journal block */
-        struct reiserfs_journal_cnode *j_first; /*  oldest journal block.  start here for traverse */
-
-        struct block_device *j_dev_bd;
-        fmode_t j_dev_mode;
-        int j_1st_reserved_block;       /* first block on s_dev of reserved area journal */
-
-        unsigned long j_state;
-        unsigned int j_trans_id;
-        unsigned long j_mount_id;
-        unsigned long j_start;  /* start of current waiting commit (index into j_ap_blocks) */
-        unsigned long j_len;    /* length of current waiting commit */
-        unsigned long j_len_alloc;      /* number of buffers requested by journal_begin() */
-        atomic_t j_wcount;      /* count of writers for current commit */
-        unsigned long j_bcount; /* batch count. allows turning X transactions into 1 */
-        unsigned long j_first_unflushed_offset; /* first unflushed transactions offset */
-        unsigned j_last_flush_trans_id; /* last fully flushed journal timestamp */
-        struct buffer_head *j_header_bh;
-
-        time_t j_trans_start_time;      /* time this transaction started */
-        struct mutex j_mutex;
-        struct mutex j_flush_mutex;
-        wait_queue_head_t j_join_wait;  /* wait for current transaction to finish before starting new one */
-        atomic_t j_jlock;       /* lock for j_join_wait */
-        int j_list_bitmap_index;        /* number of next list bitmap to use */
-        int j_must_wait;        /* no more journal begins allowed. MUST sleep on j_join_wait */
-        int j_next_full_flush;  /* next journal_end will flush all journal list */
-        int j_next_async_flush; /* next journal_end will flush all async commits */
-
-        int j_cnode_used;       /* number of cnodes on the used list */
-        int j_cnode_free;       /* number of cnodes on the free list */
-
-        unsigned int j_trans_max;       /* max number of blocks in a transaction.  */
-        unsigned int j_max_batch;       /* max number of blocks to batch into a trans */
-        unsigned int j_max_commit_age;  /* in seconds, how old can an async commit be */
-        unsigned int j_max_trans_age;   /* in seconds, how old can a transaction be */
-        unsigned int j_default_max_commit_age;  /* the default for the max commit age */
-
-        struct reiserfs_journal_cnode *j_cnode_free_list;
-        struct reiserfs_journal_cnode *j_cnode_free_orig;       /* orig pointer returned from vmalloc */
-
-        struct reiserfs_journal_list *j_current_jl;
-        int j_free_bitmap_nodes;
-        int j_used_bitmap_nodes;
-
-        int j_num_lists;        /* total number of active transactions */
-        int j_num_work_lists;   /* number that need attention from kreiserfsd */
-
-        /* debugging to make sure things are flushed in order */
-        unsigned int j_last_flush_id;
-
-        /* debugging to make sure things are committed in order */
-        unsigned int j_last_commit_id;
-
-        struct list_head j_bitmap_nodes;
-        struct list_head j_dirty_buffers;
-        spinlock_t j_dirty_buffers_lock;        /* protects j_dirty_buffers */
-
-        /* list of all active transactions */
-        struct list_head j_journal_list;
-        /* lists that haven't been touched by writeback attempts */
-        struct list_head j_working_list;
-
-        struct reiserfs_list_bitmap j_list_bitmap[JOURNAL_NUM_BITMAPS]; /* array of bitmaps to record the deleted blocks */
-        struct reiserfs_journal_cnode *j_hash_table[JOURNAL_HASH_SIZE]; /* hash table for real buffer heads in current trans */
-        struct reiserfs_journal_cnode *j_list_hash_table[JOURNAL_HASH_SIZE];    /* hash table for all the real buffer heads in all
-                                                                                   the transactions */
-        struct list_head j_prealloc_list;       /* list of inodes which have preallocated blocks */
-        int j_persistent_trans;
-        unsigned long j_max_trans_size;
-        unsigned long j_max_batch_size;
-
-        int j_errno;
-
-        /* when flushing ordered buffers, throttle new ordered writers */
-        struct delayed_work j_work;
-        struct super_block *j_work_sb;
-        atomic_t j_async_throttle;
-};
-
-enum journal_state_bits {
-        J_WRITERS_BLOCKED = 1,  /* set when new writers not allowed */
-        J_WRITERS_QUEUED,       /* set when log is full due to too many writers */
-        J_ABORTED,              /* set when log is aborted */
-};
-
-#define JOURNAL_DESC_MAGIC "ReIsErLB"   /* ick.  magic string to find desc blocks in the journal */
-
-typedef __u32(*hashf_t) (const signed char *, int);
-
-struct reiserfs_bitmap_info {
-        __u32 free_count;
-};
-
-struct proc_dir_entry;
-
-#if defined( CONFIG_PROC_FS ) && defined( CONFIG_REISERFS_PROC_INFO )
-typedef unsigned long int stat_cnt_t;
-typedef struct reiserfs_proc_info_data {
-        spinlock_t lock;
-        int exiting;
-        int max_hash_collisions;
-
-        stat_cnt_t breads;
-        stat_cnt_t bread_miss;
-        stat_cnt_t search_by_key;
-        stat_cnt_t search_by_key_fs_changed;
-        stat_cnt_t search_by_key_restarted;
-
-        stat_cnt_t insert_item_restarted;
-        stat_cnt_t paste_into_item_restarted;
-        stat_cnt_t cut_from_item_restarted;
-        stat_cnt_t delete_solid_item_restarted;
-        stat_cnt_t delete_item_restarted;
-
-        stat_cnt_t leaked_oid;
-        stat_cnt_t leaves_removable;
-
-        /* balances per level. Use explicit 5 as MAX_HEIGHT is not visible yet. */
-        stat_cnt_t balance_at[5];       /* XXX */
-        /* sbk == search_by_key */
-        stat_cnt_t sbk_read_at[5];      /* XXX */
-        stat_cnt_t sbk_fs_changed[5];
-        stat_cnt_t sbk_restarted[5];
-        stat_cnt_t items_at[5]; /* XXX */
-        stat_cnt_t free_at[5];  /* XXX */
-        stat_cnt_t can_node_be_removed[5];      /* XXX */
-        long int lnum[5];       /* XXX */
-        long int rnum[5];       /* XXX */
-        long int lbytes[5];     /* XXX */
-        long int rbytes[5];     /* XXX */
-        stat_cnt_t get_neighbors[5];
-        stat_cnt_t get_neighbors_restart[5];
-        stat_cnt_t need_l_neighbor[5];
-        stat_cnt_t need_r_neighbor[5];
-
-        stat_cnt_t free_block;
-        struct __scan_bitmap_stats {
-                stat_cnt_t call;
-                stat_cnt_t wait;
-                stat_cnt_t bmap;
-                stat_cnt_t retry;
-                stat_cnt_t in_journal_hint;
-                stat_cnt_t in_journal_nohint;
-                stat_cnt_t stolen;
-        } scan_bitmap;
-        struct __journal_stats {
-                stat_cnt_t in_journal;
-                stat_cnt_t in_journal_bitmap;
-                stat_cnt_t in_journal_reusable;
-                stat_cnt_t lock_journal;
-                stat_cnt_t lock_journal_wait;
-                stat_cnt_t journal_being;
-                stat_cnt_t journal_relock_writers;
-                stat_cnt_t journal_relock_wcount;
-                stat_cnt_t mark_dirty;
-                stat_cnt_t mark_dirty_already;
-                stat_cnt_t mark_dirty_notjournal;
-                stat_cnt_t restore_prepared;
-                stat_cnt_t prepare;
-                stat_cnt_t prepare_retry;
-        } journal;
-} reiserfs_proc_info_data_t;
-#else
-typedef struct reiserfs_proc_info_data {
-} reiserfs_proc_info_data_t;
-#endif
-
-/* reiserfs union of in-core super block data */
-struct reiserfs_sb_info {
-        struct buffer_head *s_sbh;      /* Buffer containing the super block */
-        /* both the comment and the choice of
-           name are unclear for s_rs -Hans */
-        struct reiserfs_super_block *s_rs;      /* Pointer to the super block in the buffer */
-        struct reiserfs_bitmap_info *s_ap_bitmap;
-        struct reiserfs_journal *s_journal;     /* pointer to journal information */
-        unsigned short s_mount_state;   /* reiserfs state (valid, invalid) */
-
-        /* Serialize writers access, replace the old bkl */
-        struct mutex lock;
-        /* Owner of the lock (can be recursive) */
-        struct task_struct *lock_owner;
-        /* Depth of the lock, start from -1 like the bkl */
-        int lock_depth;
-
-        /* Comment? -Hans */
-        void (*end_io_handler) (struct buffer_head *, int);
-        hashf_t s_hash_function;        /* pointer to function which is used
-                                           to sort names in directory. Set on
-                                           mount */
-        unsigned long s_mount_opt;      /* reiserfs's mount options are set
-                                           here (currently - NOTAIL, NOLOG,
-                                           REPLAYONLY) */
-
-        struct {                /* This is a structure that describes block allocator options */
-                unsigned long bits;     /* Bitfield for enable/disable kind of options */
-                unsigned long large_file_size;  /* size started from which we consider file to be a large one(in blocks) */
-                int border;     /* percentage of disk, border takes */
-                int preallocmin;        /* Minimal file size (in blocks) starting from which we do preallocations */
-                int preallocsize;       /* Number of blocks we try to prealloc when file
-                                           reaches preallocmin size (in blocks) or
-                                           prealloc_list is empty. */
-        } s_alloc_options;
-
-        /* Comment? -Hans */
-        wait_queue_head_t s_wait;
-        /* To be obsoleted soon by per buffer seals.. -Hans */
-        atomic_t s_generation_counter;  // increased by one every time the
-        // tree gets re-balanced
-        unsigned long s_properties;     /* File system properties. Currently holds
-                                           on-disk FS format */
-
-        /* session statistics */
-        int s_disk_reads;
-        int s_disk_writes;
-        int s_fix_nodes;
-        int s_do_balance;
-        int s_unneeded_left_neighbor;
-        int s_good_search_by_key_reada;
-        int s_bmaps;
-        int s_bmaps_without_search;
-        int s_direct2indirect;
-        int s_indirect2direct;
-        /* set up when it's ok for reiserfs_read_inode2() to read from
-           disk inode with nlink==0. Currently this is only used during
-           finish_unfinished() processing at mount time */
-        int s_is_unlinked_ok;
-        reiserfs_proc_info_data_t s_proc_info_data;
-        struct proc_dir_entry *procdir;
-        int reserved_blocks;    /* amount of blocks reserved for further allocations */
-        spinlock_t bitmap_lock; /* this lock on now only used to protect reserved_blocks variable */
-        struct dentry *priv_root;       /* root of /.reiserfs_priv */
-        struct dentry *xattr_root;      /* root of /.reiserfs_priv/xattrs */
-        int j_errno;
-#ifdef CONFIG_QUOTA
-        char *s_qf_names[MAXQUOTAS];
-        int s_jquota_fmt;
-#endif
-        char *s_jdev;           /* Stored jdev for mount option showing */
-#ifdef CONFIG_REISERFS_CHECK
-
-        struct tree_balance *cur_tb;    /*
-                                         * Detects whether more than one
-                                         * copy of tb exists per superblock
-                                         * as a means of checking whether
-                                         * do_balance is executing concurrently
-                                         * against another tree reader/writer
-                                         * on a same mount point.
-                                         */
-#endif
-};
-
-/* Definitions of reiserfs on-disk properties: */
-#define REISERFS_3_5 0
-#define REISERFS_3_6 1
-#define REISERFS_OLD_FORMAT 2
-
-enum reiserfs_mount_options {
-/* Mount options */
-        REISERFS_LARGETAIL,     /* large tails will be created in a session */
-        REISERFS_SMALLTAIL,     /* small (for files less than block size) tails will be created in a session */
-        REPLAYONLY,             /* replay journal and return 0. Use by fsck */
-        REISERFS_CONVERT,       /* -o conv: causes conversion of old
-                                   format super block to the new
-                                   format. If not specified - old
-                                   partition will be dealt with in a
-                                   manner of 3.5.x */
-
-/* -o hash={tea, rupasov, r5, detect} is meant for properly mounting
-** reiserfs disks from 3.5.19 or earlier.  99% of the time, this option
-** is not required.  If the normal autodection code can't determine which
-** hash to use (because both hashes had the same value for a file)
-** use this option to force a specific hash.  It won't allow you to override
-** the existing hash on the FS, so if you have a tea hash disk, and mount
-** with -o hash=rupasov, the mount will fail.
-*/
-        FORCE_TEA_HASH,         /* try to force tea hash on mount */
-        FORCE_RUPASOV_HASH,     /* try to force rupasov hash on mount */
-        FORCE_R5_HASH,          /* try to force rupasov hash on mount */
-        FORCE_HASH_DETECT,      /* try to detect hash function on mount */
-
-        REISERFS_DATA_LOG,
-        REISERFS_DATA_ORDERED,
-        REISERFS_DATA_WRITEBACK,
-
-/* used for testing experimental features, makes benchmarking new
-   features with and without more convenient, should never be used by
-   users in any code shipped to users (ideally) */
-
-        REISERFS_NO_BORDER,
-        REISERFS_NO_UNHASHED_RELOCATION,
-        REISERFS_HASHED_RELOCATION,
-        REISERFS_ATTRS,
-        REISERFS_XATTRS_USER,
-        REISERFS_POSIXACL,
-        REISERFS_EXPOSE_PRIVROOT,
-        REISERFS_BARRIER_NONE,
-        REISERFS_BARRIER_FLUSH,
-
-        /* Actions on error */
-        REISERFS_ERROR_PANIC,
-        REISERFS_ERROR_RO,
-        REISERFS_ERROR_CONTINUE,
-
-        REISERFS_USRQUOTA,      /* User quota option specified */
-        REISERFS_GRPQUOTA,      /* Group quota option specified */
-
-        REISERFS_TEST1,
-        REISERFS_TEST2,
-        REISERFS_TEST3,
-        REISERFS_TEST4,
-        REISERFS_UNSUPPORTED_OPT,
-};
-
-#define reiserfs_r5_hash(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_R5_HASH))
-#define reiserfs_rupasov_hash(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_RUPASOV_HASH))
-#define reiserfs_tea_hash(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_TEA_HASH))
-#define reiserfs_hash_detect(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_HASH_DETECT))
-#define reiserfs_no_border(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_NO_BORDER))
-#define reiserfs_no_unhashed_relocation(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_NO_UNHASHED_RELOCATION))
-#define reiserfs_hashed_relocation(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_HASHED_RELOCATION))
-#define reiserfs_test4(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_TEST4))
-
-#define have_large_tails(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_LARGETAIL))
-#define have_small_tails(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_SMALLTAIL))
-#define replay_only(s) (REISERFS_SB(s)->s_mount_opt & (1 << REPLAYONLY))
-#define reiserfs_attrs(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_ATTRS))
-#define old_format_only(s) (REISERFS_SB(s)->s_properties & (1 << REISERFS_3_5))
-#define convert_reiserfs(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_CONVERT))
-#define reiserfs_data_log(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_DATA_LOG))
-#define reiserfs_data_ordered(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_DATA_ORDERED))
-#define reiserfs_data_writeback(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_DATA_WRITEBACK))
-#define reiserfs_xattrs_user(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_XATTRS_USER))
-#define reiserfs_posixacl(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_POSIXACL))
-#define reiserfs_expose_privroot(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_EXPOSE_PRIVROOT))
-#define reiserfs_xattrs_optional(s) (reiserfs_xattrs_user(s) || reiserfs_posixacl(s))
-#define reiserfs_barrier_none(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_BARRIER_NONE))
-#define reiserfs_barrier_flush(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_BARRIER_FLUSH))
-
-#define reiserfs_error_panic(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_ERROR_PANIC))
-#define reiserfs_error_ro(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_ERROR_RO))
-
-void reiserfs_file_buffer(struct buffer_head *bh, int list);
-extern struct file_system_type reiserfs_fs_type;
-int reiserfs_resize(struct super_block *, unsigned long);
-
-#define CARRY_ON                0
-#define SCHEDULE_OCCURRED       1
-
-#define SB_BUFFER_WITH_SB(s) (REISERFS_SB(s)->s_sbh)
-#define SB_JOURNAL(s) (REISERFS_SB(s)->s_journal)
-#define SB_JOURNAL_1st_RESERVED_BLOCK(s) (SB_JOURNAL(s)->j_1st_reserved_block)
-#define SB_JOURNAL_LEN_FREE(s) (SB_JOURNAL(s)->j_journal_len_free)
-#define SB_AP_BITMAP(s) (REISERFS_SB(s)->s_ap_bitmap)
-
-#define SB_DISK_JOURNAL_HEAD(s) (SB_JOURNAL(s)->j_header_bh->)
-
-/* A safe version of the "bdevname", which returns the "s_id" field of
- * a superblock or else "Null superblock" if the super block is NULL.
- */
-static inline char *reiserfs_bdevname(struct super_block *s)
-{
-        return (s == NULL) ? "Null superblock" : s->s_id;
-}
-
-#define reiserfs_is_journal_aborted(journal) (unlikely (__reiserfs_is_journal_aborted (journal)))
-static inline int __reiserfs_is_journal_aborted(struct reiserfs_journal
-                                                *journal)
-{
-        return test_bit(J_ABORTED, &journal->j_state);
-}
-
-#endif                          /* _LINUX_REISER_FS_SB */
diff --git a/include/linux/reiserfs_xattr.h b/include/linux/reiserfs_xattr.h
index c2b71473266e..d8ce17c2459a 100644
--- a/include/linux/reiserfs_xattr.h
+++ b/include/linux/reiserfs_xattr.h
@@ -21,132 +21,4 @@ struct reiserfs_security_handle {
         size_t length;
 };
 
-#ifdef __KERNEL__
-
-#include <linux/init.h>
-#include <linux/list.h>
-#include <linux/rwsem.h>
-#include <linux/reiserfs_fs_i.h>
-#include <linux/reiserfs_fs.h>
-
-struct inode;
-struct dentry;
-struct iattr;
-struct super_block;
-struct nameidata;
-
-int reiserfs_xattr_register_handlers(void) __init;
-void reiserfs_xattr_unregister_handlers(void);
-int reiserfs_xattr_init(struct super_block *sb, int mount_flags);
-int reiserfs_lookup_privroot(struct super_block *sb);
-int reiserfs_delete_xattrs(struct inode *inode);
-int reiserfs_chown_xattrs(struct inode *inode, struct iattr *attrs);
-int reiserfs_permission(struct inode *inode, int mask);
-
-#ifdef CONFIG_REISERFS_FS_XATTR
-#define has_xattr_dir(inode) (REISERFS_I(inode)->i_flags & i_has_xattr_dir)
-ssize_t reiserfs_getxattr(struct dentry *dentry, const char *name,
-                          void *buffer, size_t size);
-int reiserfs_setxattr(struct dentry *dentry, const char *name,
-                      const void *value, size_t size, int flags);
-ssize_t reiserfs_listxattr(struct dentry *dentry, char *buffer, size_t size);
-int reiserfs_removexattr(struct dentry *dentry, const char *name);
-
-int reiserfs_xattr_get(struct inode *, const char *, void *, size_t);
-int reiserfs_xattr_set(struct inode *, const char *, const void *, size_t, int);
-int reiserfs_xattr_set_handle(struct reiserfs_transaction_handle *,
-                              struct inode *, const char *, const void *,
-                              size_t, int);
-
-extern const struct xattr_handler reiserfs_xattr_user_handler;
-extern const struct xattr_handler reiserfs_xattr_trusted_handler;
-extern const struct xattr_handler reiserfs_xattr_security_handler;
-#ifdef CONFIG_REISERFS_FS_SECURITY
-int reiserfs_security_init(struct inode *dir, struct inode *inode,
-                           const struct qstr *qstr,
-                           struct reiserfs_security_handle *sec);
-int reiserfs_security_write(struct reiserfs_transaction_handle *th,
-                            struct inode *inode,
-                            struct reiserfs_security_handle *sec);
-void reiserfs_security_free(struct reiserfs_security_handle *sec);
-#endif
-
-static inline int reiserfs_xattrs_initialized(struct super_block *sb)
-{
-        return REISERFS_SB(sb)->priv_root != NULL;
-}
-
-#define xattr_size(size) ((size) + sizeof(struct reiserfs_xattr_header))
-static inline loff_t reiserfs_xattr_nblocks(struct inode *inode, loff_t size)
-{
-        loff_t ret = 0;
-        if (reiserfs_file_data_log(inode)) {
-                ret = _ROUND_UP(xattr_size(size), inode->i_sb->s_blocksize);
-                ret >>= inode->i_sb->s_blocksize_bits;
-        }
-        return ret;
-}
-
-/* We may have to create up to 3 objects: xattr root, xattr dir, xattr file.
- * Let's try to be smart about it.
- * xattr root: We cache it. If it's not cached, we may need to create it.
- * xattr dir: If anything has been loaded for this inode, we can set a flag
- *            saying so.
- * xattr file: Since we don't cache xattrs, we can't tell. We always include
- *             blocks for it.
- *
- * However, since root and dir can be created between calls - YOU MUST SAVE
- * THIS VALUE.
- */
-static inline size_t reiserfs_xattr_jcreate_nblocks(struct inode *inode)
-{
-        size_t nblocks = JOURNAL_BLOCKS_PER_OBJECT(inode->i_sb);
-
-        if ((REISERFS_I(inode)->i_flags & i_has_xattr_dir) == 0) {
-                nblocks += JOURNAL_BLOCKS_PER_OBJECT(inode->i_sb);
-                if (!REISERFS_SB(inode->i_sb)->xattr_root->d_inode)
-                        nblocks += JOURNAL_BLOCKS_PER_OBJECT(inode->i_sb);
-        }
-
-        return nblocks;
-}
-
-static inline void reiserfs_init_xattr_rwsem(struct inode *inode)
-{
-        init_rwsem(&REISERFS_I(inode)->i_xattr_sem);
-}
-
-#else
-
-#define reiserfs_getxattr NULL
-#define reiserfs_setxattr NULL
-#define reiserfs_listxattr NULL
-#define reiserfs_removexattr NULL
-
-static inline void reiserfs_init_xattr_rwsem(struct inode *inode)
-{
-}
-#endif  /*  CONFIG_REISERFS_FS_XATTR  */
-
-#ifndef CONFIG_REISERFS_FS_SECURITY
-static inline int reiserfs_security_init(struct inode *dir,
-                                         struct inode *inode,
-                                         const struct qstr *qstr,
-                                         struct reiserfs_security_handle *sec)
-{
-        return 0;
-}
-static inline int
-reiserfs_security_write(struct reiserfs_transaction_handle *th,
-                        struct inode *inode,
-                        struct reiserfs_security_handle *sec)
-{
-        return 0;
-}
-static inline void reiserfs_security_free(struct reiserfs_security_handle *sec)
-{}
-#endif
-
-#endif  /*  __KERNEL__  */
-
 #endif  /*  _LINUX_REISERFS_XATTR_H  */
diff --git a/include/linux/relay.h b/include/linux/relay.h
index a822fd71fd64..91cacc34c159 100644
--- a/include/linux/relay.h
+++ b/include/linux/relay.h
@@ -15,6 +15,7 @@
 #include <linux/timer.h>
 #include <linux/wait.h>
 #include <linux/list.h>
+#include <linux/bug.h>
 #include <linux/fs.h>
 #include <linux/poll.h>
 #include <linux/kref.h>
diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
new file mode 100644
index 000000000000..f1ffabb978d3
--- /dev/null
+++ b/include/linux/remoteproc.h
@@ -0,0 +1,478 @@
+/*
+ * Remote Processor Framework
+ *
+ * Copyright(c) 2011 Texas Instruments, Inc.
+ * Copyright(c) 2011 Google, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in
+ *   the documentation and/or other materials provided with the
+ *   distribution.
+ * * Neither the name Texas Instruments nor the names of its
+ *   contributors may be used to endorse or promote products derived
+ *   from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef REMOTEPROC_H
+#define REMOTEPROC_H
+
+#include <linux/types.h>
+#include <linux/kref.h>
+#include <linux/klist.h>
+#include <linux/mutex.h>
+#include <linux/virtio.h>
+#include <linux/completion.h>
+#include <linux/idr.h>
+
+/**
+ * struct resource_table - firmware resource table header
+ * @ver: version number
+ * @num: number of resource entries
+ * @reserved: reserved (must be zero)
+ * @offset: array of offsets pointing at the various resource entries
+ *
+ * A resource table is essentially a list of system resources required
+ * by the remote processor. It may also include configuration entries.
+ * If needed, the remote processor firmware should contain this table
+ * as a dedicated ".resource_table" ELF section.
+ *
+ * Some resources entries are mere announcements, where the host is informed
+ * of specific remoteproc configuration. Other entries require the host to
+ * do something (e.g. allocate a system resource). Sometimes a negotiation
+ * is expected, where the firmware requests a resource, and once allocated,
+ * the host should provide back its details (e.g. address of an allocated
+ * memory region).
+ *
+ * The header of the resource table, as expressed by this structure,
+ * contains a version number (should we need to change this format in the
+ * future), the number of available resource entries, and their offsets
+ * in the table.
+ *
+ * Immediately following this header are the resource entries themselves,
+ * each of which begins with a resource entry header (as described below).
+ */
+struct resource_table {
+        u32 ver;
+        u32 num;
+        u32 reserved[2];
+        u32 offset[0];
+} __packed;
+
+/**
+ * struct fw_rsc_hdr - firmware resource entry header
+ * @type: resource type
+ * @data: resource data
+ *
+ * Every resource entry begins with a 'struct fw_rsc_hdr' header providing
+ * its @type. The content of the entry itself will immediately follow
+ * this header, and it should be parsed according to the resource type.
+ */
+struct fw_rsc_hdr {
+        u32 type;
+        u8 data[0];
+} __packed;
+
+/**
+ * enum fw_resource_type - types of resource entries
+ *
+ * @RSC_CARVEOUT:   request for allocation of a physically contiguous
+ *                  memory region.
+ * @RSC_DEVMEM:     request to iommu_map a memory-based peripheral.
+ * @RSC_TRACE:      announces the availability of a trace buffer into which
+ *                  the remote processor will be writing logs.
+ * @RSC_VDEV:       declare support for a virtio device, and serve as its
+ *                  virtio header.
+ * @RSC_LAST:       just keep this one at the end
+ *
+ * For more details regarding a specific resource type, please see its
+ * dedicated structure below.
+ *
+ * Please note that these values are used as indices to the rproc_handle_rsc
+ * lookup table, so please keep them sane. Moreover, @RSC_LAST is used to
+ * check the validity of an index before the lookup table is accessed, so
+ * please update it as needed.
+ */
+enum fw_resource_type {
+        RSC_CARVEOUT    = 0,
+        RSC_DEVMEM      = 1,
+        RSC_TRACE       = 2,
+        RSC_VDEV        = 3,
+        RSC_LAST        = 4,
+};
+
+#define FW_RSC_ADDR_ANY (0xFFFFFFFFFFFFFFFF)
+
+/**
+ * struct fw_rsc_carveout - physically contiguous memory request
+ * @da: device address
+ * @pa: physical address
+ * @len: length (in bytes)
+ * @flags: iommu protection flags
+ * @reserved: reserved (must be zero)
+ * @name: human-readable name of the requested memory region
+ *
+ * This resource entry requests the host to allocate a physically contiguous
+ * memory region.
+ *
+ * These request entries should precede other firmware resource entries,
+ * as other entries might request placing other data objects inside
+ * these memory regions (e.g. data/code segments, trace resource entries, ...).
+ *
+ * Allocating memory this way helps utilizing the reserved physical memory
+ * (e.g. CMA) more efficiently, and also minimizes the number of TLB entries
+ * needed to map it (in case @rproc is using an IOMMU). Reducing the TLB
+ * pressure is important; it may have a substantial impact on performance.
+ *
+ * If the firmware is compiled with static addresses, then @da should specify
+ * the expected device address of this memory region. If @da is set to
+ * FW_RSC_ADDR_ANY, then the host will dynamically allocate it, and then
+ * overwrite @da with the dynamically allocated address.
+ *
+ * We will always use @da to negotiate the device addresses, even if it
+ * isn't using an iommu. In that case, though, it will obviously contain
+ * physical addresses.
+ *
+ * Some remote processors needs to know the allocated physical address
+ * even if they do use an iommu. This is needed, e.g., if they control
+ * hardware accelerators which access the physical memory directly (this
+ * is the case with OMAP4 for instance). In that case, the host will
+ * overwrite @pa with the dynamically allocated physical address.
+ * Generally we don't want to expose physical addresses if we don't have to
+ * (remote processors are generally _not_ trusted), so we might want to
+ * change this to happen _only_ when explicitly required by the hardware.
+ *
+ * @flags is used to provide IOMMU protection flags, and @name should
+ * (optionally) contain a human readable name of this carveout region
+ * (mainly for debugging purposes).
+ */
+struct fw_rsc_carveout {
+        u32 da;
+        u32 pa;
+        u32 len;
+        u32 flags;
+        u32 reserved;
+        u8 name[32];
+} __packed;
+
+/**
+ * struct fw_rsc_devmem - iommu mapping request
+ * @da: device address
+ * @pa: physical address
+ * @len: length (in bytes)
+ * @flags: iommu protection flags
+ * @reserved: reserved (must be zero)
+ * @name: human-readable name of the requested region to be mapped
+ *
+ * This resource entry requests the host to iommu map a physically contiguous
+ * memory region. This is needed in case the remote processor requires
+ * access to certain memory-based peripherals; _never_ use it to access
+ * regular memory.
+ *
+ * This is obviously only needed if the remote processor is accessing memory
+ * via an iommu.
+ *
+ * @da should specify the required device address, @pa should specify
+ * the physical address we want to map, @len should specify the size of
+ * the mapping and @flags is the IOMMU protection flags. As always, @name may
+ * (optionally) contain a human readable name of this mapping (mainly for
+ * debugging purposes).
+ *
+ * Note: at this point we just "trust" those devmem entries to contain valid
+ * physical addresses, but this isn't safe and will be changed: eventually we
+ * want remoteproc implementations to provide us ranges of physical addresses
+ * the firmware is allowed to request, and not allow firmwares to request
+ * access to physical addresses that are outside those ranges.
+ */
+struct fw_rsc_devmem {
+        u32 da;
+        u32 pa;
+        u32 len;
+        u32 flags;
+        u32 reserved;
+        u8 name[32];
+} __packed;
+
+/**
+ * struct fw_rsc_trace - trace buffer declaration
+ * @da: device address
+ * @len: length (in bytes)
+ * @reserved: reserved (must be zero)
+ * @name: human-readable name of the trace buffer
+ *
+ * This resource entry provides the host information about a trace buffer
+ * into which the remote processor will write log messages.
+ *
+ * @da specifies the device address of the buffer, @len specifies
+ * its size, and @name may contain a human readable name of the trace buffer.
+ *
+ * After booting the remote processor, the trace buffers are exposed to the
+ * user via debugfs entries (called trace0, trace1, etc..).
+ */
+struct fw_rsc_trace {
+        u32 da;
+        u32 len;
+        u32 reserved;
+        u8 name[32];
+} __packed;
+
+/**
+ * struct fw_rsc_vdev_vring - vring descriptor entry
+ * @da: device address
+ * @align: the alignment between the consumer and producer parts of the vring
+ * @num: num of buffers supported by this vring (must be power of two)
+ * @notifyid is a unique rproc-wide notify index for this vring. This notify
+ * index is used when kicking a remote processor, to let it know that this
+ * vring is triggered.
+ * @reserved: reserved (must be zero)
+ *
+ * This descriptor is not a resource entry by itself; it is part of the
+ * vdev resource type (see below).
+ *
+ * Note that @da should either contain the device address where
+ * the remote processor is expecting the vring, or indicate that
+ * dynamically allocation of the vring's device address is supported.
+ */
+struct fw_rsc_vdev_vring {
+        u32 da;
+        u32 align;
+        u32 num;
+        u32 notifyid;
+        u32 reserved;
+} __packed;
+
+/**
+ * struct fw_rsc_vdev - virtio device header
+ * @id: virtio device id (as in virtio_ids.h)
+ * @notifyid is a unique rproc-wide notify index for this vdev. This notify
+ * index is used when kicking a remote processor, to let it know that the
+ * status/features of this vdev have changes.
+ * @dfeatures specifies the virtio device features supported by the firmware
+ * @gfeatures is a place holder used by the host to write back the
+ * negotiated features that are supported by both sides.
+ * @config_len is the size of the virtio config space of this vdev. The config
+ * space lies in the resource table immediate after this vdev header.
+ * @status is a place holder where the host will indicate its virtio progress.
+ * @num_of_vrings indicates how many vrings are described in this vdev header
+ * @reserved: reserved (must be zero)
+ * @vring is an array of @num_of_vrings entries of 'struct fw_rsc_vdev_vring'.
+ *
+ * This resource is a virtio device header: it provides information about
+ * the vdev, and is then used by the host and its peer remote processors
+ * to negotiate and share certain virtio properties.
+ *
+ * By providing this resource entry, the firmware essentially asks remoteproc
+ * to statically allocate a vdev upon registration of the rproc (dynamic vdev
+ * allocation is not yet supported).
+ *
+ * Note: unlike virtualization systems, the term 'host' here means
+ * the Linux side which is running remoteproc to control the remote
+ * processors. We use the name 'gfeatures' to comply with virtio's terms,
+ * though there isn't really any virtualized guest OS here: it's the host
+ * which is responsible for negotiating the final features.
+ * Yeah, it's a bit confusing.
+ *
+ * Note: immediately following this structure is the virtio config space for
+ * this vdev (which is specific to the vdev; for more info, read the virtio
+ * spec). the size of the config space is specified by @config_len.
+ */
+struct fw_rsc_vdev {
+        u32 id;
+        u32 notifyid;
+        u32 dfeatures;
+        u32 gfeatures;
+        u32 config_len;
+        u8 status;
+        u8 num_of_vrings;
+        u8 reserved[2];
+        struct fw_rsc_vdev_vring vring[0];
+} __packed;
+
+/**
+ * struct rproc_mem_entry - memory entry descriptor
+ * @va: virtual address
+ * @dma: dma address
+ * @len: length, in bytes
+ * @da: device address
+ * @priv: associated data
+ * @node: list node
+ */
+struct rproc_mem_entry {
+        void *va;
+        dma_addr_t dma;
+        int len;
+        u32 da;
+        void *priv;
+        struct list_head node;
+};
+
+struct rproc;
+
+/**
+ * struct rproc_ops - platform-specific device handlers
+ * @start:      power on the device and boot it
+ * @stop:       power off the device
+ * @kick:       kick a virtqueue (virtqueue id given as a parameter)
+ */
+struct rproc_ops {
+        int (*start)(struct rproc *rproc);
+        int (*stop)(struct rproc *rproc);
+        void (*kick)(struct rproc *rproc, int vqid);
+};
+
+/**
+ * enum rproc_state - remote processor states
+ * @RPROC_OFFLINE:      device is powered off
+ * @RPROC_SUSPENDED:    device is suspended; needs to be woken up to receive
+ *                      a message.
+ * @RPROC_RUNNING:      device is up and running
+ * @RPROC_CRASHED:      device has crashed; need to start recovery
+ * @RPROC_LAST:         just keep this one at the end
+ *
+ * Please note that the values of these states are used as indices
+ * to rproc_state_string, a state-to-name lookup table,
+ * so please keep the two synchronized. @RPROC_LAST is used to check
+ * the validity of an index before the lookup table is accessed, so
+ * please update it as needed too.
+ */
+enum rproc_state {
+        RPROC_OFFLINE   = 0,
+        RPROC_SUSPENDED = 1,
+        RPROC_RUNNING   = 2,
+        RPROC_CRASHED   = 3,
+        RPROC_LAST      = 4,
+};
+
+/**
+ * struct rproc - represents a physical remote processor device
+ * @node: klist node of this rproc object
+ * @domain: iommu domain
+ * @name: human readable name of the rproc
+ * @firmware: name of firmware file to be loaded
+ * @priv: private data which belongs to the platform-specific rproc module
+ * @ops: platform-specific start/stop rproc handlers
+ * @dev: underlying device
+ * @refcount: refcount of users that have a valid pointer to this rproc
+ * @power: refcount of users who need this rproc powered up
+ * @state: state of the device
+ * @lock: lock which protects concurrent manipulations of the rproc
+ * @dbg_dir: debugfs directory of this rproc device
+ * @traces: list of trace buffers
+ * @num_traces: number of trace buffers
+ * @carveouts: list of physically contiguous memory allocations
+ * @mappings: list of iommu mappings we initiated, needed on shutdown
+ * @firmware_loading_complete: marks e/o asynchronous firmware loading
+ * @bootaddr: address of first instruction to boot rproc with (optional)
+ * @rvdevs: list of remote virtio devices
+ * @notifyids: idr for dynamically assigning rproc-wide unique notify ids
+ */
+struct rproc {
+        struct klist_node node;
+        struct iommu_domain *domain;
+        const char *name;
+        const char *firmware;
+        void *priv;
+        const struct rproc_ops *ops;
+        struct device *dev;
+        struct kref refcount;
+        atomic_t power;
+        unsigned int state;
+        struct mutex lock;
+        struct dentry *dbg_dir;
+        struct list_head traces;
+        int num_traces;
+        struct list_head carveouts;
+        struct list_head mappings;
+        struct completion firmware_loading_complete;
+        u32 bootaddr;
+        struct list_head rvdevs;
+        struct idr notifyids;
+};
+
+/* we currently support only two vrings per rvdev */
+#define RVDEV_NUM_VRINGS 2
+
+/**
+ * struct rproc_vring - remoteproc vring state
+ * @va: virtual address
+ * @dma: dma address
+ * @len: length, in bytes
+ * @da: device address
+ * @align: vring alignment
+ * @notifyid: rproc-specific unique vring index
+ * @rvdev: remote vdev
+ * @vq: the virtqueue of this vring
+ */
+struct rproc_vring {
+        void *va;
+        dma_addr_t dma;
+        int len;
+        u32 da;
+        u32 align;
+        int notifyid;
+        struct rproc_vdev *rvdev;
+        struct virtqueue *vq;
+};
+
+/**
+ * struct rproc_vdev - remoteproc state for a supported virtio device
+ * @node: list node
+ * @rproc: the rproc handle
+ * @vdev: the virio device
+ * @vring: the vrings for this vdev
+ * @dfeatures: virtio device features
+ * @gfeatures: virtio guest features
+ */
+struct rproc_vdev {
+        struct list_head node;
+        struct rproc *rproc;
+        struct virtio_device vdev;
+        struct rproc_vring vring[RVDEV_NUM_VRINGS];
+        unsigned long dfeatures;
+        unsigned long gfeatures;
+};
+
+struct rproc *rproc_get_by_name(const char *name);
+void rproc_put(struct rproc *rproc);
+
+struct rproc *rproc_alloc(struct device *dev, const char *name,
+                                const struct rproc_ops *ops,
+                                const char *firmware, int len);
+void rproc_free(struct rproc *rproc);
+int rproc_register(struct rproc *rproc);
+int rproc_unregister(struct rproc *rproc);
+
+int rproc_boot(struct rproc *rproc);
+void rproc_shutdown(struct rproc *rproc);
+
+static inline struct rproc_vdev *vdev_to_rvdev(struct virtio_device *vdev)
+{
+        return container_of(vdev, struct rproc_vdev, vdev);
+}
+
+static inline struct rproc *vdev_to_rproc(struct virtio_device *vdev)
+{
+        struct rproc_vdev *rvdev = vdev_to_rvdev(vdev);
+
+        return rvdev->rproc;
+}
+
+#endif /* REMOTEPROC_H */
diff --git a/include/linux/rfkill.h b/include/linux/rfkill.h
index c6c608482cba..6fdf02737e9d 100644
--- a/include/linux/rfkill.h
+++ b/include/linux/rfkill.h
@@ -117,10 +117,10 @@ enum rfkill_user_states {
 #include <linux/kernel.h>
 #include <linux/list.h>
 #include <linux/mutex.h>
-#include <linux/device.h>
 #include <linux/leds.h>
 #include <linux/err.h>
 
+struct device;
 /* this is opaque */
 struct rfkill;
 
diff --git a/include/linux/rio_drv.h b/include/linux/rio_drv.h
index 229b3ca23134..7f07470e1ed9 100644
--- a/include/linux/rio_drv.h
+++ b/include/linux/rio_drv.h
@@ -17,7 +17,6 @@
 #include <linux/ioport.h>
 #include <linux/list.h>
 #include <linux/errno.h>
-#include <linux/device.h>
 #include <linux/string.h>
 #include <linux/rio.h>
 
diff --git a/include/linux/rmap.h b/include/linux/rmap.h
index 1cdd62a2788a..fd07c4542cee 100644
--- a/include/linux/rmap.h
+++ b/include/linux/rmap.h
@@ -122,7 +122,6 @@ void unlink_anon_vmas(struct vm_area_struct *);
 int anon_vma_clone(struct vm_area_struct *, struct vm_area_struct *);
 void anon_vma_moveto_tail(struct vm_area_struct *);
 int anon_vma_fork(struct vm_area_struct *, struct vm_area_struct *);
-void __anon_vma_link(struct vm_area_struct *);
 
 static inline void anon_vma_merge(struct vm_area_struct *vma,
                                   struct vm_area_struct *next)
diff --git a/include/linux/rpmsg.h b/include/linux/rpmsg.h
new file mode 100644
index 000000000000..a8e50e44203c
--- /dev/null
+++ b/include/linux/rpmsg.h
@@ -0,0 +1,326 @@
+/*
+ * Remote processor messaging
+ *
+ * Copyright (C) 2011 Texas Instruments, Inc.
+ * Copyright (C) 2011 Google, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in
+ *   the documentation and/or other materials provided with the
+ *   distribution.
+ * * Neither the name Texas Instruments nor the names of its
+ *   contributors may be used to endorse or promote products derived
+ *   from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _LINUX_RPMSG_H
+#define _LINUX_RPMSG_H
+
+#include <linux/types.h>
+#include <linux/device.h>
+#include <linux/mod_devicetable.h>
+
+/* The feature bitmap for virtio rpmsg */
+#define VIRTIO_RPMSG_F_NS       0 /* RP supports name service notifications */
+
+/**
+ * struct rpmsg_hdr - common header for all rpmsg messages
+ * @src: source address
+ * @dst: destination address
+ * @reserved: reserved for future use
+ * @len: length of payload (in bytes)
+ * @flags: message flags
+ * @data: @len bytes of message payload data
+ *
+ * Every message sent(/received) on the rpmsg bus begins with this header.
+ */
+struct rpmsg_hdr {
+        u32 src;
+        u32 dst;
+        u32 reserved;
+        u16 len;
+        u16 flags;
+        u8 data[0];
+} __packed;
+
+/**
+ * struct rpmsg_ns_msg - dynamic name service announcement message
+ * @name: name of remote service that is published
+ * @addr: address of remote service that is published
+ * @flags: indicates whether service is created or destroyed
+ *
+ * This message is sent across to publish a new service, or announce
+ * about its removal. When we receive these messages, an appropriate
+ * rpmsg channel (i.e device) is created/destroyed. In turn, the ->probe()
+ * or ->remove() handler of the appropriate rpmsg driver will be invoked
+ * (if/as-soon-as one is registered).
+ */
+struct rpmsg_ns_msg {
+        char name[RPMSG_NAME_SIZE];
+        u32 addr;
+        u32 flags;
+} __packed;
+
+/**
+ * enum rpmsg_ns_flags - dynamic name service announcement flags
+ *
+ * @RPMSG_NS_CREATE: a new remote service was just created
+ * @RPMSG_NS_DESTROY: a known remote service was just destroyed
+ */
+enum rpmsg_ns_flags {
+        RPMSG_NS_CREATE         = 0,
+        RPMSG_NS_DESTROY        = 1,
+};
+
+#define RPMSG_ADDR_ANY          0xFFFFFFFF
+
+struct virtproc_info;
+
+/**
+ * rpmsg_channel - devices that belong to the rpmsg bus are called channels
+ * @vrp: the remote processor this channel belongs to
+ * @dev: the device struct
+ * @id: device id (used to match between rpmsg drivers and devices)
+ * @src: local address
+ * @dst: destination address
+ * @ept: the rpmsg endpoint of this channel
+ * @announce: if set, rpmsg will announce the creation/removal of this channel
+ */
+struct rpmsg_channel {
+        struct virtproc_info *vrp;
+        struct device dev;
+        struct rpmsg_device_id id;
+        u32 src;
+        u32 dst;
+        struct rpmsg_endpoint *ept;
+        bool announce;
+};
+
+typedef void (*rpmsg_rx_cb_t)(struct rpmsg_channel *, void *, int, void *, u32);
+
+/**
+ * struct rpmsg_endpoint - binds a local rpmsg address to its user
+ * @rpdev: rpmsg channel device
+ * @cb: rx callback handler
+ * @addr: local rpmsg address
+ * @priv: private data for the driver's use
+ *
+ * In essence, an rpmsg endpoint represents a listener on the rpmsg bus, as
+ * it binds an rpmsg address with an rx callback handler.
+ *
+ * Simple rpmsg drivers shouldn't use this struct directly, because
+ * things just work: every rpmsg driver provides an rx callback upon
+ * registering to the bus, and that callback is then bound to its rpmsg
+ * address when the driver is probed. When relevant inbound messages arrive
+ * (i.e. messages which their dst address equals to the src address of
+ * the rpmsg channel), the driver's handler is invoked to process it.
+ *
+ * More complicated drivers though, that do need to allocate additional rpmsg
+ * addresses, and bind them to different rx callbacks, must explicitly
+ * create additional endpoints by themselves (see rpmsg_create_ept()).
+ */
+struct rpmsg_endpoint {
+        struct rpmsg_channel *rpdev;
+        rpmsg_rx_cb_t cb;
+        u32 addr;
+        void *priv;
+};
+
+/**
+ * struct rpmsg_driver - rpmsg driver struct
+ * @drv: underlying device driver
+ * @id_table: rpmsg ids serviced by this driver
+ * @probe: invoked when a matching rpmsg channel (i.e. device) is found
+ * @remove: invoked when the rpmsg channel is removed
+ * @callback: invoked when an inbound message is received on the channel
+ */
+struct rpmsg_driver {
+        struct device_driver drv;
+        const struct rpmsg_device_id *id_table;
+        int (*probe)(struct rpmsg_channel *dev);
+        void (*remove)(struct rpmsg_channel *dev);
+        void (*callback)(struct rpmsg_channel *, void *, int, void *, u32);
+};
+
+int register_rpmsg_device(struct rpmsg_channel *dev);
+void unregister_rpmsg_device(struct rpmsg_channel *dev);
+int register_rpmsg_driver(struct rpmsg_driver *drv);
+void unregister_rpmsg_driver(struct rpmsg_driver *drv);
+void rpmsg_destroy_ept(struct rpmsg_endpoint *);
+struct rpmsg_endpoint *rpmsg_create_ept(struct rpmsg_channel *,
+                                rpmsg_rx_cb_t cb, void *priv, u32 addr);
+int
+rpmsg_send_offchannel_raw(struct rpmsg_channel *, u32, u32, void *, int, bool);
+
+/**
+ * rpmsg_send() - send a message across to the remote processor
+ * @rpdev: the rpmsg channel
+ * @data: payload of message
+ * @len: length of payload
+ *
+ * This function sends @data of length @len on the @rpdev channel.
+ * The message will be sent to the remote processor which the @rpdev
+ * channel belongs to, using @rpdev's source and destination addresses.
+ * In case there are no TX buffers available, the function will block until
+ * one becomes available, or a timeout of 15 seconds elapses. When the latter
+ * happens, -ERESTARTSYS is returned.
+ *
+ * Can only be called from process context (for now).
+ *
+ * Returns 0 on success and an appropriate error value on failure.
+ */
+static inline int rpmsg_send(struct rpmsg_channel *rpdev, void *data, int len)
+{
+        u32 src = rpdev->src, dst = rpdev->dst;
+
+        return rpmsg_send_offchannel_raw(rpdev, src, dst, data, len, true);
+}
+
+/**
+ * rpmsg_sendto() - send a message across to the remote processor, specify dst
+ * @rpdev: the rpmsg channel
+ * @data: payload of message
+ * @len: length of payload
+ * @dst: destination address
+ *
+ * This function sends @data of length @len to the remote @dst address.
+ * The message will be sent to the remote processor which the @rpdev
+ * channel belongs to, using @rpdev's source address.
+ * In case there are no TX buffers available, the function will block until
+ * one becomes available, or a timeout of 15 seconds elapses. When the latter
+ * happens, -ERESTARTSYS is returned.
+ *
+ * Can only be called from process context (for now).
+ *
+ * Returns 0 on success and an appropriate error value on failure.
+ */
+static inline
+int rpmsg_sendto(struct rpmsg_channel *rpdev, void *data, int len, u32 dst)
+{
+        u32 src = rpdev->src;
+
+        return rpmsg_send_offchannel_raw(rpdev, src, dst, data, len, true);
+}
+
+/**
+ * rpmsg_send_offchannel() - send a message using explicit src/dst addresses
+ * @rpdev: the rpmsg channel
+ * @src: source address
+ * @dst: destination address
+ * @data: payload of message
+ * @len: length of payload
+ *
+ * This function sends @data of length @len to the remote @dst address,
+ * and uses @src as the source address.
+ * The message will be sent to the remote processor which the @rpdev
+ * channel belongs to.
+ * In case there are no TX buffers available, the function will block until
+ * one becomes available, or a timeout of 15 seconds elapses. When the latter
+ * happens, -ERESTARTSYS is returned.
+ *
+ * Can only be called from process context (for now).
+ *
+ * Returns 0 on success and an appropriate error value on failure.
+ */
+static inline
+int rpmsg_send_offchannel(struct rpmsg_channel *rpdev, u32 src, u32 dst,
+                                                        void *data, int len)
+{
+        return rpmsg_send_offchannel_raw(rpdev, src, dst, data, len, true);
+}
+
+/**
+ * rpmsg_send() - send a message across to the remote processor
+ * @rpdev: the rpmsg channel
+ * @data: payload of message
+ * @len: length of payload
+ *
+ * This function sends @data of length @len on the @rpdev channel.
+ * The message will be sent to the remote processor which the @rpdev
+ * channel belongs to, using @rpdev's source and destination addresses.
+ * In case there are no TX buffers available, the function will immediately
+ * return -ENOMEM without waiting until one becomes available.
+ *
+ * Can only be called from process context (for now).
+ *
+ * Returns 0 on success and an appropriate error value on failure.
+ */
+static inline
+int rpmsg_trysend(struct rpmsg_channel *rpdev, void *data, int len)
+{
+        u32 src = rpdev->src, dst = rpdev->dst;
+
+        return rpmsg_send_offchannel_raw(rpdev, src, dst, data, len, false);
+}
+
+/**
+ * rpmsg_sendto() - send a message across to the remote processor, specify dst
+ * @rpdev: the rpmsg channel
+ * @data: payload of message
+ * @len: length of payload
+ * @dst: destination address
+ *
+ * This function sends @data of length @len to the remote @dst address.
+ * The message will be sent to the remote processor which the @rpdev
+ * channel belongs to, using @rpdev's source address.
+ * In case there are no TX buffers available, the function will immediately
+ * return -ENOMEM without waiting until one becomes available.
+ *
+ * Can only be called from process context (for now).
+ *
+ * Returns 0 on success and an appropriate error value on failure.
+ */
+static inline
+int rpmsg_trysendto(struct rpmsg_channel *rpdev, void *data, int len, u32 dst)
+{
+        u32 src = rpdev->src;
+
+        return rpmsg_send_offchannel_raw(rpdev, src, dst, data, len, false);
+}
+
+/**
+ * rpmsg_send_offchannel() - send a message using explicit src/dst addresses
+ * @rpdev: the rpmsg channel
+ * @src: source address
+ * @dst: destination address
+ * @data: payload of message
+ * @len: length of payload
+ *
+ * This function sends @data of length @len to the remote @dst address,
+ * and uses @src as the source address.
+ * The message will be sent to the remote processor which the @rpdev
+ * channel belongs to.
+ * In case there are no TX buffers available, the function will immediately
+ * return -ENOMEM without waiting until one becomes available.
+ *
+ * Can only be called from process context (for now).
+ *
+ * Returns 0 on success and an appropriate error value on failure.
+ */
+static inline
+int rpmsg_trysend_offchannel(struct rpmsg_channel *rpdev, u32 src, u32 dst,
+                                                        void *data, int len)
+{
+        return rpmsg_send_offchannel_raw(rpdev, src, dst, data, len, false);
+}
+
+#endif /* _LINUX_RPMSG_H */
diff --git a/include/linux/sa11x0-dma.h b/include/linux/sa11x0-dma.h
new file mode 100644
index 000000000000..65839a58b8e5
--- /dev/null
+++ b/include/linux/sa11x0-dma.h
@@ -0,0 +1,24 @@
+/*
+ * SA11x0 DMA Engine support
+ *
+ * Copyright (C) 2012 Russell King
+ *
+ * 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_SA11X0_DMA_H
+#define __LINUX_SA11X0_DMA_H
+
+struct dma_chan;
+
+#if defined(CONFIG_DMA_SA11X0) || defined(CONFIG_DMA_SA11X0_MODULE)
+bool sa11x0_dma_filter_fn(struct dma_chan *, void *);
+#else
+static inline bool sa11x0_dma_filter_fn(struct dma_chan *c, void *d)
+{
+        return false;
+}
+#endif
+
+#endif
diff --git a/include/linux/scatterlist.h b/include/linux/scatterlist.h
index 9aaf5bfdad1a..ac9586dadfa5 100644
--- a/include/linux/scatterlist.h
+++ b/include/linux/scatterlist.h
@@ -1,10 +1,12 @@
 #ifndef _LINUX_SCATTERLIST_H
 #define _LINUX_SCATTERLIST_H
 
+#include <linux/string.h>
+#include <linux/bug.h>
+#include <linux/mm.h>
+
 #include <asm/types.h>
 #include <asm/scatterlist.h>
-#include <linux/mm.h>
-#include <linux/string.h>
 #include <asm/io.h>
 
 struct sg_table {
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 0657368bd78f..0c3854b0d4b1 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -361,6 +361,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 void schedule_preempt_disabled(void);
 extern int mutex_spin_on_owner(struct mutex *lock, struct task_struct *owner);
 
 struct nsproxy;
@@ -552,6 +553,18 @@ struct signal_struct {
         int                     group_stop_count;
         unsigned int            flags; /* see SIGNAL_* flags below */
 
+        /*
+         * PR_SET_CHILD_SUBREAPER marks a process, like a service
+         * manager, to re-parent orphan (double-forking) child processes
+         * to this process instead of 'init'. The service manager is
+         * able to receive SIGCHLD signals and is able to investigate
+         * the process until it calls wait(). All children of this
+         * process will inherit a flag if they should look for a
+         * child_subreaper process at exit.
+         */
+        unsigned int            is_child_subreaper:1;
+        unsigned int            has_child_subreaper:1;
+
         /* POSIX.1b Interval Timers */
         struct list_head posix_timers;
 
@@ -905,6 +918,7 @@ struct sched_group_power {
          * single CPU.
          */
         unsigned int power, power_orig;
+        unsigned long next_update;
         /*
          * Number of busy cpus in this group.
          */
@@ -1052,6 +1066,8 @@ static inline int test_sd_parent(struct sched_domain *sd, int flag)
 unsigned long default_scale_freq_power(struct sched_domain *sd, int cpu);
 unsigned long default_scale_smt_power(struct sched_domain *sd, int cpu);
 
+bool cpus_share_cache(int this_cpu, int that_cpu);
+
 #else /* CONFIG_SMP */
 
 struct sched_domain_attr;
@@ -1061,6 +1077,12 @@ partition_sched_domains(int ndoms_new, cpumask_var_t doms_new[],
                         struct sched_domain_attr *dattr_new)
 {
 }
+
+static inline bool cpus_share_cache(int this_cpu, int that_cpu)
+{
+        return true;
+}
+
 #endif  /* !CONFIG_SMP */
 
 
@@ -1225,6 +1247,12 @@ struct sched_rt_entity {
 #endif
 };
 
+/*
+ * default timeslice is 100 msecs (used only for SCHED_RR tasks).
+ * Timeslices get refilled after they expire.
+ */
+#define RR_TIMESLICE            (100 * HZ / 1000)
+
 struct rcu_node;
 
 enum perf_event_task_context {
@@ -1319,6 +1347,11 @@ struct task_struct {
         unsigned sched_reset_on_fork:1;
         unsigned sched_contributes_to_load:1;
 
+#ifdef CONFIG_GENERIC_HARDIRQS
+        /* IRQ handler threads */
+        unsigned irq_thread:1;
+#endif
+
         pid_t pid;
         pid_t tgid;
 
@@ -1427,11 +1460,6 @@ struct task_struct {
  * mempolicy */
         spinlock_t alloc_lock;
 
-#ifdef CONFIG_GENERIC_HARDIRQS
-        /* IRQ handler threads */
-        struct irqaction *irqaction;
-#endif
-
         /* Protection of the PI data structures: */
         raw_spinlock_t pi_lock;
 
@@ -1498,7 +1526,7 @@ struct task_struct {
 #endif
 #ifdef CONFIG_CPUSETS
         nodemask_t mems_allowed;        /* Protected by alloc_lock */
-        int mems_allowed_change_disable;
+        seqcount_t mems_allowed_seq;    /* Seqence no to catch updates */
         int cpuset_mem_spread_rotor;
         int cpuset_slab_spread_rotor;
 #endif
@@ -1863,8 +1891,7 @@ extern void task_clear_jobctl_pending(struct task_struct *task,
 #ifdef CONFIG_PREEMPT_RCU
 
 #define RCU_READ_UNLOCK_BLOCKED (1 << 0) /* blocked while in RCU read-side. */
-#define RCU_READ_UNLOCK_BOOSTED (1 << 1) /* boosted while in RCU read-side. */
-#define RCU_READ_UNLOCK_NEED_QS (1 << 2) /* RCU core needs CPU response. */
+#define RCU_READ_UNLOCK_NEED_QS (1 << 1) /* RCU core needs CPU response. */
 
 static inline void rcu_copy_process(struct task_struct *p)
 {
@@ -2048,7 +2075,7 @@ extern void sched_autogroup_fork(struct signal_struct *sig);
 extern void sched_autogroup_exit(struct signal_struct *sig);
 #ifdef CONFIG_PROC_FS
 extern void proc_sched_autogroup_show_task(struct task_struct *p, struct seq_file *m);
-extern int proc_sched_autogroup_set_nice(struct task_struct *p, int *nice);
+extern int proc_sched_autogroup_set_nice(struct task_struct *p, int nice);
 #endif
 #else
 static inline void sched_autogroup_create_attach(struct task_struct *p) { }
@@ -2065,12 +2092,20 @@ extern unsigned int sysctl_sched_cfs_bandwidth_slice;
 extern int rt_mutex_getprio(struct task_struct *p);
 extern void rt_mutex_setprio(struct task_struct *p, int prio);
 extern void rt_mutex_adjust_pi(struct task_struct *p);
+static inline bool tsk_is_pi_blocked(struct task_struct *tsk)
+{
+        return tsk->pi_blocked_on != NULL;
+}
 #else
 static inline int rt_mutex_getprio(struct task_struct *p)
 {
         return p->normal_prio;
 }
 # define rt_mutex_adjust_pi(p)          do { } while (0)
+static inline bool tsk_is_pi_blocked(struct task_struct *tsk)
+{
+        return false;
+}
 #endif
 
 extern bool yield_to(struct task_struct *p, bool preempt);
@@ -2389,12 +2424,15 @@ static inline void task_unlock(struct task_struct *p)
 extern struct sighand_struct *__lock_task_sighand(struct task_struct *tsk,
                                                         unsigned long *flags);
 
-#define lock_task_sighand(tsk, flags)                                   \
-({      struct sighand_struct *__ss;                                    \
-        __cond_lock(&(tsk)->sighand->siglock,                           \
-                    (__ss = __lock_task_sighand(tsk, flags)));          \
-        __ss;                                                           \
-})                                                                      \
+static inline struct sighand_struct *lock_task_sighand(struct task_struct *tsk,
+                                                       unsigned long *flags)
+{
+        struct sighand_struct *ret;
+
+        ret = __lock_task_sighand(tsk, flags);
+        (void)__cond_lock(&tsk->sighand->siglock, ret);
+        return ret;
+}
 
 static inline void unlock_task_sighand(struct task_struct *tsk,
                                                 unsigned long *flags)
diff --git a/include/linux/security.h b/include/linux/security.h
index 83c18e8c846d..673afbb8238a 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -22,22 +22,36 @@
 #ifndef __LINUX_SECURITY_H
 #define __LINUX_SECURITY_H
 
-#include <linux/fs.h>
-#include <linux/fsnotify.h>
-#include <linux/binfmts.h>
-#include <linux/dcache.h>
-#include <linux/signal.h>
-#include <linux/resource.h>
-#include <linux/sem.h>
-#include <linux/shm.h>
-#include <linux/mm.h> /* PAGE_ALIGN */
-#include <linux/msg.h>
-#include <linux/sched.h>
 #include <linux/key.h>
-#include <linux/xfrm.h>
+#include <linux/capability.h>
 #include <linux/slab.h>
-#include <linux/xattr.h>
-#include <net/flow.h>
+#include <linux/err.h>
+
+struct linux_binprm;
+struct cred;
+struct rlimit;
+struct siginfo;
+struct sem_array;
+struct sembuf;
+struct kern_ipc_perm;
+struct audit_context;
+struct super_block;
+struct inode;
+struct dentry;
+struct file;
+struct vfsmount;
+struct path;
+struct qstr;
+struct nameidata;
+struct iattr;
+struct fown_struct;
+struct file_operations;
+struct shmid_kernel;
+struct msg_msg;
+struct msg_queue;
+struct xattr;
+struct xfrm_sec_ctx;
+struct mm_struct;
 
 /* Maximum number of letters for an LSM name string */
 #define SECURITY_NAME_MAX       10
@@ -49,6 +63,7 @@
 struct ctl_table;
 struct audit_krule;
 struct user_namespace;
+struct timezone;
 
 /*
  * These functions are in security/capability.c and are used
@@ -131,18 +146,6 @@ struct request_sock;
 #define LSM_UNSAFE_PTRACE_CAP   4
 
 #ifdef CONFIG_MMU
-/*
- * If a hint addr is less than mmap_min_addr change hint to be as
- * low as possible but still greater than mmap_min_addr
- */
-static inline unsigned long round_hint_to_min(unsigned long hint)
-{
-        hint &= PAGE_MASK;
-        if (((void *)hint != NULL) &&
-            (hint < mmap_min_addr))
-                return PAGE_ALIGN(mmap_min_addr);
-        return hint;
-}
 extern int mmap_min_addr_handler(struct ctl_table *table, int write,
                                  void __user *buffer, size_t *lenp, loff_t *ppos);
 #endif
@@ -651,6 +654,10 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
  *      manual page for definitions of the @clone_flags.
  *      @clone_flags contains the flags indicating what should be shared.
  *      Return 0 if permission is granted.
+ * @task_free:
+ *      @task task being freed
+ *      Handle release of task-related resources. (Note that this can be called
+ *      from interrupt context.)
  * @cred_alloc_blank:
  *      @cred points to the credentials.
  *      @gfp indicates the atomicity of any memory allocations.
@@ -812,7 +819,7 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
  *      Check permissions before connecting or sending datagrams from @sock to
  *      @other.
  *      @sock contains the socket structure.
- *      @sock contains the peer socket structure.
+ *      @other contains the peer socket structure.
  *      Return 0 if permission is granted.
  *
  * The @unix_stream_connect and @unix_may_send hooks were necessary because
@@ -1493,6 +1500,7 @@ struct security_operations {
         int (*dentry_open) (struct file *file, const struct cred *cred);
 
         int (*task_create) (unsigned long clone_flags);
+        void (*task_free) (struct task_struct *task);
         int (*cred_alloc_blank) (struct cred *cred, gfp_t gfp);
         void (*cred_free) (struct cred *cred);
         int (*cred_prepare)(struct cred *new, const struct cred *old,
@@ -1674,9 +1682,7 @@ int security_quotactl(int cmds, int type, int id, struct super_block *sb);
 int security_quota_on(struct dentry *dentry);
 int security_syslog(int type);
 int security_settime(const struct timespec *ts, const struct timezone *tz);
-int security_vm_enough_memory(long pages);
 int security_vm_enough_memory_mm(struct mm_struct *mm, long pages);
-int security_vm_enough_memory_kern(long pages);
 int security_bprm_set_creds(struct linux_binprm *bprm);
 int security_bprm_check(struct linux_binprm *bprm);
 void security_bprm_committing_creds(struct linux_binprm *bprm);
@@ -1752,6 +1758,7 @@ int security_file_send_sigiotask(struct task_struct *tsk,
 int security_file_receive(struct file *file);
 int security_dentry_open(struct file *file, const struct cred *cred);
 int security_task_create(unsigned long clone_flags);
+void security_task_free(struct task_struct *task);
 int security_cred_alloc_blank(struct cred *cred, gfp_t gfp);
 void security_cred_free(struct cred *cred);
 int security_prepare_creds(struct cred *new, const struct cred *old, gfp_t gfp);
@@ -1896,25 +1903,11 @@ static inline int security_settime(const struct timespec *ts,
         return cap_settime(ts, tz);
 }
 
-static inline int security_vm_enough_memory(long pages)
-{
-        WARN_ON(current->mm == NULL);
-        return cap_vm_enough_memory(current->mm, pages);
-}
-
 static inline int security_vm_enough_memory_mm(struct mm_struct *mm, long pages)
 {
-        WARN_ON(mm == NULL);
         return cap_vm_enough_memory(mm, pages);
 }
 
-static inline int security_vm_enough_memory_kern(long pages)
-{
-        /* If current->mm is a kernel thread then we will pass NULL,
-           for this specific case that is fine */
-        return cap_vm_enough_memory(current->mm, pages);
-}
-
 static inline int security_bprm_set_creds(struct linux_binprm *bprm)
 {
         return cap_bprm_set_creds(bprm);
@@ -2245,6 +2238,9 @@ static inline int security_task_create(unsigned long clone_flags)
         return 0;
 }
 
+static inline void security_task_free(struct task_struct *task)
+{ }
+
 static inline int security_cred_alloc_blank(struct cred *cred, gfp_t gfp)
 {
         return 0;
diff --git a/include/linux/seq_file.h b/include/linux/seq_file.h
index 44f1514b00ba..fc61854f6224 100644
--- a/include/linux/seq_file.h
+++ b/include/linux/seq_file.h
@@ -3,6 +3,7 @@
 
 #include <linux/types.h>
 #include <linux/string.h>
+#include <linux/bug.h>
 #include <linux/mutex.h>
 #include <linux/cpumask.h>
 #include <linux/nodemask.h>
@@ -121,9 +122,12 @@ int single_release(struct inode *, struct file *);
 void *__seq_open_private(struct file *, const struct seq_operations *, int);
 int seq_open_private(struct file *, const struct seq_operations *, int);
 int seq_release_private(struct inode *, struct file *);
+int seq_put_decimal_ull(struct seq_file *m, char delimiter,
+                        unsigned long long num);
+int seq_put_decimal_ll(struct seq_file *m, char delimiter,
+                        long long num);
 
 #define SEQ_START_TOKEN ((void *)1)
-
 /*
  * Helpers for iteration over list_head-s in seq_files
  */
diff --git a/include/linux/serial.h b/include/linux/serial.h
index 3d86517fe7d5..441980ecc4e5 100644
--- a/include/linux/serial.h
+++ b/include/linux/serial.h
@@ -152,8 +152,8 @@ struct serial_uart_config {
 #define ASYNC_AUTOPROBE         (1U << ASYNCB_AUTOPROBE)
 
 #define ASYNC_FLAGS             ((1U << (ASYNCB_LAST_USER + 1)) - 1)
-#define ASYNC_USR_MASK          (ASYNC_SPD_HI|ASYNC_SPD_VHI| \
-                ASYNC_CALLOUT_NOHUP|ASYNC_SPD_SHI|ASYNC_LOW_LATENCY)
+#define ASYNC_USR_MASK          (ASYNC_SPD_MASK|ASYNC_CALLOUT_NOHUP| \
+                ASYNC_LOW_LATENCY)
 #define ASYNC_SPD_CUST          (ASYNC_SPD_HI|ASYNC_SPD_VHI)
 #define ASYNC_SPD_WARP          (ASYNC_SPD_HI|ASYNC_SPD_SHI)
 #define ASYNC_SPD_MASK          (ASYNC_SPD_HI|ASYNC_SPD_VHI|ASYNC_SPD_SHI)
diff --git a/include/linux/serialP.h b/include/linux/serialP.h
deleted file mode 100644
index e811a615f696..000000000000
--- a/include/linux/serialP.h
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
- * Private header file for the (dumb) serial driver
- *
- * Copyright (C) 1997 by Theodore Ts'o.
- * 
- * Redistribution of this file is permitted under the terms of the GNU 
- * Public License (GPL)
- */
-
-#ifndef _LINUX_SERIALP_H
-#define _LINUX_SERIALP_H
-
-/*
- * This is our internal structure for each serial port's state.
- * 
- * Many fields are paralleled by the structure used by the serial_struct
- * structure.
- *
- * For definitions of the flags field, see tty.h
- */
-
-#include <linux/termios.h>
-#include <linux/workqueue.h>
-#include <linux/interrupt.h>
-#include <linux/circ_buf.h>
-#include <linux/wait.h>
-
-struct serial_state {
-        int     magic;
-        int     baud_base;
-        unsigned long   port;
-        int     irq;
-        int     flags;
-        int     hub6;
-        int     type;
-        int     line;
-        int     revision;       /* Chip revision (950) */
-        int     xmit_fifo_size;
-        int     custom_divisor;
-        int     count;
-        u8      *iomem_base;
-        u16     iomem_reg_shift;
-        unsigned short  close_delay;
-        unsigned short  closing_wait; /* time to wait before closing */
-        struct async_icount     icount; 
-        int     io_type;
-        struct async_struct *info;
-        struct pci_dev  *dev;
-};
-
-struct async_struct {
-        int                     magic;
-        unsigned long           port;
-        int                     hub6;
-        int                     flags;
-        int                     xmit_fifo_size;
-        struct serial_state     *state;
-        struct tty_struct       *tty;
-        int                     read_status_mask;
-        int                     ignore_status_mask;
-        int                     timeout;
-        int                     quot;
-        int                     x_char; /* xon/xoff character */
-        int                     close_delay;
-        unsigned short          closing_wait;
-        unsigned short          closing_wait2; /* obsolete */
-        int                     IER;    /* Interrupt Enable Register */
-        int                     MCR;    /* Modem control register */
-        int                     LCR;    /* Line control register */
-        int                     ACR;     /* 16950 Additional Control Reg. */
-        unsigned long           event;
-        unsigned long           last_active;
-        int                     line;
-        int                     blocked_open; /* # of blocked opens */
-        struct circ_buf         xmit;
-        spinlock_t              xmit_lock;
-        u8                      *iomem_base;
-        u16                     iomem_reg_shift;
-        int                     io_type;
-        struct work_struct                      work;
-        struct tasklet_struct   tlet;
-#ifdef DECLARE_WAITQUEUE
-        wait_queue_head_t       open_wait;
-        wait_queue_head_t       close_wait;
-        wait_queue_head_t       delta_msr_wait;
-#else   
-        struct wait_queue       *open_wait;
-        struct wait_queue       *close_wait;
-        struct wait_queue       *delta_msr_wait;
-#endif  
-        struct async_struct     *next_port; /* For the linked list */
-        struct async_struct     *prev_port;
-};
-
-#define CONFIGURED_SERIAL_PORT(info) ((info)->port || ((info)->iomem_base))
-
-#define SERIAL_MAGIC 0x5301
-#define SSTATE_MAGIC 0x5302
-
-/*
- * Events are used to schedule things to happen at timer-interrupt
- * time, instead of at rs interrupt time.
- */
-#define RS_EVENT_WRITE_WAKEUP   0
-
-/*
- * Multiport serial configuration structure --- internal structure
- */
-struct rs_multiport_struct {
-        int             port1;
-        unsigned char   mask1, match1;
-        int             port2;
-        unsigned char   mask2, match2;
-        int             port3;
-        unsigned char   mask3, match3;
-        int             port4;
-        unsigned char   mask4, match4;
-        int             port_monitor;
-};
-
-#if defined(__alpha__) && !defined(CONFIG_PCI)
-/*
- * Digital did something really horribly wrong with the OUT1 and OUT2
- * lines on at least some ALPHA's.  The failure mode is that if either
- * is cleared, the machine locks up with endless interrupts.
- *
- * This is still used by arch/mips/au1000/common/serial.c for some weird
- * reason (mips != alpha!)
- */
-#define ALPHA_KLUDGE_MCR  (UART_MCR_OUT2 | UART_MCR_OUT1)
-#elif defined(CONFIG_SBC8560)
-/*
- * WindRiver did something similarly broken on their SBC8560 board. The
- * UART tristates its IRQ output while OUT2 is clear, but they pulled
- * the interrupt line _up_ instead of down, so if we register the IRQ
- * while the UART is in that state, we die in an IRQ storm. */
-#define ALPHA_KLUDGE_MCR (UART_MCR_OUT2)
-#else
-#define ALPHA_KLUDGE_MCR 0
-#endif
-
-#endif /* _LINUX_SERIAL_H */
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index c91ace70c21d..f51bf2e70c69 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -210,6 +210,8 @@
 /* Atheros AR933X SoC */
 #define PORT_AR933X     99
 
+/* Energy Micro efm32 SoC */
+#define PORT_EFMUART   100
 
 #ifdef __KERNEL__
 
@@ -381,6 +383,16 @@ struct uart_port {
         void                    *private_data;          /* generic platform data pointer */
 };
 
+static inline int serial_port_in(struct uart_port *up, int offset)
+{
+        return up->serial_in(up, offset);
+}
+
+static inline void serial_port_out(struct uart_port *up, int offset, int value)
+{
+        up->serial_out(up, offset, value);
+}
+
 /*
  * This is the state information which is persistent across opens.
  */
diff --git a/include/linux/serial_pnx8xxx.h b/include/linux/serial_pnx8xxx.h
index de6c19c7f340..79ad87b0be3e 100644
--- a/include/linux/serial_pnx8xxx.h
+++ b/include/linux/serial_pnx8xxx.h
@@ -20,7 +20,6 @@
 #define _LINUX_SERIAL_PNX8XXX_H
 
 #include <linux/serial_core.h>
-#include <linux/device.h>
 
 #define PNX8XXX_NR_PORTS        2
 
diff --git a/include/linux/sh_clk.h b/include/linux/sh_clk.h
index 54341d811685..0a9d8f2ac519 100644
--- a/include/linux/sh_clk.h
+++ b/include/linux/sh_clk.h
@@ -18,7 +18,8 @@ struct clk_mapping {
         struct kref             ref;
 };
 
-struct clk_ops {
+
+struct sh_clk_ops {
 #ifdef CONFIG_SH_CLK_CPG_LEGACY
         void (*init)(struct clk *clk);
 #endif
@@ -37,7 +38,7 @@ struct clk {
         unsigned short          parent_num;     /* choose between */
         unsigned char           src_shift;      /* source clock field in the */
         unsigned char           src_width;      /* configuration register */
-        struct clk_ops          *ops;
+        struct sh_clk_ops       *ops;
 
         struct list_head        children;
         struct list_head        sibling;        /* node for children */
diff --git a/include/linux/sh_eth.h b/include/linux/sh_eth.h
index 2076acf8294d..b17d765ded84 100644
--- a/include/linux/sh_eth.h
+++ b/include/linux/sh_eth.h
@@ -20,6 +20,7 @@ struct sh_eth_plat_data {
         unsigned char mac_addr[6];
         unsigned no_ether_link:1;
         unsigned ether_link_active_low:1;
+        unsigned needs_init:1;
 };
 
 #endif
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index ae86adee3746..192250bd49f5 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -18,6 +18,7 @@
 #include <linux/kmemcheck.h>
 #include <linux/compiler.h>
 #include <linux/time.h>
+#include <linux/bug.h>
 #include <linux/cache.h>
 
 #include <linux/atomic.h>
@@ -94,6 +95,13 @@
  *                        about CHECKSUM_UNNECESSARY. 8)
  *      NETIF_F_IPV6_CSUM about as dumb as the last one but does IPv6 instead.
  *
+ *      UNNECESSARY: device will do per protocol specific csum. Protocol drivers
+ *      that do not want net to perform the checksum calculation should use
+ *      this flag in their outgoing skbs.
+ *      NETIF_F_FCOE_CRC  this indicates the device can do FCoE FC CRC
+ *                        offload. Correspondingly, the FCoE protocol driver
+ *                        stack should use CHECKSUM_UNNECESSARY.
+ *
  *      Any questions? No questions, good.              --ANK
  */
 
@@ -361,6 +369,7 @@ typedef unsigned char *sk_buff_data_t;
  *              ports.
  *      @wifi_acked_valid: wifi_acked was set
  *      @wifi_acked: whether frame was acked on wifi or not
+ *      @no_fcs:  Request NIC to treat last 4 bytes as Ethernet FCS
  *      @dma_cookie: a cookie to one of several possible DMA operations
  *              done by skb DMA functions
  *      @secmark: security marking
@@ -438,6 +447,11 @@ struct sk_buff {
 #endif
 
         int                     skb_iif;
+
+        __u32                   rxhash;
+
+        __u16                   vlan_tci;
+
 #ifdef CONFIG_NET_SCHED
         __u16                   tc_index;       /* traffic control index */
 #ifdef CONFIG_NET_CLS_ACT
@@ -445,8 +459,6 @@ struct sk_buff {
 #endif
 #endif
 
-        __u32                   rxhash;
-
         __u16                   queue_mapping;
         kmemcheck_bitfield_begin(flags2);
 #ifdef CONFIG_IPV6_NDISC_NODETYPE
@@ -456,7 +468,8 @@ struct sk_buff {
         __u8                    l4_rxhash:1;
         __u8                    wifi_acked_valid:1;
         __u8                    wifi_acked:1;
-        /* 10/12 bit hole (depending on ndisc_nodetype presence) */
+        __u8                    no_fcs:1;
+        /* 9/11 bit hole (depending on ndisc_nodetype presence) */
         kmemcheck_bitfield_end(flags2);
 
 #ifdef CONFIG_NET_DMA
@@ -470,8 +483,6 @@ struct sk_buff {
                 __u32           dropcount;
         };
 
-        __u16                   vlan_tci;
-
         sk_buff_data_t          transport_header;
         sk_buff_data_t          network_header;
         sk_buff_data_t          mac_header;
@@ -876,6 +887,24 @@ static inline struct sk_buff *skb_peek(const struct sk_buff_head *list_)
 }
 
 /**
+ *      skb_peek_next - peek skb following the given one from a queue
+ *      @skb: skb to start from
+ *      @list_: list to peek at
+ *
+ *      Returns %NULL when the end of the list is met or a pointer to the
+ *      next element. The reference count is not incremented and the
+ *      reference is therefore volatile. Use with caution.
+ */
+static inline struct sk_buff *skb_peek_next(struct sk_buff *skb,
+                const struct sk_buff_head *list_)
+{
+        struct sk_buff *next = skb->next;
+        if (next == (struct sk_buff *)list_)
+                next = NULL;
+        return next;
+}
+
+/**
  *      skb_peek_tail - peek at the tail of an &sk_buff_head
  *      @list_: list to peek at
  *
@@ -1152,7 +1181,7 @@ static inline struct sk_buff *__skb_dequeue_tail(struct sk_buff_head *list)
 }
 
 
-static inline int skb_is_nonlinear(const struct sk_buff *skb)
+static inline bool skb_is_nonlinear(const struct sk_buff *skb)
 {
         return skb->data_len;
 }
@@ -1216,7 +1245,7 @@ static inline void skb_fill_page_desc(struct sk_buff *skb, int i,
 }
 
 extern void skb_add_rx_frag(struct sk_buff *skb, int i, struct page *page,
-                            int off, int size);
+                            int off, int size, unsigned int truesize);
 
 #define SKB_PAGE_ASSERT(skb)    BUG_ON(skb_shinfo(skb)->nr_frags)
 #define SKB_FRAG_ASSERT(skb)    BUG_ON(skb_has_frag_list(skb))
@@ -2055,7 +2084,7 @@ static inline void skb_frag_add_head(struct sk_buff *skb, struct sk_buff *frag)
         for (iter = skb_shinfo(skb)->frag_list; iter; iter = iter->next)
 
 extern struct sk_buff *__skb_recv_datagram(struct sock *sk, unsigned flags,
-                                           int *peeked, int *err);
+                                           int *peeked, int *off, int *err);
 extern struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags,
                                          int noblock, int *err);
 extern unsigned int    datagram_poll(struct file *file, struct socket *sock,
@@ -2448,12 +2477,12 @@ static inline struct sec_path *skb_sec_path(struct sk_buff *skb)
 }
 #endif
 
-static inline int skb_is_gso(const struct sk_buff *skb)
+static inline bool skb_is_gso(const struct sk_buff *skb)
 {
         return skb_shinfo(skb)->gso_size;
 }
 
-static inline int skb_is_gso_v6(const struct sk_buff *skb)
+static inline bool skb_is_gso_v6(const struct sk_buff *skb)
 {
         return skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6;
 }
diff --git a/include/linux/slub_def.h b/include/linux/slub_def.h
index a32bcfdc7834..ca122b36aec1 100644
--- a/include/linux/slub_def.h
+++ b/include/linux/slub_def.h
@@ -8,6 +8,7 @@
  */
 #include <linux/types.h>
 #include <linux/gfp.h>
+#include <linux/bug.h>
 #include <linux/workqueue.h>
 #include <linux/kobject.h>
 
diff --git a/include/linux/snmp.h b/include/linux/snmp.h
index c1241c428179..2e68f5ba0389 100644
--- a/include/linux/snmp.h
+++ b/include/linux/snmp.h
@@ -232,6 +232,8 @@ enum
         LINUX_MIB_TCPTIMEWAITOVERFLOW,          /* TCPTimeWaitOverflow */
         LINUX_MIB_TCPREQQFULLDOCOOKIES,         /* TCPReqQFullDoCookies */
         LINUX_MIB_TCPREQQFULLDROP,              /* TCPReqQFullDrop */
+        LINUX_MIB_TCPRETRANSFAIL,               /* TCPRetransFail */
+        LINUX_MIB_TCPRCVCOALESCE,                       /* TCPRcvCoalesce */
         __LINUX_MIB_MAX
 };
 
diff --git a/include/linux/socket.h b/include/linux/socket.h
index d0e77f607a79..da2d3e2543f3 100644
--- a/include/linux/socket.h
+++ b/include/linux/socket.h
@@ -326,11 +326,11 @@ extern int csum_partial_copy_fromiovecend(unsigned char *kdata,
                                           int offset, 
                                           unsigned int len, __wsum *csump);
 
-extern int verify_iovec(struct msghdr *m, struct iovec *iov, struct sockaddr *address, int mode);
+extern int verify_iovec(struct msghdr *m, struct iovec *iov, struct sockaddr_storage *address, int mode);
 extern int memcpy_toiovec(struct iovec *v, unsigned char *kdata, int len);
 extern int memcpy_toiovecend(const struct iovec *v, unsigned char *kdata,
                              int offset, int len);
-extern int move_addr_to_kernel(void __user *uaddr, int ulen, struct sockaddr *kaddr);
+extern int move_addr_to_kernel(void __user *uaddr, int ulen, struct sockaddr_storage *kaddr);
 extern int put_cmsg(struct msghdr*, int level, int type, int len, void *data);
 
 struct timespec;
diff --git a/include/linux/spi/mmc_spi.h b/include/linux/spi/mmc_spi.h
index 0f4eb165f254..32be8dbdf191 100644
--- a/include/linux/spi/mmc_spi.h
+++ b/include/linux/spi/mmc_spi.h
@@ -1,10 +1,10 @@
 #ifndef __LINUX_SPI_MMC_SPI_H
 #define __LINUX_SPI_MMC_SPI_H
 
-#include <linux/device.h>
 #include <linux/spi/spi.h>
 #include <linux/interrupt.h>
 
+struct device;
 struct mmc_host;
 
 /* Put this in platform_data of a device being used to manage an MMC/SD
diff --git a/include/linux/spi/orion_spi.h b/include/linux/spi/orion_spi.h
index decf6d8c77b7..b4d9fa6f797c 100644
--- a/include/linux/spi/orion_spi.h
+++ b/include/linux/spi/orion_spi.h
@@ -11,7 +11,6 @@
 
 struct orion_spi_info {
         u32     tclk;           /* no <linux/clk.h> support yet */
-        u32     enable_clock_fix;
 };
 
 
diff --git a/include/linux/spi/s3c24xx.h b/include/linux/spi/s3c24xx.h
new file mode 100644
index 000000000000..c23b923e493b
--- /dev/null
+++ b/include/linux/spi/s3c24xx.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2006 Simtec Electronics
+ *      Ben Dooks <ben@simtec.co.uk>
+ *
+ * S3C2410 - SPI Controller platform_device info
+ *
+ * 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_SPI_S3C24XX_H
+#define __LINUX_SPI_S3C24XX_H __FILE__
+
+struct s3c2410_spi_info {
+        int                      pin_cs;        /* simple gpio cs */
+        unsigned int             num_cs;        /* total chipselects */
+        int                      bus_num;       /* bus number to use. */
+
+        unsigned int             use_fiq:1;     /* use fiq */
+
+        void (*gpio_setup)(struct s3c2410_spi_info *spi, int enable);
+        void (*set_cs)(struct s3c2410_spi_info *spi, int cs, int pol);
+};
+
+#endif /* __LINUX_SPI_S3C24XX_H */
diff --git a/include/linux/spi/sh_hspi.h b/include/linux/spi/sh_hspi.h
new file mode 100644
index 000000000000..a1121f872ac1
--- /dev/null
+++ b/include/linux/spi/sh_hspi.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2011 Kuninori Morimoto
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef SH_HSPI_H
+#define SH_HSPI_H
+
+struct sh_hspi_info {
+};
+
+#endif
diff --git a/include/linux/spi/spi.h b/include/linux/spi/spi.h
index 176fce9cc6b1..98679b061b63 100644
--- a/include/linux/spi/spi.h
+++ b/include/linux/spi/spi.h
@@ -22,6 +22,7 @@
 #include <linux/device.h>
 #include <linux/mod_devicetable.h>
 #include <linux/slab.h>
+#include <linux/kthread.h>
 
 /*
  * INTERFACES between SPI master-side drivers and SPI infrastructure.
@@ -235,6 +236,27 @@ static inline void spi_unregister_driver(struct spi_driver *sdrv)
  *      the device whose settings are being modified.
  * @transfer: adds a message to the controller's transfer queue.
  * @cleanup: frees controller-specific state
+ * @queued: whether this master is providing an internal message queue
+ * @kworker: thread struct for message pump
+ * @kworker_task: pointer to task for message pump kworker thread
+ * @pump_messages: work struct for scheduling work to the message pump
+ * @queue_lock: spinlock to syncronise access to message queue
+ * @queue: message queue
+ * @cur_msg: the currently in-flight message
+ * @busy: message pump is busy
+ * @running: message pump is running
+ * @rt: whether this queue is set to run as a realtime task
+ * @prepare_transfer_hardware: a message will soon arrive from the queue
+ *      so the subsystem requests the driver to prepare the transfer hardware
+ *      by issuing this call
+ * @transfer_one_message: the subsystem calls the driver to transfer a single
+ *      message while queuing transfers that arrive in the meantime. When the
+ *      driver is finished with this message, it must call
+ *      spi_finalize_current_message() so the subsystem can issue the next
+ *      transfer
+ * @prepare_transfer_hardware: there are currently no more messages on the
+ *      queue so the subsystem notifies the driver that it may relax the
+ *      hardware by issuing this call
  *
  * Each SPI master controller can communicate with one or more @spi_device
  * children.  These make a small bus, sharing MOSI, MISO and SCK signals
@@ -318,6 +340,28 @@ struct spi_master {
 
         /* called on release() to free memory provided by spi_master */
         void                    (*cleanup)(struct spi_device *spi);
+
+        /*
+         * These hooks are for drivers that want to use the generic
+         * master transfer queueing mechanism. If these are used, the
+         * transfer() function above must NOT be specified by the driver.
+         * Over time we expect SPI drivers to be phased over to this API.
+         */
+        bool                            queued;
+        struct kthread_worker           kworker;
+        struct task_struct              *kworker_task;
+        struct kthread_work             pump_messages;
+        spinlock_t                      queue_lock;
+        struct list_head                queue;
+        struct spi_message              *cur_msg;
+        bool                            busy;
+        bool                            running;
+        bool                            rt;
+
+        int (*prepare_transfer_hardware)(struct spi_master *master);
+        int (*transfer_one_message)(struct spi_master *master,
+                                    struct spi_message *mesg);
+        int (*unprepare_transfer_hardware)(struct spi_master *master);
 };
 
 static inline void *spi_master_get_devdata(struct spi_master *master)
@@ -343,6 +387,13 @@ static inline void spi_master_put(struct spi_master *master)
                 put_device(&master->dev);
 }
 
+/* PM calls that need to be issued by the driver */
+extern int spi_master_suspend(struct spi_master *master);
+extern int spi_master_resume(struct spi_master *master);
+
+/* Calls the driver make to interact with the message queue */
+extern struct spi_message *spi_get_next_queued_message(struct spi_master *master);
+extern void spi_finalize_current_message(struct spi_master *master);
 
 /* the spi driver core manages memory for the spi_master classdev */
 extern struct spi_master *
@@ -549,7 +600,7 @@ static inline struct spi_message *spi_message_alloc(unsigned ntrans, gfp_t flags
                         + ntrans * sizeof(struct spi_transfer),
                         flags);
         if (m) {
-                int i;
+                unsigned i;
                 struct spi_transfer *t = (struct spi_transfer *)(m + 1);
 
                 INIT_LIST_HEAD(&m->transfers);
diff --git a/include/linux/spinlock.h b/include/linux/spinlock.h
index 7df6c17b0281..363239087263 100644
--- a/include/linux/spinlock.h
+++ b/include/linux/spinlock.h
@@ -375,10 +375,7 @@ static inline int spin_can_lock(spinlock_t *lock)
         return raw_spin_can_lock(&lock->rlock);
 }
 
-static inline void assert_spin_locked(spinlock_t *lock)
-{
-        assert_raw_spin_locked(&lock->rlock);
-}
+#define assert_spin_locked(lock)        assert_raw_spin_locked(&(lock)->rlock)
 
 /*
  * Pull the atomic_t declaration:
diff --git a/include/linux/srcu.h b/include/linux/srcu.h
index e1b005918bbb..d3d5fa54f25e 100644
--- a/include/linux/srcu.h
+++ b/include/linux/srcu.h
@@ -99,15 +99,18 @@ long srcu_batches_completed(struct srcu_struct *sp);
  * power mode. This way we can notice an extended quiescent state to
  * other CPUs that started a grace period. Otherwise we would delay any
  * grace period as long as we run in the idle task.
+ *
+ * Similarly, we avoid claiming an SRCU read lock held if the current
+ * CPU is offline.
  */
 static inline int srcu_read_lock_held(struct srcu_struct *sp)
 {
-        if (rcu_is_cpu_idle())
-                return 0;
-
         if (!debug_lockdep_rcu_enabled())
                 return 1;
-
+        if (rcu_is_cpu_idle())
+                return 0;
+        if (!rcu_lockdep_current_cpu_online())
+                return 0;
         return lock_is_held(&sp->dep_map);
 }
 
@@ -169,6 +172,8 @@ static inline int srcu_read_lock(struct srcu_struct *sp) __acquires(sp)
         int retval = __srcu_read_lock(sp);
 
         rcu_lock_acquire(&(sp)->dep_map);
+        rcu_lockdep_assert(!rcu_is_cpu_idle(),
+                           "srcu_read_lock() used illegally while idle");
         return retval;
 }
 
@@ -182,6 +187,8 @@ static inline int srcu_read_lock(struct srcu_struct *sp) __acquires(sp)
 static inline void srcu_read_unlock(struct srcu_struct *sp, int idx)
         __releases(sp)
 {
+        rcu_lockdep_assert(!rcu_is_cpu_idle(),
+                           "srcu_read_unlock() used illegally while idle");
         rcu_lock_release(&(sp)->dep_map);
         __srcu_read_unlock(sp, idx);
 }
diff --git a/include/linux/ssb/ssb.h b/include/linux/ssb/ssb.h
index dcf35b0f303a..d27683180025 100644
--- a/include/linux/ssb/ssb.h
+++ b/include/linux/ssb/ssb.h
@@ -16,6 +16,12 @@ struct pcmcia_device;
 struct ssb_bus;
 struct ssb_driver;
 
+struct ssb_sprom_core_pwr_info {
+        u8 itssi_2g, itssi_5g;
+        u8 maxpwr_2g, maxpwr_5gl, maxpwr_5g, maxpwr_5gh;
+        u16 pa_2g[4], pa_5gl[4], pa_5g[4], pa_5gh[4];
+};
+
 struct ssb_sprom {
         u8 revision;
         u8 il0mac[6];           /* MAC address for 802.11b/g */
@@ -26,9 +32,12 @@ struct ssb_sprom {
         u8 et0mdcport;          /* MDIO for enet0 */
         u8 et1mdcport;          /* MDIO for enet1 */
         u16 board_rev;          /* Board revision number from SPROM. */
+        u16 board_num;          /* Board number from SPROM. */
+        u16 board_type;         /* Board type from SPROM. */
         u8 country_code;        /* Country Code */
-        u16 leddc_on_time;      /* LED Powersave Duty Cycle On Count */
-        u16 leddc_off_time;     /* LED Powersave Duty Cycle Off Count */
+        char alpha2[2];         /* Country Code as two chars like EU or US */
+        u8 leddc_on_time;       /* LED Powersave Duty Cycle On Count */
+        u8 leddc_off_time;      /* LED Powersave Duty Cycle Off Count */
         u8 ant_available_a;     /* 2GHz antenna available bits (up to 4) */
         u8 ant_available_bg;    /* 5GHz antenna available bits (up to 4) */
         u16 pa0b0;
@@ -47,10 +56,10 @@ struct ssb_sprom {
         u8 gpio1;               /* GPIO pin 1 */
         u8 gpio2;               /* GPIO pin 2 */
         u8 gpio3;               /* GPIO pin 3 */
-        u16 maxpwr_bg;          /* 2.4GHz Amplifier Max Power (in dBm Q5.2) */
-        u16 maxpwr_al;          /* 5.2GHz Amplifier Max Power (in dBm Q5.2) */
-        u16 maxpwr_a;           /* 5.3GHz Amplifier Max Power (in dBm Q5.2) */
-        u16 maxpwr_ah;          /* 5.8GHz Amplifier Max Power (in dBm Q5.2) */
+        u8 maxpwr_bg;           /* 2.4GHz Amplifier Max Power (in dBm Q5.2) */
+        u8 maxpwr_al;           /* 5.2GHz Amplifier Max Power (in dBm Q5.2) */
+        u8 maxpwr_a;            /* 5.3GHz Amplifier Max Power (in dBm Q5.2) */
+        u8 maxpwr_ah;           /* 5.8GHz Amplifier Max Power (in dBm Q5.2) */
         u8 itssi_a;             /* Idle TSSI Target for A-PHY */
         u8 itssi_bg;            /* Idle TSSI Target for B/G-PHY */
         u8 tri2g;               /* 2.4GHz TX isolation */
@@ -61,8 +70,8 @@ struct ssb_sprom {
         u8 txpid5gl[4];         /* 4.9 - 5.1GHz TX power index */
         u8 txpid5g[4];          /* 5.1 - 5.5GHz TX power index */
         u8 txpid5gh[4];         /* 5.5 - ...GHz TX power index */
-        u8 rxpo2g;              /* 2GHz RX power offset */
-        u8 rxpo5g;              /* 5GHz RX power offset */
+        s8 rxpo2g;              /* 2GHz RX power offset */
+        s8 rxpo5g;              /* 5GHz RX power offset */
         u8 rssisav2g;           /* 2GHz RSSI params */
         u8 rssismc2g;
         u8 rssismf2g;
@@ -82,16 +91,13 @@ struct ssb_sprom {
         u16 boardflags2_hi;     /* Board flags (bits 48-63) */
         /* TODO store board flags in a single u64 */
 
+        struct ssb_sprom_core_pwr_info core_pwr_info[4];
+
         /* Antenna gain values for up to 4 antennas
          * on each band. Values in dBm/4 (Q5.2). Negative gain means the
          * loss in the connectors is bigger than the gain. */
         struct {
-                struct {
-                        s8 a0, a1, a2, a3;
-                } ghz24;        /* 2.4GHz band */
-                struct {
-                        s8 a0, a1, a2, a3;
-                } ghz5;         /* 5GHz band */
+                s8 a0, a1, a2, a3;
         } antenna_gain;
 
         struct {
@@ -103,7 +109,79 @@ struct ssb_sprom {
                 } ghz5;
         } fem;
 
-        /* TODO - add any parameters needed from rev 2, 3, 4, 5 or 8 SPROMs */
+        u16 mcs2gpo[8];
+        u16 mcs5gpo[8];
+        u16 mcs5glpo[8];
+        u16 mcs5ghpo[8];
+        u8 opo;
+
+        u8 rxgainerr2ga[3];
+        u8 rxgainerr5gla[3];
+        u8 rxgainerr5gma[3];
+        u8 rxgainerr5gha[3];
+        u8 rxgainerr5gua[3];
+
+        u8 noiselvl2ga[3];
+        u8 noiselvl5gla[3];
+        u8 noiselvl5gma[3];
+        u8 noiselvl5gha[3];
+        u8 noiselvl5gua[3];
+
+        u8 regrev;
+        u8 txchain;
+        u8 rxchain;
+        u8 antswitch;
+        u16 cddpo;
+        u16 stbcpo;
+        u16 bw40po;
+        u16 bwduppo;
+
+        u8 tempthresh;
+        u8 tempoffset;
+        u16 rawtempsense;
+        u8 measpower;
+        u8 tempsense_slope;
+        u8 tempcorrx;
+        u8 tempsense_option;
+        u8 freqoffset_corr;
+        u8 iqcal_swp_dis;
+        u8 hw_iqcal_en;
+        u8 elna2g;
+        u8 elna5g;
+        u8 phycal_tempdelta;
+        u8 temps_period;
+        u8 temps_hysteresis;
+        u8 measpower1;
+        u8 measpower2;
+        u8 pcieingress_war;
+
+        /* power per rate from sromrev 9 */
+        u16 cckbw202gpo;
+        u16 cckbw20ul2gpo;
+        u32 legofdmbw202gpo;
+        u32 legofdmbw20ul2gpo;
+        u32 legofdmbw205glpo;
+        u32 legofdmbw20ul5glpo;
+        u32 legofdmbw205gmpo;
+        u32 legofdmbw20ul5gmpo;
+        u32 legofdmbw205ghpo;
+        u32 legofdmbw20ul5ghpo;
+        u32 mcsbw202gpo;
+        u32 mcsbw20ul2gpo;
+        u32 mcsbw402gpo;
+        u32 mcsbw205glpo;
+        u32 mcsbw20ul5glpo;
+        u32 mcsbw405glpo;
+        u32 mcsbw205gmpo;
+        u32 mcsbw20ul5gmpo;
+        u32 mcsbw405gmpo;
+        u32 mcsbw205ghpo;
+        u32 mcsbw20ul5ghpo;
+        u32 mcsbw405ghpo;
+        u16 mcs32po;
+        u16 legofdm40duppo;
+        u8 sar2g;
+        u8 sar5g;
 };
 
 /* Information about the PCB the circuitry is soldered on. */
diff --git a/include/linux/ssb/ssb_driver_gige.h b/include/linux/ssb/ssb_driver_gige.h
index eba52a100533..6b05dcd927ff 100644
--- a/include/linux/ssb/ssb_driver_gige.h
+++ b/include/linux/ssb/ssb_driver_gige.h
@@ -2,6 +2,7 @@
 #define LINUX_SSB_DRIVER_GIGE_H_
 
 #include <linux/ssb/ssb.h>
+#include <linux/bug.h>
 #include <linux/pci.h>
 #include <linux/spinlock.h>
 
diff --git a/include/linux/ssb/ssb_regs.h b/include/linux/ssb/ssb_regs.h
index c814ae6eeb22..40b1ef8595ee 100644
--- a/include/linux/ssb/ssb_regs.h
+++ b/include/linux/ssb/ssb_regs.h
@@ -449,6 +449,39 @@
 #define SSB_SPROM8_TS_SLP_OPT_CORRX     0x00B6
 #define SSB_SPROM8_FOC_HWIQ_IQSWP       0x00B8
 #define SSB_SPROM8_PHYCAL_TEMPDELTA     0x00BA
+
+/* There are 4 blocks with power info sharing the same layout */
+#define SSB_SROM8_PWR_INFO_CORE0        0x00C0
+#define SSB_SROM8_PWR_INFO_CORE1        0x00E0
+#define SSB_SROM8_PWR_INFO_CORE2        0x0100
+#define SSB_SROM8_PWR_INFO_CORE3        0x0120
+
+#define SSB_SROM8_2G_MAXP_ITSSI         0x00
+#define  SSB_SPROM8_2G_MAXP             0x00FF
+#define  SSB_SPROM8_2G_ITSSI            0xFF00
+#define  SSB_SPROM8_2G_ITSSI_SHIFT      8
+#define SSB_SROM8_2G_PA_0               0x02    /* 2GHz power amp settings */
+#define SSB_SROM8_2G_PA_1               0x04
+#define SSB_SROM8_2G_PA_2               0x06
+#define SSB_SROM8_5G_MAXP_ITSSI         0x08    /* 5GHz ITSSI and 5.3GHz Max Power */
+#define  SSB_SPROM8_5G_MAXP             0x00FF
+#define  SSB_SPROM8_5G_ITSSI            0xFF00
+#define  SSB_SPROM8_5G_ITSSI_SHIFT      8
+#define SSB_SPROM8_5GHL_MAXP            0x0A    /* 5.2GHz and 5.8GHz Max Power */
+#define  SSB_SPROM8_5GH_MAXP            0x00FF
+#define  SSB_SPROM8_5GL_MAXP            0xFF00
+#define  SSB_SPROM8_5GL_MAXP_SHIFT      8
+#define SSB_SROM8_5G_PA_0               0x0C    /* 5.3GHz power amp settings */
+#define SSB_SROM8_5G_PA_1               0x0E
+#define SSB_SROM8_5G_PA_2               0x10
+#define SSB_SROM8_5GL_PA_0              0x12    /* 5.2GHz power amp settings */
+#define SSB_SROM8_5GL_PA_1              0x14
+#define SSB_SROM8_5GL_PA_2              0x16
+#define SSB_SROM8_5GH_PA_0              0x18    /* 5.8GHz power amp settings */
+#define SSB_SROM8_5GH_PA_1              0x1A
+#define SSB_SROM8_5GH_PA_2              0x1C
+
+/* TODO: Make it deprecated */
 #define SSB_SPROM8_MAXP_BG              0x00C0  /* Max Power 2GHz in path 1 */
 #define  SSB_SPROM8_MAXP_BG_MASK        0x00FF  /* Mask for Max Power 2GHz */
 #define  SSB_SPROM8_ITSSI_BG            0xFF00  /* Mask for path 1 itssi_bg */
@@ -473,6 +506,7 @@
 #define SSB_SPROM8_PA1HIB0              0x00D8  /* 5.8GHz power amp settings */
 #define SSB_SPROM8_PA1HIB1              0x00DA
 #define SSB_SPROM8_PA1HIB2              0x00DC
+
 #define SSB_SPROM8_CCK2GPO              0x0140  /* CCK power offset */
 #define SSB_SPROM8_OFDM2GPO             0x0142  /* 2.4GHz OFDM power offset */
 #define SSB_SPROM8_OFDM5GPO             0x0146  /* 5.3GHz OFDM power offset */
diff --git a/include/linux/static_key.h b/include/linux/static_key.h
new file mode 100644
index 000000000000..27bd3f8a0857
--- /dev/null
+++ b/include/linux/static_key.h
@@ -0,0 +1 @@
+#include <linux/jump_label.h>
diff --git a/include/linux/sunrpc/auth.h b/include/linux/sunrpc/auth.h
index 7874a8a56638..492a36d72829 100644
--- a/include/linux/sunrpc/auth.h
+++ b/include/linux/sunrpc/auth.h
@@ -99,6 +99,8 @@ struct rpc_authops {
 
         struct rpc_cred *       (*lookup_cred)(struct rpc_auth *, struct auth_cred *, int);
         struct rpc_cred *       (*crcreate)(struct rpc_auth*, struct auth_cred *, int);
+        int                     (*pipes_create)(struct rpc_auth *);
+        void                    (*pipes_destroy)(struct rpc_auth *);
 };
 
 struct rpc_credops {
diff --git a/include/linux/sunrpc/bc_xprt.h b/include/linux/sunrpc/bc_xprt.h
index f7f3ce340c08..969c0a671dbf 100644
--- a/include/linux/sunrpc/bc_xprt.h
+++ b/include/linux/sunrpc/bc_xprt.h
@@ -35,7 +35,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 struct rpc_rqst *xprt_alloc_bc_request(struct rpc_xprt *xprt);
 void xprt_free_bc_request(struct rpc_rqst *req);
 int xprt_setup_backchannel(struct rpc_xprt *, unsigned int min_reqs);
-void xprt_destroy_backchannel(struct rpc_xprt *, int max_reqs);
+void xprt_destroy_backchannel(struct rpc_xprt *, unsigned int max_reqs);
 int bc_send(struct rpc_rqst *req);
 
 /*
diff --git a/include/linux/sunrpc/cache.h b/include/linux/sunrpc/cache.h
index 57531f8e5956..f5fd6160dbca 100644
--- a/include/linux/sunrpc/cache.h
+++ b/include/linux/sunrpc/cache.h
@@ -117,6 +117,7 @@ struct cache_detail {
                 struct cache_detail_procfs procfs;
                 struct cache_detail_pipefs pipefs;
         } u;
+        struct net              *net;
 };
 
 
@@ -197,11 +198,14 @@ extern void cache_flush(void);
 extern void cache_purge(struct cache_detail *detail);
 #define NEVER (0x7FFFFFFF)
 extern void __init cache_initialize(void);
-extern int cache_register(struct cache_detail *cd);
 extern int cache_register_net(struct cache_detail *cd, struct net *net);
-extern void cache_unregister(struct cache_detail *cd);
 extern void cache_unregister_net(struct cache_detail *cd, struct net *net);
 
+extern struct cache_detail *cache_create_net(struct cache_detail *tmpl, struct net *net);
+extern void cache_destroy_net(struct cache_detail *cd, struct net *net);
+
+extern void sunrpc_init_cache_detail(struct cache_detail *cd);
+extern void sunrpc_destroy_cache_detail(struct cache_detail *cd);
 extern int sunrpc_cache_register_pipefs(struct dentry *parent, const char *,
                                         umode_t, struct cache_detail *);
 extern void sunrpc_cache_unregister_pipefs(struct cache_detail *);
diff --git a/include/linux/sunrpc/clnt.h b/include/linux/sunrpc/clnt.h
index 2c5993a17c33..523547ecfee2 100644
--- a/include/linux/sunrpc/clnt.h
+++ b/include/linux/sunrpc/clnt.h
@@ -35,14 +35,13 @@ struct rpc_clnt {
         struct list_head        cl_clients;     /* Global list of clients */
         struct list_head        cl_tasks;       /* List of tasks */
         spinlock_t              cl_lock;        /* spinlock */
-        struct rpc_xprt *       cl_xprt;        /* transport */
+        struct rpc_xprt __rcu * cl_xprt;        /* transport */
         struct rpc_procinfo *   cl_procinfo;    /* procedure info */
         u32                     cl_prog,        /* RPC program number */
                                 cl_vers,        /* RPC version number */
                                 cl_maxproc;     /* max procedure number */
 
-        char *                  cl_server;      /* server machine name */
-        char *                  cl_protname;    /* protocol name */
+        const char *            cl_protname;    /* protocol name */
         struct rpc_auth *       cl_auth;        /* authenticator */
         struct rpc_stat *       cl_stats;       /* per-program statistics */
         struct rpc_iostats *    cl_metrics;     /* per-client statistics */
@@ -57,12 +56,11 @@ struct rpc_clnt {
 
         int                     cl_nodelen;     /* nodename length */
         char                    cl_nodename[UNX_MAXNODENAME];
-        struct path             cl_path;
+        struct dentry *         cl_dentry;
         struct rpc_clnt *       cl_parent;      /* Points to parent of clones */
         struct rpc_rtt          cl_rtt_default;
         struct rpc_timeout      cl_timeout_default;
-        struct rpc_program *    cl_program;
-        char                    cl_inline_name[32];
+        const struct rpc_program *cl_program;
         char                    *cl_principal;  /* target to authenticate to */
 };
 
@@ -71,12 +69,12 @@ struct rpc_clnt {
  */
 #define RPC_MAXVERSION          4
 struct rpc_program {
-        char *                  name;           /* protocol name */
+        const char *            name;           /* protocol name */
         u32                     number;         /* program number */
         unsigned int            nrvers;         /* number of versions */
-        struct rpc_version **   version;        /* version array */
+        const struct rpc_version **     version;        /* version array */
         struct rpc_stat *       stats;          /* statistics */
-        char *                  pipe_dir_name;  /* path to rpc_pipefs dir */
+        const char *            pipe_dir_name;  /* path to rpc_pipefs dir */
 };
 
 struct rpc_version {
@@ -97,7 +95,7 @@ struct rpc_procinfo {
         unsigned int            p_count;        /* call count */
         unsigned int            p_timer;        /* Which RTT timer to use */
         u32                     p_statidx;      /* Which procedure to account */
-        char *                  p_name;         /* name of procedure */
+        const char *            p_name;         /* name of procedure */
 };
 
 #ifdef __KERNEL__
@@ -109,8 +107,8 @@ struct rpc_create_args {
         size_t                  addrsize;
         struct sockaddr         *saddress;
         const struct rpc_timeout *timeout;
-        char                    *servername;
-        struct rpc_program      *program;
+        const char              *servername;
+        const struct rpc_program *program;
         u32                     prognumber;     /* overrides program->number */
         u32                     version;
         rpc_authflavor_t        authflavor;
@@ -129,17 +127,18 @@ struct rpc_create_args {
 
 struct rpc_clnt *rpc_create(struct rpc_create_args *args);
 struct rpc_clnt *rpc_bind_new_program(struct rpc_clnt *,
-                                struct rpc_program *, u32);
+                                const struct rpc_program *, u32);
 void rpc_task_reset_client(struct rpc_task *task, struct rpc_clnt *clnt);
 struct rpc_clnt *rpc_clone_client(struct rpc_clnt *);
 void            rpc_shutdown_client(struct rpc_clnt *);
 void            rpc_release_client(struct rpc_clnt *);
 void            rpc_task_release_client(struct rpc_task *);
 
-int             rpcb_create_local(void);
-void            rpcb_put_local(void);
-int             rpcb_register(u32, u32, int, unsigned short);
-int             rpcb_v4_register(const u32 program, const u32 version,
+int             rpcb_create_local(struct net *);
+void            rpcb_put_local(struct net *);
+int             rpcb_register(struct net *, u32, u32, int, unsigned short);
+int             rpcb_v4_register(struct net *net, const u32 program,
+                                 const u32 version,
                                  const struct sockaddr *address,
                                  const char *netid);
 void            rpcb_getport_async(struct rpc_task *);
@@ -156,16 +155,19 @@ struct rpc_task *rpc_call_null(struct rpc_clnt *clnt, struct rpc_cred *cred,
 int             rpc_restart_call_prepare(struct rpc_task *);
 int             rpc_restart_call(struct rpc_task *);
 void            rpc_setbufsize(struct rpc_clnt *, unsigned int, unsigned int);
+int             rpc_protocol(struct rpc_clnt *);
+struct net *    rpc_net_ns(struct rpc_clnt *);
 size_t          rpc_max_payload(struct rpc_clnt *);
 void            rpc_force_rebind(struct rpc_clnt *);
 size_t          rpc_peeraddr(struct rpc_clnt *, struct sockaddr *, size_t);
 const char      *rpc_peeraddr2str(struct rpc_clnt *, enum rpc_display_format_t);
+int             rpc_localaddr(struct rpc_clnt *, struct sockaddr *, size_t);
 
 size_t          rpc_ntop(const struct sockaddr *, char *, const size_t);
-size_t          rpc_pton(const char *, const size_t,
+size_t          rpc_pton(struct net *, const char *, const size_t,
                          struct sockaddr *, const size_t);
 char *          rpc_sockaddr2uaddr(const struct sockaddr *, gfp_t);
-size_t          rpc_uaddr2sockaddr(const char *, const size_t,
+size_t          rpc_uaddr2sockaddr(struct net *, const char *, const size_t,
                                    struct sockaddr *, const size_t);
 
 static inline unsigned short rpc_get_port(const struct sockaddr *sap)
diff --git a/include/linux/sunrpc/debug.h b/include/linux/sunrpc/debug.h
index c2786f20016f..a76cc20d98ce 100644
--- a/include/linux/sunrpc/debug.h
+++ b/include/linux/sunrpc/debug.h
@@ -31,9 +31,12 @@
 /*
  * Enable RPC debugging/profiling.
  */
-#ifdef CONFIG_SYSCTL
+#ifdef CONFIG_SUNRPC_DEBUG
 #define  RPC_DEBUG
 #endif
+#ifdef CONFIG_TRACEPOINTS
+#define RPC_TRACEPOINTS
+#endif
 /* #define  RPC_PROFILE */
 
 /*
@@ -47,15 +50,32 @@ extern unsigned int		nlm_debug;
 #endif
 
 #define dprintk(args...)        dfprintk(FACILITY, ## args)
+#define dprintk_rcu(args...)    dfprintk_rcu(FACILITY, ## args)
 
 #undef ifdebug
 #ifdef RPC_DEBUG                        
 # define ifdebug(fac)           if (unlikely(rpc_debug & RPCDBG_##fac))
-# define dfprintk(fac, args...) do { ifdebug(fac) printk(args); } while(0)
+
+# define dfprintk(fac, args...) \
+        do { \
+                ifdebug(fac) \
+                        printk(KERN_DEFAULT args); \
+        } while (0)
+
+# define dfprintk_rcu(fac, args...)     \
+        do { \
+                ifdebug(fac) { \
+                        rcu_read_lock(); \
+                        printk(KERN_DEFAULT args); \
+                        rcu_read_unlock(); \
+                } \
+        } while (0)
+
 # define RPC_IFDEBUG(x)         x
 #else
 # define ifdebug(fac)           if (0)
-# define dfprintk(fac, args...) do ; while (0)
+# define dfprintk(fac, args...) do {} while (0)
+# define dfprintk_rcu(fac, args...)     do {} while (0)
 # define RPC_IFDEBUG(x)
 #endif
 
diff --git a/include/linux/sunrpc/metrics.h b/include/linux/sunrpc/metrics.h
index b6edbc0ea83d..1565bbe86d51 100644
--- a/include/linux/sunrpc/metrics.h
+++ b/include/linux/sunrpc/metrics.h
@@ -74,14 +74,16 @@ struct rpc_clnt;
 #ifdef CONFIG_PROC_FS
 
 struct rpc_iostats *    rpc_alloc_iostats(struct rpc_clnt *);
-void                    rpc_count_iostats(struct rpc_task *);
+void                    rpc_count_iostats(const struct rpc_task *,
+                                          struct rpc_iostats *);
 void                    rpc_print_iostats(struct seq_file *, struct rpc_clnt *);
 void                    rpc_free_iostats(struct rpc_iostats *);
 
 #else  /*  CONFIG_PROC_FS  */
 
 static inline struct rpc_iostats *rpc_alloc_iostats(struct rpc_clnt *clnt) { return NULL; }
-static inline void rpc_count_iostats(struct rpc_task *task) {}
+static inline void rpc_count_iostats(const struct rpc_task *task,
+                                     struct rpc_iostats *stats) {}
 static inline void rpc_print_iostats(struct seq_file *seq, struct rpc_clnt *clnt) {}
 static inline void rpc_free_iostats(struct rpc_iostats *stats) {}
 
diff --git a/include/linux/sunrpc/rpc_pipe_fs.h b/include/linux/sunrpc/rpc_pipe_fs.h
index 2bb03d77375a..a7b422b33eda 100644
--- a/include/linux/sunrpc/rpc_pipe_fs.h
+++ b/include/linux/sunrpc/rpc_pipe_fs.h
@@ -21,21 +21,26 @@ struct rpc_pipe_ops {
         void (*destroy_msg)(struct rpc_pipe_msg *);
 };
 
-struct rpc_inode {
-        struct inode vfs_inode;
-        void *private;
+struct rpc_pipe {
         struct list_head pipe;
         struct list_head in_upcall;
         struct list_head in_downcall;
         int pipelen;
         int nreaders;
         int nwriters;
-        int nkern_readwriters;
-        wait_queue_head_t waitq;
 #define RPC_PIPE_WAIT_FOR_OPEN  1
         int flags;
         struct delayed_work queue_timeout;
         const struct rpc_pipe_ops *ops;
+        spinlock_t lock;
+        struct dentry *dentry;
+};
+
+struct rpc_inode {
+        struct inode vfs_inode;
+        void *private;
+        struct rpc_pipe *pipe;
+        wait_queue_head_t waitq;
 };
 
 static inline struct rpc_inode *
@@ -44,9 +49,28 @@ RPC_I(struct inode *inode)
         return container_of(inode, struct rpc_inode, vfs_inode);
 }
 
+enum {
+        SUNRPC_PIPEFS_NFS_PRIO,
+        SUNRPC_PIPEFS_RPC_PRIO,
+};
+
+extern int rpc_pipefs_notifier_register(struct notifier_block *);
+extern void rpc_pipefs_notifier_unregister(struct notifier_block *);
+
+enum {
+        RPC_PIPEFS_MOUNT,
+        RPC_PIPEFS_UMOUNT,
+};
+
+extern struct dentry *rpc_d_lookup_sb(const struct super_block *sb,
+                                      const unsigned char *dir_name);
+extern void rpc_pipefs_init_net(struct net *net);
+extern struct super_block *rpc_get_sb_net(const struct net *net);
+extern void rpc_put_sb_net(const struct net *net);
+
 extern ssize_t rpc_pipe_generic_upcall(struct file *, struct rpc_pipe_msg *,
                                        char __user *, size_t);
-extern int rpc_queue_upcall(struct inode *, struct rpc_pipe_msg *);
+extern int rpc_queue_upcall(struct rpc_pipe *, struct rpc_pipe_msg *);
 
 struct rpc_clnt;
 extern struct dentry *rpc_create_client_dir(struct dentry *, struct qstr *, struct rpc_clnt *);
@@ -59,11 +83,13 @@ extern struct dentry *rpc_create_cache_dir(struct dentry *,
                                            struct cache_detail *);
 extern void rpc_remove_cache_dir(struct dentry *);
 
-extern struct dentry *rpc_mkpipe(struct dentry *, const char *, void *,
-                                 const struct rpc_pipe_ops *, int flags);
+extern int rpc_rmdir(struct dentry *dentry);
+
+struct rpc_pipe *rpc_mkpipe_data(const struct rpc_pipe_ops *ops, int flags);
+void rpc_destroy_pipe_data(struct rpc_pipe *pipe);
+extern struct dentry *rpc_mkpipe_dentry(struct dentry *, const char *, void *,
+                                        struct rpc_pipe *);
 extern int rpc_unlink(struct dentry *);
-extern struct vfsmount *rpc_get_mount(void);
-extern void rpc_put_mount(void);
 extern int register_rpc_pipefs(void);
 extern void unregister_rpc_pipefs(void);
 
diff --git a/include/linux/sunrpc/sched.h b/include/linux/sunrpc/sched.h
index e7756896f3ca..dc0c3cc3ada3 100644
--- a/include/linux/sunrpc/sched.h
+++ b/include/linux/sunrpc/sched.h
@@ -103,6 +103,7 @@ typedef void			(*rpc_action)(struct rpc_task *);
 struct rpc_call_ops {
         void (*rpc_call_prepare)(struct rpc_task *, void *);
         void (*rpc_call_done)(struct rpc_task *, void *);
+        void (*rpc_count_stats)(struct rpc_task *, void *);
         void (*rpc_release)(void *);
 };
 
@@ -195,7 +196,7 @@ struct rpc_wait_queue {
         unsigned char           nr;                     /* # tasks remaining for cookie */
         unsigned short          qlen;                   /* total # tasks waiting in queue */
         struct rpc_timer        timer_list;
-#ifdef RPC_DEBUG
+#if defined(RPC_DEBUG) || defined(RPC_TRACEPOINTS)
         const char *            name;
 #endif
 };
@@ -235,6 +236,9 @@ void		rpc_wake_up_queued_task(struct rpc_wait_queue *,
                                         struct rpc_task *);
 void            rpc_wake_up(struct rpc_wait_queue *);
 struct rpc_task *rpc_wake_up_next(struct rpc_wait_queue *);
+struct rpc_task *rpc_wake_up_first(struct rpc_wait_queue *,
+                                        bool (*)(struct rpc_task *, void *),
+                                        void *);
 void            rpc_wake_up_status(struct rpc_wait_queue *, int);
 int             rpc_queue_empty(struct rpc_wait_queue *);
 void            rpc_delay(struct rpc_task *, unsigned long);
@@ -244,7 +248,8 @@ int		rpciod_up(void);
 void            rpciod_down(void);
 int             __rpc_wait_for_completion_task(struct rpc_task *task, int (*)(void *));
 #ifdef RPC_DEBUG
-void            rpc_show_tasks(void);
+struct net;
+void            rpc_show_tasks(struct net *);
 #endif
 int             rpc_init_mempool(void);
 void            rpc_destroy_mempool(void);
@@ -266,11 +271,22 @@ static inline int rpc_task_has_priority(struct rpc_task *task, unsigned char pri
         return (task->tk_priority + RPC_PRIORITY_LOW == prio);
 }
 
-#ifdef RPC_DEBUG
-static inline const char * rpc_qname(struct rpc_wait_queue *q)
+#if defined(RPC_DEBUG) || defined (RPC_TRACEPOINTS)
+static inline const char * rpc_qname(const struct rpc_wait_queue *q)
 {
         return ((q && q->name) ? q->name : "unknown");
 }
+
+static inline void rpc_assign_waitqueue_name(struct rpc_wait_queue *q,
+                const char *name)
+{
+        q->name = name;
+}
+#else
+static inline void rpc_assign_waitqueue_name(struct rpc_wait_queue *q,
+                const char *name)
+{
+}
 #endif
 
 #endif /* _LINUX_SUNRPC_SCHED_H_ */
diff --git a/include/linux/sunrpc/stats.h b/include/linux/sunrpc/stats.h
index 680471d1f28a..edc64219f92b 100644
--- a/include/linux/sunrpc/stats.h
+++ b/include/linux/sunrpc/stats.h
@@ -12,7 +12,7 @@
 #include <linux/proc_fs.h>
 
 struct rpc_stat {
-        struct rpc_program *    program;
+        const struct rpc_program *program;
 
         unsigned int            netcnt,
                                 netudpcnt,
@@ -58,24 +58,24 @@ void			rpc_modcount(struct inode *, int);
 #endif
 
 #ifdef CONFIG_PROC_FS
-struct proc_dir_entry * rpc_proc_register(struct rpc_stat *);
-void                    rpc_proc_unregister(const char *);
-void                    rpc_proc_zero(struct rpc_program *);
-struct proc_dir_entry * svc_proc_register(struct svc_stat *,
+struct proc_dir_entry * rpc_proc_register(struct net *,struct rpc_stat *);
+void                    rpc_proc_unregister(struct net *,const char *);
+void                    rpc_proc_zero(const struct rpc_program *);
+struct proc_dir_entry * svc_proc_register(struct net *, struct svc_stat *,
                                           const struct file_operations *);
-void                    svc_proc_unregister(const char *);
+void                    svc_proc_unregister(struct net *, const char *);
 
 void                    svc_seq_show(struct seq_file *,
                                      const struct svc_stat *);
 #else
 
-static inline struct proc_dir_entry *rpc_proc_register(struct rpc_stat *s) { return NULL; }
-static inline void rpc_proc_unregister(const char *p) {}
-static inline void rpc_proc_zero(struct rpc_program *p) {}
+static inline struct proc_dir_entry *rpc_proc_register(struct net *net, struct rpc_stat *s) { return NULL; }
+static inline void rpc_proc_unregister(struct net *net, const char *p) {}
+static inline void rpc_proc_zero(const struct rpc_program *p) {}
 
-static inline struct proc_dir_entry *svc_proc_register(struct svc_stat *s,
+static inline struct proc_dir_entry *svc_proc_register(struct net *net, struct svc_stat *s,
                                                        const struct file_operations *f) { return NULL; }
-static inline void svc_proc_unregister(const char *p) {}
+static inline void svc_proc_unregister(struct net *net, const char *p) {}
 
 static inline void svc_seq_show(struct seq_file *seq,
                                 const struct svc_stat *st) {}
diff --git a/include/linux/sunrpc/svc.h b/include/linux/sunrpc/svc.h
index 35b37b1e9299..51b29ac45a8e 100644
--- a/include/linux/sunrpc/svc.h
+++ b/include/linux/sunrpc/svc.h
@@ -84,7 +84,8 @@ struct svc_serv {
         unsigned int            sv_nrpools;     /* number of thread pools */
         struct svc_pool *       sv_pools;       /* array of thread pools */
 
-        void                    (*sv_shutdown)(struct svc_serv *serv);
+        void                    (*sv_shutdown)(struct svc_serv *serv,
+                                               struct net *net);
                                                 /* Callback to use when last thread
                                                  * exits.
                                                  */
@@ -413,22 +414,24 @@ struct svc_procedure {
 /*
  * Function prototypes.
  */
-void svc_rpcb_cleanup(struct svc_serv *serv);
+int svc_rpcb_setup(struct svc_serv *serv, struct net *net);
+void svc_rpcb_cleanup(struct svc_serv *serv, struct net *net);
 struct svc_serv *svc_create(struct svc_program *, unsigned int,
-                            void (*shutdown)(struct svc_serv *));
+                            void (*shutdown)(struct svc_serv *, struct net *net));
 struct svc_rqst *svc_prepare_thread(struct svc_serv *serv,
                                         struct svc_pool *pool, int node);
 void               svc_exit_thread(struct svc_rqst *);
 struct svc_serv *  svc_create_pooled(struct svc_program *, unsigned int,
-                        void (*shutdown)(struct svc_serv *),
+                        void (*shutdown)(struct svc_serv *, struct net *net),
                         svc_thread_fn, struct module *);
 int                svc_set_num_threads(struct svc_serv *, struct svc_pool *, int);
 int                svc_pool_stats_open(struct svc_serv *serv, struct file *file);
 void               svc_destroy(struct svc_serv *);
+void               svc_shutdown_net(struct svc_serv *, struct net *);
 int                svc_process(struct svc_rqst *);
 int                bc_svc_process(struct svc_serv *, struct rpc_rqst *,
                         struct svc_rqst *);
-int                svc_register(const struct svc_serv *, const int,
+int                svc_register(const struct svc_serv *, struct net *, const int,
                                 const unsigned short, const unsigned short);
 
 void               svc_wake_up(struct svc_serv *);
diff --git a/include/linux/sunrpc/svc_xprt.h b/include/linux/sunrpc/svc_xprt.h
index dfa900948af7..b3f64b12f141 100644
--- a/include/linux/sunrpc/svc_xprt.h
+++ b/include/linux/sunrpc/svc_xprt.h
@@ -121,7 +121,8 @@ void	svc_close_xprt(struct svc_xprt *xprt);
 int     svc_port_is_privileged(struct sockaddr *sin);
 int     svc_print_xprts(char *buf, int maxlen);
 struct  svc_xprt *svc_find_xprt(struct svc_serv *serv, const char *xcl_name,
-                        const sa_family_t af, const unsigned short port);
+                        struct net *net, const sa_family_t af,
+                        const unsigned short port);
 int     svc_xprt_names(struct svc_serv *serv, char *buf, const int buflen);
 
 static inline void svc_xprt_get(struct svc_xprt *xprt)
diff --git a/include/linux/sunrpc/svcauth.h b/include/linux/sunrpc/svcauth.h
index 25d333c1b571..548790e9113b 100644
--- a/include/linux/sunrpc/svcauth.h
+++ b/include/linux/sunrpc/svcauth.h
@@ -135,6 +135,9 @@ extern void svcauth_unix_purge(void);
 extern void svcauth_unix_info_release(struct svc_xprt *xpt);
 extern int svcauth_unix_set_client(struct svc_rqst *rqstp);
 
+extern int unix_gid_cache_create(struct net *net);
+extern void unix_gid_cache_destroy(struct net *net);
+
 static inline unsigned long hash_str(char *name, int bits)
 {
         unsigned long hash = 0;
diff --git a/include/linux/sunrpc/svcauth_gss.h b/include/linux/sunrpc/svcauth_gss.h
index 83bbee3f089c..7c32daa025eb 100644
--- a/include/linux/sunrpc/svcauth_gss.h
+++ b/include/linux/sunrpc/svcauth_gss.h
@@ -18,6 +18,8 @@
 
 int gss_svc_init(void);
 void gss_svc_shutdown(void);
+int gss_svc_init_net(struct net *net);
+void gss_svc_shutdown_net(struct net *net);
 int svcauth_gss_register_pseudoflavor(u32 pseudoflavor, char * name);
 u32 svcauth_gss_flavor(struct auth_domain *dom);
 char *svc_gss_principal(struct svc_rqst *);
diff --git a/include/linux/sunrpc/svcsock.h b/include/linux/sunrpc/svcsock.h
index c84e9741cb2a..cb4ac69e1f33 100644
--- a/include/linux/sunrpc/svcsock.h
+++ b/include/linux/sunrpc/svcsock.h
@@ -34,7 +34,7 @@ struct svc_sock {
 /*
  * Function prototypes.
  */
-void            svc_close_all(struct svc_serv *);
+void            svc_close_net(struct svc_serv *, struct net *);
 int             svc_recv(struct svc_rqst *, long);
 int             svc_send(struct svc_rqst *);
 void            svc_drop(struct svc_rqst *);
diff --git a/include/linux/sunrpc/xprt.h b/include/linux/sunrpc/xprt.h
index 15518a152ac3..77d278defa70 100644
--- a/include/linux/sunrpc/xprt.h
+++ b/include/linux/sunrpc/xprt.h
@@ -21,8 +21,8 @@
 
 #define RPC_MIN_SLOT_TABLE      (2U)
 #define RPC_DEF_SLOT_TABLE      (16U)
-#define RPC_MAX_SLOT_TABLE      (128U)
 #define RPC_MAX_SLOT_TABLE_LIMIT        (65536U)
+#define RPC_MAX_SLOT_TABLE      RPC_MAX_SLOT_TABLE_LIMIT
 
 /*
  * This describes a timeout strategy
@@ -219,13 +219,17 @@ struct rpc_xprt {
                                         connect_time,   /* jiffies waiting for connect */
                                         sends,          /* how many complete requests */
                                         recvs,          /* how many complete requests */
-                                        bad_xids;       /* lookup_rqst didn't find XID */
+                                        bad_xids,       /* lookup_rqst didn't find XID */
+                                        max_slots;      /* max rpc_slots used */
 
                 unsigned long long      req_u,          /* average requests on the wire */
-                                        bklog_u;        /* backlog queue utilization */
+                                        bklog_u,        /* backlog queue utilization */
+                                        sending_u,      /* send q utilization */
+                                        pending_u;      /* pend q utilization */
         } stat;
 
         struct net              *xprt_net;
+        const char              *servername;
         const char              *address_strings[RPC_DISPLAY_MAX];
 };
 
@@ -255,6 +259,7 @@ struct xprt_create {
         struct sockaddr *       srcaddr;        /* optional local address */
         struct sockaddr *       dstaddr;        /* remote peer address */
         size_t                  addrlen;
+        const char              *servername;
         struct svc_xprt         *bc_xprt;       /* NFSv4.1 backchannel */
 };
 
diff --git a/include/linux/sunrpc/xprtsock.h b/include/linux/sunrpc/xprtsock.h
index 3f14a02e9cc0..1ad36cc25b2e 100644
--- a/include/linux/sunrpc/xprtsock.h
+++ b/include/linux/sunrpc/xprtsock.h
@@ -12,18 +12,6 @@
 int             init_socket_xprt(void);
 void            cleanup_socket_xprt(void);
 
-/*
- * RPC slot table sizes for UDP, TCP transports
- */
-extern unsigned int xprt_udp_slot_table_entries;
-extern unsigned int xprt_tcp_slot_table_entries;
-
-/*
- * Parameters for choosing a free port
- */
-extern unsigned int xprt_min_resvport;
-extern unsigned int xprt_max_resvport;
-
 #define RPC_MIN_RESVPORT        (1U)
 #define RPC_MAX_RESVPORT        (65535U)
 #define RPC_DEF_MIN_RESVPORT    (665U)
diff --git a/include/linux/sunserialcore.h b/include/linux/sunserialcore.h
new file mode 100644
index 000000000000..68e7430bb0fe
--- /dev/null
+++ b/include/linux/sunserialcore.h
@@ -0,0 +1,33 @@
+/* sunserialcore.h
+ *
+ * Generic SUN serial/kbd/ms layer.  Based entirely
+ * upon drivers/sbus/char/sunserial.h which is:
+ *
+ * Copyright (C) 1997  Eddie C. Dost  (ecd@skynet.be)
+ *
+ * Port to new UART layer is:
+ *
+ * Copyright (C) 2002 David S. Miller (davem@redhat.com)
+ */
+
+#ifndef _SERIAL_SUN_H
+#define _SERIAL_SUN_H
+
+/* Serial keyboard defines for L1-A processing... */
+#define SUNKBD_RESET            0xff
+#define SUNKBD_L1               0x01
+#define SUNKBD_UP               0x80
+#define SUNKBD_A                0x4d
+
+extern unsigned int suncore_mouse_baud_cflag_next(unsigned int, int *);
+extern int suncore_mouse_baud_detection(unsigned char, int);
+
+extern int sunserial_register_minors(struct uart_driver *, int);
+extern void sunserial_unregister_minors(struct uart_driver *, int);
+
+extern int sunserial_console_match(struct console *, struct device_node *,
+                                   struct uart_driver *, int, bool);
+extern void sunserial_console_termios(struct console *,
+                                      struct device_node *);
+
+#endif /* !(_SERIAL_SUN_H) */
diff --git a/include/linux/suspend.h b/include/linux/suspend.h
index 91784a4f8608..ac1c114c499d 100644
--- a/include/linux/suspend.h
+++ b/include/linux/suspend.h
@@ -42,8 +42,10 @@ enum suspend_stat_step {
         SUSPEND_FREEZE = 1,
         SUSPEND_PREPARE,
         SUSPEND_SUSPEND,
+        SUSPEND_SUSPEND_LATE,
         SUSPEND_SUSPEND_NOIRQ,
         SUSPEND_RESUME_NOIRQ,
+        SUSPEND_RESUME_EARLY,
         SUSPEND_RESUME
 };
 
@@ -53,8 +55,10 @@ struct suspend_stats {
         int     failed_freeze;
         int     failed_prepare;
         int     failed_suspend;
+        int     failed_suspend_late;
         int     failed_suspend_noirq;
         int     failed_resume;
+        int     failed_resume_early;
         int     failed_resume_noirq;
 #define REC_FAILED_NUM  2
         int     last_failed_dev;
diff --git a/include/linux/swap.h b/include/linux/swap.h
index 3e60228e7299..b86b5c20617d 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -223,6 +223,7 @@ extern void lru_add_page_tail(struct zone* zone,
 extern void activate_page(struct page *);
 extern void mark_page_accessed(struct page *);
 extern void lru_add_drain(void);
+extern void lru_add_drain_cpu(int cpu);
 extern int lru_add_drain_all(void);
 extern void rotate_reclaimable_page(struct page *page);
 extern void deactivate_page(struct page *page);
@@ -329,7 +330,6 @@ extern long total_swap_pages;
 extern void si_swapinfo(struct sysinfo *);
 extern swp_entry_t get_swap_page(void);
 extern swp_entry_t get_swap_page_of_type(int);
-extern int valid_swaphandles(swp_entry_t, unsigned long *);
 extern int add_swap_count_continuation(swp_entry_t, gfp_t);
 extern void swap_shmem_alloc(swp_entry_t);
 extern int swap_duplicate(swp_entry_t);
diff --git a/include/linux/swapops.h b/include/linux/swapops.h
index 2189d3ffc85d..792d16d9cbc7 100644
--- a/include/linux/swapops.h
+++ b/include/linux/swapops.h
@@ -2,6 +2,7 @@
 #define _LINUX_SWAPOPS_H
 
 #include <linux/radix-tree.h>
+#include <linux/bug.h>
 
 /*
  * swapcache pages are stored in the swapper_space radix tree.  We want to
diff --git a/include/linux/sys_soc.h b/include/linux/sys_soc.h
new file mode 100644
index 000000000000..2739ccb69571
--- /dev/null
+++ b/include/linux/sys_soc.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) ST-Ericsson SA 2011
+ * Author: Lee Jones <lee.jones@linaro.org> for ST-Ericsson.
+ * License terms:  GNU General Public License (GPL), version 2
+ */
+#ifndef __SOC_BUS_H
+#define __SOC_BUS_H
+
+#include <linux/device.h>
+
+struct soc_device_attribute {
+        const char *machine;
+        const char *family;
+        const char *revision;
+        const char *soc_id;
+};
+
+/**
+ * soc_device_register - register SoC as a device
+ * @soc_plat_dev_attr: Attributes passed from platform to be attributed to a SoC
+ */
+struct soc_device *soc_device_register(
+        struct soc_device_attribute *soc_plat_dev_attr);
+
+/**
+ * soc_device_unregister - unregister SoC device
+ * @dev: SoC device to be unregistered
+ */
+void soc_device_unregister(struct soc_device *soc_dev);
+
+/**
+ * soc_device_to_device - helper function to fetch struct device
+ * @soc: Previously registered SoC device container
+ */
+struct device *soc_device_to_device(struct soc_device *soc);
+
+#endif /* __SOC_BUS_H */
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 8ec1153ff57b..3de3acb84a95 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -68,6 +68,7 @@ struct file_handle;
 #include <linux/aio_abi.h>
 #include <linux/capability.h>
 #include <linux/list.h>
+#include <linux/bug.h>
 #include <linux/sem.h>
 #include <asm/siginfo.h>
 #include <asm/signal.h>
diff --git a/include/linux/sysctl.h b/include/linux/sysctl.h
index bb9127dd814b..c34b4c82b0dc 100644
--- a/include/linux/sysctl.h
+++ b/include/linux/sysctl.h
@@ -932,34 +932,14 @@ enum
 #include <linux/list.h>
 #include <linux/rcupdate.h>
 #include <linux/wait.h>
+#include <linux/rbtree.h>
 
 /* For the /proc/sys support */
 struct ctl_table;
 struct nsproxy;
 struct ctl_table_root;
-
-struct ctl_table_set {
-        struct list_head list;
-        struct ctl_table_set *parent;
-        int (*is_seen)(struct ctl_table_set *);
-};
-
-extern void setup_sysctl_set(struct ctl_table_set *p,
-        struct ctl_table_set *parent,
-        int (*is_seen)(struct ctl_table_set *));
-
 struct ctl_table_header;
-
-extern void sysctl_head_get(struct ctl_table_header *);
-extern void sysctl_head_put(struct ctl_table_header *);
-extern int sysctl_is_seen(struct ctl_table_header *);
-extern struct ctl_table_header *sysctl_head_grab(struct ctl_table_header *);
-extern struct ctl_table_header *sysctl_head_next(struct ctl_table_header *prev);
-extern struct ctl_table_header *__sysctl_head_next(struct nsproxy *namespaces,
-                                                struct ctl_table_header *prev);
-extern void sysctl_head_finish(struct ctl_table_header *prev);
-extern int sysctl_perm(struct ctl_table_root *root,
-                struct ctl_table *table, int op);
+struct ctl_dir;
 
 typedef struct ctl_table ctl_table;
 
@@ -1023,8 +1003,6 @@ static inline void *proc_sys_poll_event(struct ctl_table_poll *poll)
         return (void *)(unsigned long)atomic_read(&poll->event);
 }
 
-void proc_sys_poll_notify(struct ctl_table_poll *poll);
-
 #define __CTL_TABLE_POLL_INITIALIZER(name) {                            \
         .event = ATOMIC_INIT(0),                                        \
         .wait = __WAIT_QUEUE_HEAD_INITIALIZER(name.wait) }
@@ -1039,21 +1017,16 @@ struct ctl_table
         void *data;
         int maxlen;
         umode_t mode;
-        struct ctl_table *child;
-        struct ctl_table *parent;       /* Automatically set */
+        struct ctl_table *child;        /* Deprecated */
         proc_handler *proc_handler;     /* Callback for text formatting */
         struct ctl_table_poll *poll;
         void *extra1;
         void *extra2;
 };
 
-struct ctl_table_root {
-        struct list_head root_list;
-        struct ctl_table_set default_set;
-        struct ctl_table_set *(*lookup)(struct ctl_table_root *root,
-                                           struct nsproxy *namespaces);
-        int (*permissions)(struct ctl_table_root *root,
-                        struct nsproxy *namespaces, struct ctl_table *table);
+struct ctl_node {
+        struct rb_node node;
+        struct ctl_table_header *header;
 };
 
 /* struct ctl_table_header is used to maintain dynamic lists of
@@ -1063,9 +1036,9 @@ struct ctl_table_header
         union {
                 struct {
                         struct ctl_table *ctl_table;
-                        struct list_head ctl_entry;
                         int used;
                         int count;
+                        int nreg;
                 };
                 struct rcu_head rcu;
         };
@@ -1073,9 +1046,27 @@ struct ctl_table_header
         struct ctl_table *ctl_table_arg;
         struct ctl_table_root *root;
         struct ctl_table_set *set;
-        struct ctl_table *attached_by;
-        struct ctl_table *attached_to;
-        struct ctl_table_header *parent;
+        struct ctl_dir *parent;
+        struct ctl_node *node;
+};
+
+struct ctl_dir {
+        /* Header must be at the start of ctl_dir */
+        struct ctl_table_header header;
+        struct rb_root root;
+};
+
+struct ctl_table_set {
+        int (*is_seen)(struct ctl_table_set *);
+        struct ctl_dir dir;
+};
+
+struct ctl_table_root {
+        struct ctl_table_set default_set;
+        struct ctl_table_set *(*lookup)(struct ctl_table_root *root,
+                                           struct nsproxy *namespaces);
+        int (*permissions)(struct ctl_table_root *root,
+                        struct nsproxy *namespaces, struct ctl_table *table);
 };
 
 /* struct ctl_path describes where in the hierarchy a table is added */
@@ -1083,16 +1074,53 @@ struct ctl_path {
         const char *procname;
 };
 
+#ifdef CONFIG_SYSCTL
+
+void proc_sys_poll_notify(struct ctl_table_poll *poll);
+
+extern void setup_sysctl_set(struct ctl_table_set *p,
+        struct ctl_table_root *root,
+        int (*is_seen)(struct ctl_table_set *));
+extern void retire_sysctl_set(struct ctl_table_set *set);
+
 void register_sysctl_root(struct ctl_table_root *root);
+struct ctl_table_header *__register_sysctl_table(
+        struct ctl_table_set *set,
+        const char *path, struct ctl_table *table);
 struct ctl_table_header *__register_sysctl_paths(
-        struct ctl_table_root *root, struct nsproxy *namespaces,
+        struct ctl_table_set *set,
         const struct ctl_path *path, struct ctl_table *table);
+struct ctl_table_header *register_sysctl(const char *path, struct ctl_table *table);
 struct ctl_table_header *register_sysctl_table(struct ctl_table * table);
 struct ctl_table_header *register_sysctl_paths(const struct ctl_path *path,
                                                 struct ctl_table *table);
 
 void unregister_sysctl_table(struct ctl_table_header * table);
-int sysctl_check_table(struct nsproxy *namespaces, struct ctl_table *table);
+
+extern int sysctl_init(void);
+#else /* CONFIG_SYSCTL */
+static inline struct ctl_table_header *register_sysctl_table(struct ctl_table * table)
+{
+        return NULL;
+}
+
+static inline struct ctl_table_header *register_sysctl_paths(
+                        const struct ctl_path *path, struct ctl_table *table)
+{
+        return NULL;
+}
+
+static inline void unregister_sysctl_table(struct ctl_table_header * table)
+{
+}
+
+static inline void setup_sysctl_set(struct ctl_table_set *p,
+        struct ctl_table_root *root,
+        int (*is_seen)(struct ctl_table_set *))
+{
+}
+
+#endif /* CONFIG_SYSCTL */
 
 #endif /* __KERNEL__ */
 
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index 3c7ffdb40dc6..b6c62d294380 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -464,7 +464,7 @@ struct tcp_sock {
         const struct tcp_sock_af_ops    *af_specific;
 
 /* TCP MD5 Signature Option information */
-        struct tcp_md5sig_info  *md5sig_info;
+        struct tcp_md5sig_info  __rcu *md5sig_info;
 #endif
 
         /* When the cookie options are generated and exchanged, then this
@@ -487,8 +487,7 @@ struct tcp_timewait_sock {
         u32                       tw_ts_recent;
         long                      tw_ts_recent_stamp;
 #ifdef CONFIG_TCP_MD5SIG
-        u16                       tw_md5_keylen;
-        u8                        tw_md5_key[TCP_MD5SIG_MAXKEYLEN];
+        struct tcp_md5sig_key   *tw_md5_key;
 #endif
         /* Few sockets in timewait have cookies; in that case, then this
          * object holds a reference to them (tw_cookie_values->kref).
diff --git a/include/linux/timex.h b/include/linux/timex.h
index aa60fe7b6ed6..b75e1864ed19 100644
--- a/include/linux/timex.h
+++ b/include/linux/timex.h
@@ -234,23 +234,9 @@ struct timex {
 extern unsigned long tick_usec;         /* USER_HZ period (usec) */
 extern unsigned long tick_nsec;         /* ACTHZ          period (nsec) */
 
-/*
- * phase-lock loop variables
- */
-extern int time_status;         /* clock synchronization status bits */
-
 extern void ntp_init(void);
 extern void ntp_clear(void);
 
-/**
- * ntp_synced - Returns 1 if the NTP status is not UNSYNC
- *
- */
-static inline int ntp_synced(void)
-{
-        return !(time_status & STA_UNSYNC);
-}
-
 /* Required to safely shift negative values */
 #define shift_right(x, s) ({    \
         __typeof__(x) __x = (x);        \
@@ -264,10 +250,9 @@ static inline int ntp_synced(void)
 #define NTP_INTERVAL_LENGTH (NSEC_PER_SEC/NTP_INTERVAL_FREQ)
 
 /* Returns how long ticks are at present, in ns / 2^NTP_SCALE_SHIFT. */
-extern u64 tick_length;
+extern u64 ntp_tick_length(void);
 
 extern void second_overflow(void);
-extern void update_ntp_one_tick(void);
 extern int do_adjtimex(struct timex *);
 extern void hardpps(const struct timespec *, const struct timespec *);
 
diff --git a/include/linux/trace_seq.h b/include/linux/trace_seq.h
index 7dadc3df0c77..a32d86ec8bf2 100644
--- a/include/linux/trace_seq.h
+++ b/include/linux/trace_seq.h
@@ -44,7 +44,7 @@ extern int trace_seq_putmem(struct trace_seq *s, const void *mem, size_t len);
 extern int trace_seq_putmem_hex(struct trace_seq *s, const void *mem,
                                 size_t len);
 extern void *trace_seq_reserve(struct trace_seq *s, size_t len);
-extern int trace_seq_path(struct trace_seq *s, struct path *path);
+extern int trace_seq_path(struct trace_seq *s, const struct path *path);
 
 #else /* CONFIG_TRACING */
 static inline int trace_seq_printf(struct trace_seq *s, const char *fmt, ...)
@@ -88,7 +88,7 @@ static inline void *trace_seq_reserve(struct trace_seq *s, size_t len)
 {
         return NULL;
 }
-static inline int trace_seq_path(struct trace_seq *s, struct path *path)
+static inline int trace_seq_path(struct trace_seq *s, const struct path *path)
 {
         return 0;
 }
diff --git a/include/linux/tracehook.h b/include/linux/tracehook.h
index a71a2927a6a0..51bd91d911c3 100644
--- a/include/linux/tracehook.h
+++ b/include/linux/tracehook.h
@@ -54,12 +54,12 @@ struct linux_binprm;
 /*
  * ptrace report for syscall entry and exit looks identical.
  */
-static inline void ptrace_report_syscall(struct pt_regs *regs)
+static inline int ptrace_report_syscall(struct pt_regs *regs)
 {
         int ptrace = current->ptrace;
 
         if (!(ptrace & PT_PTRACED))
-                return;
+                return 0;
 
         ptrace_notify(SIGTRAP | ((ptrace & PT_TRACESYSGOOD) ? 0x80 : 0));
 
@@ -72,6 +72,8 @@ static inline void ptrace_report_syscall(struct pt_regs *regs)
                 send_sig(current->exit_code, current, 1);
                 current->exit_code = 0;
         }
+
+        return fatal_signal_pending(current);
 }
 
 /**
@@ -96,8 +98,7 @@ static inline void ptrace_report_syscall(struct pt_regs *regs)
 static inline __must_check int tracehook_report_syscall_entry(
         struct pt_regs *regs)
 {
-        ptrace_report_syscall(regs);
-        return 0;
+        return ptrace_report_syscall(regs);
 }
 
 /**
diff --git a/include/linux/tracepoint.h b/include/linux/tracepoint.h
index df0a779c1bbd..bd96ecd0e05c 100644
--- a/include/linux/tracepoint.h
+++ b/include/linux/tracepoint.h
@@ -17,7 +17,7 @@
 #include <linux/errno.h>
 #include <linux/types.h>
 #include <linux/rcupdate.h>
-#include <linux/jump_label.h>
+#include <linux/static_key.h>
 
 struct module;
 struct tracepoint;
@@ -29,7 +29,7 @@ struct tracepoint_func {
 
 struct tracepoint {
         const char *name;               /* Tracepoint name */
-        struct jump_label_key key;
+        struct static_key key;
         void (*regfunc)(void);
         void (*unregfunc)(void);
         struct tracepoint_func __rcu *funcs;
@@ -114,7 +114,7 @@ static inline void tracepoint_synchronize_unregister(void)
  * as "(void *, void)". The DECLARE_TRACE_NOARGS() will pass in just
  * "void *data", where as the DECLARE_TRACE() will pass in "void *data, proto".
  */
-#define __DO_TRACE(tp, proto, args, cond)                               \
+#define __DO_TRACE(tp, proto, args, cond, prercu, postrcu)              \
         do {                                                            \
                 struct tracepoint_func *it_func_ptr;                    \
                 void *it_func;                                          \
@@ -122,6 +122,7 @@ static inline void tracepoint_synchronize_unregister(void)
                                                                         \
                 if (!(cond))                                            \
                         return;                                         \
+                prercu;                                                 \
                 rcu_read_lock_sched_notrace();                          \
                 it_func_ptr = rcu_dereference_sched((tp)->funcs);       \
                 if (it_func_ptr) {                                      \
@@ -132,6 +133,7 @@ static inline void tracepoint_synchronize_unregister(void)
                         } while ((++it_func_ptr)->func);                \
                 }                                                       \
                 rcu_read_unlock_sched_notrace();                        \
+                postrcu;                                                \
         } while (0)
 
 /*
@@ -139,15 +141,25 @@ static inline void tracepoint_synchronize_unregister(void)
  * not add unwanted padding between the beginning of the section and the
  * structure. Force alignment to the same alignment as the section start.
  */
-#define __DECLARE_TRACE(name, proto, args, cond, data_proto, data_args) \
+#define __DECLARE_TRACE(name, proto, args, cond, data_proto, data_args) \
         extern struct tracepoint __tracepoint_##name;                   \
         static inline void trace_##name(proto)                          \
         {                                                               \
+                if (static_key_false(&__tracepoint_##name.key))         \
+                        __DO_TRACE(&__tracepoint_##name,                \
+                                TP_PROTO(data_proto),                   \
+                                TP_ARGS(data_args),                     \
+                                TP_CONDITION(cond),,);                  \
+        }                                                               \
+        static inline void trace_##name##_rcuidle(proto)                \
+        {                                                               \
                 if (static_branch(&__tracepoint_##name.key))            \
                         __DO_TRACE(&__tracepoint_##name,                \
                                 TP_PROTO(data_proto),                   \
                                 TP_ARGS(data_args),                     \
-                                TP_CONDITION(cond));                    \
+                                TP_CONDITION(cond),                     \
+                                rcu_idle_exit(),                        \
+                                rcu_idle_enter());                      \
         }                                                               \
         static inline int                                               \
         register_trace_##name(void (*probe)(data_proto), void *data)    \
@@ -176,7 +188,7 @@ static inline void tracepoint_synchronize_unregister(void)
         __attribute__((section("__tracepoints_strings"))) = #name;       \
         struct tracepoint __tracepoint_##name                            \
         __attribute__((section("__tracepoints"))) =                      \
-                { __tpstrtab_##name, JUMP_LABEL_INIT, reg, unreg, NULL };\
+                { __tpstrtab_##name, STATIC_KEY_INIT_FALSE, reg, unreg, NULL };\
         static struct tracepoint * const __tracepoint_ptr_##name __used  \
         __attribute__((section("__tracepoints_ptrs"))) =                 \
                 &__tracepoint_##name;
@@ -190,9 +202,11 @@ static inline void tracepoint_synchronize_unregister(void)
         EXPORT_SYMBOL(__tracepoint_##name)
 
 #else /* !CONFIG_TRACEPOINTS */
-#define __DECLARE_TRACE(name, proto, args, cond, data_proto, data_args) \
+#define __DECLARE_TRACE(name, proto, args, cond, data_proto, data_args) \
         static inline void trace_##name(proto)                          \
         { }                                                             \
+        static inline void trace_##name##_rcuidle(proto)                \
+        { }                                                             \
         static inline int                                               \
         register_trace_##name(void (*probe)(data_proto),                \
                               void *data)                               \
diff --git a/include/linux/transport_class.h b/include/linux/transport_class.h
index 9ae8da3e6407..11087cdd4ad3 100644
--- a/include/linux/transport_class.h
+++ b/include/linux/transport_class.h
@@ -10,6 +10,7 @@
 #define _TRANSPORT_CLASS_H_
 
 #include <linux/device.h>
+#include <linux/bug.h>
 #include <linux/attribute_container.h>
 
 struct transport_container;
diff --git a/include/linux/tty.h b/include/linux/tty.h
index 5dbb3cb05a82..a91ff403b3bf 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -52,6 +52,7 @@
  * hardcoded at present.)
  */
 #define NR_UNIX98_PTY_DEFAULT   4096      /* Default maximum for Unix98 ptys */
+#define NR_UNIX98_PTY_RESERVE   1024      /* Default reserve for main devpts */
 #define NR_UNIX98_PTY_MAX       (1 << MINORBITS) /* Absolute limit */
 
 /*
@@ -480,10 +481,11 @@ 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 struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx);
 extern int tty_release(struct inode *inode, struct file *filp);
 extern int tty_init_termios(struct tty_struct *tty);
+extern int tty_standard_install(struct tty_driver *driver,
+                struct tty_struct *tty);
 
 extern struct tty_struct *tty_pair_get_tty(struct tty_struct *tty);
 extern struct tty_struct *tty_pair_get_pty(struct tty_struct *tty);
diff --git a/include/linux/tty_driver.h b/include/linux/tty_driver.h
index 5cf685086dd3..6e6dbb7447b6 100644
--- a/include/linux/tty_driver.h
+++ b/include/linux/tty_driver.h
@@ -50,6 +50,8 @@
  *      Note that tty_shutdown() is not called if ops->shutdown is defined.
  *      This means one is responsible to take care of calling ops->remove (e.g.
  *      via tty_driver_remove_tty) and releasing tty->termios.
+ *      Note that this hook may be called from *all* the contexts where one
+ *      uses tty refcounting (e.g. tty_port_tty_get).
  *
  *
  * void (*cleanup)(struct tty_struct * tty);
@@ -234,6 +236,7 @@
  *      if provided (otherwise EINVAL will be returned).
  */
 
+#include <linux/export.h>
 #include <linux/fs.h>
 #include <linux/list.h>
 #include <linux/cdev.h>
@@ -298,7 +301,6 @@ struct tty_driver {
         int     name_base;      /* offset of printed name */
         int     major;          /* major device number */
         int     minor_start;    /* start of minor device number */
-        int     minor_num;      /* number of *possible* devices */
         int     num;            /* number of devices allocated */
         short   type;           /* type of tty driver */
         short   subtype;        /* subtype of tty driver */
@@ -324,7 +326,7 @@ struct tty_driver {
 
 extern struct list_head tty_drivers;
 
-extern struct tty_driver *alloc_tty_driver(int lines);
+extern struct tty_driver *__alloc_tty_driver(int lines, struct module *owner);
 extern void put_tty_driver(struct tty_driver *driver);
 extern void tty_set_operations(struct tty_driver *driver,
                         const struct tty_operations *op);
@@ -332,6 +334,8 @@ extern struct tty_driver *tty_find_polling_driver(char *name, int *line);
 
 extern void tty_driver_kref_put(struct tty_driver *driver);
 
+#define alloc_tty_driver(lines) __alloc_tty_driver(lines, THIS_MODULE)
+
 static inline struct tty_driver *tty_driver_kref_get(struct tty_driver *d)
 {
         kref_get(&d->kref);
diff --git a/include/linux/usb.h b/include/linux/usb.h
index 69d845739bc2..73b68d1f2cb0 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -376,6 +376,12 @@ struct usb_bus {
 
 struct usb_tt;
 
+enum usb_device_removable {
+        USB_DEVICE_REMOVABLE_UNKNOWN = 0,
+        USB_DEVICE_REMOVABLE,
+        USB_DEVICE_FIXED,
+};
+
 /**
  * struct usb_device - kernel's representation of a USB device
  * @devnum: device number; address on a USB bus
@@ -432,6 +438,7 @@ struct usb_tt;
  * @wusb_dev: if this is a Wireless USB device, link to the WUSB
  *      specific data for the device.
  * @slot_id: Slot ID assigned by xHCI
+ * @removable: Device can be physically removed from this port
  *
  * Notes:
  * Usbcore drivers should not set usbdev->state directly.  Instead use
@@ -494,7 +501,7 @@ struct usb_device {
 #endif
 
         int maxchild;
-        struct usb_device *children[USB_MAXCHILDREN];
+        struct usb_device **children;
 
         u32 quirks;
         atomic_t urbnum;
@@ -509,6 +516,7 @@ struct usb_device {
 #endif
         struct wusb_dev *wusb_dev;
         int slot_id;
+        enum usb_device_removable removable;
 };
 #define to_usb_device(d) container_of(d, struct usb_device, dev)
 
diff --git a/include/linux/usb/audio-v2.h b/include/linux/usb/audio-v2.h
index 964cb603f7c7..ed13053153f4 100644
--- a/include/linux/usb/audio-v2.h
+++ b/include/linux/usb/audio-v2.h
@@ -43,6 +43,27 @@ static inline bool uac2_control_is_writeable(u32 bmControls, u8 control)
         return (bmControls >> (control * 2)) & 0x2;
 }
 
+/* 4.7.2 Class-Specific AC Interface Descriptor */
+struct uac2_ac_header_descriptor {
+        __u8  bLength;                  /* 9 */
+        __u8  bDescriptorType;          /* USB_DT_CS_INTERFACE */
+        __u8  bDescriptorSubtype;       /* UAC_MS_HEADER */
+        __le16 bcdADC;                  /* 0x0200 */
+        __u8  bCategory;
+        __le16 wTotalLength;            /* includes Unit and Terminal desc. */
+        __u8  bmControls;
+} __packed;
+
+/* 2.3.1.6 Type I Format Type Descriptor (Frmts20 final.pdf)*/
+struct uac2_format_type_i_descriptor {
+        __u8  bLength;                  /* in bytes: 6 */
+        __u8  bDescriptorType;          /* USB_DT_CS_INTERFACE */
+        __u8  bDescriptorSubtype;       /* FORMAT_TYPE */
+        __u8  bFormatType;              /* FORMAT_TYPE_1 */
+        __u8  bSubslotSize;             /* {1,2,3,4} */
+        __u8  bBitResolution;
+} __packed;
+
 /* 4.7.2.1 Clock Source Descriptor */
 
 struct uac_clock_source_descriptor {
diff --git a/include/linux/usb/cdc-wdm.h b/include/linux/usb/cdc-wdm.h
new file mode 100644
index 000000000000..719c332620fa
--- /dev/null
+++ b/include/linux/usb/cdc-wdm.h
@@ -0,0 +1,19 @@
+/*
+ * USB CDC Device Management subdriver
+ *
+ * Copyright (c) 2012  Bjørn Mork <bjorn@mork.no>
+ *
+ * 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_USB_CDC_WDM_H
+#define __LINUX_USB_CDC_WDM_H
+
+extern struct usb_driver *usb_cdc_wdm_register(struct usb_interface *intf,
+                                        struct usb_endpoint_descriptor *ep,
+                                        int bufsize,
+                                        int (*manage_power)(struct usb_interface *, int));
+
+#endif /* __LINUX_USB_CDC_WDM_H */
diff --git a/include/linux/usb/ch11.h b/include/linux/usb/ch11.h
index 0b83acd3360a..f1d26b6067f1 100644
--- a/include/linux/usb/ch11.h
+++ b/include/linux/usb/ch11.h
@@ -76,6 +76,11 @@
 #define USB_PORT_FEAT_C_BH_PORT_RESET           29
 #define USB_PORT_FEAT_FORCE_LINKPM_ACCEPT       30
 
+/* USB 3.0 hub remote wake mask bits, see table 10-14 */
+#define USB_PORT_FEAT_REMOTE_WAKE_CONNECT       (1 << 8)
+#define USB_PORT_FEAT_REMOTE_WAKE_DISCONNECT    (1 << 9)
+#define USB_PORT_FEAT_REMOTE_WAKE_OVER_CURRENT  (1 << 10)
+
 /*
  * Hub Status and Hub Change results
  * See USB 2.0 spec Table 11-19 and Table 11-20
diff --git a/include/linux/usb/ch9.h b/include/linux/usb/ch9.h
index 3b6f628880f8..af21f3115919 100644
--- a/include/linux/usb/ch9.h
+++ b/include/linux/usb/ch9.h
@@ -789,6 +789,11 @@ struct usb_ext_cap_descriptor {		/* Link Power Management */
         __u8  bDevCapabilityType;
         __le32 bmAttributes;
 #define USB_LPM_SUPPORT                 (1 << 1)        /* supports LPM */
+#define USB_BESL_SUPPORT                (1 << 2)        /* supports BESL */
+#define USB_BESL_BASELINE_VALID         (1 << 3)        /* Baseline BESL valid*/
+#define USB_BESL_DEEP_VALID             (1 << 4)        /* Deep BESL valid */
+#define USB_GET_BESL_BASELINE(p)        (((p) & (0xf << 8)) >> 8)
+#define USB_GET_BESL_DEEP(p)            (((p) & (0xf << 12)) >> 12)
 } __attribute__((packed));
 
 #define USB_DT_USB_EXT_CAP_SIZE 7
diff --git a/include/linux/usb/ehci_pdriver.h b/include/linux/usb/ehci_pdriver.h
new file mode 100644
index 000000000000..1894f42fe3f7
--- /dev/null
+++ b/include/linux/usb/ehci_pdriver.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2012 Hauke Mehrtens <hauke@hauke-m.de>
+ *
+ * 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 __USB_CORE_EHCI_PDRIVER_H
+#define __USB_CORE_EHCI_PDRIVER_H
+
+/**
+ * struct usb_ehci_pdata - platform_data for generic ehci driver
+ *
+ * @caps_offset:        offset of the EHCI Capability Registers to the start of
+ *                      the io memory region provided to the driver.
+ * @has_tt:             set to 1 if TT is integrated in root hub.
+ * @port_power_on:      set to 1 if the controller needs a power up after
+ *                      initialization.
+ * @port_power_off:     set to 1 if the controller needs to be powered down
+ *                      after initialization.
+ *
+ * These are general configuration options for the EHCI controller. All of
+ * these options are activating more or less workarounds for some hardware.
+ */
+struct usb_ehci_pdata {
+        int             caps_offset;
+        unsigned        has_tt:1;
+        unsigned        has_synopsys_hc_bug:1;
+        unsigned        big_endian_desc:1;
+        unsigned        big_endian_mmio:1;
+        unsigned        port_power_on:1;
+        unsigned        port_power_off:1;
+};
+
+#endif /* __USB_CORE_EHCI_PDRIVER_H */
diff --git a/include/linux/usb/gadget.h b/include/linux/usb/gadget.h
index da653b5c7134..9517466ababb 100644
--- a/include/linux/usb/gadget.h
+++ b/include/linux/usb/gadget.h
@@ -950,6 +950,16 @@ static inline void usb_free_descriptors(struct usb_descriptor_header **v)
 
 /*-------------------------------------------------------------------------*/
 
+/* utility to simplify map/unmap of usb_requests to/from DMA */
+
+extern int usb_gadget_map_request(struct usb_gadget *gadget,
+                struct usb_request *req, int is_in);
+
+extern void usb_gadget_unmap_request(struct usb_gadget *gadget,
+                struct usb_request *req, int is_in);
+
+/*-------------------------------------------------------------------------*/
+
 /* utility wrapping a simple endpoint selection policy */
 
 extern struct usb_ep *usb_ep_autoconfig(struct usb_gadget *,
diff --git a/include/linux/usb/hcd.h b/include/linux/usb/hcd.h
index b2f62f3a32af..5de415707c23 100644
--- a/include/linux/usb/hcd.h
+++ b/include/linux/usb/hcd.h
@@ -127,7 +127,7 @@ struct usb_hcd {
         unsigned                authorized_default:1;
         unsigned                has_tt:1;       /* Integrated TT in root hub */
 
-        int                     irq;            /* irq allocated */
+        unsigned int            irq;            /* irq allocated */
         void __iomem            *regs;          /* device memory/io */
         u64                     rsrc_start;     /* memory/io resource start */
         u64                     rsrc_len;       /* memory/io resource length */
@@ -412,6 +412,8 @@ extern irqreturn_t usb_hcd_irq(int irq, void *__hcd);
 
 extern void usb_hc_died(struct usb_hcd *hcd);
 extern void usb_hcd_poll_rh_status(struct usb_hcd *hcd);
+extern void usb_wakeup_notification(struct usb_device *hdev,
+                unsigned int portnum);
 
 /* The D0/D1 toggle bits ... USE WITH CAUTION (they're almost hcd-internal) */
 #define usb_gettoggle(dev, ep, out) (((dev)->toggle[out] >> (ep)) & 1)
diff --git a/include/linux/usb/intel_mid_otg.h b/include/linux/usb/intel_mid_otg.h
index a0ccf795f362..756cf5543ffd 100644
--- a/include/linux/usb/intel_mid_otg.h
+++ b/include/linux/usb/intel_mid_otg.h
@@ -104,11 +104,11 @@ struct iotg_ulpi_access_ops {
 /*
  * the Intel MID (Langwell/Penwell) otg transceiver driver needs to interact
  * with device and host drivers to implement the USB OTG related feature. More
- * function members are added based on otg_transceiver data structure for this
+ * function members are added based on usb_phy data structure for this
  * purpose.
  */
 struct intel_mid_otg_xceiv {
-        struct otg_transceiver  otg;
+        struct usb_phy          otg;
         struct otg_hsm          hsm;
 
         /* base address */
@@ -147,7 +147,7 @@ struct intel_mid_otg_xceiv {
 
 };
 static inline
-struct intel_mid_otg_xceiv *otg_to_mid_xceiv(struct otg_transceiver *otg)
+struct intel_mid_otg_xceiv *otg_to_mid_xceiv(struct usb_phy *otg)
 {
         return container_of(otg, struct intel_mid_otg_xceiv, otg);
 }
diff --git a/include/linux/usb/msm_hsusb.h b/include/linux/usb/msm_hsusb.h
index 00311fe9d0df..22a396c13f3a 100644
--- a/include/linux/usb/msm_hsusb.h
+++ b/include/linux/usb/msm_hsusb.h
@@ -160,7 +160,7 @@ struct msm_otg_platform_data {
  *               detection process.
  */
 struct msm_otg {
-        struct otg_transceiver otg;
+        struct usb_phy phy;
         struct msm_otg_platform_data *pdata;
         int irq;
         struct clk *clk;
diff --git a/include/linux/usb/ohci_pdriver.h b/include/linux/usb/ohci_pdriver.h
new file mode 100644
index 000000000000..2808f2a9cce8
--- /dev/null
+++ b/include/linux/usb/ohci_pdriver.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2012 Hauke Mehrtens <hauke@hauke-m.de>
+ *
+ * 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 __USB_CORE_OHCI_PDRIVER_H
+#define __USB_CORE_OHCI_PDRIVER_H
+
+/**
+ * struct usb_ohci_pdata - platform_data for generic ohci driver
+ *
+ * @big_endian_desc:    BE descriptors
+ * @big_endian_mmio:    BE registers
+ * @no_big_frame_no:    no big endian frame_no shift
+ *
+ * These are general configuration options for the OHCI controller. All of
+ * these options are activating more or less workarounds for some hardware.
+ */
+struct usb_ohci_pdata {
+        unsigned        big_endian_desc:1;
+        unsigned        big_endian_mmio:1;
+        unsigned        no_big_frame_no:1;
+};
+
+#endif /* __USB_CORE_OHCI_PDRIVER_H */
diff --git a/include/linux/usb/otg.h b/include/linux/usb/otg.h
index d87f44f5b04e..f67810f8f21b 100644
--- a/include/linux/usb/otg.h
+++ b/include/linux/usb/otg.h
@@ -35,7 +35,7 @@ enum usb_otg_state {
         OTG_STATE_A_VBUS_ERR,
 };
 
-enum usb_xceiv_events {
+enum usb_phy_events {
         USB_EVENT_NONE,         /* no events or cable disconnected */
         USB_EVENT_VBUS,         /* vbus valid event */
         USB_EVENT_ID,           /* id was grounded */
@@ -43,14 +43,39 @@ enum usb_xceiv_events {
         USB_EVENT_ENUMERATED,   /* gadget driver enumerated */
 };
 
-struct otg_transceiver;
+struct usb_phy;
 
 /* for transceivers connected thru an ULPI interface, the user must
  * provide access ops
  */
-struct otg_io_access_ops {
-        int (*read)(struct otg_transceiver *otg, u32 reg);
-        int (*write)(struct otg_transceiver *otg, u32 val, u32 reg);
+struct usb_phy_io_ops {
+        int (*read)(struct usb_phy *x, u32 reg);
+        int (*write)(struct usb_phy *x, u32 val, u32 reg);
+};
+
+struct usb_otg {
+        u8                      default_a;
+
+        struct usb_phy          *phy;
+        struct usb_bus          *host;
+        struct usb_gadget       *gadget;
+
+        /* bind/unbind the host controller */
+        int     (*set_host)(struct usb_otg *otg, struct usb_bus *host);
+
+        /* bind/unbind the peripheral controller */
+        int     (*set_peripheral)(struct usb_otg *otg,
+                                        struct usb_gadget *gadget);
+
+        /* effective for A-peripheral, ignored for B devices */
+        int     (*set_vbus)(struct usb_otg *otg, bool enabled);
+
+        /* for B devices only:  start session with A-Host */
+        int     (*start_srp)(struct usb_otg *otg);
+
+        /* start or continue HNP role switch */
+        int     (*start_hnp)(struct usb_otg *otg);
+
 };
 
 /*
@@ -59,22 +84,20 @@ struct otg_io_access_ops {
  * moment, using the transceiver, ID signal, HNP and sometimes static
  * configuration information (including "board isn't wired for otg").
  */
-struct otg_transceiver {
+struct usb_phy {
         struct device           *dev;
         const char              *label;
         unsigned int             flags;
 
-        u8                      default_a;
         enum usb_otg_state      state;
-        enum usb_xceiv_events   last_event;
+        enum usb_phy_events     last_event;
 
-        struct usb_bus          *host;
-        struct usb_gadget       *gadget;
+        struct usb_otg          *otg;
 
-        struct otg_io_access_ops        *io_ops;
-        void __iomem                    *io_priv;
+        struct usb_phy_io_ops   *io_ops;
+        void __iomem            *io_priv;
 
-        /* for notification of usb_xceiv_events */
+        /* for notification of usb_phy_events */
         struct atomic_notifier_head     notifier;
 
         /* to pass extra port status to the root hub */
@@ -82,40 +105,22 @@ struct otg_transceiver {
         u16                     port_change;
 
         /* initialize/shutdown the OTG controller */
-        int     (*init)(struct otg_transceiver *otg);
-        void    (*shutdown)(struct otg_transceiver *otg);
-
-        /* bind/unbind the host controller */
-        int     (*set_host)(struct otg_transceiver *otg,
-                                struct usb_bus *host);
-
-        /* bind/unbind the peripheral controller */
-        int     (*set_peripheral)(struct otg_transceiver *otg,
-                                struct usb_gadget *gadget);
+        int     (*init)(struct usb_phy *x);
+        void    (*shutdown)(struct usb_phy *x);
 
         /* effective for B devices, ignored for A-peripheral */
-        int     (*set_power)(struct otg_transceiver *otg,
+        int     (*set_power)(struct usb_phy *x,
                                 unsigned mA);
 
-        /* effective for A-peripheral, ignored for B devices */
-        int     (*set_vbus)(struct otg_transceiver *otg,
-                                bool enabled);
-
         /* for non-OTG B devices: set transceiver into suspend mode */
-        int     (*set_suspend)(struct otg_transceiver *otg,
+        int     (*set_suspend)(struct usb_phy *x,
                                 int suspend);
 
-        /* for B devices only:  start session with A-Host */
-        int     (*start_srp)(struct otg_transceiver *otg);
-
-        /* start or continue HNP role switch */
-        int     (*start_hnp)(struct otg_transceiver *otg);
-
 };
 
 
 /* for board-specific init logic */
-extern int otg_set_transceiver(struct otg_transceiver *);
+extern int usb_set_transceiver(struct usb_phy *);
 
 #if defined(CONFIG_NOP_USB_XCEIV) || (defined(CONFIG_NOP_USB_XCEIV_MODULE) && defined(MODULE))
 /* sometimes transceivers are accessed only through e.g. ULPI */
@@ -132,50 +137,50 @@ static inline void usb_nop_xceiv_unregister(void)
 #endif
 
 /* helpers for direct access thru low-level io interface */
-static inline int otg_io_read(struct otg_transceiver *otg, u32 reg)
+static inline int usb_phy_io_read(struct usb_phy *x, u32 reg)
 {
-        if (otg->io_ops && otg->io_ops->read)
-                return otg->io_ops->read(otg, reg);
+        if (x->io_ops && x->io_ops->read)
+                return x->io_ops->read(x, reg);
 
         return -EINVAL;
 }
 
-static inline int otg_io_write(struct otg_transceiver *otg, u32 val, u32 reg)
+static inline int usb_phy_io_write(struct usb_phy *x, u32 val, u32 reg)
 {
-        if (otg->io_ops && otg->io_ops->write)
-                return otg->io_ops->write(otg, val, reg);
+        if (x->io_ops && x->io_ops->write)
+                return x->io_ops->write(x, val, reg);
 
         return -EINVAL;
 }
 
 static inline int
-otg_init(struct otg_transceiver *otg)
+usb_phy_init(struct usb_phy *x)
 {
-        if (otg->init)
-                return otg->init(otg);
+        if (x->init)
+                return x->init(x);
 
         return 0;
 }
 
 static inline void
-otg_shutdown(struct otg_transceiver *otg)
+usb_phy_shutdown(struct usb_phy *x)
 {
-        if (otg->shutdown)
-                otg->shutdown(otg);
+        if (x->shutdown)
+                x->shutdown(x);
 }
 
 /* for usb host and peripheral controller drivers */
 #ifdef CONFIG_USB_OTG_UTILS
-extern struct otg_transceiver *otg_get_transceiver(void);
-extern void otg_put_transceiver(struct otg_transceiver *);
+extern struct usb_phy *usb_get_transceiver(void);
+extern void usb_put_transceiver(struct usb_phy *);
 extern const char *otg_state_string(enum usb_otg_state state);
 #else
-static inline struct otg_transceiver *otg_get_transceiver(void)
+static inline struct usb_phy *usb_get_transceiver(void)
 {
         return NULL;
 }
 
-static inline void otg_put_transceiver(struct otg_transceiver *x)
+static inline void usb_put_transceiver(struct usb_phy *x)
 {
 }
 
@@ -187,67 +192,84 @@ static inline const char *otg_state_string(enum usb_otg_state state)
 
 /* Context: can sleep */
 static inline int
-otg_start_hnp(struct otg_transceiver *otg)
+otg_start_hnp(struct usb_otg *otg)
 {
-        return otg->start_hnp(otg);
+        if (otg && otg->start_hnp)
+                return otg->start_hnp(otg);
+
+        return -ENOTSUPP;
 }
 
 /* Context: can sleep */
 static inline int
-otg_set_vbus(struct otg_transceiver *otg, bool enabled)
+otg_set_vbus(struct usb_otg *otg, bool enabled)
 {
-        return otg->set_vbus(otg, enabled);
+        if (otg && otg->set_vbus)
+                return otg->set_vbus(otg, enabled);
+
+        return -ENOTSUPP;
 }
 
 /* for HCDs */
 static inline int
-otg_set_host(struct otg_transceiver *otg, struct usb_bus *host)
+otg_set_host(struct usb_otg *otg, struct usb_bus *host)
 {
-        return otg->set_host(otg, host);
+        if (otg && otg->set_host)
+                return otg->set_host(otg, host);
+
+        return -ENOTSUPP;
 }
 
 /* for usb peripheral controller drivers */
 
 /* Context: can sleep */
 static inline int
-otg_set_peripheral(struct otg_transceiver *otg, struct usb_gadget *periph)
+otg_set_peripheral(struct usb_otg *otg, struct usb_gadget *periph)
 {
-        return otg->set_peripheral(otg, periph);
+        if (otg && otg->set_peripheral)
+                return otg->set_peripheral(otg, periph);
+
+        return -ENOTSUPP;
 }
 
 static inline int
-otg_set_power(struct otg_transceiver *otg, unsigned mA)
+usb_phy_set_power(struct usb_phy *x, unsigned mA)
 {
-        return otg->set_power(otg, mA);
+        if (x && x->set_power)
+                return x->set_power(x, mA);
+        return 0;
 }
 
 /* Context: can sleep */
 static inline int
-otg_set_suspend(struct otg_transceiver *otg, int suspend)
+usb_phy_set_suspend(struct usb_phy *x, int suspend)
 {
-        if (otg->set_suspend != NULL)
-                return otg->set_suspend(otg, suspend);
+        if (x->set_suspend != NULL)
+                return x->set_suspend(x, suspend);
         else
                 return 0;
 }
 
 static inline int
-otg_start_srp(struct otg_transceiver *otg)
+otg_start_srp(struct usb_otg *otg)
 {
-        return otg->start_srp(otg);
+        if (otg && otg->start_srp)
+                return otg->start_srp(otg);
+
+        return -ENOTSUPP;
 }
 
 /* notifiers */
 static inline int
-otg_register_notifier(struct otg_transceiver *otg, struct notifier_block *nb)
+usb_register_notifier(struct usb_phy *x, struct notifier_block *nb)
 {
-        return atomic_notifier_chain_register(&otg->notifier, nb);
+        return atomic_notifier_chain_register(&x->notifier, nb);
 }
 
 static inline void
-otg_unregister_notifier(struct otg_transceiver *otg, struct notifier_block *nb)
+usb_unregister_notifier(struct usb_phy *x, struct notifier_block *nb)
 {
-        atomic_notifier_chain_unregister(&otg->notifier, nb);
+        atomic_notifier_chain_unregister(&x->notifier, nb);
 }
 
 /* for OTG controller drivers (and maybe other stuff) */
diff --git a/include/linux/usb/renesas_usbhs.h b/include/linux/usb/renesas_usbhs.h
index 0d3f98879256..547e59cc00ea 100644
--- a/include/linux/usb/renesas_usbhs.h
+++ b/include/linux/usb/renesas_usbhs.h
@@ -149,6 +149,7 @@ struct renesas_usbhs_driver_param {
          * option:
          */
         u32 has_otg:1; /* for controlling PWEN/EXTLP */
+        u32 has_sudmac:1; /* for SUDMAC */
 };
 
 /*
diff --git a/include/linux/usb/serial.h b/include/linux/usb/serial.h
index 4267a9c717ba..fbb666b1b670 100644
--- a/include/linux/usb/serial.h
+++ b/include/linux/usb/serial.h
@@ -300,8 +300,10 @@ struct usb_serial_driver {
 #define to_usb_serial_driver(d) \
         container_of(d, struct usb_serial_driver, driver)
 
-extern int  usb_serial_register(struct usb_serial_driver *driver);
-extern void usb_serial_deregister(struct usb_serial_driver *driver);
+extern int usb_serial_register_drivers(struct usb_driver *udriver,
+                struct usb_serial_driver * const serial_drivers[]);
+extern void usb_serial_deregister_drivers(struct usb_driver *udriver,
+                struct usb_serial_driver * const serial_drivers[]);
 extern void usb_serial_port_softint(struct usb_serial_port *port);
 
 extern int usb_serial_probe(struct usb_interface *iface,
@@ -389,5 +391,35 @@ do {									\
                 printk(KERN_DEBUG "%s: " format "\n", __FILE__, ##arg); \
 } while (0)
 
+/*
+ * Macro for reporting errors in write path to avoid inifinite loop
+ * when port is used as a console.
+ */
+#define dev_err_console(usport, fmt, ...)                               \
+do {                                                                    \
+        static bool __print_once;                                       \
+        struct usb_serial_port *__port = (usport);                      \
+                                                                        \
+        if (!__port->port.console || !__print_once) {                   \
+                __print_once = true;                                    \
+                dev_err(&__port->dev, fmt, ##__VA_ARGS__);              \
+        }                                                               \
+} while (0)
+
+/*
+ * module_usb_serial_driver() - Helper macro for registering a USB Serial driver
+ * @__usb_driver: usb_driver struct to register
+ * @__serial_drivers: list of usb_serial drivers to register
+ *
+ * Helper macro for USB serial drivers which do not do anything special
+ * in module init/exit. This eliminates a lot of boilerplate. Each
+ * module may only use this macro once, and calling it replaces
+ * module_init() and module_exit()
+ *
+ */
+#define module_usb_serial_driver(__usb_driver, __serial_drivers)        \
+        module_driver(__usb_driver, usb_serial_register_drivers,        \
+                       usb_serial_deregister_drivers, __serial_drivers)
+
 #endif /* __LINUX_USB_SERIAL_H */
 
diff --git a/include/linux/usb/storage.h b/include/linux/usb/storage.h
index d7fc910f1dc4..cb33fff2ba0b 100644
--- a/include/linux/usb/storage.h
+++ b/include/linux/usb/storage.h
@@ -45,4 +45,42 @@
 
 #define USB_PR_DEVICE   0xff            /* Use device's value */
 
+ /*
+  * Bulk only data structures
+  */
+
+/* command block wrapper */
+struct bulk_cb_wrap {
+        __le32  Signature;              /* contains 'USBC' */
+        __u32   Tag;                    /* unique per command id */
+        __le32  DataTransferLength;     /* size of data */
+        __u8    Flags;                  /* direction in bit 0 */
+        __u8    Lun;                    /* LUN normally 0 */
+        __u8    Length;                 /* of of the CDB */
+        __u8    CDB[16];                /* max command */
+};
+
+#define US_BULK_CB_WRAP_LEN     31
+#define US_BULK_CB_SIGN         0x43425355      /*spells out USBC */
+#define US_BULK_FLAG_IN         (1 << 7)
+#define US_BULK_FLAG_OUT        0
+
+/* command status wrapper */
+struct bulk_cs_wrap {
+        __le32  Signature;      /* should = 'USBS' */
+        __u32   Tag;            /* same as original command */
+        __le32  Residue;        /* amount not transferred */
+        __u8    Status;         /* see below */
+};
+
+#define US_BULK_CS_WRAP_LEN     13
+#define US_BULK_CS_SIGN         0x53425355      /* spells out 'USBS' */
+#define US_BULK_STAT_OK         0
+#define US_BULK_STAT_FAIL       1
+#define US_BULK_STAT_PHASE      2
+
+/* bulk-only class specific requests */
+#define US_BULK_RESET_REQUEST   0xff
+#define US_BULK_GET_MAX_LUN     0xfe
+
 #endif
diff --git a/include/linux/usb/uas.h b/include/linux/usb/uas.h
new file mode 100644
index 000000000000..9a988e413694
--- /dev/null
+++ b/include/linux/usb/uas.h
@@ -0,0 +1,69 @@
+#ifndef __USB_UAS_H__
+#define __USB_UAS_H__
+
+#include <scsi/scsi.h>
+#include <scsi/scsi_cmnd.h>
+
+/* Common header for all IUs */
+struct iu {
+        __u8 iu_id;
+        __u8 rsvd1;
+        __be16 tag;
+};
+
+enum {
+        IU_ID_COMMAND           = 0x01,
+        IU_ID_STATUS            = 0x03,
+        IU_ID_RESPONSE          = 0x04,
+        IU_ID_TASK_MGMT         = 0x05,
+        IU_ID_READ_READY        = 0x06,
+        IU_ID_WRITE_READY       = 0x07,
+};
+
+struct command_iu {
+        __u8 iu_id;
+        __u8 rsvd1;
+        __be16 tag;
+        __u8 prio_attr;
+        __u8 rsvd5;
+        __u8 len;
+        __u8 rsvd7;
+        struct scsi_lun lun;
+        __u8 cdb[16];   /* XXX: Overflow-checking tools may misunderstand */
+};
+
+/*
+ * Also used for the Read Ready and Write Ready IUs since they have the
+ * same first four bytes
+ */
+struct sense_iu {
+        __u8 iu_id;
+        __u8 rsvd1;
+        __be16 tag;
+        __be16 status_qual;
+        __u8 status;
+        __u8 rsvd7[7];
+        __be16 len;
+        __u8 sense[SCSI_SENSE_BUFFERSIZE];
+};
+
+struct usb_pipe_usage_descriptor {
+        __u8  bLength;
+        __u8  bDescriptorType;
+
+        __u8  bPipeID;
+        __u8  Reserved;
+} __attribute__((__packed__));
+
+enum {
+        CMD_PIPE_ID             = 1,
+        STATUS_PIPE_ID          = 2,
+        DATA_IN_PIPE_ID         = 3,
+        DATA_OUT_PIPE_ID        = 4,
+
+        UAS_SIMPLE_TAG          = 0,
+        UAS_HEAD_TAG            = 1,
+        UAS_ORDERED_TAG         = 2,
+        UAS_ACA                 = 4,
+};
+#endif
diff --git a/include/linux/usb/ulpi.h b/include/linux/usb/ulpi.h
index 9595796d62ed..6f033a415ecb 100644
--- a/include/linux/usb/ulpi.h
+++ b/include/linux/usb/ulpi.h
@@ -181,12 +181,12 @@
 
 /*-------------------------------------------------------------------------*/
 
-struct otg_transceiver *otg_ulpi_create(struct otg_io_access_ops *ops,
+struct usb_phy *otg_ulpi_create(struct usb_phy_io_ops *ops,
                                         unsigned int flags);
 
 #ifdef CONFIG_USB_ULPI_VIEWPORT
 /* access ops for controllers with a viewport register */
-extern struct otg_io_access_ops ulpi_viewport_access_ops;
+extern struct usb_phy_io_ops ulpi_viewport_access_ops;
 #endif
 
 #endif /* __LINUX_USB_ULPI_H */
diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
index 5e11f8a1f867..c9c9a4680cc5 100644
--- a/include/linux/videodev2.h
+++ b/include/linux/videodev2.h
@@ -235,16 +235,25 @@ struct v4l2_fract {
         __u32   denominator;
 };
 
-/*
- *      D R I V E R   C A P A B I L I T I E S
- */
+/**
+  * struct v4l2_capability - Describes V4L2 device caps returned by VIDIOC_QUERYCAP
+  *
+  * @driver:       name of the driver module (e.g. "bttv")
+  * @card:         name of the card (e.g. "Hauppauge WinTV")
+  * @bus_info:     name of the bus (e.g. "PCI:" + pci_name(pci_dev) )
+  * @version:      KERNEL_VERSION
+  * @capabilities: capabilities of the physical device as a whole
+  * @device_caps:  capabilities accessed via this particular device (node)
+  * @reserved:     reserved fields for future extensions
+  */
 struct v4l2_capability {
-        __u8    driver[16];     /* i.e. "bttv" */
-        __u8    card[32];       /* i.e. "Hauppauge WinTV" */
-        __u8    bus_info[32];   /* "PCI:" + pci_name(pci_dev) */
-        __u32   version;        /* should use KERNEL_VERSION() */
-        __u32   capabilities;   /* Device capabilities */
-        __u32   reserved[4];
+        __u8    driver[16];
+        __u8    card[32];
+        __u8    bus_info[32];
+        __u32   version;
+        __u32   capabilities;
+        __u32   device_caps;
+        __u32   reserved[3];
 };
 
 /* Values for 'capabilities' field */
@@ -274,6 +283,8 @@ struct v4l2_capability {
 #define V4L2_CAP_ASYNCIO                0x02000000  /* async I/O */
 #define V4L2_CAP_STREAMING              0x04000000  /* streaming I/O ioctls */
 
+#define V4L2_CAP_DEVICE_CAPS            0x80000000  /* sets device capabilities field */
+
 /*
  *      V I D E O   I M A G E   F O R M A T
  */
@@ -751,20 +762,20 @@ struct v4l2_crop {
 
 /* Selection targets */
 
-/* current cropping area */
-#define V4L2_SEL_TGT_CROP_ACTIVE        0
-/* default cropping area */
-#define V4L2_SEL_TGT_CROP_DEFAULT       1
-/* cropping bounds */
-#define V4L2_SEL_TGT_CROP_BOUNDS        2
-/* current composing area */
-#define V4L2_SEL_TGT_COMPOSE_ACTIVE     256
-/* default composing area */
-#define V4L2_SEL_TGT_COMPOSE_DEFAULT    257
-/* composing bounds */
-#define V4L2_SEL_TGT_COMPOSE_BOUNDS     258
-/* current composing area plus all padding pixels */
-#define V4L2_SEL_TGT_COMPOSE_PADDED     259
+/* Current cropping area */
+#define V4L2_SEL_TGT_CROP_ACTIVE        0x0000
+/* Default cropping area */
+#define V4L2_SEL_TGT_CROP_DEFAULT       0x0001
+/* Cropping bounds */
+#define V4L2_SEL_TGT_CROP_BOUNDS        0x0002
+/* Current composing area */
+#define V4L2_SEL_TGT_COMPOSE_ACTIVE     0x0100
+/* Default composing area */
+#define V4L2_SEL_TGT_COMPOSE_DEFAULT    0x0101
+/* Composing bounds */
+#define V4L2_SEL_TGT_COMPOSE_BOUNDS     0x0102
+/* Current composing area plus all padding pixels */
+#define V4L2_SEL_TGT_COMPOSE_PADDED     0x0103
 
 /**
  * struct v4l2_selection - selection info
@@ -774,7 +785,7 @@ struct v4l2_crop {
  * @r:          coordinates of selection window
  * @reserved:   for future use, rounds structure size to 64 bytes, set to zero
  *
- * Hardware may use multiple helper window to process a video stream.
+ * Hardware may use multiple helper windows to process a video stream.
  * The structure is used to exchange this selection areas between
  * an application and a driver.
  */
@@ -1125,6 +1136,7 @@ struct v4l2_ext_controls {
 #define V4L2_CTRL_CLASS_CAMERA 0x009a0000       /* Camera class controls */
 #define V4L2_CTRL_CLASS_FM_TX 0x009b0000        /* FM Modulator control class */
 #define V4L2_CTRL_CLASS_FLASH 0x009c0000        /* Camera flash controls */
+#define V4L2_CTRL_CLASS_JPEG 0x009d0000         /* JPEG-compression controls */
 
 #define V4L2_CTRL_ID_MASK         (0x0fffffff)
 #define V4L2_CTRL_ID2CLASS(id)    ((id) & 0x0fff0000UL)
@@ -1396,6 +1408,16 @@ enum v4l2_mpeg_audio_ac3_bitrate {
         V4L2_MPEG_AUDIO_AC3_BITRATE_576K = 17,
         V4L2_MPEG_AUDIO_AC3_BITRATE_640K = 18,
 };
+#define V4L2_CID_MPEG_AUDIO_DEC_PLAYBACK        (V4L2_CID_MPEG_BASE+112)
+enum v4l2_mpeg_audio_dec_playback {
+        V4L2_MPEG_AUDIO_DEC_PLAYBACK_AUTO           = 0,
+        V4L2_MPEG_AUDIO_DEC_PLAYBACK_STEREO         = 1,
+        V4L2_MPEG_AUDIO_DEC_PLAYBACK_LEFT           = 2,
+        V4L2_MPEG_AUDIO_DEC_PLAYBACK_RIGHT          = 3,
+        V4L2_MPEG_AUDIO_DEC_PLAYBACK_MONO           = 4,
+        V4L2_MPEG_AUDIO_DEC_PLAYBACK_SWAPPED_STEREO = 5,
+};
+#define V4L2_CID_MPEG_AUDIO_DEC_MULTILINGUAL_PLAYBACK (V4L2_CID_MPEG_BASE+113)
 
 /*  MPEG video controls specific to multiplexed streams */
 #define V4L2_CID_MPEG_VIDEO_ENCODING            (V4L2_CID_MPEG_BASE+200)
@@ -1446,6 +1468,9 @@ enum v4l2_mpeg_video_multi_slice_mode {
         V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_BYTES       = 2,
 };
 #define V4L2_CID_MPEG_VIDEO_VBV_SIZE                    (V4L2_CID_MPEG_BASE+222)
+#define V4L2_CID_MPEG_VIDEO_DEC_PTS                     (V4L2_CID_MPEG_BASE+223)
+#define V4L2_CID_MPEG_VIDEO_DEC_FRAME                   (V4L2_CID_MPEG_BASE+224)
+
 #define V4L2_CID_MPEG_VIDEO_H263_I_FRAME_QP             (V4L2_CID_MPEG_BASE+300)
 #define V4L2_CID_MPEG_VIDEO_H263_P_FRAME_QP             (V4L2_CID_MPEG_BASE+301)
 #define V4L2_CID_MPEG_VIDEO_H263_B_FRAME_QP             (V4L2_CID_MPEG_BASE+302)
@@ -1734,6 +1759,29 @@ enum v4l2_flash_strobe_source {
 #define V4L2_CID_FLASH_CHARGE                   (V4L2_CID_FLASH_CLASS_BASE + 11)
 #define V4L2_CID_FLASH_READY                    (V4L2_CID_FLASH_CLASS_BASE + 12)
 
+/*  JPEG-class control IDs defined by V4L2 */
+#define V4L2_CID_JPEG_CLASS_BASE                (V4L2_CTRL_CLASS_JPEG | 0x900)
+#define V4L2_CID_JPEG_CLASS                     (V4L2_CTRL_CLASS_JPEG | 1)
+
+#define V4L2_CID_JPEG_CHROMA_SUBSAMPLING        (V4L2_CID_JPEG_CLASS_BASE + 1)
+enum v4l2_jpeg_chroma_subsampling {
+        V4L2_JPEG_CHROMA_SUBSAMPLING_444        = 0,
+        V4L2_JPEG_CHROMA_SUBSAMPLING_422        = 1,
+        V4L2_JPEG_CHROMA_SUBSAMPLING_420        = 2,
+        V4L2_JPEG_CHROMA_SUBSAMPLING_411        = 3,
+        V4L2_JPEG_CHROMA_SUBSAMPLING_410        = 4,
+        V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY       = 5,
+};
+#define V4L2_CID_JPEG_RESTART_INTERVAL          (V4L2_CID_JPEG_CLASS_BASE + 2)
+#define V4L2_CID_JPEG_COMPRESSION_QUALITY       (V4L2_CID_JPEG_CLASS_BASE + 3)
+
+#define V4L2_CID_JPEG_ACTIVE_MARKER             (V4L2_CID_JPEG_CLASS_BASE + 4)
+#define V4L2_JPEG_ACTIVE_MARKER_APP0            (1 << 0)
+#define V4L2_JPEG_ACTIVE_MARKER_APP1            (1 << 1)
+#define V4L2_JPEG_ACTIVE_MARKER_COM             (1 << 16)
+#define V4L2_JPEG_ACTIVE_MARKER_DQT             (1 << 17)
+#define V4L2_JPEG_ACTIVE_MARKER_DHT             (1 << 18)
+
 /*
  *      T U N I N G
  */
@@ -1897,6 +1945,54 @@ struct v4l2_encoder_cmd {
         };
 };
 
+/* Decoder commands */
+#define V4L2_DEC_CMD_START       (0)
+#define V4L2_DEC_CMD_STOP        (1)
+#define V4L2_DEC_CMD_PAUSE       (2)
+#define V4L2_DEC_CMD_RESUME      (3)
+
+/* Flags for V4L2_DEC_CMD_START */
+#define V4L2_DEC_CMD_START_MUTE_AUDIO   (1 << 0)
+
+/* Flags for V4L2_DEC_CMD_PAUSE */
+#define V4L2_DEC_CMD_PAUSE_TO_BLACK     (1 << 0)
+
+/* Flags for V4L2_DEC_CMD_STOP */
+#define V4L2_DEC_CMD_STOP_TO_BLACK      (1 << 0)
+#define V4L2_DEC_CMD_STOP_IMMEDIATELY   (1 << 1)
+
+/* Play format requirements (returned by the driver): */
+
+/* The decoder has no special format requirements */
+#define V4L2_DEC_START_FMT_NONE         (0)
+/* The decoder requires full GOPs */
+#define V4L2_DEC_START_FMT_GOP          (1)
+
+/* The structure must be zeroed before use by the application
+   This ensures it can be extended safely in the future. */
+struct v4l2_decoder_cmd {
+        __u32 cmd;
+        __u32 flags;
+        union {
+                struct {
+                        __u64 pts;
+                } stop;
+
+                struct {
+                        /* 0 or 1000 specifies normal speed,
+                           1 specifies forward single stepping,
+                           -1 specifies backward single stepping,
+                           >1: playback at speed/1000 of the normal speed,
+                           <-1: reverse playback at (-speed/1000) of the normal speed. */
+                        __s32 speed;
+                        __u32 format;
+                } start;
+
+                struct {
+                        __u32 data[16];
+                } raw;
+        };
+};
 #endif
 
 
@@ -2307,6 +2403,11 @@ struct v4l2_create_buffers {
 #define VIDIOC_G_SELECTION      _IOWR('V', 94, struct v4l2_selection)
 #define VIDIOC_S_SELECTION      _IOWR('V', 95, struct v4l2_selection)
 
+/* Experimental, these two ioctls may change over the next couple of kernel
+   versions. */
+#define VIDIOC_DECODER_CMD      _IOWR('V', 96, struct v4l2_decoder_cmd)
+#define VIDIOC_TRY_DECODER_CMD  _IOWR('V', 97, struct v4l2_decoder_cmd)
+
 /* Reminder: when adding new ioctls please add support for them to
    drivers/media/video/v4l2-compat-ioctl32.c as well! */
 
diff --git a/include/linux/virtio_config.h b/include/linux/virtio_config.h
index 5206d6541da5..7323a3390206 100644
--- a/include/linux/virtio_config.h
+++ b/include/linux/virtio_config.h
@@ -53,6 +53,7 @@
 
 #ifdef __KERNEL__
 #include <linux/err.h>
+#include <linux/bug.h>
 #include <linux/virtio.h>
 
 /**
diff --git a/include/linux/virtio_ids.h b/include/linux/virtio_ids.h
index 85bb0bb66ffc..7529b854b7fd 100644
--- a/include/linux/virtio_ids.h
+++ b/include/linux/virtio_ids.h
@@ -34,6 +34,8 @@
 #define VIRTIO_ID_CONSOLE       3 /* virtio console */
 #define VIRTIO_ID_RNG           4 /* virtio ring */
 #define VIRTIO_ID_BALLOON       5 /* virtio balloon */
+#define VIRTIO_ID_RPMSG         7 /* virtio remote processor messaging */
+#define VIRTIO_ID_SCSI          8 /* virtio scsi */
 #define VIRTIO_ID_9P            9 /* 9p virtio console */
 
 #endif /* _LINUX_VIRTIO_IDS_H */
diff --git a/include/linux/virtio_scsi.h b/include/linux/virtio_scsi.h
new file mode 100644
index 000000000000..8ddeafdc0546
--- /dev/null
+++ b/include/linux/virtio_scsi.h
@@ -0,0 +1,114 @@
+#ifndef _LINUX_VIRTIO_SCSI_H
+#define _LINUX_VIRTIO_SCSI_H
+/* This header is BSD licensed so anyone can use the definitions to implement
+ * compatible drivers/servers. */
+
+#define VIRTIO_SCSI_CDB_SIZE   32
+#define VIRTIO_SCSI_SENSE_SIZE 96
+
+/* SCSI command request, followed by data-out */
+struct virtio_scsi_cmd_req {
+        u8 lun[8];              /* Logical Unit Number */
+        u64 tag;                /* Command identifier */
+        u8 task_attr;           /* Task attribute */
+        u8 prio;
+        u8 crn;
+        u8 cdb[VIRTIO_SCSI_CDB_SIZE];
+} __packed;
+
+/* Response, followed by sense data and data-in */
+struct virtio_scsi_cmd_resp {
+        u32 sense_len;          /* Sense data length */
+        u32 resid;              /* Residual bytes in data buffer */
+        u16 status_qualifier;   /* Status qualifier */
+        u8 status;              /* Command completion status */
+        u8 response;            /* Response values */
+        u8 sense[VIRTIO_SCSI_SENSE_SIZE];
+} __packed;
+
+/* Task Management Request */
+struct virtio_scsi_ctrl_tmf_req {
+        u32 type;
+        u32 subtype;
+        u8 lun[8];
+        u64 tag;
+} __packed;
+
+struct virtio_scsi_ctrl_tmf_resp {
+        u8 response;
+} __packed;
+
+/* Asynchronous notification query/subscription */
+struct virtio_scsi_ctrl_an_req {
+        u32 type;
+        u8 lun[8];
+        u32 event_requested;
+} __packed;
+
+struct virtio_scsi_ctrl_an_resp {
+        u32 event_actual;
+        u8 response;
+} __packed;
+
+struct virtio_scsi_event {
+        u32 event;
+        u8 lun[8];
+        u32 reason;
+} __packed;
+
+struct virtio_scsi_config {
+        u32 num_queues;
+        u32 seg_max;
+        u32 max_sectors;
+        u32 cmd_per_lun;
+        u32 event_info_size;
+        u32 sense_size;
+        u32 cdb_size;
+        u16 max_channel;
+        u16 max_target;
+        u32 max_lun;
+} __packed;
+
+/* Response codes */
+#define VIRTIO_SCSI_S_OK                       0
+#define VIRTIO_SCSI_S_OVERRUN                  1
+#define VIRTIO_SCSI_S_ABORTED                  2
+#define VIRTIO_SCSI_S_BAD_TARGET               3
+#define VIRTIO_SCSI_S_RESET                    4
+#define VIRTIO_SCSI_S_BUSY                     5
+#define VIRTIO_SCSI_S_TRANSPORT_FAILURE        6
+#define VIRTIO_SCSI_S_TARGET_FAILURE           7
+#define VIRTIO_SCSI_S_NEXUS_FAILURE            8
+#define VIRTIO_SCSI_S_FAILURE                  9
+#define VIRTIO_SCSI_S_FUNCTION_SUCCEEDED       10
+#define VIRTIO_SCSI_S_FUNCTION_REJECTED        11
+#define VIRTIO_SCSI_S_INCORRECT_LUN            12
+
+/* Controlq type codes.  */
+#define VIRTIO_SCSI_T_TMF                      0
+#define VIRTIO_SCSI_T_AN_QUERY                 1
+#define VIRTIO_SCSI_T_AN_SUBSCRIBE             2
+
+/* Valid TMF subtypes.  */
+#define VIRTIO_SCSI_T_TMF_ABORT_TASK           0
+#define VIRTIO_SCSI_T_TMF_ABORT_TASK_SET       1
+#define VIRTIO_SCSI_T_TMF_CLEAR_ACA            2
+#define VIRTIO_SCSI_T_TMF_CLEAR_TASK_SET       3
+#define VIRTIO_SCSI_T_TMF_I_T_NEXUS_RESET      4
+#define VIRTIO_SCSI_T_TMF_LOGICAL_UNIT_RESET   5
+#define VIRTIO_SCSI_T_TMF_QUERY_TASK           6
+#define VIRTIO_SCSI_T_TMF_QUERY_TASK_SET       7
+
+/* Events.  */
+#define VIRTIO_SCSI_T_EVENTS_MISSED            0x80000000
+#define VIRTIO_SCSI_T_NO_EVENT                 0
+#define VIRTIO_SCSI_T_TRANSPORT_RESET          1
+#define VIRTIO_SCSI_T_ASYNC_NOTIFY             2
+
+#define VIRTIO_SCSI_S_SIMPLE                   0
+#define VIRTIO_SCSI_S_ORDERED                  1
+#define VIRTIO_SCSI_S_HEAD                     2
+#define VIRTIO_SCSI_S_ACA                      3
+
+
+#endif /* _LINUX_VIRTIO_SCSI_H */
diff --git a/include/linux/vt_kern.h b/include/linux/vt_kern.h
index c2164fad0083..e33d77f15bda 100644
--- a/include/linux/vt_kern.h
+++ b/include/linux/vt_kern.h
@@ -167,4 +167,30 @@ extern int unregister_vt_notifier(struct notifier_block *nb);
 
 extern void hide_boot_cursor(bool hide);
 
+/* keyboard  provided interfaces */
+extern int vt_do_diacrit(unsigned int cmd, void __user *up, int eperm);
+extern int vt_do_kdskbmode(int console, unsigned int arg);
+extern int vt_do_kdskbmeta(int console, unsigned int arg);
+extern int vt_do_kbkeycode_ioctl(int cmd, struct kbkeycode __user *user_kbkc,
+                                                                int perm);
+extern int vt_do_kdsk_ioctl(int cmd, struct kbentry __user *user_kbe,
+                                        int perm, int console);
+extern int vt_do_kdgkb_ioctl(int cmd, struct kbsentry __user *user_kdgkb,
+                                        int perm);
+extern int vt_do_kdskled(int console, int cmd, unsigned long arg, int perm);
+extern int vt_do_kdgkbmode(int console);
+extern int vt_do_kdgkbmeta(int console);
+extern void vt_reset_unicode(int console);
+extern int vt_get_shift_state(void);
+extern void vt_reset_keyboard(int console);
+extern int vt_get_leds(int console, int flag);
+extern int vt_get_kbd_mode_bit(int console, int bit);
+extern void vt_set_kbd_mode_bit(int console, int bit);
+extern void vt_clr_kbd_mode_bit(int console, int bit);
+extern void vt_set_led_state(int console, int leds);
+extern void vt_set_led_state(int console, int leds);
+extern void vt_kbd_con_start(int console);
+extern void vt_kbd_con_stop(int console);
+
+
 #endif /* _VT_KERN_H */
diff --git a/include/linux/wait.h b/include/linux/wait.h
index a9ce45e8501c..7d9a9e990ce6 100644
--- a/include/linux/wait.h
+++ b/include/linux/wait.h
@@ -157,7 +157,7 @@ void __wake_up(wait_queue_head_t *q, unsigned int mode, int nr, void *key);
 void __wake_up_locked_key(wait_queue_head_t *q, unsigned int mode, void *key);
 void __wake_up_sync_key(wait_queue_head_t *q, unsigned int mode, int nr,
                         void *key);
-void __wake_up_locked(wait_queue_head_t *q, unsigned int mode);
+void __wake_up_locked(wait_queue_head_t *q, unsigned int mode, int nr);
 void __wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr);
 void __wake_up_bit(wait_queue_head_t *, void *, int);
 int __wait_on_bit(wait_queue_head_t *, struct wait_bit_queue *, int (*)(void *), unsigned);
@@ -170,7 +170,8 @@ wait_queue_head_t *bit_waitqueue(void *, int);
 #define wake_up(x)                      __wake_up(x, TASK_NORMAL, 1, NULL)
 #define wake_up_nr(x, nr)               __wake_up(x, TASK_NORMAL, nr, NULL)
 #define wake_up_all(x)                  __wake_up(x, TASK_NORMAL, 0, NULL)
-#define wake_up_locked(x)               __wake_up_locked((x), TASK_NORMAL)
+#define wake_up_locked(x)               __wake_up_locked((x), TASK_NORMAL, 1)
+#define wake_up_all_locked(x)           __wake_up_locked((x), TASK_NORMAL, 0)
 
 #define wake_up_interruptible(x)        __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)
 #define wake_up_interruptible_nr(x, nr) __wake_up(x, TASK_INTERRUPTIBLE, nr, NULL)
diff --git a/include/linux/watchdog.h b/include/linux/watchdog.h
index 43ba5b3ce2a3..ac40716b44e9 100644
--- a/include/linux/watchdog.h
+++ b/include/linux/watchdog.h
@@ -66,6 +66,7 @@ struct watchdog_device;
  * @ping:       The routine that sends a keepalive ping to the watchdog device.
  * @status:     The routine that shows the status of the watchdog device.
  * @set_timeout:The routine for setting the watchdog devices timeout value.
+ * @get_timeleft:The routine that get's the time that's left before a reset.
  * @ioctl:      The routines that handles extra ioctl calls.
  *
  * The watchdog_ops structure contains a list of low-level operations
@@ -82,6 +83,7 @@ struct watchdog_ops {
         int (*ping)(struct watchdog_device *);
         unsigned int (*status)(struct watchdog_device *);
         int (*set_timeout)(struct watchdog_device *, unsigned int);
+        unsigned int (*get_timeleft)(struct watchdog_device *);
         long (*ioctl)(struct watchdog_device *, unsigned int, unsigned long);
 };
 
@@ -127,7 +129,7 @@ struct watchdog_device {
 #endif
 
 /* Use the following function to set the nowayout feature */
-static inline void watchdog_set_nowayout(struct watchdog_device *wdd, int nowayout)
+static inline void watchdog_set_nowayout(struct watchdog_device *wdd, bool nowayout)
 {
         if (nowayout)
                 set_bit(WDOG_NO_WAY_OUT, &wdd->status);
diff --git a/include/linux/wimax/debug.h b/include/linux/wimax/debug.h
index 57031b4d12f2..aaf24ba12c4d 100644
--- a/include/linux/wimax/debug.h
+++ b/include/linux/wimax/debug.h
@@ -154,9 +154,9 @@
 #define __debug__h__
 
 #include <linux/types.h>
-#include <linux/device.h>
 #include <linux/slab.h>
 
+struct device;
 
 /* Backend stuff */
 
diff --git a/include/linux/writeback.h b/include/linux/writeback.h
index 995b8bf630ac..a2b84f598e2b 100644
--- a/include/linux/writeback.h
+++ b/include/linux/writeback.h
@@ -64,7 +64,7 @@ struct writeback_control {
         long pages_skipped;             /* Pages which were not written */
 
         /*
-         * For a_ops->writepages(): is start or end are non-zero then this is
+         * For a_ops->writepages(): if start or end are non-zero then this is
          * a hint that the filesystem need only write out the pages inside that
          * byterange.  The byte at `end' is included in the writeout request.
          */