246 files changed, 4510 insertions, 2313 deletions

diff --git a/include/acpi/acpiosxf.h b/include/acpi/acpiosxf.h
index 2fe8639b3ae..7c9aebe8a7a 100644
--- a/include/acpi/acpiosxf.h
+++ b/include/acpi/acpiosxf.h
@@ -218,9 +218,13 @@ acpi_status acpi_os_write_port(acpi_io_address address, u32 value, u32 width);
  */
 acpi_status
 acpi_os_read_memory(acpi_physical_address address, u32 * value, u32 width);
+acpi_status
+acpi_os_read_memory64(acpi_physical_address address, u64 *value, u32 width);
 
 acpi_status
 acpi_os_write_memory(acpi_physical_address address, u32 value, u32 width);
+acpi_status
+acpi_os_write_memory64(acpi_physical_address address, u64 value, u32 width);
 
 /*
  * Platform and hardware-independent PCI configuration space access
diff --git a/include/acpi/atomicio.h b/include/acpi/atomicio.h
deleted file mode 100644
index 8b9fb4b0b9c..00000000000
--- a/include/acpi/atomicio.h
+++ /dev/null
@@ -1,10 +0,0 @@
-#ifndef ACPI_ATOMIC_IO_H
-#define ACPI_ATOMIC_IO_H
-
-int acpi_pre_map_gar(struct acpi_generic_address *reg);
-int acpi_post_unmap_gar(struct acpi_generic_address *reg);
-
-int acpi_atomic_read(u64 *val, struct acpi_generic_address *reg);
-int acpi_atomic_write(u64 val, struct acpi_generic_address *reg);
-
-#endif
diff --git a/include/acpi/processor.h b/include/acpi/processor.h
index 610f6fb1bbc..9d650476d5d 100644
--- a/include/acpi/processor.h
+++ b/include/acpi/processor.h
@@ -195,6 +195,7 @@ struct acpi_processor_flags {
         u8 has_cst:1;
         u8 power_setup_done:1;
         u8 bm_rld_set:1;
+        u8 need_hotplug_init:1;
 };
 
 struct acpi_processor {
@@ -224,6 +225,7 @@ struct acpi_processor_errata {
         } piix4;
 };
 
+extern void acpi_processor_load_module(struct acpi_processor *pr);
 extern int acpi_processor_preregister_performance(struct
                                                   acpi_processor_performance
                                                   __percpu *performance);
diff --git a/include/asm-generic/io-64-nonatomic-hi-lo.h b/include/asm-generic/io-64-nonatomic-hi-lo.h
new file mode 100644
index 00000000000..a6806a94250
--- /dev/null
+++ b/include/asm-generic/io-64-nonatomic-hi-lo.h
@@ -0,0 +1,28 @@
+#ifndef _ASM_IO_64_NONATOMIC_HI_LO_H_
+#define _ASM_IO_64_NONATOMIC_HI_LO_H_
+
+#include <linux/io.h>
+#include <asm-generic/int-ll64.h>
+
+#ifndef readq
+static inline __u64 readq(const volatile void __iomem *addr)
+{
+        const volatile u32 __iomem *p = addr;
+        u32 low, high;
+
+        high = readl(p + 1);
+        low = readl(p);
+
+        return low + ((u64)high << 32);
+}
+#endif
+
+#ifndef writeq
+static inline void writeq(__u64 val, volatile void __iomem *addr)
+{
+        writel(val >> 32, addr + 4);
+        writel(val, addr);
+}
+#endif
+
+#endif  /* _ASM_IO_64_NONATOMIC_HI_LO_H_ */
diff --git a/include/asm-generic/io-64-nonatomic-lo-hi.h b/include/asm-generic/io-64-nonatomic-lo-hi.h
new file mode 100644
index 00000000000..ca546b1ff8b
--- /dev/null
+++ b/include/asm-generic/io-64-nonatomic-lo-hi.h
@@ -0,0 +1,28 @@
+#ifndef _ASM_IO_64_NONATOMIC_LO_HI_H_
+#define _ASM_IO_64_NONATOMIC_LO_HI_H_
+
+#include <linux/io.h>
+#include <asm-generic/int-ll64.h>
+
+#ifndef readq
+static inline __u64 readq(const volatile void __iomem *addr)
+{
+        const volatile u32 __iomem *p = addr;
+        u32 low, high;
+
+        low = readl(p);
+        high = readl(p + 1);
+
+        return low + ((u64)high << 32);
+}
+#endif
+
+#ifndef writeq
+static inline void writeq(__u64 val, volatile void __iomem *addr)
+{
+        writel(val, addr);
+        writel(val >> 32, addr + 4);
+}
+#endif
+
+#endif  /* _ASM_IO_64_NONATOMIC_LO_HI_H_ */
diff --git a/include/asm-generic/iomap.h b/include/asm-generic/iomap.h
index 8a3d4fde260..6afd7d6a989 100644
--- a/include/asm-generic/iomap.h
+++ b/include/asm-generic/iomap.h
@@ -70,7 +70,7 @@ extern void ioport_unmap(void __iomem *);
 /* Destroy a virtual mapping cookie for a PCI BAR (memory or IO) */
 struct pci_dev;
 extern void pci_iounmap(struct pci_dev *dev, void __iomem *);
-#else
+#elif defined(CONFIG_GENERIC_IOMAP)
 struct pci_dev;
 static inline void pci_iounmap(struct pci_dev *dev, void __iomem *addr)
 { }
diff --git a/include/asm-generic/pci_iomap.h b/include/asm-generic/pci_iomap.h
index 8de4b73e19e..ce37349860f 100644
--- a/include/asm-generic/pci_iomap.h
+++ b/include/asm-generic/pci_iomap.h
@@ -15,7 +15,17 @@ struct pci_dev;
 #ifdef CONFIG_PCI
 /* Create a virtual mapping cookie for a PCI BAR (memory or IO) */
 extern void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long max);
+/* Create a virtual mapping cookie for a port on a given PCI device.
+ * Do not call this directly, it exists to make it easier for architectures
+ * to override */
+#ifdef CONFIG_NO_GENERIC_PCI_IOPORT_MAP
+extern void __iomem *__pci_ioport_map(struct pci_dev *dev, unsigned long port,
+                                      unsigned int nr);
 #else
+#define __pci_ioport_map(dev, port, nr) ioport_map((port), (nr))
+#endif
+
+#elif defined(CONFIG_GENERIC_PCI_IOMAP)
 static inline void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long max)
 {
         return NULL;
diff --git a/include/asm-generic/poll.h b/include/asm-generic/poll.h
index 44bce836d35..9ce7f44aebd 100644
--- a/include/asm-generic/poll.h
+++ b/include/asm-generic/poll.h
@@ -28,6 +28,8 @@
 #define POLLRDHUP       0x2000
 #endif
 
+#define POLLFREE        0x4000  /* currently only for epoll */
+
 struct pollfd {
         int fd;
         short events;
diff --git a/include/asm-generic/socket.h b/include/asm-generic/socket.h
index 49c1704173e..b1bea03274d 100644
--- a/include/asm-generic/socket.h
+++ b/include/asm-generic/socket.h
@@ -67,4 +67,9 @@
 
 #define SO_WIFI_STATUS          41
 #define SCM_WIFI_STATUS SO_WIFI_STATUS
+#define SO_PEEK_OFF             42
+
+/* Instruct lower device to use last 4-bytes of skb data as FCS */
+#define SO_NOFCS                43
+
 #endif /* __ASM_GENERIC_SOCKET_H */
diff --git a/include/crypto/scatterwalk.h b/include/crypto/scatterwalk.h
index 4fd95a323be..3744d2a642d 100644
--- a/include/crypto/scatterwalk.h
+++ b/include/crypto/scatterwalk.h
@@ -25,28 +25,6 @@
 #include <linux/scatterlist.h>
 #include <linux/sched.h>
 
-static inline enum km_type crypto_kmap_type(int out)
-{
-        enum km_type type;
-
-        if (in_softirq())
-                type = out * (KM_SOFTIRQ1 - KM_SOFTIRQ0) + KM_SOFTIRQ0;
-        else
-                type = out * (KM_USER1 - KM_USER0) + KM_USER0;
-
-        return type;
-}
-
-static inline void *crypto_kmap(struct page *page, int out)
-{
-        return kmap_atomic(page, crypto_kmap_type(out));
-}
-
-static inline void crypto_kunmap(void *vaddr, int out)
-{
-        kunmap_atomic(vaddr, crypto_kmap_type(out));
-}
-
 static inline void crypto_yield(u32 flags)
 {
         if (flags & CRYPTO_TFM_REQ_MAY_SLEEP)
@@ -121,15 +99,15 @@ static inline struct page *scatterwalk_page(struct scatter_walk *walk)
         return sg_page(walk->sg) + (walk->offset >> PAGE_SHIFT);
 }
 
-static inline void scatterwalk_unmap(void *vaddr, int out)
+static inline void scatterwalk_unmap(void *vaddr)
 {
-        crypto_kunmap(vaddr, out);
+        kunmap_atomic(vaddr);
 }
 
 void scatterwalk_start(struct scatter_walk *walk, struct scatterlist *sg);
 void scatterwalk_copychunks(void *buf, struct scatter_walk *walk,
                             size_t nbytes, int out);
-void *scatterwalk_map(struct scatter_walk *walk, int out);
+void *scatterwalk_map(struct scatter_walk *walk);
 void scatterwalk_done(struct scatter_walk *walk, int out, int more);
 
 void scatterwalk_map_and_copy(void *buf, struct scatterlist *sg,
diff --git a/include/drm/Kbuild b/include/drm/Kbuild
index a5c0e10fd47..1e38a19d68f 100644
--- a/include/drm/Kbuild
+++ b/include/drm/Kbuild
@@ -2,6 +2,7 @@ header-y += drm.h
 header-y += drm_fourcc.h
 header-y += drm_mode.h
 header-y += drm_sarea.h
+header-y += exynos_drm.h
 header-y += i810_drm.h
 header-y += i915_drm.h
 header-y += mga_drm.h
diff --git a/include/drm/drmP.h b/include/drm/drmP.h
index 76caa67c22e..92f0981b5fb 100644
--- a/include/drm/drmP.h
+++ b/include/drm/drmP.h
@@ -1328,6 +1328,7 @@ extern int drm_getmagic(struct drm_device *dev, void *data,
                         struct drm_file *file_priv);
 extern int drm_authmagic(struct drm_device *dev, void *data,
                          struct drm_file *file_priv);
+extern int drm_remove_magic(struct drm_master *master, drm_magic_t magic);
 
 /* Cache management (drm_cache.c) */
 void drm_clflush_pages(struct page *pages[], unsigned long num_pages);
diff --git a/include/drm/exynos_drm.h b/include/drm/exynos_drm.h
index 5e120f1c5cd..1ed3aae893a 100644
--- a/include/drm/exynos_drm.h
+++ b/include/drm/exynos_drm.h
@@ -97,15 +97,30 @@ struct drm_exynos_plane_set_zpos {
 #define DRM_IOCTL_EXYNOS_PLANE_SET_ZPOS DRM_IOWR(DRM_COMMAND_BASE + \
                 DRM_EXYNOS_PLANE_SET_ZPOS, struct drm_exynos_plane_set_zpos)
 
+#ifdef __KERNEL__
+
 /**
- * Platform Specific Structure for DRM based FIMD.
+ * A structure for lcd panel information.
  *
  * @timing: default video mode for initializing
+ * @width_mm: physical size of lcd width.
+ * @height_mm: physical size of lcd height.
+ */
+struct exynos_drm_panel_info {
+        struct fb_videomode timing;
+        u32 width_mm;
+        u32 height_mm;
+};
+
+/**
+ * Platform Specific Structure for DRM based FIMD.
+ *
+ * @panel: default panel info for initializing
  * @default_win: default window layer number to be used for UI.
  * @bpp: default bit per pixel.
  */
 struct exynos_drm_fimd_pdata {
-        struct fb_videomode             timing;
+        struct exynos_drm_panel_info panel;
         u32                             vidcon0;
         u32                             vidcon1;
         unsigned int                    default_win;
@@ -139,4 +154,5 @@ struct exynos_drm_hdmi_pdata {
         unsigned int                    bpp;
 };
 
-#endif
+#endif  /* __KERNEL__ */
+#endif  /* _EXYNOS_DRM_H_ */
diff --git a/include/keys/user-type.h b/include/keys/user-type.h
index c37c34275a4..bc9ec1d7698 100644
--- a/include/keys/user-type.h
+++ b/include/keys/user-type.h
@@ -17,7 +17,7 @@
 
 /*****************************************************************************/
 /*
- * the payload for a key of type "user"
+ * the payload for a key of type "user" or "logon"
  * - once filled in and attached to a key:
  *   - the payload struct is invariant may not be changed, only replaced
  *   - the payload must be read with RCU procedures or with the key semaphore
@@ -33,6 +33,7 @@ struct user_key_payload {
 };
 
 extern struct key_type key_type_user;
+extern struct key_type key_type_logon;
 
 extern int user_instantiate(struct key *key, const void *data, size_t datalen);
 extern int user_update(struct key *key, const void *data, size_t datalen);
diff --git a/include/linux/Kbuild b/include/linux/Kbuild
index c94e71781b7..a2555538109 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/altera_uart.h b/include/linux/altera_uart.h
index a10a9079197..c022c82db7c 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/serial.h b/include/linux/amba/serial.h
index 514ed45c462..d117b29d106 100644
--- a/include/linux/amba/serial.h
+++ b/include/linux/amba/serial.h
@@ -23,6 +23,8 @@
 #ifndef ASM_ARM_HARDWARE_SERIAL_AMBA_H
 #define ASM_ARM_HARDWARE_SERIAL_AMBA_H
 
+#include <linux/types.h>
+
 /* -------------------------------------------------------------------------------
  *  From AMBA UART (PL010) Block Specification
  * -------------------------------------------------------------------------------
diff --git a/include/linux/bcma/bcma.h b/include/linux/bcma/bcma.h
index 83c209f3949..5af9a075498 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 a33086a7530..8bbfe31fbac 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 3871b668caf..46c71e27d31 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 9faae2ae02e..5a71d571964 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 fd88a3945aa..0092102db2d 100644
--- a/include/linux/binfmts.h
+++ b/include/linux/binfmts.h
@@ -18,7 +18,7 @@ struct pt_regs;
 #define BINPRM_BUF_SIZE 128
 
 #ifdef __KERNEL__
-#include <linux/list.h>
+#include <linux/sched.h>
 
 #define CORENAME_MAX_SIZE 128
 
@@ -58,6 +58,7 @@ struct linux_binprm {
         unsigned interp_flags;
         unsigned interp_data;
         unsigned long loader, exec;
+        char tcomm[TASK_COMM_LEN];
 };
 
 #define BINPRM_FLAGS_ENFORCE_NONDUMP_BIT 0
diff --git a/include/linux/bio.h b/include/linux/bio.h
index 129a9c09795..de5422a5751 100644
--- a/include/linux/bio.h
+++ b/include/linux/bio.h
@@ -101,10 +101,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 +317,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 +328,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/bitops.h b/include/linux/bitops.h
index 3c1063acb2a..94300fe46cc 100644
--- a/include/linux/bitops.h
+++ b/include/linux/bitops.h
@@ -56,6 +56,26 @@ static inline unsigned long hweight_long(unsigned long w)
 }
 
 /**
+ * rol64 - rotate a 64-bit value left
+ * @word: value to rotate
+ * @shift: bits to roll
+ */
+static inline __u64 rol64(__u64 word, unsigned int shift)
+{
+        return (word << shift) | (word >> (64 - shift));
+}
+
+/**
+ * ror64 - rotate a 64-bit value right
+ * @word: value to rotate
+ * @shift: bits to roll
+ */
+static inline __u64 ror64(__u64 word, unsigned int shift)
+{
+        return (word >> shift) | (word << (64 - shift));
+}
+
+/**
  * rol32 - rotate a 32-bit value left
  * @word: value to rotate
  * @shift: bits to roll
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 6c6a1f00806..606cf339bb5 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -399,9 +399,6 @@ struct request_queue {
         /* Throttle data */
         struct throtl_data *td;
 #endif
-#ifdef CONFIG_LOCKDEP
-        int                     ioc_release_depth;
-#endif
 };
 
 #define QUEUE_FLAG_QUEUED       1       /* uses generic tag queueing */
diff --git a/include/linux/can/dev.h b/include/linux/can/dev.h
index a0969fcb72b..5d2efe7e3f1 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 35eae4b6750..7c48029dffe 100644
--- a/include/linux/cdrom.h
+++ b/include/linux/cdrom.h
@@ -952,7 +952,8 @@ struct cdrom_device_info {
         char name[20];                  /* name of the device type */
 /* per-device flags */
         __u8 sanyo_slot         : 2;    /* Sanyo 3 CD changer support */
-        __u8 reserved           : 6;    /* not used yet */
+        __u8 keeplocked         : 1;    /* CDROM_LOCKDOOR status */
+        __u8 reserved           : 5;    /* not used yet */
         int cdda_method;                /* see flags */
         __u8 last_sense;
         __u8 media_written;             /* dirty flag, DVD+RW bookkeeping */
diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h
index e9b602151ca..501adb1b2f4 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;
@@ -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/clocksource.h b/include/linux/clocksource.h
index 081147da056..fbe89e17124 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/compat.h b/include/linux/compat.h
index 41c9f6515f4..7e05fcee75a 100644
--- a/include/linux/compat.h
+++ b/include/linux/compat.h
@@ -561,5 +561,9 @@ asmlinkage ssize_t compat_sys_process_vm_writev(compat_pid_t pid,
                 unsigned long liovcnt, const struct compat_iovec __user *rvec,
                 unsigned long riovcnt, unsigned long flags);
 
+#else
+
+#define is_compat_task() (0)
+
 #endif /* CONFIG_COMPAT */
 #endif /* _LINUX_COMPAT_H */
diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index 4a243546d14..923d093c9ce 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 3c9c54fd569..76384074262 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 1f6587590a1..6e53b4823d7 100644
--- a/include/linux/cpu.h
+++ b/include/linux/cpu.h
@@ -44,6 +44,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/dcache.h b/include/linux/dcache.h
index d64a55b23af..ff5f5256d17 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -47,27 +47,6 @@ struct dentry_stat_t {
 };
 extern struct dentry_stat_t dentry_stat;
 
-/*
- * Compare 2 name strings, return 0 if they match, otherwise non-zero.
- * The strings are both count bytes long, and count is non-zero.
- */
-static inline int dentry_cmp(const unsigned char *cs, size_t scount,
-                                const unsigned char *ct, size_t tcount)
-{
-        int ret;
-        if (scount != tcount)
-                return 1;
-        do {
-                ret = (*cs != *ct);
-                if (ret)
-                        break;
-                cs++;
-                ct++;
-                tcount--;
-        } while (tcount);
-        return ret;
-}
-
 /* Name hashing routines. Initial hash value */
 /* Hash courtesy of the R5 hash in reiserfs modulo sign bits */
 #define init_name_hash()                0
@@ -89,14 +68,7 @@ static inline unsigned long end_name_hash(unsigned long hash)
 }
 
 /* Compute the hash for a name string. */
-static inline unsigned int
-full_name_hash(const unsigned char *name, unsigned int len)
-{
-        unsigned long hash = init_name_hash();
-        while (len--)
-                hash = partial_name_hash(*name++, hash);
-        return end_name_hash(hash);
-}
+extern unsigned int full_name_hash(const unsigned char *, unsigned int);
 
 /*
  * Try to keep struct dentry aligned on 64 byte cachelines (this will
@@ -309,7 +281,8 @@ extern struct dentry *d_ancestor(struct dentry *, struct dentry *);
 extern struct dentry *d_lookup(struct dentry *, struct qstr *);
 extern struct dentry *d_hash_and_lookup(struct dentry *, struct qstr *);
 extern struct dentry *__d_lookup(struct dentry *, struct qstr *);
-extern struct dentry *__d_lookup_rcu(struct dentry *parent, struct qstr *name,
+extern struct dentry *__d_lookup_rcu(const struct dentry *parent,
+                                const struct qstr *name,
                                 unsigned *seq, struct inode **inode);
 
 /**
diff --git a/include/linux/dccp.h b/include/linux/dccp.h
index 710c04302a1..eaf95a023af 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/devfreq.h b/include/linux/devfreq.h
index 98ce8124b1c..281c72a3b9d 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 5b3adb8f958..7c46bc32fcb 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);
@@ -279,11 +277,11 @@ struct device *driver_find_device(struct device_driver *drv,
 
 /**
  * struct subsys_interface - interfaces to device functions
- * @name        name of the device function
- * @subsystem   subsytem of the devices to attach to
- * @node        the list of functions registered at the subsystem
- * @add         device hookup to device function handler
- * @remove      device hookup to device function handler
+ * @name:       name of the device function
+ * @subsys:     subsytem of the devices to attach to
+ * @node:       the list of functions registered at the subsystem
+ * @add_dev:    device hookup to device function handler
+ * @remove_dev: device hookup to device function handler
  *
  * Simple interfaces attached to a subsystem. Multiple interfaces can
  * attach to a subsystem and its devices. Unlike drivers, they do not
@@ -612,6 +610,7 @@ struct device_dma_parameters {
  * @archdata:   For arch-specific additions.
  * @of_node:    Associated device tree node.
  * @devt:       For creating the sysfs "dev".
+ * @id:         device instance
  * @devres_lock: Spinlock to protect the resource of the device.
  * @devres_head: The resources list of the device.
  * @knode_class: The node used to add the device to the class list.
@@ -945,14 +944,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...)                            \
 ({                                                              \
@@ -1003,18 +1002,23 @@ extern long sysfs_deprecated;
  * Each module may only use this macro once, and calling it replaces
  * module_init() and module_exit().
  *
+ * @__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/digsig.h b/include/linux/digsig.h
index b01558b1581..6f85a070bb4 100644
--- a/include/linux/digsig.h
+++ b/include/linux/digsig.h
@@ -30,7 +30,7 @@ enum digest_algo {
 
 struct pubkey_hdr {
         uint8_t         version;        /* key format version */
-        time_t          timestamp;      /* key made, always 0 for now */
+        uint32_t        timestamp;      /* key made, always 0 for now */
         uint8_t         algo;
         uint8_t         nmpi;
         char            mpi[0];
@@ -38,7 +38,7 @@ struct pubkey_hdr {
 
 struct signature_hdr {
         uint8_t         version;        /* signature format version */
-        time_t          timestamp;      /* signature made */
+        uint32_t        timestamp;      /* signature made */
         uint8_t         algo;
         uint8_t         hash;
         uint8_t         keyid[8];
diff --git a/include/linux/dynamic_debug.h b/include/linux/dynamic_debug.h
index 0564e3c3988..7e3c53a900d 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/elevator.h b/include/linux/elevator.h
index c24f3d7fbf1..7d4e0356f32 100644
--- a/include/linux/elevator.h
+++ b/include/linux/elevator.h
@@ -42,12 +42,6 @@ struct elevator_ops
         elevator_merged_fn *elevator_merged_fn;
         elevator_merge_req_fn *elevator_merge_req_fn;
         elevator_allow_merge_fn *elevator_allow_merge_fn;
-
-        /*
-         * Used for both plugged list and elevator merging and in the
-         * former case called without queue_lock.  Read comment on top of
-         * attempt_plug_merge() for details.
-         */
         elevator_bio_merged_fn *elevator_bio_merged_fn;
 
         elevator_dispatch_fn *elevator_dispatch_fn;
@@ -122,7 +116,6 @@ extern void elv_dispatch_add_tail(struct request_queue *, struct request *);
 extern void elv_add_request(struct request_queue *, struct request *, int);
 extern void __elv_add_request(struct request_queue *, struct request *, int);
 extern int elv_merge(struct request_queue *, struct request **, struct bio *);
-extern int elv_try_merge(struct request *, struct bio *);
 extern void elv_merge_requests(struct request_queue *, struct request *,
                                struct request *);
 extern void elv_merged_request(struct request_queue *, struct request *, int);
@@ -155,7 +148,7 @@ extern ssize_t elv_iosched_store(struct request_queue *, const char *, size_t);
 extern int elevator_init(struct request_queue *, char *);
 extern void elevator_exit(struct elevator_queue *);
 extern int elevator_change(struct request_queue *, const char *);
-extern int elv_rq_merge_ok(struct request *, struct bio *);
+extern bool elv_rq_merge_ok(struct request *, struct bio *);
 
 /*
  * Helper functions.
diff --git a/include/linux/errno.h b/include/linux/errno.h
index 46685832ed9..2d09bfa5c26 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 05955cf0993..8a1835855fa 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 da5b2de99ae..e1d9e0ede30 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/freezer.h b/include/linux/freezer.h
index 0ab54e16a91..d09af4b67cf 100644
--- a/include/linux/freezer.h
+++ b/include/linux/freezer.h
@@ -39,6 +39,7 @@ extern bool __refrigerator(bool check_kthr_stop);
 extern int freeze_processes(void);
 extern int freeze_kernel_threads(void);
 extern void thaw_processes(void);
+extern void thaw_kernel_threads(void);
 
 static inline bool try_to_freeze(void)
 {
@@ -174,6 +175,7 @@ static inline bool __refrigerator(bool check_kthr_stop) { return false; }
 static inline int freeze_processes(void) { return -ENOSYS; }
 static inline int freeze_kernel_threads(void) { return -ENOSYS; }
 static inline void thaw_processes(void) {}
+static inline void thaw_kernel_threads(void) {}
 
 static inline bool try_to_freeze(void) { return false; }
 
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 0244082d42c..69cd5bb640f 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -396,6 +396,7 @@ struct inodes_stat_t {
 #include <linux/rculist_bl.h>
 #include <linux/atomic.h>
 #include <linux/shrinker.h>
+#include <linux/migrate_mode.h>
 
 #include <asm/byteorder.h>
 
@@ -526,7 +527,6 @@ enum positive_aop_returns {
 struct page;
 struct address_space;
 struct writeback_control;
-enum migrate_mode;
 
 struct iov_iter {
         const struct iovec *iov;
@@ -2496,6 +2496,7 @@ extern void get_filesystem(struct file_system_type *fs);
 extern void put_filesystem(struct file_system_type *fs);
 extern struct file_system_type *get_fs_type(const char *name);
 extern struct super_block *get_super(struct block_device *);
+extern struct super_block *get_super_thawed(struct block_device *);
 extern struct super_block *get_active_super(struct block_device *bdev);
 extern void drop_super(struct super_block *sb);
 extern void iterate_supers(void (*)(struct super_block *, void *), void *);
diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h
index 028e26f0bf0..72a6cabb4d5 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 c3da42dd22b..dd478fc8f9f 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/genhd.h b/include/linux/genhd.h
index fe23ee76858..e61d3192448 100644
--- a/include/linux/genhd.h
+++ b/include/linux/genhd.h
@@ -596,6 +596,7 @@ extern char *disk_name (struct gendisk *hd, int partno, char *buf);
 
 extern int disk_expand_part_tbl(struct gendisk *disk, int target);
 extern int rescan_partitions(struct gendisk *disk, struct block_device *bdev);
+extern int invalidate_partitions(struct gendisk *disk, struct block_device *bdev);
 extern struct hd_struct * __must_check add_partition(struct gendisk *disk,
                                                      int partno, sector_t start,
                                                      sector_t len, int flags,
diff --git a/include/linux/gpio_keys.h b/include/linux/gpio_keys.h
index b5ca4b2c08e..004ff33ab38 100644
--- a/include/linux/gpio_keys.h
+++ b/include/linux/gpio_keys.h
@@ -1,6 +1,8 @@
 #ifndef _GPIO_KEYS_H
 #define _GPIO_KEYS_H
 
+struct device;
+
 struct gpio_keys_button {
         /* Configuration parameters */
         unsigned int code;      /* input event code (KEY_*, SW_*) */
diff --git a/include/linux/highmem.h b/include/linux/highmem.h
index 3a93f73a8ac..6549ed75e0a 100644
--- a/include/linux/highmem.h
+++ b/include/linux/highmem.h
@@ -55,12 +55,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 +109,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 +215,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 +234,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 +263,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 +276,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/hyperv.h b/include/linux/hyperv.h
index 62b908e0e59..5852545e6bb 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>
@@ -35,7 +202,7 @@
 #include <linux/mod_devicetable.h>
 
 
-#define MAX_PAGE_BUFFER_COUNT                           18
+#define MAX_PAGE_BUFFER_COUNT                           19
 #define MAX_MULTIPAGE_BUFFER_COUNT                      32 /* 128K */
 
 #pragma pack(push, 1)
@@ -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/if.h b/include/linux/if.h
index 06b6ef60c82..f995c663c49 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_link.h b/include/linux/if_link.h
index c52d4b5f872..4b24ff453ae 100644
--- a/include/linux/if_link.h
+++ b/include/linux/if_link.h
@@ -137,6 +137,7 @@ enum {
         IFLA_AF_SPEC,
         IFLA_GROUP,             /* Group the device belongs to */
         IFLA_NET_NS_FD,
+        IFLA_EXT_MASK,          /* Extended info mask, VFs, etc */
         __IFLA_MAX
 };
 
diff --git a/include/linux/if_ppp.h b/include/linux/if_ppp.h
index c9ad3832257..9048fabb7a4 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_team.h b/include/linux/if_team.h
index 828181fbad5..58404b0c501 100644
--- a/include/linux/if_team.h
+++ b/include/linux/if_team.h
@@ -46,6 +46,10 @@ struct team_port {
         u32 speed;
         u8 duplex;
 
+        /* Custom gennetlink interface related flags */
+        bool changed;
+        bool removed;
+
         struct rcu_head rcu;
 };
 
@@ -72,6 +76,10 @@ struct team_option {
         enum team_option_type type;
         int (*getter)(struct team *team, void *arg);
         int (*setter)(struct team *team, void *arg);
+
+        /* Custom gennetlink interface related flags */
+        bool changed;
+        bool removed;
 };
 
 struct team_mode {
@@ -207,6 +215,7 @@ enum {
         TEAM_ATTR_OPTION_CHANGED,       /* flag */
         TEAM_ATTR_OPTION_TYPE,          /* u8 */
         TEAM_ATTR_OPTION_DATA,          /* dynamic */
+        TEAM_ATTR_OPTION_REMOVED,       /* flag */
 
         __TEAM_ATTR_OPTION_MAX,
         TEAM_ATTR_OPTION_MAX = __TEAM_ATTR_OPTION_MAX - 1,
@@ -227,6 +236,7 @@ enum {
         TEAM_ATTR_PORT_LINKUP,          /* flag */
         TEAM_ATTR_PORT_SPEED,           /* u32 */
         TEAM_ATTR_PORT_DUPLEX,          /* u8 */
+        TEAM_ATTR_PORT_REMOVED,         /* flag */
 
         __TEAM_ATTR_PORT_MAX,
         TEAM_ATTR_PORT_MAX = __TEAM_ATTR_PORT_MAX - 1,
diff --git a/include/linux/if_vlan.h b/include/linux/if_vlan.h
index 13aff1e2183..33a6e1951d4 100644
--- a/include/linux/if_vlan.h
+++ b/include/linux/if_vlan.h
@@ -18,10 +18,9 @@
 #include <linux/etherdevice.h>
 #include <linux/rtnetlink.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 +176,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 01129c0ea87..e0337f11d92 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 097a34b5556..5c83d9e3eb8 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 5f8146695b7..597f4a9f324 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 9c66b1ada9d..f994d51f70f 100644
--- a/include/linux/init_task.h
+++ b/include/linux/init_task.h
@@ -149,7 +149,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),                    \
diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h
index a64b00e286f..3f830e00511 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/iocontext.h b/include/linux/iocontext.h
index 7e1371c4bcc..1a301806303 100644
--- a/include/linux/iocontext.h
+++ b/include/linux/iocontext.h
@@ -6,8 +6,11 @@
 #include <linux/workqueue.h>
 
 enum {
-        ICQ_IOPRIO_CHANGED,
-        ICQ_CGROUP_CHANGED,
+        ICQ_IOPRIO_CHANGED      = 1 << 0,
+        ICQ_CGROUP_CHANGED      = 1 << 1,
+        ICQ_EXITED              = 1 << 2,
+
+        ICQ_CHANGED_MASK        = ICQ_IOPRIO_CHANGED | ICQ_CGROUP_CHANGED,
 };
 
 /*
@@ -88,7 +91,7 @@ struct io_cq {
                 struct rcu_head         __rcu_head;
         };
 
-        unsigned long           changed;
+        unsigned int            flags;
 };
 
 /*
@@ -133,16 +136,16 @@ static inline struct io_context *ioc_task_link(struct io_context *ioc)
 
 struct task_struct;
 #ifdef CONFIG_BLOCK
-void put_io_context(struct io_context *ioc, struct request_queue *locked_q);
+void put_io_context(struct io_context *ioc);
 void exit_io_context(struct task_struct *task);
 struct io_context *get_task_io_context(struct task_struct *task,
                                        gfp_t gfp_flags, int node);
 void ioc_ioprio_changed(struct io_context *ioc, int ioprio);
 void ioc_cgroup_changed(struct io_context *ioc);
+unsigned int icq_get_changed(struct io_cq *icq);
 #else
 struct io_context;
-static inline void put_io_context(struct io_context *ioc,
-                                  struct request_queue *locked_q) { }
+static inline void put_io_context(struct io_context *ioc) { }
 static inline void exit_io_context(struct task_struct *task) { }
 #endif
 
diff --git a/include/linux/ipv6.h b/include/linux/ipv6.h
index 6318268dcaf..8260ef77976 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 bd4272b61a1..ead4a421579 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 4ccf95d681b..292f27a793d 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/jump_label.h b/include/linux/jump_label.h
index 5ce8b140428..c513a40510f 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/kbd_kern.h b/include/linux/kbd_kern.h
index ec2d17bc1f1..daf4a3a40ee 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.h b/include/linux/kernel.h
index e8343422240..d801acb5e68 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -85,6 +85,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; })
 
diff --git a/include/linux/kexec.h b/include/linux/kexec.h
index 2fa0901219d..0d7d6a1b172 100644
--- a/include/linux/kexec.h
+++ b/include/linux/kexec.h
@@ -50,9 +50,11 @@
  * note header.  For kdump, the code in vmcore.c runs in the context
  * of the second kernel to combine them into one note.
  */
+#ifndef KEXEC_NOTE_BYTES
 #define KEXEC_NOTE_BYTES ( (KEXEC_NOTE_HEAD_BYTES * 2) +                \
                             KEXEC_CORE_NOTE_NAME_BYTES +                \
                             KEXEC_CORE_NOTE_DESC_BYTES )
+#endif
 
 /*
  * This structure is used to hold the arguments that are used when loading
diff --git a/include/linux/keyboard.h b/include/linux/keyboard.h
index 33a63f62d57..86e5214ae73 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/kmsg_dump.h b/include/linux/kmsg_dump.h
index fee66317e07..35f7237ec97 100644
--- a/include/linux/kmsg_dump.h
+++ b/include/linux/kmsg_dump.h
@@ -15,13 +15,18 @@
 #include <linux/errno.h>
 #include <linux/list.h>
 
+/*
+ * Keep this list arranged in rough order of priority. Anything listed after
+ * KMSG_DUMP_OOPS will not be logged by default unless printk.always_kmsg_dump
+ * is passed to the kernel.
+ */
 enum kmsg_dump_reason {
-        KMSG_DUMP_OOPS,
         KMSG_DUMP_PANIC,
+        KMSG_DUMP_OOPS,
+        KMSG_DUMP_EMERG,
         KMSG_DUMP_RESTART,
         KMSG_DUMP_HALT,
         KMSG_DUMP_POWEROFF,
-        KMSG_DUMP_EMERG,
 };
 
 /**
diff --git a/include/linux/lp8727.h b/include/linux/lp8727.h
index d21fa2865bf..d21fa2865bf 100755..100644
--- a/include/linux/lp8727.h
+++ b/include/linux/lp8727.h
diff --git a/include/linux/math64.h b/include/linux/math64.h
index 23fcdfcba81..b8ba8554472 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 b1494aced21..dfb947959ec 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 4d34356fe64..b80de520670 100644
--- a/include/linux/memcontrol.h
+++ b/include/linux/memcontrol.h
@@ -129,7 +129,6 @@ extern void mem_cgroup_print_oom_info(struct mem_cgroup *memcg,
 extern void mem_cgroup_replace_page_cache(struct page *oldpage,
                                         struct page *newpage);
 
-extern void mem_cgroup_reset_owner(struct page *page);
 #ifdef CONFIG_CGROUP_MEM_RES_CTLR_SWAP
 extern int do_swap_account;
 #endif
@@ -392,10 +391,6 @@ static inline void mem_cgroup_replace_page_cache(struct page *oldpage,
                                 struct page *newpage)
 {
 }
-
-static inline void mem_cgroup_reset_owner(struct page *page)
-{
-}
 #endif /* CONFIG_CGROUP_MEM_CONT */
 
 #if !defined(CONFIG_CGROUP_MEM_RES_CTLR) || !defined(CONFIG_DEBUG_VM)
diff --git a/include/linux/mfd/mcp.h b/include/linux/mfd/mcp.h
index 1515e64e366..f88c1cc0cb0 100644
--- a/include/linux/mfd/mcp.h
+++ b/include/linux/mfd/mcp.h
@@ -10,7 +10,6 @@
 #ifndef MCP_H
 #define MCP_H
 
-#include <linux/mod_devicetable.h>
 #include <mach/dma.h>
 
 struct mcp_ops;
@@ -27,7 +26,7 @@ struct mcp {
         dma_device_t    dma_telco_rd;
         dma_device_t    dma_telco_wr;
         struct device   attached_device;
-        const char      *codec;
+        int             gpio_base;
 };
 
 struct mcp_ops {
@@ -45,11 +44,10 @@ void mcp_reg_write(struct mcp *, unsigned int, unsigned int);
 unsigned int mcp_reg_read(struct mcp *, unsigned int);
 void mcp_enable(struct mcp *);
 void mcp_disable(struct mcp *);
-const struct mcp_device_id *mcp_get_device_id(const struct mcp *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 *);
+int mcp_host_register(struct mcp *);
 void mcp_host_unregister(struct mcp *);
 
 struct mcp_driver {
@@ -58,7 +56,6 @@ struct mcp_driver {
         void (*remove)(struct mcp *);
         int (*suspend)(struct mcp *, pm_message_t);
         int (*resume)(struct mcp *);
-        const struct mcp_device_id *id_table;
 };
 
 int mcp_driver_register(struct mcp_driver *);
@@ -67,6 +64,9 @@ void mcp_driver_unregister(struct mcp_driver *);
 #define mcp_get_drvdata(mcp)    dev_get_drvdata(&(mcp)->attached_device)
 #define mcp_set_drvdata(mcp,d)  dev_set_drvdata(&(mcp)->attached_device, d)
 
-#define mcp_priv(mcp)           ((void *)((mcp)+1))
+static inline void *mcp_priv(struct mcp *mcp)
+{
+        return mcp + 1;
+}
 
 #endif
diff --git a/include/linux/mfd/twl6040.h b/include/linux/mfd/twl6040.h
index 2463c261959..9bc9ac651da 100644
--- a/include/linux/mfd/twl6040.h
+++ b/include/linux/mfd/twl6040.h
@@ -187,8 +187,10 @@ struct twl6040 {
         int rev;
         u8 vibra_ctrl_cache[2];
 
+        /* PLL configuration */
         int pll;
         unsigned int sysclk;
+        unsigned int mclk;
 
         unsigned int irq;
         unsigned int irq_base;
diff --git a/include/linux/mfd/ucb1x00.h b/include/linux/mfd/ucb1x00.h
index bc19e5fb7ea..4321f044d1e 100644
--- a/include/linux/mfd/ucb1x00.h
+++ b/include/linux/mfd/ucb1x00.h
@@ -104,9 +104,6 @@
 #define UCB_MODE_DYN_VFLAG_ENA  (1 << 12)
 #define UCB_MODE_AUD_OFF_CAN    (1 << 13)
 
-struct ucb1x00_plat_data {
-        int             gpio_base;
-};
 
 struct ucb1x00_irq {
         void *devid;
@@ -119,7 +116,7 @@ struct ucb1x00 {
         unsigned int            irq;
         struct semaphore        adc_sem;
         spinlock_t              io_lock;
-        const struct mcp_device_id *id;
+        u16                     id;
         u16                     io_dir;
         u16                     io_out;
         u16                     adc_cr;
diff --git a/include/linux/migrate.h b/include/linux/migrate.h
index eaf867412f7..05ed2828a55 100644
--- a/include/linux/migrate.h
+++ b/include/linux/migrate.h
@@ -3,22 +3,10 @@
 
 #include <linux/mm.h>
 #include <linux/mempolicy.h>
+#include <linux/migrate_mode.h>
 
 typedef struct page *new_page_t(struct page *, unsigned long private, int **);
 
-/*
- * MIGRATE_ASYNC means never block
- * MIGRATE_SYNC_LIGHT in the current implementation means to allow blocking
- *      on most operations but not ->writepage as the potential stall time
- *      is too significant
- * MIGRATE_SYNC will block when migrating pages
- */
-enum migrate_mode {
-        MIGRATE_ASYNC,
-        MIGRATE_SYNC_LIGHT,
-        MIGRATE_SYNC,
-};
-
 #ifdef CONFIG_MIGRATION
 #define PAGE_MIGRATION 1
 
diff --git a/include/linux/migrate_mode.h b/include/linux/migrate_mode.h
new file mode 100644
index 00000000000..ebf3d89a391
--- /dev/null
+++ b/include/linux/migrate_mode.h
@@ -0,0 +1,16 @@
+#ifndef MIGRATE_MODE_H_INCLUDED
+#define MIGRATE_MODE_H_INCLUDED
+/*
+ * MIGRATE_ASYNC means never block
+ * MIGRATE_SYNC_LIGHT in the current implementation means to allow blocking
+ *      on most operations but not ->writepage as the potential stall time
+ *      is too significant
+ * MIGRATE_SYNC will block when migrating pages
+ */
+enum migrate_mode {
+        MIGRATE_ASYNC,
+        MIGRATE_SYNC_LIGHT,
+        MIGRATE_SYNC,
+};
+
+#endif          /* MIGRATE_MODE_H_INCLUDED */
diff --git a/include/linux/mlx4/device.h b/include/linux/mlx4/device.h
index 5c4fe8e5bfe..44d8144e9ae 100644
--- a/include/linux/mlx4/device.h
+++ b/include/linux/mlx4/device.h
@@ -621,7 +621,11 @@ void mlx4_unregister_mac(struct mlx4_dev *dev, u8 port, u64 mac);
 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/qp.h b/include/linux/mlx4/qp.h
index bee8fa23127..091f9e7dc8b 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/mmc/card.h b/include/linux/mmc/card.h
index 9f22ba572de..19a41d1737a 100644
--- a/include/linux/mmc/card.h
+++ b/include/linux/mmc/card.h
@@ -217,6 +217,7 @@ struct mmc_card {
 #define MMC_CARD_SDXC           (1<<6)          /* card is SDXC */
 #define MMC_CARD_REMOVED        (1<<7)          /* card has been removed */
 #define MMC_STATE_HIGHSPEED_200 (1<<8)          /* card is in HS200 mode */
+#define MMC_STATE_SLEEP         (1<<9)          /* card is in sleep state */
         unsigned int            quirks;         /* card quirks */
 #define MMC_QUIRK_LENIENT_FN0   (1<<0)          /* allow SDIO FN0 writes outside of the VS CCCR range */
 #define MMC_QUIRK_BLKSZ_FOR_BYTE_MODE (1<<1)    /* use func->cur_blksize */
@@ -382,6 +383,7 @@ static inline void __maybe_unused remove_quirk(struct mmc_card *card, int data)
 #define mmc_sd_card_uhs(c)      ((c)->state & MMC_STATE_ULTRAHIGHSPEED)
 #define mmc_card_ext_capacity(c) ((c)->state & MMC_CARD_SDXC)
 #define mmc_card_removed(c)     ((c) && ((c)->state & MMC_CARD_REMOVED))
+#define mmc_card_is_sleep(c)    ((c)->state & MMC_STATE_SLEEP)
 
 #define mmc_card_set_present(c) ((c)->state |= MMC_STATE_PRESENT)
 #define mmc_card_set_readonly(c) ((c)->state |= MMC_STATE_READONLY)
@@ -393,7 +395,9 @@ static inline void __maybe_unused remove_quirk(struct mmc_card *card, int data)
 #define mmc_sd_card_set_uhs(c) ((c)->state |= MMC_STATE_ULTRAHIGHSPEED)
 #define mmc_card_set_ext_capacity(c) ((c)->state |= MMC_CARD_SDXC)
 #define mmc_card_set_removed(c) ((c)->state |= MMC_CARD_REMOVED)
+#define mmc_card_set_sleep(c)   ((c)->state |= MMC_STATE_SLEEP)
 
+#define mmc_card_clr_sleep(c)   ((c)->state &= ~MMC_STATE_SLEEP)
 /*
  * Quirk add/remove for MMC products.
  */
diff --git a/include/linux/mmc/dw_mmc.h b/include/linux/mmc/dw_mmc.h
index e8779c6d175..aae5d1f1bb3 100644
--- a/include/linux/mmc/dw_mmc.h
+++ b/include/linux/mmc/dw_mmc.h
@@ -14,6 +14,8 @@
 #ifndef LINUX_MMC_DW_MMC_H
 #define LINUX_MMC_DW_MMC_H
 
+#include <linux/scatterlist.h>
+
 #define MAX_MCI_SLOTS   2
 
 enum dw_mci_state {
@@ -40,7 +42,7 @@ struct mmc_data;
  * @lock: Spinlock protecting the queue and associated data.
  * @regs: Pointer to MMIO registers.
  * @sg: Scatterlist entry currently being processed by PIO code, if any.
- * @pio_offset: Offset into the current scatterlist entry.
+ * @sg_miter: PIO mapping scatterlist iterator.
  * @cur_slot: The slot which is currently using the controller.
  * @mrq: The request currently being processed on @cur_slot,
  *      or NULL if the controller is idle.
@@ -115,7 +117,7 @@ struct dw_mci {
         void __iomem            *regs;
 
         struct scatterlist      *sg;
-        unsigned int            pio_offset;
+        struct sg_mapping_iter  sg_miter;
 
         struct dw_mci_slot      *cur_slot;
         struct mmc_request      *mrq;
diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h
index 0beba1e5e1e..ee2b0363c04 100644
--- a/include/linux/mmc/host.h
+++ b/include/linux/mmc/host.h
@@ -257,6 +257,7 @@ struct mmc_host {
 #define MMC_CAP2_HS200_1_2V_SDR (1 << 6)        /* can support */
 #define MMC_CAP2_HS200          (MMC_CAP2_HS200_1_8V_SDR | \
                                  MMC_CAP2_HS200_1_2V_SDR)
+#define MMC_CAP2_BROKEN_VOLTAGE (1 << 7)        /* Use the broken voltage */
 
         mmc_pm_flag_t           pm_caps;        /* supported pm features */
         unsigned int        power_notify_type;
@@ -444,4 +445,23 @@ static inline int mmc_boot_partition_access(struct mmc_host *host)
         return !(host->caps2 & MMC_CAP2_BOOTPART_NOACC);
 }
 
+#ifdef CONFIG_MMC_CLKGATE
+void mmc_host_clk_hold(struct mmc_host *host);
+void mmc_host_clk_release(struct mmc_host *host);
+unsigned int mmc_host_clk_rate(struct mmc_host *host);
+
+#else
+static inline void mmc_host_clk_hold(struct mmc_host *host)
+{
+}
+
+static inline void mmc_host_clk_release(struct mmc_host *host)
+{
+}
+
+static inline unsigned int mmc_host_clk_rate(struct mmc_host *host)
+{
+        return host->ios.clock;
+}
+#endif
 #endif /* LINUX_MMC_HOST_H */
diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetable.h
index b29e7f6f8fa..fb69ad191ad 100644
--- a/include/linux/mod_devicetable.h
+++ b/include/linux/mod_devicetable.h
@@ -436,17 +436,6 @@ struct spi_device_id {
                         __attribute__((aligned(sizeof(kernel_ulong_t))));
 };
 
-/* mcp */
-
-#define MCP_NAME_SIZE   20
-#define MCP_MODULE_PREFIX "mcp:"
-
-struct mcp_device_id {
-        char name[MCP_NAME_SIZE];
-        kernel_ulong_t driver_data      /* Data private to the driver */
-                        __attribute__((aligned(sizeof(kernel_ulong_t))));
-};
-
 /* dmi */
 enum dmi_field {
         DMI_NONE,
@@ -571,4 +560,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/mpi.h b/include/linux/mpi.h
index 06f88994cca..d02cca6cc8c 100644
--- a/include/linux/mpi.h
+++ b/include/linux/mpi.h
@@ -57,8 +57,6 @@ struct gcry_mpi {
 
 typedef struct gcry_mpi *MPI;
 
-#define MPI_NULL NULL
-
 #define mpi_get_nlimbs(a)     ((a)->nlimbs)
 #define mpi_is_neg(a)         ((a)->sign)
 
diff --git a/include/linux/mtd/mtd.h b/include/linux/mtd/mtd.h
index 1a81fde8f33..d43dc25af82 100644
--- a/include/linux/mtd/mtd.h
+++ b/include/linux/mtd/mtd.h
@@ -427,9 +427,7 @@ static inline int mtd_is_locked(struct mtd_info *mtd, loff_t ofs, uint64_t len)
 
 static inline int mtd_suspend(struct mtd_info *mtd)
 {
-        if (!mtd->suspend)
-                return -EOPNOTSUPP;
-        return mtd->suspend(mtd);
+        return mtd->suspend ? mtd->suspend(mtd) : 0;
 }
 
 static inline void mtd_resume(struct mtd_info *mtd)
@@ -441,7 +439,7 @@ static inline void mtd_resume(struct mtd_info *mtd)
 static inline int mtd_block_isbad(struct mtd_info *mtd, loff_t ofs)
 {
         if (!mtd->block_isbad)
-                return -EOPNOTSUPP;
+                return 0;
         return mtd->block_isbad(mtd, ofs);
 }
 
diff --git a/include/linux/net.h b/include/linux/net.h
index b29923006b1..be60c7f5e14 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 77f5202977c..5ac32123035 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 0eac07c9525..8debe299676 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -214,8 +214,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 +417,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 +431,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 +451,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 +1082,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 +1868,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 +1879,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 +1899,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 +1927,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 +1956,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 +1972,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 +2022,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 +2070,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 +2140,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 +2206,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 +2258,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 +2270,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 +2282,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 +2352,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 +2575,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 +2632,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 +2647,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 +2667,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 +2714,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 b809265607d..29734be334c 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 e144f54185c..1697036336b 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 3540c6e262f..2f8e18a2322 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 b89fb79cb44..05a5d72680b 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 6e135f97e59..e59868ae12d 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 b64454c2f79..6fd1f0d07e6 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 debf1aefd75..e58e4b93c10 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 00000000000..a2810a7c5e3
--- /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 b56e76811c0..a064b8af360 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 00000000000..cac07909530
--- /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_bridge/ebtables.h b/include/linux/netfilter_bridge/ebtables.h
index 8797ed16feb..4dd5bd6994a 100644
--- a/include/linux/netfilter_bridge/ebtables.h
+++ b/include/linux/netfilter_bridge/ebtables.h
@@ -285,8 +285,8 @@ struct ebt_table {
         struct module *me;
 };
 
-#define EBT_ALIGN(s) (((s) + (__alignof__(struct ebt_replace)-1)) & \
-                     ~(__alignof__(struct ebt_replace)-1))
+#define EBT_ALIGN(s) (((s) + (__alignof__(struct _xt_align)-1)) & \
+                     ~(__alignof__(struct _xt_align)-1))
 extern struct ebt_table *ebt_register_table(struct net *net,
                                             const struct ebt_table *table);
 extern void ebt_unregister_table(struct net *net, struct ebt_table *table);
diff --git a/include/linux/netfilter_ipv4/Kbuild b/include/linux/netfilter_ipv4/Kbuild
index f9930c87fff..31f8bec9565 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 dcdbadf9fd4..5d8152077d7 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 5bca78267af..00000000000
--- 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 b3996eaa018..00000000000
--- 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 9dd5579e02e..3dd0bc4e073 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 52e48959cfa..a2092f582a7 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 01d4e5d6032..39c1fcf089c 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_xdr.h b/include/linux/nfs_xdr.h
index a764cef06b7..d6ba9a12591 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -614,7 +614,6 @@ struct nfs_getaclargs {
         size_t                          acl_len;
         unsigned int                    acl_pgbase;
         struct page **                  acl_pages;
-        struct page *                   acl_scratch;
         struct nfs4_sequence_args       seq_args;
 };
 
@@ -624,6 +623,7 @@ struct nfs_getaclres {
         size_t                          acl_len;
         size_t                          acl_data_offset;
         int                             acl_flags;
+        struct page *                   acl_scratch;
         struct nfs4_sequence_res        seq_res;
 };
 
diff --git a/include/linux/nl80211.h b/include/linux/nl80211.h
index 0f5ff373982..e474f6e780c 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/of.h b/include/linux/of.h
index a75a831e205..f02d8b2f799 100644
--- a/include/linux/of.h
+++ b/include/linux/of.h
@@ -72,19 +72,17 @@ struct of_phandle_args {
         uint32_t args[MAX_PHANDLE_ARGS];
 };
 
-#if defined(CONFIG_SPARC) || !defined(CONFIG_OF)
+#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 +215,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,
@@ -281,6 +282,14 @@ static inline struct property *of_find_property(const struct device_node *np,
         return NULL;
 }
 
+static inline struct device_node *of_find_compatible_node(
+                                                struct device_node *from,
+                                                const char *type,
+                                                const char *compat)
+{
+        return NULL;
+}
+
 static inline int of_property_read_u32_array(const struct device_node *np,
                                              const char *propname,
                                              u32 *out_values, size_t sz)
diff --git a/include/linux/of_address.h b/include/linux/of_address.h
index 3118623c2c1..01b925ad8d7 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 ae5638480ef..cbc42143fa5 100644
--- a/include/linux/of_device.h
+++ b/include/linux/of_device.h
@@ -34,7 +34,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 +50,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_irq.h b/include/linux/of_irq.h
index d0307eed20c..d229ad3edee 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_platform.h b/include/linux/of_platform.h
index 040ce2f6e8d..b47d2040c9f 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/pci.h b/include/linux/pci.h
index a16b1df3def..b843fe79583 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -746,28 +746,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);
@@ -946,6 +946,19 @@ 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);
+
+/**
+ * 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_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,
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 31d77af2ef4..3329965ed63 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/percpu.h b/include/linux/percpu.h
index 32cd1f67462..21638ae14e0 100644
--- a/include/linux/percpu.h
+++ b/include/linux/percpu.h
@@ -348,9 +348,9 @@ do {									\
 #define _this_cpu_generic_to_op(pcp, val, op)                           \
 do {                                                                    \
         unsigned long flags;                                            \
-        local_irq_save(flags);                                          \
+        raw_local_irq_save(flags);                                      \
         *__this_cpu_ptr(&(pcp)) op val;                                 \
-        local_irq_restore(flags);                                       \
+        raw_local_irq_restore(flags);                                   \
 } while (0)
 
 #ifndef this_cpu_write
@@ -449,10 +449,10 @@ do {									\
 ({                                                                      \
         typeof(pcp) ret__;                                              \
         unsigned long flags;                                            \
-        local_irq_save(flags);                                          \
+        raw_local_irq_save(flags);                                      \
         __this_cpu_add(pcp, val);                                       \
         ret__ = __this_cpu_read(pcp);                                   \
-        local_irq_restore(flags);                                       \
+        raw_local_irq_restore(flags);                                   \
         ret__;                                                          \
 })
 
@@ -479,10 +479,10 @@ do {									\
 #define _this_cpu_generic_xchg(pcp, nval)                               \
 ({      typeof(pcp) ret__;                                              \
         unsigned long flags;                                            \
-        local_irq_save(flags);                                          \
+        raw_local_irq_save(flags);                                      \
         ret__ = __this_cpu_read(pcp);                                   \
         __this_cpu_write(pcp, nval);                                    \
-        local_irq_restore(flags);                                       \
+        raw_local_irq_restore(flags);                                   \
         ret__;                                                          \
 })
 
@@ -507,11 +507,11 @@ do {									\
 ({                                                                      \
         typeof(pcp) ret__;                                              \
         unsigned long flags;                                            \
-        local_irq_save(flags);                                          \
+        raw_local_irq_save(flags);                                      \
         ret__ = __this_cpu_read(pcp);                                   \
         if (ret__ == (oval))                                            \
                 __this_cpu_write(pcp, nval);                            \
-        local_irq_restore(flags);                                       \
+        raw_local_irq_restore(flags);                                   \
         ret__;                                                          \
 })
 
@@ -544,10 +544,10 @@ do {									\
 ({                                                                      \
         int ret__;                                                      \
         unsigned long flags;                                            \
-        local_irq_save(flags);                                          \
+        raw_local_irq_save(flags);                                      \
         ret__ = __this_cpu_generic_cmpxchg_double(pcp1, pcp2,           \
                         oval1, oval2, nval1, nval2);                    \
-        local_irq_restore(flags);                                       \
+        raw_local_irq_restore(flags);                                   \
         ret__;                                                          \
 })
 
@@ -718,12 +718,13 @@ do {									\
 # ifndef __this_cpu_add_return_8
 #  define __this_cpu_add_return_8(pcp, val)     __this_cpu_generic_add_return(pcp, val)
 # endif
-# define __this_cpu_add_return(pcp, val)        __pcpu_size_call_return2(this_cpu_add_return_, pcp, val)
+# define __this_cpu_add_return(pcp, val)        \
+        __pcpu_size_call_return2(__this_cpu_add_return_, pcp, val)
 #endif
 
-#define __this_cpu_sub_return(pcp, val) this_cpu_add_return(pcp, -(val))
-#define __this_cpu_inc_return(pcp)      this_cpu_add_return(pcp, 1)
-#define __this_cpu_dec_return(pcp)      this_cpu_add_return(pcp, -1)
+#define __this_cpu_sub_return(pcp, val) __this_cpu_add_return(pcp, -(val))
+#define __this_cpu_inc_return(pcp)      __this_cpu_add_return(pcp, 1)
+#define __this_cpu_dec_return(pcp)      __this_cpu_add_return(pcp, -1)
 
 #define __this_cpu_generic_xchg(pcp, nval)                              \
 ({      typeof(pcp) ret__;                                              \
diff --git a/include/linux/perf_event.h b/include/linux/perf_event.h
index 08855613ceb..bd9f55a5958 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;
@@ -587,6 +647,7 @@ struct hw_perf_event {
         u64                             sample_period;
         u64                             last_period;
         local64_t                       period_left;
+        u64                             interrupts_seq;
         u64                             interrupts;
 
         u64                             freq_time_stamp;
@@ -615,6 +676,7 @@ struct pmu {
         struct list_head                entry;
 
         struct device                   *dev;
+        const struct attribute_group    **attr_groups;
         char                            *name;
         int                             type;
 
@@ -680,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);
 };
 
 /**
@@ -849,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
@@ -910,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;
 };
 
@@ -975,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;
 
@@ -994,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,
@@ -1028,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);
 
@@ -1056,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;
@@ -1065,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);
 }
 
@@ -1079,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);
 }
 
@@ -1138,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/pkt_sched.h b/include/linux/pkt_sched.h
index 0d5b79365d0..410b33d014d 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/cpsw.h b/include/linux/platform_data/cpsw.h
new file mode 100644
index 00000000000..c4e23d02949
--- /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 00000000000..5eb7da9b377
--- /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 00000000000..ed0e975b3c5
--- /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/pm.h b/include/linux/pm.h
index e4982ac3fbb..715305e0512 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 a03a0ad998b..1236d262b3e 100644
--- a/include/linux/pm_domain.h
+++ b/include/linux/pm_domain.h
@@ -11,6 +11,7 @@
 
 #include <linux/device.h>
 #include <linux/err.h>
+#include <linux/of.h>
 
 enum gpd_status {
         GPD_STATE_ACTIVE = 0,   /* PM domain is active */
@@ -70,6 +71,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 +99,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 +120,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 +157,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 +181,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 +202,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 +214,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 e5bbcbaa6f5..2e9191a712f 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,33 +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)
-                        { return 0; }
-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)
@@ -160,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 a32da962d69..d9f05113e5f 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/ppp-comp.h b/include/linux/ppp-comp.h
index b8d4ddd2273..e53ff65935d 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 00000000000..2d9a8859550
--- /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 0f93ed6b4a8..ba416f67eb6 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/preempt.h b/include/linux/preempt.h
index 58969b2a8a8..5a710b9c578 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 f0e22f75143..0525927f203 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/proportions.h b/include/linux/proportions.h
index ef35bb73f69..26a8a4ed9b0 100644
--- a/include/linux/proportions.h
+++ b/include/linux/proportions.h
@@ -81,7 +81,11 @@ void prop_inc_percpu(struct prop_descriptor *pd, struct prop_local_percpu *pl)
  * Limit the time part in order to ensure there are some bits left for the
  * cycle counter and fraction multiply.
  */
+#if BITS_PER_LONG == 32
 #define PROP_MAX_SHIFT (3*BITS_PER_LONG/4)
+#else
+#define PROP_MAX_SHIFT (BITS_PER_LONG/2)
+#endif
 
 #define PROP_FRAC_SHIFT         (BITS_PER_LONG - PROP_MAX_SHIFT - 1)
 #define PROP_FRAC_BASE          (1UL << PROP_FRAC_SHIFT)
diff --git a/include/linux/quota.h b/include/linux/quota.h
index cb785569903..c09fa042b5e 100644
--- a/include/linux/quota.h
+++ b/include/linux/quota.h
@@ -230,7 +230,11 @@ struct mem_dqinfo {
 struct super_block;
 
 #define DQF_MASK 0xffff         /* Mask for format specific flags */
-#define DQF_INFO_DIRTY_B 16
+#define DQF_GETINFO_MASK 0x1ffff        /* Mask for flags passed to userspace */
+#define DQF_SETINFO_MASK 0xffff         /* Mask for flags modifiable from userspace */
+#define DQF_SYS_FILE_B          16
+#define DQF_SYS_FILE (1 << DQF_SYS_FILE_B)      /* Quota file stored as system file */
+#define DQF_INFO_DIRTY_B        31
 #define DQF_INFO_DIRTY (1 << DQF_INFO_DIRTY_B)  /* Is info dirty? */
 
 extern void mark_info_dirty(struct super_block *sb, int type);
diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
index 81c04f4348e..937217425c4 100644
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -190,6 +190,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 +253,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 +275,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 +304,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 +314,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 +352,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 +365,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();
@@ -381,8 +425,22 @@ extern int rcu_my_thread_group_empty(void);
                 }                                                       \
         } 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 +528,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 +724,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 +745,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 +774,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 +785,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 +810,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 +828,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 +918,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 00b7a5e493d..e93df77176d 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 67458468f1a..e8ee5dd0854 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/regset.h b/include/linux/regset.h
index 8abee655622..686f37327a4 100644
--- a/include/linux/regset.h
+++ b/include/linux/regset.h
@@ -335,8 +335,11 @@ static inline int copy_regset_to_user(struct task_struct *target,
 {
         const struct user_regset *regset = &view->regsets[setno];
 
+        if (!regset->get)
+                return -EOPNOTSUPP;
+
         if (!access_ok(VERIFY_WRITE, data, size))
-                return -EIO;
+                return -EFAULT;
 
         return regset->get(target, regset, offset, size, NULL, data);
 }
@@ -358,8 +361,11 @@ static inline int copy_regset_from_user(struct task_struct *target,
 {
         const struct user_regset *regset = &view->regsets[setno];
 
+        if (!regset->set)
+                return -EOPNOTSUPP;
+
         if (!access_ok(VERIFY_READ, data, size))
-                return -EIO;
+                return -EFAULT;
 
         return regset->set(target, regset, offset, size, NULL, data);
 }
diff --git a/include/linux/res_counter.h b/include/linux/res_counter.h
index c9d625ca659..da81af086ea 100644
--- a/include/linux/res_counter.h
+++ b/include/linux/res_counter.h
@@ -109,12 +109,18 @@ void res_counter_init(struct res_counter *counter, struct res_counter *parent);
  *
  * returns 0 on success and <0 if the counter->usage will exceed the
  * counter->limit _locked call expects the counter->lock to be taken
+ *
+ * charge_nofail works the same, except that it charges the resource
+ * counter unconditionally, and returns < 0 if the after the current
+ * charge we are over limit.
  */
 
 int __must_check res_counter_charge_locked(struct res_counter *counter,
                 unsigned long val);
 int __must_check res_counter_charge(struct res_counter *counter,
                 unsigned long val, struct res_counter **limit_fail_at);
+int __must_check res_counter_charge_nofail(struct res_counter *counter,
+                unsigned long val, struct res_counter **limit_fail_at);
 
 /*
  * uncharge - tell that some portion of the resource is released
@@ -142,7 +148,10 @@ static inline unsigned long long res_counter_margin(struct res_counter *cnt)
         unsigned long flags;
 
         spin_lock_irqsave(&cnt->lock, flags);
-        margin = cnt->limit - cnt->usage;
+        if (cnt->limit > cnt->usage)
+                margin = cnt->limit - cnt->usage;
+        else
+                margin = 0;
         spin_unlock_irqrestore(&cnt->lock, flags);
         return margin;
 }
diff --git a/include/linux/rtnetlink.h b/include/linux/rtnetlink.h
index 8e872ead88b..577592ea0ea 100644
--- a/include/linux/rtnetlink.h
+++ b/include/linux/rtnetlink.h
@@ -602,6 +602,9 @@ struct tcamsg {
 #define TCA_ACT_TAB 1 /* attr type must be >=1 */       
 #define TCAA_MAX 1
 
+/* New extended info filters for IFLA_EXT_MASK */
+#define RTEXT_FILTER_VF         (1 << 0)
+
 /* End of information exported to user level */
 
 #ifdef __KERNEL__
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 4032ec1cf83..e074e1e54f8 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;
@@ -905,6 +906,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 +1054,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 +1065,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 +1235,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 +1335,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 +1448,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;
 
@@ -1777,7 +1793,6 @@ extern void thread_group_times(struct task_struct *p, cputime_t *ut, cputime_t *
 /*
  * Per process flags
  */
-#define PF_STARTING     0x00000002      /* being created */
 #define PF_EXITING      0x00000004      /* getting shut down */
 #define PF_EXITPIDONE   0x00000008      /* pi exit done on shut down */
 #define PF_VCPU         0x00000010      /* I'm a virtual CPU */
@@ -1864,8 +1879,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)
 {
@@ -2049,7 +2063,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) { }
@@ -2066,12 +2080,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);
@@ -2088,9 +2110,9 @@ extern int sched_setscheduler_nocheck(struct task_struct *, int,
 extern struct task_struct *idle_task(int cpu);
 /**
  * is_idle_task - is the specified task an idle task?
- * @tsk: the task in question.
+ * @p: the task in question.
  */
-static inline bool is_idle_task(struct task_struct *p)
+static inline bool is_idle_task(const struct task_struct *p)
 {
         return p->pid == 0;
 }
@@ -2259,6 +2281,12 @@ static inline void mmdrop(struct mm_struct * mm)
 extern void mmput(struct mm_struct *);
 /* Grab a reference to a task's mm, if it is not already going away */
 extern struct mm_struct *get_task_mm(struct task_struct *task);
+/*
+ * Grab a reference to a task's mm, if it is not already going away
+ * and ptrace_may_access with the mode parameter passed to it
+ * succeeds.
+ */
+extern struct mm_struct *mm_access(struct task_struct *task, unsigned int mode);
 /* Remove the current tasks stale references to the old mm_struct */
 extern void mm_release(struct task_struct *, struct mm_struct *);
 /* Allocate a new mm structure and copy contents from tsk->mm */
@@ -2365,7 +2393,7 @@ static inline int thread_group_empty(struct task_struct *p)
  * Protects ->fs, ->files, ->mm, ->group_info, ->comm, keyring
  * subscriptions and synchronises with wait4().  Also used in procfs.  Also
  * pins the final release of task.io_context.  Also protects ->cpuset and
- * ->cgroup.subsys[].
+ * ->cgroup.subsys[]. And ->vfork_done.
  *
  * Nests both inside and outside of read_lock(&tasklist_lock).
  * It must not be nested with write_lock_irq(&tasklist_lock),
@@ -2384,12 +2412,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 83c18e8c846..c8949385e56 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -812,7 +812,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
diff --git a/include/linux/serial.h b/include/linux/serial.h
index 3d86517fe7d..441980ecc4e 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 e811a615f69..00000000000
--- 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 c91ace70c21..f51bf2e70c6 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/sh_dma.h b/include/linux/sh_dma.h
index 8cd7fe59cf1..425450b980b 100644
--- a/include/linux/sh_dma.h
+++ b/include/linux/sh_dma.h
@@ -70,6 +70,7 @@ struct sh_dmae_pdata {
         unsigned int needs_tend_set:1;
         unsigned int no_dmars:1;
         unsigned int chclr_present:1;
+        unsigned int slave_only:1;
 };
 
 /* DMA register */
diff --git a/include/linux/sh_eth.h b/include/linux/sh_eth.h
index 2076acf8294..b17d765ded8 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/shmem_fs.h b/include/linux/shmem_fs.h
index e4c711c6f32..79ab2555b3b 100644
--- a/include/linux/shmem_fs.h
+++ b/include/linux/shmem_fs.h
@@ -48,6 +48,7 @@ extern struct file *shmem_file_setup(const char *name,
                                         loff_t size, unsigned long flags);
 extern int shmem_zero_setup(struct vm_area_struct *);
 extern int shmem_lock(struct file *file, int lock, struct user_struct *user);
+extern void shmem_unlock_mapping(struct address_space *mapping);
 extern struct page *shmem_read_mapping_page_gfp(struct address_space *mapping,
                                         pgoff_t index, gfp_t gfp_mask);
 extern void shmem_truncate_range(struct inode *inode, loff_t start, loff_t end);
diff --git a/include/linux/signalfd.h b/include/linux/signalfd.h
index 3ff4961da9b..247399b2979 100644
--- a/include/linux/signalfd.h
+++ b/include/linux/signalfd.h
@@ -61,13 +61,16 @@ static inline void signalfd_notify(struct task_struct *tsk, int sig)
                 wake_up(&tsk->sighand->signalfd_wqh);
 }
 
+extern void signalfd_cleanup(struct sighand_struct *sighand);
+
 #else /* CONFIG_SIGNALFD */
 
 static inline void signalfd_notify(struct task_struct *tsk, int sig) { }
 
+static inline void signalfd_cleanup(struct sighand_struct *sighand) { }
+
 #endif /* CONFIG_SIGNALFD */
 
 #endif /* __KERNEL__ */
 
 #endif /* _LINUX_SIGNALFD_H */
-
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 50db9b04a55..a2b9953b582 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -94,6 +94,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 +368,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 +446,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 +458,6 @@ struct sk_buff {
 #endif
 #endif
 
-        __u32                   rxhash;
-
         __u16                   queue_mapping;
         kmemcheck_bitfield_begin(flags2);
 #ifdef CONFIG_IPV6_NDISC_NODETYPE
@@ -456,7 +467,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 +482,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 +886,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 +1180,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;
 }
@@ -1465,6 +1493,16 @@ static inline void skb_set_mac_header(struct sk_buff *skb, const int offset)
 }
 #endif /* NET_SKBUFF_DATA_USES_OFFSET */
 
+static inline void skb_mac_header_rebuild(struct sk_buff *skb)
+{
+        if (skb_mac_header_was_set(skb)) {
+                const unsigned char *old_mac = skb_mac_header(skb);
+
+                skb_set_mac_header(skb, -skb->mac_len);
+                memmove(skb_mac_header(skb), old_mac, skb->mac_len);
+        }
+}
+
 static inline int skb_checksum_start_offset(const struct sk_buff *skb)
 {
         return skb->csum_start - skb_headroom(skb);
@@ -2045,7 +2083,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,
@@ -2438,12 +2476,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/snmp.h b/include/linux/snmp.h
index e16557a357e..2e68f5ba038 100644
--- a/include/linux/snmp.h
+++ b/include/linux/snmp.h
@@ -192,7 +192,6 @@ enum
         LINUX_MIB_TCPPARTIALUNDO,               /* TCPPartialUndo */
         LINUX_MIB_TCPDSACKUNDO,                 /* TCPDSACKUndo */
         LINUX_MIB_TCPLOSSUNDO,                  /* TCPLossUndo */
-        LINUX_MIB_TCPLOSS,                      /* TCPLoss */
         LINUX_MIB_TCPLOSTRETRANSMIT,            /* TCPLostRetransmit */
         LINUX_MIB_TCPRENOFAILURES,              /* TCPRenoFailures */
         LINUX_MIB_TCPSACKFAILURES,              /* TCPSackFailures */
@@ -233,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 d0e77f607a7..da2d3e2543f 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/srcu.h b/include/linux/srcu.h
index e1b005918bb..d3d5fa54f25 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 dcf35b0f303..d2768318002 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_regs.h b/include/linux/ssb/ssb_regs.h
index c814ae6eeb2..40b1ef8595e 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 00000000000..27bd3f8a085
--- /dev/null
+++ b/include/linux/static_key.h
@@ -0,0 +1 @@
+#include <linux/jump_label.h>
diff --git a/include/linux/sunserialcore.h b/include/linux/sunserialcore.h
new file mode 100644
index 00000000000..68e7430bb0f
--- /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 95040cc3310..ac1c114c499 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;
@@ -357,14 +361,29 @@ extern bool pm_save_wakeup_count(unsigned int count);
 
 static inline void lock_system_sleep(void)
 {
-        freezer_do_not_count();
+        current->flags |= PF_FREEZER_SKIP;
         mutex_lock(&pm_mutex);
 }
 
 static inline void unlock_system_sleep(void)
 {
+        /*
+         * Don't use freezer_count() because we don't want the call to
+         * try_to_freeze() here.
+         *
+         * Reason:
+         * Fundamentally, we just don't need it, because freezing condition
+         * doesn't come into effect until we release the pm_mutex lock,
+         * since the freezer always works with pm_mutex held.
+         *
+         * More importantly, in the case of hibernation,
+         * unlock_system_sleep() gets called in snapshot_read() and
+         * snapshot_write() when the freezing condition is still in effect.
+         * Which means, if we use try_to_freeze() here, it would make them
+         * enter the refrigerator, thus causing hibernation to lockup.
+         */
+        current->flags &= ~PF_FREEZER_SKIP;
         mutex_unlock(&pm_mutex);
-        freezer_count();
 }
 
 #else /* !CONFIG_PM_SLEEP */
diff --git a/include/linux/swap.h b/include/linux/swap.h
index 06061a7f8e6..3e60228e729 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -273,7 +273,7 @@ static inline int zone_reclaim(struct zone *z, gfp_t mask, unsigned int order)
 #endif
 
 extern int page_evictable(struct page *page, struct vm_area_struct *vma);
-extern void scan_mapping_unevictable_pages(struct address_space *);
+extern void check_move_unevictable_pages(struct page **, int nr_pages);
 
 extern unsigned long scan_unevictable_pages;
 extern int scan_unevictable_handler(struct ctl_table *, int,
diff --git a/include/linux/sys_soc.h b/include/linux/sys_soc.h
new file mode 100644
index 00000000000..2739ccb6957
--- /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 515669fa3c1..8ec1153ff57 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -624,7 +624,7 @@ asmlinkage long sys_socketpair(int, int, int, int __user *);
 asmlinkage long sys_socketcall(int call, unsigned long __user *args);
 asmlinkage long sys_listen(int, int);
 asmlinkage long sys_poll(struct pollfd __user *ufds, unsigned int nfds,
-                                long timeout);
+                                int timeout);
 asmlinkage long sys_select(int n, fd_set __user *inp, fd_set __user *outp,
                         fd_set __user *exp, struct timeval __user *tvp);
 asmlinkage long sys_old_select(struct sel_arg_struct __user *arg);
diff --git a/include/linux/sysdev.h b/include/linux/sysdev.h
deleted file mode 100644
index 20f63d3e614..00000000000
--- a/include/linux/sysdev.h
+++ /dev/null
@@ -1,164 +0,0 @@
-/**
- * System devices follow a slightly different driver model. 
- * They don't need to do dynammic driver binding, can't be probed, 
- * and don't reside on any type of peripheral bus. 
- * So, we represent and treat them a little differently.
- * 
- * We still have a notion of a driver for a system device, because we still
- * want to perform basic operations on these devices. 
- *
- * We also support auxiliary drivers binding to devices of a certain class.
- * 
- * This allows configurable drivers to register themselves for devices of
- * a certain type. And, it allows class definitions to reside in generic
- * code while arch-specific code can register specific drivers.
- *
- * Auxiliary drivers registered with a NULL cls are registered as drivers
- * for all system devices, and get notification calls for each device. 
- */
-
-
-#ifndef _SYSDEV_H_
-#define _SYSDEV_H_
-
-#include <linux/kobject.h>
-#include <linux/pm.h>
-
-
-struct sys_device;
-struct sysdev_class_attribute;
-
-struct sysdev_class {
-        const char *name;
-        struct list_head        drivers;
-        struct sysdev_class_attribute **attrs;
-        struct kset             kset;
-};
-
-struct sysdev_class_attribute {
-        struct attribute attr;
-        ssize_t (*show)(struct sysdev_class *, struct sysdev_class_attribute *,
-                        char *);
-        ssize_t (*store)(struct sysdev_class *, struct sysdev_class_attribute *,
-                         const char *, size_t);
-};
-
-#define _SYSDEV_CLASS_ATTR(_name,_mode,_show,_store)            \
-{                                                               \
-        .attr = {.name = __stringify(_name), .mode = _mode },   \
-        .show   = _show,                                        \
-        .store  = _store,                                       \
-}
-
-#define SYSDEV_CLASS_ATTR(_name,_mode,_show,_store)             \
-        struct sysdev_class_attribute attr_##_name =            \
-                _SYSDEV_CLASS_ATTR(_name,_mode,_show,_store)
-
-
-extern int sysdev_class_register(struct sysdev_class *);
-extern void sysdev_class_unregister(struct sysdev_class *);
-
-extern int sysdev_class_create_file(struct sysdev_class *,
-        struct sysdev_class_attribute *);
-extern void sysdev_class_remove_file(struct sysdev_class *,
-        struct sysdev_class_attribute *);
-/**
- * Auxiliary system device drivers.
- */
-
-struct sysdev_driver {
-        struct list_head        entry;
-        int     (*add)(struct sys_device *);
-        int     (*remove)(struct sys_device *);
-};
-
-
-extern int sysdev_driver_register(struct sysdev_class *, struct sysdev_driver *);
-extern void sysdev_driver_unregister(struct sysdev_class *, struct sysdev_driver *);
-
-
-/**
- * sys_devices can be simplified a lot from regular devices, because they're
- * simply not as versatile. 
- */
-
-struct sys_device {
-        u32             id;
-        struct sysdev_class     * cls;
-        struct kobject          kobj;
-};
-
-extern int sysdev_register(struct sys_device *);
-extern void sysdev_unregister(struct sys_device *);
-
-
-struct sysdev_attribute { 
-        struct attribute        attr;
-        ssize_t (*show)(struct sys_device *, struct sysdev_attribute *, char *);
-        ssize_t (*store)(struct sys_device *, struct sysdev_attribute *,
-                         const char *, size_t);
-};
-
-
-#define _SYSDEV_ATTR(_name, _mode, _show, _store)               \
-{                                                               \
-        .attr = { .name = __stringify(_name), .mode = _mode },  \
-        .show   = _show,                                        \
-        .store  = _store,                                       \
-}
-
-#define SYSDEV_ATTR(_name, _mode, _show, _store)                \
-        struct sysdev_attribute attr_##_name =                  \
-                _SYSDEV_ATTR(_name, _mode, _show, _store);
-
-extern int sysdev_create_file(struct sys_device *, struct sysdev_attribute *);
-extern void sysdev_remove_file(struct sys_device *, struct sysdev_attribute *);
-
-/* Create/remove NULL terminated attribute list */
-static inline int
-sysdev_create_files(struct sys_device *d, struct sysdev_attribute **a)
-{
-        return sysfs_create_files(&d->kobj, (const struct attribute **)a);
-}
-
-static inline void
-sysdev_remove_files(struct sys_device *d, struct sysdev_attribute **a)
-{
-        return sysfs_remove_files(&d->kobj, (const struct attribute **)a);
-}
-
-struct sysdev_ext_attribute {
-        struct sysdev_attribute attr;
-        void *var;
-};
-
-/*
- * Support for simple variable sysdev attributes.
- * The pointer to the variable is stored in a sysdev_ext_attribute
- */
-
-/* Add more types as needed */
-
-extern ssize_t sysdev_show_ulong(struct sys_device *, struct sysdev_attribute *,
-                                char *);
-extern ssize_t sysdev_store_ulong(struct sys_device *,
-                        struct sysdev_attribute *, const char *, size_t);
-extern ssize_t sysdev_show_int(struct sys_device *, struct sysdev_attribute *,
-                                char *);
-extern ssize_t sysdev_store_int(struct sys_device *,
-                        struct sysdev_attribute *, const char *, size_t);
-
-#define _SYSDEV_ULONG_ATTR(_name, _mode, _var)                          \
-        { _SYSDEV_ATTR(_name, _mode, sysdev_show_ulong, sysdev_store_ulong), \
-          &(_var) }
-#define SYSDEV_ULONG_ATTR(_name, _mode, _var)                   \
-        struct sysdev_ext_attribute attr_##_name =              \
-                _SYSDEV_ULONG_ATTR(_name, _mode, _var);
-#define _SYSDEV_INT_ATTR(_name, _mode, _var)                            \
-        { _SYSDEV_ATTR(_name, _mode, sysdev_show_int, sysdev_store_int), \
-          &(_var) }
-#define SYSDEV_INT_ATTR(_name, _mode, _var)                     \
-        struct sysdev_ext_attribute attr_##_name =              \
-                _SYSDEV_INT_ATTR(_name, _mode, _var);
-
-#endif /* _SYSDEV_H_ */
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index 46a85c9e1f2..b6c62d29438 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -412,7 +412,8 @@ struct tcp_sock {
 
         struct tcp_sack_block recv_sack_cache[4];
 
-        struct sk_buff *highest_sack;   /* highest skb with SACK received
+        struct sk_buff *highest_sack;   /* skb just after the highest
+                                         * skb with SACKed bit set
                                          * (validity guaranteed only if
                                          * sacked_out > 0)
                                          */
@@ -463,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
@@ -486,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/thermal.h b/include/linux/thermal.h
index 47b4a27e6e9..796f1ff0388 100644
--- a/include/linux/thermal.h
+++ b/include/linux/thermal.h
@@ -152,9 +152,9 @@ struct thermal_cooling_device *thermal_cooling_device_register(char *, void *,
 void thermal_cooling_device_unregister(struct thermal_cooling_device *);
 
 #ifdef CONFIG_NET
-extern int generate_netlink_event(u32 orig, enum events event);
+extern int thermal_generate_netlink_event(u32 orig, enum events event);
 #else
-static inline int generate_netlink_event(u32 orig, enum events event)
+static inline int thermal_generate_netlink_event(u32 orig, enum events event)
 {
         return 0;
 }
diff --git a/include/linux/timex.h b/include/linux/timex.h
index aa60fe7b6ed..b75e1864ed1 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/tracepoint.h b/include/linux/tracepoint.h
index df0a779c1bb..bd96ecd0e05 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/tty.h b/include/linux/tty.h
index 5dbb3cb05a8..a91ff403b3b 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 5cf685086dd..6e6dbb7447b 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 27a4e16d2bf..73b68d1f2cb 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)
 
@@ -1073,6 +1081,7 @@ typedef void (*usb_complete_t)(struct urb *);
  *      which the host controller driver should use in preference to the
  *      transfer_buffer.
  * @sg: scatter gather buffer list
+ * @num_mapped_sgs: (internal) number of mapped sg entries
  * @num_sgs: number of entries in the sg list
  * @transfer_buffer_length: How big is transfer_buffer.  The transfer may
  *      be broken up into chunks according to the current maximum packet
diff --git a/include/linux/usb/audio-v2.h b/include/linux/usb/audio-v2.h
index 964cb603f7c..ed13053153f 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 00000000000..719c332620f
--- /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 31fdb4c6ee3..f1d26b6067f 100644
--- a/include/linux/usb/ch11.h
+++ b/include/linux/usb/ch11.h
@@ -61,12 +61,6 @@
 #define USB_PORT_FEAT_TEST              21
 #define USB_PORT_FEAT_INDICATOR         22
 #define USB_PORT_FEAT_C_PORT_L1         23
-#define USB_PORT_FEAT_C_PORT_LINK_STATE 25
-#define USB_PORT_FEAT_C_PORT_CONFIG_ERROR 26
-#define USB_PORT_FEAT_PORT_REMOTE_WAKE_MASK 27
-#define USB_PORT_FEAT_BH_PORT_RESET     28
-#define USB_PORT_FEAT_C_BH_PORT_RESET   29
-#define USB_PORT_FEAT_FORCE_LINKPM_ACCEPT 30
 
 /*
  * Port feature selectors added by USB 3.0 spec.
@@ -75,13 +69,18 @@
 #define USB_PORT_FEAT_LINK_STATE                5
 #define USB_PORT_FEAT_U1_TIMEOUT                23
 #define USB_PORT_FEAT_U2_TIMEOUT                24
-#define USB_PORT_FEAT_C_LINK_STATE              25
-#define USB_PORT_FEAT_C_CONFIG_ERR              26
+#define USB_PORT_FEAT_C_PORT_LINK_STATE         25
+#define USB_PORT_FEAT_C_PORT_CONFIG_ERROR       26
 #define USB_PORT_FEAT_REMOTE_WAKE_MASK          27
 #define USB_PORT_FEAT_BH_PORT_RESET             28
 #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 61b29057b05..af21f311591 100644
--- a/include/linux/usb/ch9.h
+++ b/include/linux/usb/ch9.h
@@ -589,7 +589,7 @@ static inline int usb_endpoint_is_isoc_out(
  */
 static inline int usb_endpoint_maxp(const struct usb_endpoint_descriptor *epd)
 {
-        return le16_to_cpu(epd->wMaxPacketSize);
+        return __le16_to_cpu(epd->wMaxPacketSize);
 }
 
 /*-------------------------------------------------------------------------*/
@@ -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 00000000000..1894f42fe3f
--- /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 da653b5c713..9517466abab 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 b2f62f3a32a..5de415707c2 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 a0ccf795f36..756cf5543ff 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/langwell_otg.h b/include/linux/usb/langwell_otg.h
deleted file mode 100644
index 51f17b16d31..00000000000
--- a/include/linux/usb/langwell_otg.h
+++ /dev/null
@@ -1,139 +0,0 @@
-/*
- * Intel Langwell USB OTG transceiver driver
- * Copyright (C) 2008 - 2010, Intel Corporation.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License,
- * version 2, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
- *
- */
-
-#ifndef __LANGWELL_OTG_H
-#define __LANGWELL_OTG_H
-
-#include <linux/usb/intel_mid_otg.h>
-
-#define CI_USBCMD               0x30
-#       define USBCMD_RST               BIT(1)
-#       define USBCMD_RS                BIT(0)
-#define CI_USBSTS               0x34
-#       define USBSTS_SLI               BIT(8)
-#       define USBSTS_URI               BIT(6)
-#       define USBSTS_PCI               BIT(2)
-#define CI_PORTSC1              0x74
-#       define PORTSC_PP                BIT(12)
-#       define PORTSC_LS                (BIT(11) | BIT(10))
-#       define PORTSC_SUSP              BIT(7)
-#       define PORTSC_CCS               BIT(0)
-#define CI_HOSTPC1              0xb4
-#       define HOSTPC1_PHCD             BIT(22)
-#define CI_OTGSC                0xf4
-#       define OTGSC_DPIE               BIT(30)
-#       define OTGSC_1MSE               BIT(29)
-#       define OTGSC_BSEIE              BIT(28)
-#       define OTGSC_BSVIE              BIT(27)
-#       define OTGSC_ASVIE              BIT(26)
-#       define OTGSC_AVVIE              BIT(25)
-#       define OTGSC_IDIE               BIT(24)
-#       define OTGSC_DPIS               BIT(22)
-#       define OTGSC_1MSS               BIT(21)
-#       define OTGSC_BSEIS              BIT(20)
-#       define OTGSC_BSVIS              BIT(19)
-#       define OTGSC_ASVIS              BIT(18)
-#       define OTGSC_AVVIS              BIT(17)
-#       define OTGSC_IDIS               BIT(16)
-#       define OTGSC_DPS                BIT(14)
-#       define OTGSC_1MST               BIT(13)
-#       define OTGSC_BSE                BIT(12)
-#       define OTGSC_BSV                BIT(11)
-#       define OTGSC_ASV                BIT(10)
-#       define OTGSC_AVV                BIT(9)
-#       define OTGSC_ID                 BIT(8)
-#       define OTGSC_HABA               BIT(7)
-#       define OTGSC_HADP               BIT(6)
-#       define OTGSC_IDPU               BIT(5)
-#       define OTGSC_DP                 BIT(4)
-#       define OTGSC_OT                 BIT(3)
-#       define OTGSC_HAAR               BIT(2)
-#       define OTGSC_VC                 BIT(1)
-#       define OTGSC_VD                 BIT(0)
-#       define OTGSC_INTEN_MASK         (0x7f << 24)
-#       define OTGSC_INT_MASK           (0x5f << 24)
-#       define OTGSC_INTSTS_MASK        (0x7f << 16)
-#define CI_USBMODE              0xf8
-#       define USBMODE_CM               (BIT(1) | BIT(0))
-#       define USBMODE_IDLE             0
-#       define USBMODE_DEVICE           0x2
-#       define USBMODE_HOST             0x3
-#define USBCFG_ADDR                     0xff10801c
-#define USBCFG_LEN                      4
-#       define USBCFG_VBUSVAL           BIT(14)
-#       define USBCFG_AVALID            BIT(13)
-#       define USBCFG_BVALID            BIT(12)
-#       define USBCFG_SESEND            BIT(11)
-
-#define INTR_DUMMY_MASK (USBSTS_SLI | USBSTS_URI | USBSTS_PCI)
-
-enum langwell_otg_timer_type {
-        TA_WAIT_VRISE_TMR,
-        TA_WAIT_BCON_TMR,
-        TA_AIDL_BDIS_TMR,
-        TB_ASE0_BRST_TMR,
-        TB_SE0_SRP_TMR,
-        TB_SRP_INIT_TMR,
-        TB_SRP_FAIL_TMR,
-        TB_BUS_SUSPEND_TMR
-};
-
-#define TA_WAIT_VRISE   100
-#define TA_WAIT_BCON    30000
-#define TA_AIDL_BDIS    15000
-#define TB_ASE0_BRST    5000
-#define TB_SE0_SRP      2
-#define TB_SRP_INIT     100
-#define TB_SRP_FAIL     5500
-#define TB_BUS_SUSPEND  500
-
-struct langwell_otg_timer {
-        unsigned long expires;  /* Number of count increase to timeout */
-        unsigned long count;    /* Tick counter */
-        void (*function)(unsigned long);        /* Timeout function */
-        unsigned long data;     /* Data passed to function */
-        struct list_head list;
-};
-
-struct langwell_otg {
-        struct intel_mid_otg_xceiv      iotg;
-        struct device                   *dev;
-
-        void __iomem                    *usbcfg;        /* SCCBUSB config Reg */
-
-        unsigned                        region;
-        unsigned                        cfg_region;
-
-        struct work_struct              work;
-        struct workqueue_struct         *qwork;
-        struct timer_list               hsm_timer;
-
-        spinlock_t                      lock;
-        spinlock_t                      wq_lock;
-
-        struct notifier_block           iotg_notifier;
-};
-
-static inline
-struct langwell_otg *mid_xceiv_to_lnw(struct intel_mid_otg_xceiv *iotg)
-{
-        return container_of(iotg, struct langwell_otg, iotg);
-}
-
-#endif /* __LANGWELL_OTG_H__ */
diff --git a/include/linux/usb/msm_hsusb.h b/include/linux/usb/msm_hsusb.h
index 00311fe9d0d..22a396c13f3 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 00000000000..2808f2a9cce
--- /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 d87f44f5b04..f67810f8f21 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 0d3f9887925..547e59cc00e 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 4267a9c717b..fbb666b1b67 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 d7fc910f1dc..cb33fff2ba0 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 00000000000..9a988e41369
--- /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 9595796d62e..6f033a415ec 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/vt_kern.h b/include/linux/vt_kern.h
index c2164fad008..e33d77f15bd 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 a9ce45e8501..7d9a9e990ce 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/workqueue.h b/include/linux/workqueue.h
index eb8b9f15f2e..af155450cab 100644
--- a/include/linux/workqueue.h
+++ b/include/linux/workqueue.h
@@ -289,12 +289,16 @@ enum {
  *
  * system_freezable_wq is equivalent to system_wq except that it's
  * freezable.
+ *
+ * system_nrt_freezable_wq is equivalent to system_nrt_wq except that
+ * it's freezable.
  */
 extern struct workqueue_struct *system_wq;
 extern struct workqueue_struct *system_long_wq;
 extern struct workqueue_struct *system_nrt_wq;
 extern struct workqueue_struct *system_unbound_wq;
 extern struct workqueue_struct *system_freezable_wq;
+extern struct workqueue_struct *system_nrt_freezable_wq;
 
 extern struct workqueue_struct *
 __alloc_workqueue_key(const char *fmt, unsigned int flags, int max_active,
diff --git a/include/linux/writeback.h b/include/linux/writeback.h
index 995b8bf630a..a2b84f598e2 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.
          */
diff --git a/include/net/addrconf.h b/include/net/addrconf.h
index f68dce2d8d8..757a17638b1 100644
--- a/include/net/addrconf.h
+++ b/include/net/addrconf.h
@@ -160,7 +160,6 @@ extern void addrconf_prefix_rcv(struct net_device *dev,
 extern int ipv6_sock_ac_join(struct sock *sk,int ifindex, const struct in6_addr *addr);
 extern int ipv6_sock_ac_drop(struct sock *sk,int ifindex, const struct in6_addr *addr);
 extern void ipv6_sock_ac_close(struct sock *sk);
-extern int inet6_ac_check(struct sock *sk, const struct in6_addr *addr, int ifindex);
 
 extern int ipv6_dev_ac_inc(struct net_device *dev, const struct in6_addr *addr);
 extern int __ipv6_dev_ac_dec(struct inet6_dev *idev, const struct in6_addr *addr);
diff --git a/include/net/arp.h b/include/net/arp.h
index 0013dc87940..4a1f3fb562e 100644
--- a/include/net/arp.h
+++ b/include/net/arp.h
@@ -15,14 +15,14 @@ static inline u32 arp_hashfn(u32 key, const struct net_device *dev, u32 hash_rnd
         return val * hash_rnd;
 }
 
-static inline struct neighbour *__ipv4_neigh_lookup(struct neigh_table *tbl, struct net_device *dev, u32 key)
+static inline struct neighbour *__ipv4_neigh_lookup(struct net_device *dev, u32 key)
 {
         struct neigh_hash_table *nht;
         struct neighbour *n;
         u32 hash_val;
 
         rcu_read_lock_bh();
-        nht = rcu_dereference_bh(tbl->nht);
+        nht = rcu_dereference_bh(arp_tbl.nht);
         hash_val = arp_hashfn(key, dev, nht->hash_rnd[0]) >> (32 - nht->hash_shift);
         for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]);
              n != NULL;
diff --git a/include/net/bluetooth/bluetooth.h b/include/net/bluetooth/bluetooth.h
index abaad6ed9b8..262ebd1747d 100644
--- a/include/net/bluetooth/bluetooth.h
+++ b/include/net/bluetooth/bluetooth.h
@@ -109,12 +109,14 @@ struct bt_power {
  */
 #define BT_CHANNEL_POLICY_AMP_PREFERRED         2
 
-__printf(2, 3)
-int bt_printk(const char *level, const char *fmt, ...);
+__printf(1, 2)
+int bt_info(const char *fmt, ...);
+__printf(1, 2)
+int bt_err(const char *fmt, ...);
 
-#define BT_INFO(fmt, arg...)   bt_printk(KERN_INFO, pr_fmt(fmt), ##arg)
-#define BT_ERR(fmt, arg...)    bt_printk(KERN_ERR, pr_fmt(fmt), ##arg)
-#define BT_DBG(fmt, arg...)    pr_debug(fmt "\n", ##arg)
+#define BT_INFO(fmt, ...)       bt_info(fmt "\n", ##__VA_ARGS__)
+#define BT_ERR(fmt, ...)        bt_err(fmt "\n", ##__VA_ARGS__)
+#define BT_DBG(fmt, ...)        pr_debug(fmt "\n", ##__VA_ARGS__)
 
 /* Connection and socket states */
 enum {
@@ -129,6 +131,33 @@ enum {
         BT_CLOSED
 };
 
+/* If unused will be removed by compiler */
+static inline const char *state_to_string(int state)
+{
+        switch (state) {
+        case BT_CONNECTED:
+                return "BT_CONNECTED";
+        case BT_OPEN:
+                return "BT_OPEN";
+        case BT_BOUND:
+                return "BT_BOUND";
+        case BT_LISTEN:
+                return "BT_LISTEN";
+        case BT_CONNECT:
+                return "BT_CONNECT";
+        case BT_CONNECT2:
+                return "BT_CONNECT2";
+        case BT_CONFIG:
+                return "BT_CONFIG";
+        case BT_DISCONN:
+                return "BT_DISCONN";
+        case BT_CLOSED:
+                return "BT_CLOSED";
+        }
+
+        return "invalid state";
+}
+
 /* BD Address */
 typedef struct {
         __u8 b[6];
@@ -193,7 +222,6 @@ struct bt_skb_cb {
         __u16 tx_seq;
         __u8 retries;
         __u8 sar;
-        unsigned short channel;
         __u8 force_active;
 };
 #define bt_cb(skb) ((struct bt_skb_cb *)((skb)->cb))
@@ -256,4 +284,6 @@ void l2cap_exit(void);
 int sco_init(void);
 void sco_exit(void);
 
+void bt_sock_reclassify_lock(struct sock *sk, int proto);
+
 #endif /* __BLUETOOTH_H */
diff --git a/include/net/bluetooth/hci.h b/include/net/bluetooth/hci.h
index 5b2fed5eebf..344b0f97282 100644
--- a/include/net/bluetooth/hci.h
+++ b/include/net/bluetooth/hci.h
@@ -77,14 +77,6 @@ enum {
 
         HCI_RAW,
 
-        HCI_SETUP,
-        HCI_AUTO_OFF,
-        HCI_MGMT,
-        HCI_PAIRABLE,
-        HCI_SERVICE_CACHE,
-        HCI_LINK_KEYS,
-        HCI_DEBUG_KEYS,
-
         HCI_RESET,
 };
 
@@ -93,7 +85,22 @@ enum {
  * states from the controller.
  */
 enum {
+        HCI_SETUP,
+        HCI_AUTO_OFF,
+        HCI_MGMT,
+        HCI_PAIRABLE,
+        HCI_SERVICE_CACHE,
+        HCI_LINK_KEYS,
+        HCI_DEBUG_KEYS,
+
         HCI_LE_SCAN,
+        HCI_SSP_ENABLED,
+        HCI_HS_ENABLED,
+        HCI_LE_ENABLED,
+        HCI_CONNECTABLE,
+        HCI_DISCOVERABLE,
+        HCI_LINK_SECURITY,
+        HCI_PENDING_CLASS,
 };
 
 /* HCI ioctl defines */
@@ -130,6 +137,7 @@ enum {
 #define HCI_IDLE_TIMEOUT        (6000)  /* 6 seconds */
 #define HCI_INIT_TIMEOUT        (10000) /* 10 seconds */
 #define HCI_CMD_TIMEOUT         (1000)  /* 1 seconds */
+#define HCI_ACL_TX_TIMEOUT      (45000) /* 45 seconds */
 
 /* HCI data types */
 #define HCI_COMMAND_PKT         0x01
@@ -229,7 +237,9 @@ enum {
 #define LMP_EXTFEATURES 0x80
 
 /* Extended LMP features */
-#define LMP_HOST_LE     0x02
+#define LMP_HOST_SSP            0x01
+#define LMP_HOST_LE             0x02
+#define LMP_HOST_LE_BREDR       0x04
 
 /* Connection modes */
 #define HCI_CM_ACTIVE   0x0000
@@ -268,10 +278,11 @@ enum {
 #define HCI_LK_UNAUTH_COMBINATION       0x04
 #define HCI_LK_AUTH_COMBINATION         0x05
 #define HCI_LK_CHANGED_COMBINATION      0x06
-/* The spec doesn't define types for SMP keys */
-#define HCI_LK_SMP_LTK                  0x81
-#define HCI_LK_SMP_IRK                  0x82
-#define HCI_LK_SMP_CSRK                 0x83
+/* The spec doesn't define types for SMP keys, the _MASTER suffix is implied */
+#define HCI_SMP_STK                     0x80
+#define HCI_SMP_STK_SLAVE               0x81
+#define HCI_SMP_LTK                     0x82
+#define HCI_SMP_LTK_SLAVE               0x83
 
 /* ---- HCI Error Codes ---- */
 #define HCI_ERROR_AUTH_FAILURE          0x05
@@ -284,6 +295,22 @@ enum {
 #define HCI_FLOW_CTL_MODE_PACKET_BASED  0x00
 #define HCI_FLOW_CTL_MODE_BLOCK_BASED   0x01
 
+/* Extended Inquiry Response field types */
+#define EIR_FLAGS               0x01 /* flags */
+#define EIR_UUID16_SOME         0x02 /* 16-bit UUID, more available */
+#define EIR_UUID16_ALL          0x03 /* 16-bit UUID, all listed */
+#define EIR_UUID32_SOME         0x04 /* 32-bit UUID, more available */
+#define EIR_UUID32_ALL          0x05 /* 32-bit UUID, all listed */
+#define EIR_UUID128_SOME        0x06 /* 128-bit UUID, more available */
+#define EIR_UUID128_ALL         0x07 /* 128-bit UUID, all listed */
+#define EIR_NAME_SHORT          0x08 /* shortened local name */
+#define EIR_NAME_COMPLETE       0x09 /* complete local name */
+#define EIR_TX_POWER            0x0A /* transmit power level */
+#define EIR_CLASS_OF_DEV        0x0D /* Class of Device */
+#define EIR_SSP_HASH_C          0x0E /* Simple Pairing Hash C */
+#define EIR_SSP_RAND_R          0x0F /* Simple Pairing Randomizer R */
+#define EIR_DEVICE_ID           0x10 /* device ID */
+
 /* -----  HCI Commands ---- */
 #define HCI_OP_NOP                      0x0000
 
@@ -666,8 +693,8 @@ struct hci_cp_host_buffer_size {
 
 #define HCI_OP_WRITE_EIR                0x0c52
 struct hci_cp_write_eir {
-        uint8_t         fec;
-        uint8_t         data[HCI_MAX_EIR_LENGTH];
+        __u8    fec;
+        __u8    data[HCI_MAX_EIR_LENGTH];
 } __packed;
 
 #define HCI_OP_READ_SSP_MODE            0x0c55
@@ -698,8 +725,8 @@ struct hci_rp_read_flow_control_mode {
 
 #define HCI_OP_WRITE_LE_HOST_SUPPORTED  0x0c6d
 struct hci_cp_write_le_host_supported {
-        __u8 le;
-        __u8 simul;
+        __u8    le;
+        __u8    simul;
 } __packed;
 
 #define HCI_OP_READ_LOCAL_VERSION       0x1001
@@ -1155,6 +1182,19 @@ struct hci_ev_le_meta {
         __u8     subevent;
 } __packed;
 
+#define HCI_EV_NUM_COMP_BLOCKS          0x48
+struct hci_comp_blocks_info {
+        __le16   handle;
+        __le16   pkts;
+        __le16   blocks;
+} __packed;
+
+struct hci_ev_num_comp_blocks {
+        __le16   num_blocks;
+        __u8     num_hndl;
+        struct hci_comp_blocks_info handles[0];
+} __packed;
+
 /* Low energy meta events */
 #define HCI_EV_LE_CONN_COMPLETE         0x01
 struct hci_ev_le_conn_complete {
@@ -1288,6 +1328,7 @@ struct sockaddr_hci {
 
 #define HCI_CHANNEL_RAW         0
 #define HCI_CHANNEL_CONTROL     1
+#define HCI_CHANNEL_MONITOR     2
 
 struct hci_filter {
         unsigned long type_mask;
@@ -1388,6 +1429,7 @@ struct hci_inquiry_req {
 };
 #define IREQ_CACHE_FLUSH 0x0001
 
-extern int enable_hs;
+extern bool enable_hs;
+extern bool enable_le;
 
 #endif /* __HCI_H */
diff --git a/include/net/bluetooth/hci_core.h b/include/net/bluetooth/hci_core.h
index ea9231f4935..daefaac5113 100644
--- a/include/net/bluetooth/hci_core.h
+++ b/include/net/bluetooth/hci_core.h
@@ -44,14 +44,31 @@ struct inquiry_data {
 };
 
 struct inquiry_entry {
-        struct inquiry_entry    *next;
+        struct list_head        all;            /* inq_cache.all */
+        struct list_head        list;           /* unknown or resolve */
+        enum {
+                NAME_NOT_KNOWN,
+                NAME_NEEDED,
+                NAME_PENDING,
+                NAME_KNOWN,
+        } name_state;
         __u32                   timestamp;
         struct inquiry_data     data;
 };
 
-struct inquiry_cache {
+struct discovery_state {
+        int                     type;
+        enum {
+                DISCOVERY_STOPPED,
+                DISCOVERY_STARTING,
+                DISCOVERY_FINDING,
+                DISCOVERY_RESOLVING,
+                DISCOVERY_STOPPING,
+        } state;
+        struct list_head        all;            /* All devices found during inquiry */
+        struct list_head        unknown;        /* Name state not known */
+        struct list_head        resolve;        /* Name needs to be resolved */
         __u32                   timestamp;
-        struct inquiry_entry    *list;
 };
 
 struct hci_conn_hash {
@@ -72,18 +89,16 @@ struct bt_uuid {
         u8 svc_hint;
 };
 
-struct key_master_id {
-        __le16 ediv;
-        u8 rand[8];
-} __packed;
-
-struct link_key_data {
+struct smp_ltk {
+        struct list_head list;
         bdaddr_t bdaddr;
+        u8 bdaddr_type;
+        u8 authenticated;
         u8 type;
+        u8 enc_size;
+        __le16 ediv;
+        u8 rand[8];
         u8 val[16];
-        u8 pin_len;
-        u8 dlen;
-        u8 data[0];
 } __packed;
 
 struct link_key {
@@ -92,8 +107,6 @@ struct link_key {
         u8 type;
         u8 val[16];
         u8 pin_len;
-        u8 dlen;
-        u8 data[0];
 };
 
 struct oob_data {
@@ -109,11 +122,19 @@ struct adv_entry {
         u8 bdaddr_type;
 };
 
+struct le_scan_params {
+        u8 type;
+        u16 interval;
+        u16 window;
+        int timeout;
+};
+
+#define HCI_MAX_SHORT_NAME_LENGTH       10
+
 #define NUM_REASSEMBLY 4
 struct hci_dev {
         struct list_head list;
         struct mutex    lock;
-        atomic_t        refcnt;
 
         char            name[8];
         unsigned long   flags;
@@ -122,6 +143,7 @@ struct hci_dev {
         __u8            dev_type;
         bdaddr_t        bdaddr;
         __u8            dev_name[HCI_MAX_NAME_LENGTH];
+        __u8            short_name[HCI_MAX_SHORT_NAME_LENGTH];
         __u8            eir[HCI_MAX_EIR_LENGTH];
         __u8            dev_class[3];
         __u8            major_class;
@@ -129,7 +151,6 @@ struct hci_dev {
         __u8            features[8];
         __u8            host_features[8];
         __u8            commands[64];
-        __u8            ssp_mode;
         __u8            hci_ver;
         __u16           hci_rev;
         __u8            lmp_ver;
@@ -217,7 +238,7 @@ struct hci_dev {
 
         struct list_head        mgmt_pending;
 
-        struct inquiry_cache    inq_cache;
+        struct discovery_state  discovery;
         struct hci_conn_hash    conn_hash;
         struct list_head        blacklist;
 
@@ -225,6 +246,8 @@ struct hci_dev {
 
         struct list_head        link_keys;
 
+        struct list_head        long_term_keys;
+
         struct list_head        remote_oob_data;
 
         struct list_head        adv_entries;
@@ -234,7 +257,6 @@ struct hci_dev {
 
         struct sk_buff_head     driver_init;
 
-        void                    *driver_data;
         void                    *core_data;
 
         atomic_t                promisc;
@@ -246,15 +268,17 @@ struct hci_dev {
 
         struct rfkill           *rfkill;
 
-        struct module           *owner;
-
         unsigned long           dev_flags;
 
+        struct delayed_work     le_scan_disable;
+
+        struct work_struct      le_scan;
+        struct le_scan_params   le_scan_params;
+
         int (*open)(struct hci_dev *hdev);
         int (*close)(struct hci_dev *hdev);
         int (*flush)(struct hci_dev *hdev);
         int (*send)(struct sk_buff *skb);
-        void (*destruct)(struct hci_dev *hdev);
         void (*notify)(struct hci_dev *hdev, unsigned int evt);
         int (*ioctl)(struct hci_dev *hdev, unsigned int cmd, unsigned long arg);
 };
@@ -270,11 +294,10 @@ struct hci_conn {
         __u16           state;
         __u8            mode;
         __u8            type;
-        __u8            out;
+        bool            out;
         __u8            attempt;
         __u8            dev_class[3];
         __u8            features[8];
-        __u8            ssp_mode;
         __u16           interval;
         __u16           pkt_type;
         __u16           link_policy;
@@ -286,12 +309,10 @@ struct hci_conn {
         __u8            pin_length;
         __u8            enc_key_size;
         __u8            io_capability;
-        __u8            power_save;
         __u16           disc_timeout;
-        unsigned long   pend;
+        unsigned long   flags;
 
         __u8            remote_cap;
-        __u8            remote_oob;
         __u8            remote_auth;
 
         unsigned int    sent;
@@ -348,21 +369,26 @@ extern int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb);
 #define INQUIRY_CACHE_AGE_MAX   (HZ*30)   /* 30 seconds */
 #define INQUIRY_ENTRY_AGE_MAX   (HZ*60)   /* 60 seconds */
 
-static inline void inquiry_cache_init(struct hci_dev *hdev)
+static inline void discovery_init(struct hci_dev *hdev)
 {
-        struct inquiry_cache *c = &hdev->inq_cache;
-        c->list = NULL;
+        hdev->discovery.state = DISCOVERY_STOPPED;
+        INIT_LIST_HEAD(&hdev->discovery.all);
+        INIT_LIST_HEAD(&hdev->discovery.unknown);
+        INIT_LIST_HEAD(&hdev->discovery.resolve);
 }
 
+bool hci_discovery_active(struct hci_dev *hdev);
+
+void hci_discovery_set_state(struct hci_dev *hdev, int state);
+
 static inline int inquiry_cache_empty(struct hci_dev *hdev)
 {
-        struct inquiry_cache *c = &hdev->inq_cache;
-        return c->list == NULL;
+        return list_empty(&hdev->discovery.all);
 }
 
 static inline long inquiry_cache_age(struct hci_dev *hdev)
 {
-        struct inquiry_cache *c = &hdev->inq_cache;
+        struct discovery_state *c = &hdev->discovery;
         return jiffies - c->timestamp;
 }
 
@@ -372,8 +398,16 @@ static inline long inquiry_entry_age(struct inquiry_entry *e)
 }
 
 struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev,
-                                                        bdaddr_t *bdaddr);
-void hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data);
+                                               bdaddr_t *bdaddr);
+struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev,
+                                                       bdaddr_t *bdaddr);
+struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev,
+                                                       bdaddr_t *bdaddr,
+                                                       int state);
+void hci_inquiry_cache_update_resolve(struct hci_dev *hdev,
+                                      struct inquiry_entry *ie);
+bool hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data,
+                              bool name_known, bool *ssp);
 
 /* ----- HCI Connections ----- */
 enum {
@@ -384,8 +418,19 @@ enum {
         HCI_CONN_MODE_CHANGE_PEND,
         HCI_CONN_SCO_SETUP_PEND,
         HCI_CONN_LE_SMP_PEND,
+        HCI_CONN_MGMT_CONNECTED,
+        HCI_CONN_SSP_ENABLED,
+        HCI_CONN_POWER_SAVE,
+        HCI_CONN_REMOTE_OOB,
 };
 
+static inline bool hci_conn_ssp_enabled(struct hci_conn *conn)
+{
+        struct hci_dev *hdev = conn->hdev;
+        return (test_bit(HCI_SSP_ENABLED, &hdev->flags) &&
+                                test_bit(HCI_CONN_SSP_ENABLED, &conn->flags));
+}
+
 static inline void hci_conn_hash_init(struct hci_dev *hdev)
 {
         struct hci_conn_hash *h = &hdev->conn_hash;
@@ -540,7 +585,7 @@ void hci_conn_put_device(struct hci_conn *conn);
 static inline void hci_conn_hold(struct hci_conn *conn)
 {
         atomic_inc(&conn->refcnt);
-        cancel_delayed_work_sync(&conn->disc_work);
+        cancel_delayed_work(&conn->disc_work);
 }
 
 static inline void hci_conn_put(struct hci_conn *conn)
@@ -559,43 +604,40 @@ static inline void hci_conn_put(struct hci_conn *conn)
                 } else {
                         timeo = msecs_to_jiffies(10);
                 }
-                cancel_delayed_work_sync(&conn->disc_work);
+                cancel_delayed_work(&conn->disc_work);
                 queue_delayed_work(conn->hdev->workqueue,
-                                        &conn->disc_work, jiffies + timeo);
+                                        &conn->disc_work, timeo);
         }
 }
 
 /* ----- HCI Devices ----- */
-static inline void __hci_dev_put(struct hci_dev *d)
+static inline void hci_dev_put(struct hci_dev *d)
 {
-        if (atomic_dec_and_test(&d->refcnt))
-                d->destruct(d);
+        put_device(&d->dev);
 }
 
-/*
- * hci_dev_put and hci_dev_hold are macros to avoid dragging all the
- * overhead of all the modular infrastructure into this header.
- */
-#define hci_dev_put(d)          \
-do {                            \
-        __hci_dev_put(d);       \
-        module_put(d->owner);   \
-} while (0)
-
-static inline struct hci_dev *__hci_dev_hold(struct hci_dev *d)
+static inline struct hci_dev *hci_dev_hold(struct hci_dev *d)
 {
-        atomic_inc(&d->refcnt);
+        get_device(&d->dev);
         return d;
 }
 
-#define hci_dev_hold(d)                                         \
-({                                                              \
-        try_module_get(d->owner) ? __hci_dev_hold(d) : NULL;    \
-})
-
 #define hci_dev_lock(d)         mutex_lock(&d->lock)
 #define hci_dev_unlock(d)       mutex_unlock(&d->lock)
 
+#define to_hci_dev(d) container_of(d, struct hci_dev, dev)
+#define to_hci_conn(c) container_of(c, struct hci_conn, dev)
+
+static inline void *hci_get_drvdata(struct hci_dev *hdev)
+{
+        return dev_get_drvdata(&hdev->dev);
+}
+
+static inline void hci_set_drvdata(struct hci_dev *hdev, void *data)
+{
+        dev_set_drvdata(&hdev->dev, data);
+}
+
 struct hci_dev *hci_dev_get(int index);
 struct hci_dev *hci_get_route(bdaddr_t *src, bdaddr_t *dst);
 
@@ -619,20 +661,23 @@ int hci_inquiry(void __user *arg);
 
 struct bdaddr_list *hci_blacklist_lookup(struct hci_dev *hdev, bdaddr_t *bdaddr);
 int hci_blacklist_clear(struct hci_dev *hdev);
-int hci_blacklist_add(struct hci_dev *hdev, bdaddr_t *bdaddr);
-int hci_blacklist_del(struct hci_dev *hdev, bdaddr_t *bdaddr);
+int hci_blacklist_add(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type);
+int hci_blacklist_del(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type);
 
 int hci_uuids_clear(struct hci_dev *hdev);
 
 int hci_link_keys_clear(struct hci_dev *hdev);
 struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr);
 int hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, int new_key,
-                        bdaddr_t *bdaddr, u8 *val, u8 type, u8 pin_len);
-struct link_key *hci_find_ltk(struct hci_dev *hdev, __le16 ediv, u8 rand[8]);
-struct link_key *hci_find_link_key_type(struct hci_dev *hdev,
-                                        bdaddr_t *bdaddr, u8 type);
-int hci_add_ltk(struct hci_dev *hdev, int new_key, bdaddr_t *bdaddr,
-                        u8 key_size, __le16 ediv, u8 rand[8], u8 ltk[16]);
+                     bdaddr_t *bdaddr, u8 *val, u8 type, u8 pin_len);
+struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, __le16 ediv, u8 rand[8]);
+int hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type, u8 type,
+                int new_key, u8 authenticated, u8 tk[16], u8 enc_size, u16 ediv,
+                u8 rand[8]);
+struct smp_ltk *hci_find_ltk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr,
+                                     u8 addr_type);
+int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr);
+int hci_smp_ltks_clear(struct hci_dev *hdev);
 int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr);
 
 int hci_remote_oob_data_clear(struct hci_dev *hdev);
@@ -674,6 +719,7 @@ void hci_conn_del_sysfs(struct hci_conn *conn);
 #define lmp_ssp_capable(dev)       ((dev)->features[6] & LMP_SIMPLE_PAIR)
 #define lmp_no_flush_capable(dev)  ((dev)->features[6] & LMP_NO_FLUSH)
 #define lmp_le_capable(dev)        ((dev)->features[4] & LMP_LE)
+#define lmp_bredr_capable(dev)     (!((dev)->features[4] & LMP_NO_BREDR))
 
 /* ----- Extended LMP capabilities ----- */
 #define lmp_host_le_capable(dev)   ((dev)->host_features[0] & LMP_HOST_LE)
@@ -755,7 +801,7 @@ static inline void hci_proto_auth_cfm(struct hci_conn *conn, __u8 status)
         if (conn->type != ACL_LINK && conn->type != LE_LINK)
                 return;
 
-        if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend))
+        if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))
                 return;
 
         encrypt = (conn->link_mode & HCI_LM_ENCRYPT) ? 0x01 : 0x00;
@@ -796,7 +842,7 @@ static inline void hci_auth_cfm(struct hci_conn *conn, __u8 status)
 
         hci_proto_auth_cfm(conn, status);
 
-        if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend))
+        if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))
                 return;
 
         encrypt = (conn->link_mode & HCI_LM_ENCRYPT) ? 0x01 : 0x00;
@@ -859,25 +905,71 @@ static inline void hci_role_switch_cfm(struct hci_conn *conn, __u8 status,
         read_unlock(&hci_cb_list_lock);
 }
 
+static inline bool eir_has_data_type(u8 *data, size_t data_len, u8 type)
+{
+        u8 field_len;
+        size_t parsed;
+
+        for (parsed = 0; parsed < data_len - 1; parsed += field_len) {
+                field_len = data[0];
+
+                if (field_len == 0)
+                        break;
+
+                parsed += field_len + 1;
+
+                if (parsed > data_len)
+                        break;
+
+                if (data[1] == type)
+                        return true;
+
+                data += field_len + 1;
+        }
+
+        return false;
+}
+
+static inline u16 eir_append_data(u8 *eir, u16 eir_len, u8 type, u8 *data,
+                                  u8 data_len)
+{
+        eir[eir_len++] = sizeof(type) + data_len;
+        eir[eir_len++] = type;
+        memcpy(&eir[eir_len], data, data_len);
+        eir_len += data_len;
+
+        return eir_len;
+}
+
 int hci_register_cb(struct hci_cb *hcb);
 int hci_unregister_cb(struct hci_cb *hcb);
 
-int hci_register_notifier(struct notifier_block *nb);
-int hci_unregister_notifier(struct notifier_block *nb);
-
 int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, void *param);
 void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags);
 void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb);
 
 void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode);
 
-void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data);
-
 /* ----- HCI Sockets ----- */
-void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb,
-                                                        struct sock *skip_sk);
+void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb);
+void hci_send_to_control(struct sk_buff *skb, struct sock *skip_sk);
+void hci_send_to_monitor(struct hci_dev *hdev, struct sk_buff *skb);
+
+void hci_sock_dev_event(struct hci_dev *hdev, int event);
 
 /* Management interface */
+#define MGMT_ADDR_BREDR                 0x00
+#define MGMT_ADDR_LE_PUBLIC             0x01
+#define MGMT_ADDR_LE_RANDOM             0x02
+#define MGMT_ADDR_INVALID               0xff
+
+#define DISCOV_TYPE_BREDR               (BIT(MGMT_ADDR_BREDR))
+#define DISCOV_TYPE_LE                  (BIT(MGMT_ADDR_LE_PUBLIC) | \
+                                                BIT(MGMT_ADDR_LE_RANDOM))
+#define DISCOV_TYPE_INTERLEAVED         (BIT(MGMT_ADDR_BREDR) | \
+                                                BIT(MGMT_ADDR_LE_PUBLIC) | \
+                                                BIT(MGMT_ADDR_LE_RANDOM))
+
 int mgmt_control(struct sock *sk, struct msghdr *msg, size_t len);
 int mgmt_index_added(struct hci_dev *hdev);
 int mgmt_index_removed(struct hci_dev *hdev);
@@ -886,56 +978,67 @@ int mgmt_discoverable(struct hci_dev *hdev, u8 discoverable);
 int mgmt_connectable(struct hci_dev *hdev, u8 connectable);
 int mgmt_write_scan_failed(struct hci_dev *hdev, u8 scan, u8 status);
 int mgmt_new_link_key(struct hci_dev *hdev, struct link_key *key,
-                                                                u8 persistent);
-int mgmt_connected(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
-                                                                u8 addr_type);
-int mgmt_disconnected(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
-                                                                u8 addr_type);
-int mgmt_disconnect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 status);
+                      u8 persistent);
+int mgmt_device_connected(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
+                          u8 addr_type, u32 flags, u8 *name, u8 name_len,
+                          u8 *dev_class);
+int mgmt_device_disconnected(struct hci_dev *hdev, bdaddr_t *bdaddr,
+                             u8 link_type, u8 addr_type);
+int mgmt_disconnect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr,
+                           u8 link_type, u8 addr_type, u8 status);
 int mgmt_connect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
-                                                u8 addr_type, u8 status);
+                        u8 addr_type, u8 status);
 int mgmt_pin_code_request(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 secure);
 int mgmt_pin_code_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
-                                                                u8 status);
+                                 u8 status);
 int mgmt_pin_code_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
-                                                                u8 status);
+                                     u8 status);
 int mgmt_user_confirm_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
-                                                __le32 value, u8 confirm_hint);
+                              u8 link_type, u8 addr_type, __le32 value,
+                              u8 confirm_hint);
 int mgmt_user_confirm_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
-                                                                u8 status);
-int mgmt_user_confirm_neg_reply_complete(struct hci_dev *hdev,
-                                                bdaddr_t *bdaddr, u8 status);
-int mgmt_user_passkey_request(struct hci_dev *hdev, bdaddr_t *bdaddr);
+                                     u8 link_type, u8 addr_type, u8 status);
+int mgmt_user_confirm_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
+                                         u8 link_type, u8 addr_type, u8 status);
+int mgmt_user_passkey_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
+                              u8 link_type, u8 addr_type);
 int mgmt_user_passkey_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
-                                                                u8 status);
-int mgmt_user_passkey_neg_reply_complete(struct hci_dev *hdev,
-                                                bdaddr_t *bdaddr, u8 status);
-int mgmt_auth_failed(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 status);
+                                     u8 link_type, u8 addr_type, u8 status);
+int mgmt_user_passkey_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
+                                         u8 link_type, u8 addr_type, u8 status);
+int mgmt_auth_failed(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
+                     u8 addr_type, u8 status);
+int mgmt_auth_enable_complete(struct hci_dev *hdev, u8 status);
+int mgmt_ssp_enable_complete(struct hci_dev *hdev, u8 enable, u8 status);
+int mgmt_set_class_of_dev_complete(struct hci_dev *hdev, u8 *dev_class,
+                                   u8 status);
 int mgmt_set_local_name_complete(struct hci_dev *hdev, u8 *name, u8 status);
 int mgmt_read_local_oob_data_reply_complete(struct hci_dev *hdev, u8 *hash,
-                                                u8 *randomizer, u8 status);
+                                            u8 *randomizer, u8 status);
+int mgmt_le_enable_complete(struct hci_dev *hdev, u8 enable, u8 status);
 int mgmt_device_found(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
-                                u8 addr_type, u8 *dev_class, s8 rssi, u8 *eir);
-int mgmt_remote_name(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 *name);
+                      u8 addr_type, u8 *dev_class, s8 rssi, u8 cfm_name,
+                      u8 ssp, u8 *eir, u16 eir_len);
+int mgmt_remote_name(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
+                     u8 addr_type, s8 rssi, u8 *name, u8 name_len);
 int mgmt_start_discovery_failed(struct hci_dev *hdev, u8 status);
 int mgmt_stop_discovery_failed(struct hci_dev *hdev, u8 status);
 int mgmt_discovering(struct hci_dev *hdev, u8 discovering);
-int mgmt_device_blocked(struct hci_dev *hdev, bdaddr_t *bdaddr);
-int mgmt_device_unblocked(struct hci_dev *hdev, bdaddr_t *bdaddr);
+int mgmt_interleaved_discovery(struct hci_dev *hdev);
+int mgmt_device_blocked(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type);
+int mgmt_device_unblocked(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type);
+
+int mgmt_new_ltk(struct hci_dev *hdev, struct smp_ltk *key, u8 persistent);
 
 /* HCI info for socket */
 #define hci_pi(sk) ((struct hci_pinfo *) sk)
 
-/* HCI socket flags */
-#define HCI_PI_MGMT_INIT        0
-
 struct hci_pinfo {
         struct bt_sock    bt;
         struct hci_dev    *hdev;
         struct hci_filter filter;
         __u32             cmsg_mask;
         unsigned short   channel;
-        unsigned long     flags;
 };
 
 /* HCI security filter */
@@ -966,5 +1069,7 @@ void hci_le_ltk_neg_reply(struct hci_conn *conn);
 
 int hci_do_inquiry(struct hci_dev *hdev, u8 length);
 int hci_cancel_inquiry(struct hci_dev *hdev);
+int hci_le_scan(struct hci_dev *hdev, u8 type, u16 interval, u16 window,
+                int timeout);
 
 #endif /* __HCI_CORE_H */
diff --git a/include/net/bluetooth/hci_mon.h b/include/net/bluetooth/hci_mon.h
new file mode 100644
index 00000000000..77d1e576418
--- /dev/null
+++ b/include/net/bluetooth/hci_mon.h
@@ -0,0 +1,51 @@
+/*
+   BlueZ - Bluetooth protocol stack for Linux
+
+   Copyright (C) 2011-2012  Intel Corporation
+
+   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;
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
+   IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
+   CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
+   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+   ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
+   COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
+   SOFTWARE IS DISCLAIMED.
+*/
+
+#ifndef __HCI_MON_H
+#define __HCI_MON_H
+
+struct hci_mon_hdr {
+        __le16  opcode;
+        __le16  index;
+        __le16  len;
+} __packed;
+#define HCI_MON_HDR_SIZE 6
+
+#define HCI_MON_NEW_INDEX       0
+#define HCI_MON_DEL_INDEX       1
+#define HCI_MON_COMMAND_PKT     2
+#define HCI_MON_EVENT_PKT       3
+#define HCI_MON_ACL_TX_PKT      4
+#define HCI_MON_ACL_RX_PKT      5
+#define HCI_MON_SCO_TX_PKT      6
+#define HCI_MON_SCO_RX_PKT      7
+
+struct hci_mon_new_index {
+        __u8            type;
+        __u8            bus;
+        bdaddr_t        bdaddr;
+        char            name[8];
+} __packed;
+#define HCI_MON_NEW_INDEX_SIZE 16
+
+#endif /* __HCI_MON_H */
diff --git a/include/net/bluetooth/l2cap.h b/include/net/bluetooth/l2cap.h
index 68f58915069..9b242c6bf55 100644
--- a/include/net/bluetooth/l2cap.h
+++ b/include/net/bluetooth/l2cap.h
@@ -45,11 +45,11 @@
 #define L2CAP_DEFAULT_SDU_ITIME         0xFFFFFFFF
 #define L2CAP_DEFAULT_ACC_LAT           0xFFFFFFFF
 
-#define L2CAP_DISC_TIMEOUT             (100)
-#define L2CAP_DISC_REJ_TIMEOUT         (5000)  /*  5 seconds */
-#define L2CAP_ENC_TIMEOUT              (5000)  /*  5 seconds */
-#define L2CAP_CONN_TIMEOUT             (40000) /* 40 seconds */
-#define L2CAP_INFO_TIMEOUT             (4000)  /*  4 seconds */
+#define L2CAP_DISC_TIMEOUT              msecs_to_jiffies(100)
+#define L2CAP_DISC_REJ_TIMEOUT          msecs_to_jiffies(5000)
+#define L2CAP_ENC_TIMEOUT               msecs_to_jiffies(5000)
+#define L2CAP_CONN_TIMEOUT              msecs_to_jiffies(40000)
+#define L2CAP_INFO_TIMEOUT              msecs_to_jiffies(4000)
 
 /* L2CAP socket address */
 struct sockaddr_l2 {
@@ -492,51 +492,56 @@ struct l2cap_chan {
         struct sk_buff_head     srej_q;
         struct list_head        srej_l;
 
-        struct list_head list;
-        struct list_head global_l;
+        struct list_head        list;
+        struct list_head        global_l;
 
-        void            *data;
-        struct l2cap_ops *ops;
+        void                    *data;
+        struct l2cap_ops        *ops;
+        struct mutex            lock;
 };
 
 struct l2cap_ops {
-        char            *name;
+        char                    *name;
 
         struct l2cap_chan       *(*new_connection) (void *data);
         int                     (*recv) (void *data, struct sk_buff *skb);
         void                    (*close) (void *data);
         void                    (*state_change) (void *data, int state);
+        struct sk_buff          *(*alloc_skb) (struct l2cap_chan *chan,
+                                        unsigned long len, int nb, int *err);
+
 };
 
 struct l2cap_conn {
-        struct hci_conn *hcon;
-        struct hci_chan *hchan;
+        struct hci_conn         *hcon;
+        struct hci_chan         *hchan;
 
-        bdaddr_t        *dst;
-        bdaddr_t        *src;
+        bdaddr_t                *dst;
+        bdaddr_t                *src;
 
-        unsigned int    mtu;
+        unsigned int            mtu;
 
-        __u32           feat_mask;
+        __u32                   feat_mask;
+        __u8                    fixed_chan_mask;
 
-        __u8            info_state;
-        __u8            info_ident;
+        __u8                    info_state;
+        __u8                    info_ident;
 
-        struct delayed_work info_timer;
+        struct delayed_work     info_timer;
 
-        spinlock_t      lock;
+        spinlock_t              lock;
 
-        struct sk_buff *rx_skb;
-        __u32           rx_len;
-        __u8            tx_ident;
+        struct sk_buff          *rx_skb;
+        __u32                   rx_len;
+        __u8                    tx_ident;
 
-        __u8            disc_reason;
+        __u8                    disc_reason;
 
-        struct delayed_work  security_timer;
-        struct smp_chan *smp_chan;
+        struct delayed_work     security_timer;
+        struct smp_chan         *smp_chan;
 
-        struct list_head chan_l;
-        struct mutex    chan_lock;
+        struct list_head        chan_l;
+        struct mutex            chan_lock;
 };
 
 #define L2CAP_INFO_CL_MTU_REQ_SENT      0x01
@@ -551,9 +556,9 @@ struct l2cap_conn {
 #define l2cap_pi(sk) ((struct l2cap_pinfo *) sk)
 
 struct l2cap_pinfo {
-        struct bt_sock  bt;
+        struct bt_sock          bt;
         struct l2cap_chan       *chan;
-        struct sk_buff  *rx_busy_skb;
+        struct sk_buff          *rx_busy_skb;
 };
 
 enum {
@@ -606,33 +611,49 @@ static inline void l2cap_chan_put(struct l2cap_chan *c)
                 kfree(c);
 }
 
+static inline void l2cap_chan_lock(struct l2cap_chan *chan)
+{
+        mutex_lock(&chan->lock);
+}
+
+static inline void l2cap_chan_unlock(struct l2cap_chan *chan)
+{
+        mutex_unlock(&chan->lock);
+}
+
 static inline void l2cap_set_timer(struct l2cap_chan *chan,
                                         struct delayed_work *work, long timeout)
 {
-        BT_DBG("chan %p state %d timeout %ld", chan, chan->state, timeout);
+        BT_DBG("chan %p state %s timeout %ld", chan,
+                                        state_to_string(chan->state), timeout);
 
-        if (!__cancel_delayed_work(work))
+        if (!cancel_delayed_work(work))
                 l2cap_chan_hold(chan);
         schedule_delayed_work(work, timeout);
 }
 
-static inline void l2cap_clear_timer(struct l2cap_chan *chan,
+static inline bool l2cap_clear_timer(struct l2cap_chan *chan,
                                         struct delayed_work *work)
 {
-        if (__cancel_delayed_work(work))
+        bool ret;
+
+        ret = cancel_delayed_work(work);
+        if (ret)
                 l2cap_chan_put(chan);
+
+        return ret;
 }
 
 #define __set_chan_timer(c, t) l2cap_set_timer(c, &c->chan_timer, (t))
 #define __clear_chan_timer(c) l2cap_clear_timer(c, &c->chan_timer)
 #define __set_retrans_timer(c) l2cap_set_timer(c, &c->retrans_timer, \
-                L2CAP_DEFAULT_RETRANS_TO);
+                msecs_to_jiffies(L2CAP_DEFAULT_RETRANS_TO));
 #define __clear_retrans_timer(c) l2cap_clear_timer(c, &c->retrans_timer)
 #define __set_monitor_timer(c) l2cap_set_timer(c, &c->monitor_timer, \
-                L2CAP_DEFAULT_MONITOR_TO);
+                msecs_to_jiffies(L2CAP_DEFAULT_MONITOR_TO));
 #define __clear_monitor_timer(c) l2cap_clear_timer(c, &c->monitor_timer)
 #define __set_ack_timer(c) l2cap_set_timer(c, &chan->ack_timer, \
-                L2CAP_DEFAULT_ACK_TO);
+                msecs_to_jiffies(L2CAP_DEFAULT_ACK_TO));
 #define __clear_ack_timer(c) l2cap_clear_timer(c, &c->ack_timer)
 
 static inline int __seq_offset(struct l2cap_chan *chan, __u16 seq1, __u16 seq2)
@@ -834,7 +855,7 @@ int l2cap_add_scid(struct l2cap_chan *chan,  __u16 scid);
 struct l2cap_chan *l2cap_chan_create(struct sock *sk);
 void l2cap_chan_close(struct l2cap_chan *chan, int reason);
 void l2cap_chan_destroy(struct l2cap_chan *chan);
-inline int l2cap_chan_connect(struct l2cap_chan *chan, __le16 psm, u16 cid,
+int l2cap_chan_connect(struct l2cap_chan *chan, __le16 psm, u16 cid,
                                                                 bdaddr_t *dst);
 int l2cap_chan_send(struct l2cap_chan *chan, struct msghdr *msg, size_t len,
                                                                 u32 priority);
diff --git a/include/net/bluetooth/mgmt.h b/include/net/bluetooth/mgmt.h
index be65d341788..ffc1377e092 100644
--- a/include/net/bluetooth/mgmt.h
+++ b/include/net/bluetooth/mgmt.h
@@ -2,6 +2,7 @@
    BlueZ - Bluetooth protocol stack for Linux
 
    Copyright (C) 2010  Nokia Corporation
+   Copyright (C) 2011-2012  Intel Corporation
 
    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
@@ -39,29 +40,47 @@
 #define MGMT_STATUS_INVALID_PARAMS      0x0d
 #define MGMT_STATUS_DISCONNECTED        0x0e
 #define MGMT_STATUS_NOT_POWERED         0x0f
+#define MGMT_STATUS_CANCELLED           0x10
+#define MGMT_STATUS_INVALID_INDEX       0x11
 
 struct mgmt_hdr {
-        __le16 opcode;
-        __le16 index;
-        __le16 len;
+        __le16  opcode;
+        __le16  index;
+        __le16  len;
 } __packed;
 
+struct mgmt_addr_info {
+        bdaddr_t        bdaddr;
+        __u8            type;
+} __packed;
+#define MGMT_ADDR_INFO_SIZE             7
+
 #define MGMT_OP_READ_VERSION            0x0001
+#define MGMT_READ_VERSION_SIZE          0
 struct mgmt_rp_read_version {
-        __u8 version;
-        __le16 revision;
+        __u8    version;
+        __le16  revision;
+} __packed;
+
+#define MGMT_OP_READ_COMMANDS           0x0002
+#define MGMT_READ_COMMANDS_SIZE         0
+struct mgmt_rp_read_commands {
+        __le16  num_commands;
+        __le16  num_events;
+        __le16  opcodes[0];
 } __packed;
 
 #define MGMT_OP_READ_INDEX_LIST         0x0003
+#define MGMT_READ_INDEX_LIST_SIZE       0
 struct mgmt_rp_read_index_list {
-        __le16 num_controllers;
-        __le16 index[0];
+        __le16  num_controllers;
+        __le16  index[0];
 } __packed;
 
 /* Reserve one extra byte for names in management messages so that they
  * are always guaranteed to be nul-terminated */
 #define MGMT_MAX_NAME_LENGTH            (HCI_MAX_NAME_LENGTH + 1)
-#define MGMT_MAX_SHORT_NAME_LENGTH      (10 + 1)
+#define MGMT_MAX_SHORT_NAME_LENGTH      (HCI_MAX_SHORT_NAME_LENGTH + 1)
 
 #define MGMT_SETTING_POWERED            0x00000001
 #define MGMT_SETTING_CONNECTABLE        0x00000002
@@ -75,28 +94,32 @@ struct mgmt_rp_read_index_list {
 #define MGMT_SETTING_LE                 0x00000200
 
 #define MGMT_OP_READ_INFO               0x0004
+#define MGMT_READ_INFO_SIZE             0
 struct mgmt_rp_read_info {
-        bdaddr_t bdaddr;
-        __u8 version;
-        __le16 manufacturer;
-        __le32 supported_settings;
-        __le32 current_settings;
-        __u8 dev_class[3];
-        __u8 name[MGMT_MAX_NAME_LENGTH];
-        __u8 short_name[MGMT_MAX_SHORT_NAME_LENGTH];
+        bdaddr_t        bdaddr;
+        __u8            version;
+        __le16          manufacturer;
+        __le32          supported_settings;
+        __le32          current_settings;
+        __u8            dev_class[3];
+        __u8            name[MGMT_MAX_NAME_LENGTH];
+        __u8            short_name[MGMT_MAX_SHORT_NAME_LENGTH];
 } __packed;
 
 struct mgmt_mode {
         __u8 val;
 } __packed;
 
+#define MGMT_SETTING_SIZE               1
+
 #define MGMT_OP_SET_POWERED             0x0005
 
 #define MGMT_OP_SET_DISCOVERABLE        0x0006
 struct mgmt_cp_set_discoverable {
-        __u8 val;
-        __u16 timeout;
+        __u8    val;
+        __u16   timeout;
 } __packed;
+#define MGMT_SET_DISCOVERABLE_SIZE      3
 
 #define MGMT_OP_SET_CONNECTABLE         0x0007
 
@@ -111,73 +134,76 @@ struct mgmt_cp_set_discoverable {
 #define MGMT_OP_SET_HS                  0x000C
 
 #define MGMT_OP_SET_LE                  0x000D
-
 #define MGMT_OP_SET_DEV_CLASS           0x000E
 struct mgmt_cp_set_dev_class {
-        __u8 major;
-        __u8 minor;
+        __u8    major;
+        __u8    minor;
 } __packed;
+#define MGMT_SET_DEV_CLASS_SIZE         2
 
 #define MGMT_OP_SET_LOCAL_NAME          0x000F
 struct mgmt_cp_set_local_name {
-        __u8 name[MGMT_MAX_NAME_LENGTH];
+        __u8    name[MGMT_MAX_NAME_LENGTH];
+        __u8    short_name[MGMT_MAX_SHORT_NAME_LENGTH];
 } __packed;
+#define MGMT_SET_LOCAL_NAME_SIZE        260
 
 #define MGMT_OP_ADD_UUID                0x0010
 struct mgmt_cp_add_uuid {
-        __u8 uuid[16];
-        __u8 svc_hint;
+        __u8    uuid[16];
+        __u8    svc_hint;
 } __packed;
+#define MGMT_ADD_UUID_SIZE              17
 
 #define MGMT_OP_REMOVE_UUID             0x0011
 struct mgmt_cp_remove_uuid {
-        __u8 uuid[16];
+        __u8    uuid[16];
 } __packed;
+#define MGMT_REMOVE_UUID_SIZE           16
 
 struct mgmt_link_key_info {
-        bdaddr_t bdaddr;
-        u8 type;
-        u8 val[16];
-        u8 pin_len;
+        struct mgmt_addr_info addr;
+        __u8    type;
+        __u8    val[16];
+        __u8    pin_len;
 } __packed;
 
 #define MGMT_OP_LOAD_LINK_KEYS          0x0012
 struct mgmt_cp_load_link_keys {
-        __u8 debug_keys;
-        __le16 key_count;
-        struct mgmt_link_key_info keys[0];
+        __u8    debug_keys;
+        __le16  key_count;
+        struct  mgmt_link_key_info keys[0];
 } __packed;
+#define MGMT_LOAD_LINK_KEYS_SIZE        3
 
-#define MGMT_OP_REMOVE_KEYS             0x0013
-struct mgmt_cp_remove_keys {
-        bdaddr_t bdaddr;
-        __u8 disconnect;
+struct mgmt_ltk_info {
+        struct mgmt_addr_info addr;
+        __u8    authenticated;
+        __u8    master;
+        __u8    enc_size;
+        __le16  ediv;
+        __u8    rand[8];
+        __u8    val[16];
 } __packed;
-struct mgmt_rp_remove_keys {
-        bdaddr_t bdaddr;
-        __u8 status;
-};
+
+#define MGMT_OP_LOAD_LONG_TERM_KEYS     0x0013
+struct mgmt_cp_load_long_term_keys {
+        __le16  key_count;
+        struct  mgmt_ltk_info keys[0];
+} __packed;
+#define MGMT_LOAD_LONG_TERM_KEYS_SIZE   2
 
 #define MGMT_OP_DISCONNECT              0x0014
 struct mgmt_cp_disconnect {
-        bdaddr_t bdaddr;
+        struct mgmt_addr_info addr;
 } __packed;
+#define MGMT_DISCONNECT_SIZE            MGMT_ADDR_INFO_SIZE
 struct mgmt_rp_disconnect {
-        bdaddr_t bdaddr;
-        __u8 status;
-} __packed;
-
-#define MGMT_ADDR_BREDR                 0x00
-#define MGMT_ADDR_LE_PUBLIC             0x01
-#define MGMT_ADDR_LE_RANDOM             0x02
-#define MGMT_ADDR_INVALID               0xff
-
-struct mgmt_addr_info {
-        bdaddr_t bdaddr;
-        __u8 type;
+        struct mgmt_addr_info addr;
 } __packed;
 
 #define MGMT_OP_GET_CONNECTIONS         0x0015
+#define MGMT_GET_CONNECTIONS_SIZE       0
 struct mgmt_rp_get_connections {
         __le16 conn_count;
         struct mgmt_addr_info addr[0];
@@ -185,124 +211,152 @@ struct mgmt_rp_get_connections {
 
 #define MGMT_OP_PIN_CODE_REPLY          0x0016
 struct mgmt_cp_pin_code_reply {
-        bdaddr_t bdaddr;
-        __u8 pin_len;
-        __u8 pin_code[16];
+        struct mgmt_addr_info addr;
+        __u8    pin_len;
+        __u8    pin_code[16];
 } __packed;
+#define MGMT_PIN_CODE_REPLY_SIZE        (MGMT_ADDR_INFO_SIZE + 17)
 struct mgmt_rp_pin_code_reply {
-        bdaddr_t bdaddr;
-        uint8_t status;
+        struct mgmt_addr_info addr;
 } __packed;
 
 #define MGMT_OP_PIN_CODE_NEG_REPLY      0x0017
 struct mgmt_cp_pin_code_neg_reply {
-        bdaddr_t bdaddr;
+        struct mgmt_addr_info addr;
 } __packed;
+#define MGMT_PIN_CODE_NEG_REPLY_SIZE    MGMT_ADDR_INFO_SIZE
 
 #define MGMT_OP_SET_IO_CAPABILITY       0x0018
 struct mgmt_cp_set_io_capability {
-        __u8 io_capability;
+        __u8    io_capability;
 } __packed;
+#define MGMT_SET_IO_CAPABILITY_SIZE     1
 
 #define MGMT_OP_PAIR_DEVICE             0x0019
 struct mgmt_cp_pair_device {
         struct mgmt_addr_info addr;
-        __u8 io_cap;
+        __u8    io_cap;
 } __packed;
+#define MGMT_PAIR_DEVICE_SIZE           (MGMT_ADDR_INFO_SIZE + 1)
 struct mgmt_rp_pair_device {
         struct mgmt_addr_info addr;
-        __u8 status;
 } __packed;
 
-#define MGMT_OP_USER_CONFIRM_REPLY      0x001A
+#define MGMT_OP_CANCEL_PAIR_DEVICE      0x001A
+#define MGMT_CANCEL_PAIR_DEVICE_SIZE    MGMT_ADDR_INFO_SIZE
+
+#define MGMT_OP_UNPAIR_DEVICE           0x001B
+struct mgmt_cp_unpair_device {
+        struct mgmt_addr_info addr;
+        __u8 disconnect;
+} __packed;
+#define MGMT_UNPAIR_DEVICE_SIZE         (MGMT_ADDR_INFO_SIZE + 1)
+struct mgmt_rp_unpair_device {
+        struct mgmt_addr_info addr;
+};
+
+#define MGMT_OP_USER_CONFIRM_REPLY      0x001C
 struct mgmt_cp_user_confirm_reply {
-        bdaddr_t bdaddr;
+        struct mgmt_addr_info addr;
 } __packed;
+#define MGMT_USER_CONFIRM_REPLY_SIZE    MGMT_ADDR_INFO_SIZE
 struct mgmt_rp_user_confirm_reply {
-        bdaddr_t bdaddr;
-        __u8 status;
+        struct mgmt_addr_info addr;
 } __packed;
 
-#define MGMT_OP_USER_CONFIRM_NEG_REPLY  0x001B
+#define MGMT_OP_USER_CONFIRM_NEG_REPLY  0x001D
 struct mgmt_cp_user_confirm_neg_reply {
-        bdaddr_t bdaddr;
+        struct mgmt_addr_info addr;
 } __packed;
+#define MGMT_USER_CONFIRM_NEG_REPLY_SIZE MGMT_ADDR_INFO_SIZE
 
-#define MGMT_OP_USER_PASSKEY_REPLY      0x001C
+#define MGMT_OP_USER_PASSKEY_REPLY      0x001E
 struct mgmt_cp_user_passkey_reply {
-        bdaddr_t bdaddr;
-        __le32 passkey;
+        struct mgmt_addr_info addr;
+        __le32  passkey;
 } __packed;
+#define MGMT_USER_PASSKEY_REPLY_SIZE    (MGMT_ADDR_INFO_SIZE + 4)
 struct mgmt_rp_user_passkey_reply {
-        bdaddr_t bdaddr;
-        __u8 status;
+        struct mgmt_addr_info addr;
 } __packed;
 
-#define MGMT_OP_USER_PASSKEY_NEG_REPLY  0x001D
+#define MGMT_OP_USER_PASSKEY_NEG_REPLY  0x001F
 struct mgmt_cp_user_passkey_neg_reply {
-        bdaddr_t bdaddr;
+        struct mgmt_addr_info addr;
 } __packed;
+#define MGMT_USER_PASSKEY_NEG_REPLY_SIZE MGMT_ADDR_INFO_SIZE
 
-#define MGMT_OP_READ_LOCAL_OOB_DATA     0x001E
+#define MGMT_OP_READ_LOCAL_OOB_DATA     0x0020
+#define MGMT_READ_LOCAL_OOB_DATA_SIZE   0
 struct mgmt_rp_read_local_oob_data {
-        __u8 hash[16];
-        __u8 randomizer[16];
+        __u8    hash[16];
+        __u8    randomizer[16];
 } __packed;
 
-#define MGMT_OP_ADD_REMOTE_OOB_DATA     0x001F
+#define MGMT_OP_ADD_REMOTE_OOB_DATA     0x0021
 struct mgmt_cp_add_remote_oob_data {
-        bdaddr_t bdaddr;
-        __u8 hash[16];
-        __u8 randomizer[16];
+        struct mgmt_addr_info addr;
+        __u8    hash[16];
+        __u8    randomizer[16];
 } __packed;
+#define MGMT_ADD_REMOTE_OOB_DATA_SIZE   (MGMT_ADDR_INFO_SIZE + 32)
 
-#define MGMT_OP_REMOVE_REMOTE_OOB_DATA  0x0020
+#define MGMT_OP_REMOVE_REMOTE_OOB_DATA  0x0022
 struct mgmt_cp_remove_remote_oob_data {
-        bdaddr_t bdaddr;
+        struct mgmt_addr_info addr;
 } __packed;
+#define MGMT_REMOVE_REMOTE_OOB_DATA_SIZE MGMT_ADDR_INFO_SIZE
 
-#define MGMT_OP_START_DISCOVERY         0x0021
+#define MGMT_OP_START_DISCOVERY         0x0023
 struct mgmt_cp_start_discovery {
         __u8 type;
 } __packed;
+#define MGMT_START_DISCOVERY_SIZE       1
 
-#define MGMT_OP_STOP_DISCOVERY          0x0022
+#define MGMT_OP_STOP_DISCOVERY          0x0024
+struct mgmt_cp_stop_discovery {
+        __u8 type;
+} __packed;
+#define MGMT_STOP_DISCOVERY_SIZE        1
 
-#define MGMT_OP_CONFIRM_NAME            0x0023
+#define MGMT_OP_CONFIRM_NAME            0x0025
 struct mgmt_cp_confirm_name {
-        bdaddr_t bdaddr;
-        __u8 name_known;
+        struct mgmt_addr_info addr;
+        __u8    name_known;
 } __packed;
+#define MGMT_CONFIRM_NAME_SIZE          (MGMT_ADDR_INFO_SIZE + 1)
 struct mgmt_rp_confirm_name {
-        bdaddr_t bdaddr;
-        __u8 status;
+        struct mgmt_addr_info addr;
 } __packed;
 
-#define MGMT_OP_BLOCK_DEVICE            0x0024
+#define MGMT_OP_BLOCK_DEVICE            0x0026
 struct mgmt_cp_block_device {
-        bdaddr_t bdaddr;
+        struct mgmt_addr_info addr;
 } __packed;
+#define MGMT_BLOCK_DEVICE_SIZE          MGMT_ADDR_INFO_SIZE
 
-#define MGMT_OP_UNBLOCK_DEVICE          0x0025
+#define MGMT_OP_UNBLOCK_DEVICE          0x0027
 struct mgmt_cp_unblock_device {
-        bdaddr_t bdaddr;
+        struct mgmt_addr_info addr;
 } __packed;
+#define MGMT_UNBLOCK_DEVICE_SIZE        MGMT_ADDR_INFO_SIZE
 
 #define MGMT_EV_CMD_COMPLETE            0x0001
 struct mgmt_ev_cmd_complete {
-        __le16 opcode;
-        __u8 data[0];
+        __le16  opcode;
+        __u8    status;
+        __u8    data[0];
 } __packed;
 
 #define MGMT_EV_CMD_STATUS              0x0002
 struct mgmt_ev_cmd_status {
-        __u8 status;
-        __le16 opcode;
+        __le16  opcode;
+        __u8    status;
 } __packed;
 
 #define MGMT_EV_CONTROLLER_ERROR        0x0003
 struct mgmt_ev_controller_error {
-        __u8 error_code;
+        __u8    error_code;
 } __packed;
 
 #define MGMT_EV_INDEX_ADDED             0x0004
@@ -313,78 +367,96 @@ struct mgmt_ev_controller_error {
 
 #define MGMT_EV_CLASS_OF_DEV_CHANGED    0x0007
 struct mgmt_ev_class_of_dev_changed {
-        __u8 dev_class[3];
+        __u8    dev_class[3];
 };
 
 #define MGMT_EV_LOCAL_NAME_CHANGED      0x0008
 struct mgmt_ev_local_name_changed {
-        __u8 name[MGMT_MAX_NAME_LENGTH];
-        __u8 short_name[MGMT_MAX_SHORT_NAME_LENGTH];
+        __u8    name[MGMT_MAX_NAME_LENGTH];
+        __u8    short_name[MGMT_MAX_SHORT_NAME_LENGTH];
 } __packed;
 
 #define MGMT_EV_NEW_LINK_KEY            0x0009
 struct mgmt_ev_new_link_key {
-        __u8 store_hint;
+        __u8    store_hint;
         struct mgmt_link_key_info key;
 } __packed;
 
-#define MGMT_EV_CONNECTED               0x000A
+#define MGMT_EV_NEW_LONG_TERM_KEY       0x000A
+struct mgmt_ev_new_long_term_key {
+        __u8    store_hint;
+        struct mgmt_ltk_info key;
+} __packed;
 
-#define MGMT_EV_DISCONNECTED            0x000B
+#define MGMT_EV_DEVICE_CONNECTED        0x000B
+struct mgmt_ev_device_connected {
+        struct mgmt_addr_info addr;
+        __le32  flags;
+        __le16  eir_len;
+        __u8    eir[0];
+} __packed;
+
+#define MGMT_EV_DEVICE_DISCONNECTED     0x000C
 
-#define MGMT_EV_CONNECT_FAILED          0x000C
+#define MGMT_EV_CONNECT_FAILED          0x000D
 struct mgmt_ev_connect_failed {
         struct mgmt_addr_info addr;
-        __u8 status;
+        __u8    status;
 } __packed;
 
-#define MGMT_EV_PIN_CODE_REQUEST        0x000D
+#define MGMT_EV_PIN_CODE_REQUEST        0x000E
 struct mgmt_ev_pin_code_request {
-        bdaddr_t bdaddr;
-        __u8 secure;
+        struct mgmt_addr_info addr;
+        __u8    secure;
 } __packed;
 
-#define MGMT_EV_USER_CONFIRM_REQUEST    0x000E
+#define MGMT_EV_USER_CONFIRM_REQUEST    0x000F
 struct mgmt_ev_user_confirm_request {
-        bdaddr_t bdaddr;
-        __u8 confirm_hint;
-        __le32 value;
+        struct mgmt_addr_info addr;
+        __u8    confirm_hint;
+        __le32  value;
 } __packed;
 
-#define MGMT_EV_USER_PASSKEY_REQUEST    0x000F
+#define MGMT_EV_USER_PASSKEY_REQUEST    0x0010
 struct mgmt_ev_user_passkey_request {
-        bdaddr_t bdaddr;
+        struct mgmt_addr_info addr;
 } __packed;
 
-#define MGMT_EV_AUTH_FAILED             0x0010
+#define MGMT_EV_AUTH_FAILED             0x0011
 struct mgmt_ev_auth_failed {
-        bdaddr_t bdaddr;
-        __u8 status;
+        struct mgmt_addr_info addr;
+        __u8    status;
 } __packed;
 
-#define MGMT_EV_DEVICE_FOUND            0x0011
+#define MGMT_DEV_FOUND_CONFIRM_NAME    0x01
+#define MGMT_DEV_FOUND_LEGACY_PAIRING  0x02
+
+#define MGMT_EV_DEVICE_FOUND            0x0012
 struct mgmt_ev_device_found {
         struct mgmt_addr_info addr;
-        __u8 dev_class[3];
-        __s8 rssi;
-        __u8 confirm_name;
-        __u8 eir[HCI_MAX_EIR_LENGTH];
-} __packed;
-
-#define MGMT_EV_REMOTE_NAME             0x0012
-struct mgmt_ev_remote_name {
-        bdaddr_t bdaddr;
-        __u8 name[MGMT_MAX_NAME_LENGTH];
+        __s8    rssi;
+        __u8    flags[4];
+        __le16  eir_len;
+        __u8    eir[0];
 } __packed;
 
 #define MGMT_EV_DISCOVERING             0x0013
+struct mgmt_ev_discovering {
+        __u8    type;
+        __u8    discovering;
+} __packed;
 
 #define MGMT_EV_DEVICE_BLOCKED          0x0014
 struct mgmt_ev_device_blocked {
-        bdaddr_t bdaddr;
+        struct mgmt_addr_info addr;
 } __packed;
 
 #define MGMT_EV_DEVICE_UNBLOCKED        0x0015
 struct mgmt_ev_device_unblocked {
-        bdaddr_t bdaddr;
+        struct mgmt_addr_info addr;
+} __packed;
+
+#define MGMT_EV_DEVICE_UNPAIRED         0x0016
+struct mgmt_ev_device_unpaired {
+        struct mgmt_addr_info addr;
 } __packed;
diff --git a/include/net/bluetooth/smp.h b/include/net/bluetooth/smp.h
index aeaf5fa2b9f..7b3acdd2913 100644
--- a/include/net/bluetooth/smp.h
+++ b/include/net/bluetooth/smp.h
@@ -127,7 +127,7 @@ struct smp_chan {
         u8              rrnd[16]; /* SMP Pairing Random (remote) */
         u8              pcnf[16]; /* SMP Pairing Confirm */
         u8              tk[16]; /* SMP Temporary Key */
-        u8              smp_key_size;
+        u8              enc_key_size;
         unsigned long   smp_flags;
         struct crypto_blkcipher *tfm;
         struct work_struct confirm;
diff --git a/include/net/caif/caif_hsi.h b/include/net/caif/caif_hsi.h
index 8d552519ff6..6db8ecf52aa 100644
--- a/include/net/caif/caif_hsi.h
+++ b/include/net/caif/caif_hsi.h
@@ -138,6 +138,7 @@ struct cfhsi {
         u8 *rx_ptr;
         u8 *tx_buf;
         u8 *rx_buf;
+        u8 *rx_flip_buf;
         spinlock_t lock;
         int flow_off_sent;
         u32 q_low_mark;
diff --git a/include/net/cfg80211.h b/include/net/cfg80211.h
index 15f4be7d768..69b7ad3a992 100644
--- a/include/net/cfg80211.h
+++ b/include/net/cfg80211.h
@@ -120,6 +120,7 @@ enum ieee80211_channel_flags {
  * @band: band this channel belongs to.
  * @max_antenna_gain: maximum antenna gain in dBi
  * @max_power: maximum transmission power (in dBm)
+ * @max_reg_power: maximum regulatory transmission power (in dBm)
  * @beacon_found: helper to regulatory code to indicate when a beacon
  *      has been found on this channel. Use regulatory_hint_found_beacon()
  *      to enable this, this is useful only on 5 GHz band.
@@ -133,6 +134,7 @@ struct ieee80211_channel {
         u32 flags;
         int max_antenna_gain;
         int max_power;
+        int max_reg_power;
         bool beacon_found;
         u32 orig_flags;
         int orig_mag, orig_mpwr;
@@ -364,25 +366,13 @@ struct cfg80211_crypto_settings {
 };
 
 /**
- * struct beacon_parameters - beacon parameters
- *
- * Used to configure the beacon for an interface.
- *
+ * struct cfg80211_beacon_data - beacon data
  * @head: head portion of beacon (before TIM IE)
  *     or %NULL if not changed
  * @tail: tail portion of beacon (after TIM IE)
  *     or %NULL if not changed
- * @interval: beacon interval or zero if not changed
- * @dtim_period: DTIM period or zero if not changed
  * @head_len: length of @head
  * @tail_len: length of @tail
- * @ssid: SSID to be used in the BSS (note: may be %NULL if not provided from
- *      user space)
- * @ssid_len: length of @ssid
- * @hidden_ssid: whether to hide the SSID in Beacon/Probe Response frames
- * @crypto: crypto settings
- * @privacy: the BSS uses privacy
- * @auth_type: Authentication type (algorithm)
  * @beacon_ies: extra information element(s) to add into Beacon frames or %NULL
  * @beacon_ies_len: length of beacon_ies in octets
  * @proberesp_ies: extra information element(s) to add into Probe Response
@@ -394,24 +384,48 @@ struct cfg80211_crypto_settings {
  * @probe_resp_len: length of probe response template (@probe_resp)
  * @probe_resp: probe response template (AP mode only)
  */
-struct beacon_parameters {
-        u8 *head, *tail;
-        int interval, dtim_period;
-        int head_len, tail_len;
+struct cfg80211_beacon_data {
+        const u8 *head, *tail;
+        const u8 *beacon_ies;
+        const u8 *proberesp_ies;
+        const u8 *assocresp_ies;
+        const u8 *probe_resp;
+
+        size_t head_len, tail_len;
+        size_t beacon_ies_len;
+        size_t proberesp_ies_len;
+        size_t assocresp_ies_len;
+        size_t probe_resp_len;
+};
+
+/**
+ * struct cfg80211_ap_settings - AP configuration
+ *
+ * Used to configure an AP interface.
+ *
+ * @beacon: beacon data
+ * @beacon_interval: beacon interval
+ * @dtim_period: DTIM period
+ * @ssid: SSID to be used in the BSS (note: may be %NULL if not provided from
+ *      user space)
+ * @ssid_len: length of @ssid
+ * @hidden_ssid: whether to hide the SSID in Beacon/Probe Response frames
+ * @crypto: crypto settings
+ * @privacy: the BSS uses privacy
+ * @auth_type: Authentication type (algorithm)
+ * @inactivity_timeout: time in seconds to determine station's inactivity.
+ */
+struct cfg80211_ap_settings {
+        struct cfg80211_beacon_data beacon;
+
+        int beacon_interval, dtim_period;
         const u8 *ssid;
         size_t ssid_len;
         enum nl80211_hidden_ssid hidden_ssid;
         struct cfg80211_crypto_settings crypto;
         bool privacy;
         enum nl80211_auth_type auth_type;
-        const u8 *beacon_ies;
-        size_t beacon_ies_len;
-        const u8 *proberesp_ies;
-        size_t proberesp_ies_len;
-        const u8 *assocresp_ies;
-        size_t assocresp_ies_len;
-        int probe_resp_len;
-        u8 *probe_resp;
+        int inactivity_timeout;
 };
 
 /**
@@ -796,6 +810,8 @@ struct mesh_config {
          * mesh gate, but not necessarily using the gate announcement protocol.
          * Still keeping the same nomenclature to be in sync with the spec. */
         bool  dot11MeshGateAnnouncementProtocol;
+        bool dot11MeshForwarding;
+        s32 rssi_threshold;
 };
 
 /**
@@ -1036,10 +1052,6 @@ const u8 *ieee80211_bss_get_ie(struct cfg80211_bss *bss, u8 ie);
  * @key_len: length of WEP key for shared key authentication
  * @key_idx: index of WEP key for shared key authentication
  * @key: WEP key for shared key authentication
- * @local_state_change: This is a request for a local state only, i.e., no
- *      Authentication frame is to be transmitted and authentication state is
- *      to be changed without having to wait for a response from the peer STA
- *      (AP).
  */
 struct cfg80211_auth_request {
         struct cfg80211_bss *bss;
@@ -1048,7 +1060,6 @@ struct cfg80211_auth_request {
         enum nl80211_auth_type auth_type;
         const u8 *key;
         u8 key_len, key_idx;
-        bool local_state_change;
 };
 
 /**
@@ -1065,7 +1076,11 @@ enum cfg80211_assoc_req_flags {
  *
  * This structure provides information needed to complete IEEE 802.11
  * (re)association.
- * @bss: The BSS to associate with.
+ * @bss: The BSS to associate with. If the call is successful the driver
+ *      is given a reference that it must release, normally via a call to
+ *      cfg80211_send_rx_assoc(), or, if association timed out, with a
+ *      call to cfg80211_put_bss() (in addition to calling
+ *      cfg80211_send_assoc_timeout())
  * @ie: Extra IEs to add to (Re)Association Request frame or %NULL
  * @ie_len: Length of ie buffer in octets
  * @use_mfp: Use management frame protection (IEEE 802.11w) in this association
@@ -1093,19 +1108,16 @@ struct cfg80211_assoc_request {
  * This structure provides information needed to complete IEEE 802.11
  * deauthentication.
  *
- * @bss: the BSS to deauthenticate from
+ * @bssid: the BSSID of the BSS to deauthenticate from
  * @ie: Extra IEs to add to Deauthentication frame or %NULL
  * @ie_len: Length of ie buffer in octets
  * @reason_code: The reason code for the deauthentication
- * @local_state_change: This is a request for a local state only, i.e., no
- *      Deauthentication frame is to be transmitted.
  */
 struct cfg80211_deauth_request {
-        struct cfg80211_bss *bss;
+        const u8 *bssid;
         const u8 *ie;
         size_t ie_len;
         u16 reason_code;
-        bool local_state_change;
 };
 
 /**
@@ -1140,6 +1152,7 @@ struct cfg80211_disassoc_request {
  * @bssid: Fixed BSSID requested, maybe be %NULL, if set do not
  *      search for IBSSs with a different BSSID.
  * @channel: The channel to use if no IBSS can be found to join.
+ * @channel_type: channel type (HT mode)
  * @channel_fixed: The channel should be fixed -- do not search for
  *      IBSSs to join on other channels.
  * @ie: information element(s) to include in the beacon
@@ -1147,6 +1160,10 @@ struct cfg80211_disassoc_request {
  * @beacon_interval: beacon interval to use
  * @privacy: this is a protected network, keys will be configured
  *      after joining
+ * @control_port: whether user space controls IEEE 802.1X port, i.e.,
+ *      sets/clears %NL80211_STA_FLAG_AUTHORIZED. If true, the driver is
+ *      required to assume that the port is unauthorized until authorized by
+ *      user space. Otherwise, port is marked authorized by default.
  * @basic_rates: bitmap of basic rates to use when creating the IBSS
  * @mcast_rate: per-band multicast rate index + 1 (0: disabled)
  */
@@ -1161,6 +1178,7 @@ struct cfg80211_ibss_params {
         u32 basic_rates;
         bool channel_fixed;
         bool privacy;
+        bool control_port;
         int mcast_rate[IEEE80211_NUM_BANDS];
 };
 
@@ -1185,6 +1203,8 @@ struct cfg80211_ibss_params {
  * @key_idx: index of WEP key for shared key authentication
  * @key: WEP key for shared key authentication
  * @flags:  See &enum cfg80211_assoc_req_flags
+ * @bg_scan_period:  Background scan period in seconds
+ *   or -1 to indicate that default value is to be used.
  * @ht_capa:  HT Capabilities over-rides.  Values set in ht_capa_mask
  *   will be used in ht_capa.  Un-supported values will be ignored.
  * @ht_capa_mask:  The bits of ht_capa which are to be used.
@@ -1202,6 +1222,7 @@ struct cfg80211_connect_params {
         const u8 *key;
         u8 key_len, key_idx;
         u32 flags;
+        int bg_scan_period;
         struct ieee80211_ht_cap ht_capa;
         struct ieee80211_ht_cap ht_capa_mask;
 };
@@ -1228,8 +1249,7 @@ enum wiphy_params_flags {
 struct cfg80211_bitrate_mask {
         struct {
                 u32 legacy;
-                /* TODO: add support for masking MCS rates; e.g.: */
-                /* u8 mcs[IEEE80211_HT_MCS_MASK_LEN]; */
+                u8 mcs[IEEE80211_HT_MCS_MASK_LEN];
         } control[IEEE80211_NUM_BANDS];
 };
 /**
@@ -1342,12 +1362,10 @@ struct cfg80211_gtk_rekey_data {
  *
  * @set_rekey_data: give the data necessary for GTK rekeying to the driver
  *
- * @add_beacon: Add a beacon with given parameters, @head, @interval
- *      and @dtim_period will be valid, @tail is optional.
- * @set_beacon: Change the beacon parameters for an access point mode
- *      interface. This should reject the call when no beacon has been
- *      configured.
- * @del_beacon: Remove beacon configuration and stop sending the beacon.
+ * @start_ap: Start acting in AP mode defined by the parameters.
+ * @change_beacon: Change the beacon parameters for an access point mode
+ *      interface. This should reject the call when AP mode wasn't started.
+ * @stop_ap: Stop being an AP, including stopping beaconing.
  *
  * @add_station: Add a new station.
  * @del_station: Remove a station; @mac may be NULL to remove all stations.
@@ -1514,11 +1532,11 @@ struct cfg80211_ops {
                                         struct net_device *netdev,
                                         u8 key_index);
 
-        int     (*add_beacon)(struct wiphy *wiphy, struct net_device *dev,
-                              struct beacon_parameters *info);
-        int     (*set_beacon)(struct wiphy *wiphy, struct net_device *dev,
-                              struct beacon_parameters *info);
-        int     (*del_beacon)(struct wiphy *wiphy, struct net_device *dev);
+        int     (*start_ap)(struct wiphy *wiphy, struct net_device *dev,
+                            struct cfg80211_ap_settings *settings);
+        int     (*change_beacon)(struct wiphy *wiphy, struct net_device *dev,
+                                 struct cfg80211_beacon_data *info);
+        int     (*stop_ap)(struct wiphy *wiphy, struct net_device *dev);
 
 
         int     (*add_station)(struct wiphy *wiphy, struct net_device *dev,
@@ -1573,11 +1591,9 @@ struct cfg80211_ops {
         int     (*assoc)(struct wiphy *wiphy, struct net_device *dev,
                          struct cfg80211_assoc_request *req);
         int     (*deauth)(struct wiphy *wiphy, struct net_device *dev,
-                          struct cfg80211_deauth_request *req,
-                          void *cookie);
+                          struct cfg80211_deauth_request *req);
         int     (*disassoc)(struct wiphy *wiphy, struct net_device *dev,
-                            struct cfg80211_disassoc_request *req,
-                            void *cookie);
+                            struct cfg80211_disassoc_request *req);
 
         int     (*connect)(struct wiphy *wiphy, struct net_device *dev,
                            struct cfg80211_connect_params *sme);
@@ -1978,6 +1994,11 @@ struct wiphy_wowlan_support {
  *      configured as RX antennas. Antenna configuration commands will be
  *      rejected unless this or @available_antennas_tx is set.
  *
+ * @probe_resp_offload:
+ *       Bitmap of supported protocols for probe response offloading.
+ *       See &enum nl80211_probe_resp_offload_support_attr. Only valid
+ *       when the wiphy flag @WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD is set.
+ *
  * @max_remain_on_channel_duration: Maximum time a remain-on-channel operation
  *      may request, if implemented.
  *
@@ -2198,8 +2219,6 @@ struct cfg80211_conn;
 struct cfg80211_internal_bss;
 struct cfg80211_cached_keys;
 
-#define MAX_AUTH_BSSES          4
-
 /**
  * struct wireless_dev - wireless per-netdev state
  *
@@ -2263,8 +2282,6 @@ struct wireless_dev {
         struct list_head event_list;
         spinlock_t event_lock;
 
-        struct cfg80211_internal_bss *authtry_bsses[MAX_AUTH_BSSES];
-        struct cfg80211_internal_bss *auth_bsses[MAX_AUTH_BSSES];
         struct cfg80211_internal_bss *current_bss; /* associated / joined */
         struct ieee80211_channel *channel;
 
@@ -2680,7 +2697,7 @@ cfg80211_inform_bss_frame(struct wiphy *wiphy,
  * @wiphy: the wiphy reporting the BSS
  * @channel: The channel the frame was received on
  * @bssid: the BSSID of the BSS
- * @timestamp: the TSF timestamp sent by the peer
+ * @tsf: the TSF sent by the peer in the beacon/probe response (or 0)
  * @capability: the capability field sent by the peer
  * @beacon_interval: the beacon interval announced by the peer
  * @ie: additional IEs sent by the peer
@@ -2696,9 +2713,8 @@ cfg80211_inform_bss_frame(struct wiphy *wiphy,
 struct cfg80211_bss * __must_check
 cfg80211_inform_bss(struct wiphy *wiphy,
                     struct ieee80211_channel *channel,
-                    const u8 *bssid,
-                    u64 timestamp, u16 capability, u16 beacon_interval,
-                    const u8 *ie, size_t ielen,
+                    const u8 *bssid, u64 tsf, u16 capability,
+                    u16 beacon_interval, const u8 *ie, size_t ielen,
                     s32 signal, gfp_t gfp);
 
 struct cfg80211_bss *cfg80211_get_bss(struct wiphy *wiphy,
@@ -2719,6 +2735,20 @@ struct cfg80211_bss *cfg80211_get_mesh(struct wiphy *wiphy,
                                        struct ieee80211_channel *channel,
                                        const u8 *meshid, size_t meshidlen,
                                        const u8 *meshcfg);
+/**
+ * cfg80211_ref_bss - reference BSS struct
+ * @bss: the BSS struct to reference
+ *
+ * Increments the refcount of the given BSS struct.
+ */
+void cfg80211_ref_bss(struct cfg80211_bss *bss);
+
+/**
+ * cfg80211_put_bss - unref BSS struct
+ * @bss: the BSS struct
+ *
+ * Decrements the refcount of the given BSS struct.
+ */
 void cfg80211_put_bss(struct cfg80211_bss *bss);
 
 /**
@@ -2756,20 +2786,10 @@ void cfg80211_send_rx_auth(struct net_device *dev, const u8 *buf, size_t len);
 void cfg80211_send_auth_timeout(struct net_device *dev, const u8 *addr);
 
 /**
- * __cfg80211_auth_canceled - notify cfg80211 that authentication was canceled
- * @dev: network device
- * @addr: The MAC address of the device with which the authentication timed out
- *
- * When a pending authentication had no action yet, the driver may decide
- * to not send a deauth frame, but in that case must calls this function
- * to tell cfg80211 about this decision. It is only valid to call this
- * function within the deauth() callback.
- */
-void __cfg80211_auth_canceled(struct net_device *dev, const u8 *addr);
-
-/**
  * cfg80211_send_rx_assoc - notification of processed association
  * @dev: network device
+ * @bss: the BSS struct association was requested for, the struct reference
+ *      is owned by cfg80211 after this call
  * @buf: (re)association response frame (header + body)
  * @len: length of the frame data
  *
@@ -2778,7 +2798,8 @@ void __cfg80211_auth_canceled(struct net_device *dev, const u8 *addr);
  * function or cfg80211_send_assoc_timeout() to indicate the result of
  * cfg80211_ops::assoc() call. This function may sleep.
  */
-void cfg80211_send_rx_assoc(struct net_device *dev, const u8 *buf, size_t len);
+void cfg80211_send_rx_assoc(struct net_device *dev, struct cfg80211_bss *bss,
+                            const u8 *buf, size_t len);
 
 /**
  * cfg80211_send_assoc_timeout - notification of timed out association
@@ -3170,6 +3191,7 @@ void cfg80211_del_sta(struct net_device *dev, const u8 *mac_addr, gfp_t gfp);
  * cfg80211_rx_mgmt - notification of received, unprocessed management frame
  * @dev: network device
  * @freq: Frequency on which the frame was received in MHz
+ * @sig_dbm: signal strength in mBm, or 0 if unknown
  * @buf: Management frame (header + body)
  * @len: length of the frame data
  * @gfp: context flags
@@ -3182,8 +3204,8 @@ void cfg80211_del_sta(struct net_device *dev, const u8 *mac_addr, gfp_t gfp);
  * This function is called whenever an Action frame is received for a station
  * mode interface, but is not processed in kernel.
  */
-bool cfg80211_rx_mgmt(struct net_device *dev, int freq, const u8 *buf,
-                      size_t len, gfp_t gfp);
+bool cfg80211_rx_mgmt(struct net_device *dev, int freq, int sig_dbm,
+                      const u8 *buf, size_t len, gfp_t gfp);
 
 /**
  * cfg80211_mgmt_tx_status - notification of TX status for management frame
@@ -3296,6 +3318,7 @@ void cfg80211_probe_status(struct net_device *dev, const u8 *addr,
  * @frame: the frame
  * @len: length of the frame
  * @freq: frequency the frame was received on
+ * @sig_dbm: signal strength in mBm, or 0 if unknown
  * @gfp: allocation flags
  *
  * Use this function to report to userspace when a beacon was
@@ -3304,7 +3327,7 @@ void cfg80211_probe_status(struct net_device *dev, const u8 *addr,
  */
 void cfg80211_report_obss_beacon(struct wiphy *wiphy,
                                  const u8 *frame, size_t len,
-                                 int freq, gfp_t gfp);
+                                 int freq, int sig_dbm, gfp_t gfp);
 
 /*
  * cfg80211_can_beacon_sec_chan - test if ht40 on extension channel can be used
@@ -3316,6 +3339,14 @@ int cfg80211_can_beacon_sec_chan(struct wiphy *wiphy,
                                  struct ieee80211_channel *chan,
                                  enum nl80211_channel_type channel_type);
 
+/*
+ * cfg80211_calculate_bitrate - calculate actual bitrate (in 100Kbps units)
+ * @rate: given rate_info to calculate bitrate from
+ *
+ * return 0 if MCS index >= 32
+ */
+u16 cfg80211_calculate_bitrate(struct rate_info *rate);
+
 /* Logging, debugging and troubleshooting/diagnostic helpers. */
 
 /* wiphy_printk helpers, similar to dev_printk */
diff --git a/include/net/compat.h b/include/net/compat.h
index 9ee75edcc29..a974ae92d18 100644
--- a/include/net/compat.h
+++ b/include/net/compat.h
@@ -41,7 +41,7 @@ extern int compat_sock_get_timestampns(struct sock *, struct timespec __user *);
 #endif /* defined(CONFIG_COMPAT) */
 
 extern int get_compat_msghdr(struct msghdr *, struct compat_msghdr __user *);
-extern int verify_compat_iovec(struct msghdr *, struct iovec *, struct sockaddr *, int);
+extern int verify_compat_iovec(struct msghdr *, struct iovec *, struct sockaddr_storage *, int);
 extern asmlinkage long compat_sys_sendmsg(int,struct compat_msghdr __user *,unsigned);
 extern asmlinkage long compat_sys_sendmmsg(int, struct compat_mmsghdr __user *,
                                            unsigned, unsigned);
diff --git a/include/net/dcbnl.h b/include/net/dcbnl.h
index 2cd66d0be34..f55c980d8e2 100644
--- a/include/net/dcbnl.h
+++ b/include/net/dcbnl.h
@@ -72,8 +72,8 @@ struct dcbnl_rtnl_ops {
         void (*getpfccfg)(struct net_device *, int, u8 *);
         u8   (*setall)(struct net_device *);
         u8   (*getcap)(struct net_device *, int, u8 *);
-        u8   (*getnumtcs)(struct net_device *, int, u8 *);
-        u8   (*setnumtcs)(struct net_device *, int, u8);
+        int  (*getnumtcs)(struct net_device *, int, u8 *);
+        int  (*setnumtcs)(struct net_device *, int, u8);
         u8   (*getpfcstate)(struct net_device *);
         void (*setpfcstate)(struct net_device *, u8);
         void (*getbcncfg)(struct net_device *, int, u32 *);
diff --git a/include/net/dn.h b/include/net/dn.h
index 298521e0d8a..814af0b9387 100644
--- a/include/net/dn.h
+++ b/include/net/dn.h
@@ -3,6 +3,7 @@
 
 #include <linux/dn.h>
 #include <net/sock.h>
+#include <net/flow.h>
 #include <asm/byteorder.h>
 #include <asm/unaligned.h>
 
diff --git a/include/net/flow.h b/include/net/flow.h
index 9b582437fbe..6c469dbdb91 100644
--- a/include/net/flow.h
+++ b/include/net/flow.h
@@ -93,6 +93,16 @@ static inline void flowi4_init_output(struct flowi4 *fl4, int oif,
         fl4->fl4_dport = dport;
         fl4->fl4_sport = sport;
 }
+
+/* Reset some input parameters after previous lookup */
+static inline void flowi4_update_output(struct flowi4 *fl4, int oif, __u8 tos,
+                                        __be32 daddr, __be32 saddr)
+{
+        fl4->flowi4_oif = oif;
+        fl4->flowi4_tos = tos;
+        fl4->daddr = daddr;
+        fl4->saddr = saddr;
+}
                                       
 
 struct flowi6 {
diff --git a/include/net/genetlink.h b/include/net/genetlink.h
index 7db32995ccd..ccb68880abf 100644
--- a/include/net/genetlink.h
+++ b/include/net/genetlink.h
@@ -131,35 +131,8 @@ extern void genl_unregister_mc_group(struct genl_family *family,
 extern void genl_notify(struct sk_buff *skb, struct net *net, u32 pid,
                         u32 group, struct nlmsghdr *nlh, gfp_t flags);
 
-/**
- * genlmsg_put - Add generic netlink header to netlink message
- * @skb: socket buffer holding the message
- * @pid: netlink pid the message is addressed to
- * @seq: sequence number (usually the one of the sender)
- * @family: generic netlink family
- * @flags netlink message flags
- * @cmd: generic netlink command
- *
- * Returns pointer to user specific header
- */
-static inline void *genlmsg_put(struct sk_buff *skb, u32 pid, u32 seq,
-                                struct genl_family *family, int flags, u8 cmd)
-{
-        struct nlmsghdr *nlh;
-        struct genlmsghdr *hdr;
-
-        nlh = nlmsg_put(skb, pid, seq, family->id, GENL_HDRLEN +
-                        family->hdrsize, flags);
-        if (nlh == NULL)
-                return NULL;
-
-        hdr = nlmsg_data(nlh);
-        hdr->cmd = cmd;
-        hdr->version = family->version;
-        hdr->reserved = 0;
-
-        return (char *) hdr + GENL_HDRLEN;
-}
+void *genlmsg_put(struct sk_buff *skb, u32 pid, u32 seq,
+                                struct genl_family *family, int flags, u8 cmd);
 
 /**
  * genlmsg_nlhdr - Obtain netlink header from user specified header
diff --git a/include/net/inet_sock.h b/include/net/inet_sock.h
index e3e405106af..ae17e1352d7 100644
--- a/include/net/inet_sock.h
+++ b/include/net/inet_sock.h
@@ -132,6 +132,7 @@ struct rtable;
  * @tos - TOS
  * @mc_ttl - Multicasting TTL
  * @is_icsk - is this an inet_connection_sock?
+ * @uc_index - Unicast outgoing device index
  * @mc_index - Multicast device index
  * @mc_list - Group array
  * @cork - info to build ip hdr on each ip frag while socket is corked
@@ -167,6 +168,8 @@ struct inet_sock {
                                 transparent:1,
                                 mc_all:1,
                                 nodefrag:1;
+        __u8                    rcv_tos;
+        int                     uc_index;
         int                     mc_index;
         __be32                  mc_addr;
         struct ip_mc_socklist __rcu     *mc_list;
diff --git a/include/net/inetpeer.h b/include/net/inetpeer.h
index 06b795dd590..b94765e38e8 100644
--- a/include/net/inetpeer.h
+++ b/include/net/inetpeer.h
@@ -35,12 +35,12 @@ struct inet_peer {
 
         u32                     metrics[RTAX_MAX];
         u32                     rate_tokens;    /* rate limiting for ICMP */
-        int                     redirect_genid;
         unsigned long           rate_last;
         unsigned long           pmtu_expires;
         u32                     pmtu_orig;
         u32                     pmtu_learned;
         struct inetpeer_addr_base redirect_learned;
+        struct list_head        gc_list;
         /*
          * Once inet_peer is queued for deletion (refcnt == -1), following fields
          * are not available: rid, ip_id_count, tcp_ts, tcp_ts_stamp
@@ -96,6 +96,8 @@ static inline struct inet_peer *inet_getpeer_v6(const struct in6_addr *v6daddr,
 extern void inet_putpeer(struct inet_peer *p);
 extern bool inet_peer_xrlim_allow(struct inet_peer *peer, int timeout);
 
+extern void inetpeer_invalidate_tree(int family);
+
 /*
  * temporary check to make sure we dont access rid, ip_id_count, tcp_ts,
  * tcp_ts_stamp if no refcount is taken on inet_peer
diff --git a/include/net/ip.h b/include/net/ip.h
index 775009f9eab..b53d65f24f7 100644
--- a/include/net/ip.h
+++ b/include/net/ip.h
@@ -388,7 +388,7 @@ static inline int sk_mc_loop(struct sock *sk)
         return 1;
 }
 
-extern int      ip_call_ra_chain(struct sk_buff *skb);
+extern bool ip_call_ra_chain(struct sk_buff *skb);
 
 /*
  *      Functions provided by ip_fragment.c
diff --git a/include/net/iucv/af_iucv.h b/include/net/iucv/af_iucv.h
index 0954ec95915..cc7c1973238 100644
--- a/include/net/iucv/af_iucv.h
+++ b/include/net/iucv/af_iucv.h
@@ -62,6 +62,7 @@ struct sock_msg_q {
 #define AF_IUCV_FLAG_SYN 0x2
 #define AF_IUCV_FLAG_FIN 0x4
 #define AF_IUCV_FLAG_WIN 0x8
+#define AF_IUCV_FLAG_SHT 0x10
 
 struct af_iucv_trans_hdr {
         u16 magic;
@@ -113,6 +114,7 @@ struct iucv_sock {
         spinlock_t              accept_q_lock;
         struct sock             *parent;
         struct iucv_path        *path;
+        struct net_device       *hs_dev;
         struct sk_buff_head     send_skb_q;
         struct sk_buff_head     backlog_skb_q;
         struct sock_msg_q       message_q;
@@ -131,6 +133,7 @@ struct iucv_sock {
 /* iucv socket options (SOL_IUCV) */
 #define SO_IPRMDATA_MSG 0x0080          /* send/recv IPRM_DATA msgs */
 #define SO_MSGLIMIT     0x1000          /* get/set IUCV MSGLIMIT */
+#define SO_MSGSIZE      0x0800          /* get maximum msgsize */
 
 /* iucv related control messages (scm) */
 #define SCM_IUCV_TRGCLS 0x0001          /* target class control message */
diff --git a/include/net/mac80211.h b/include/net/mac80211.h
index d49928ba5d0..9a012be615f 100644
--- a/include/net/mac80211.h
+++ b/include/net/mac80211.h
@@ -229,7 +229,8 @@ enum ieee80211_rssi_event {
  *      valid in station mode only while @assoc is true and if also
  *      requested by %IEEE80211_HW_NEED_DTIM_PERIOD (cf. also hw conf
  *      @ps_dtim_period)
- * @timestamp: beacon timestamp
+ * @last_tsf: last beacon's/probe response's TSF timestamp (could be old
+ *      as it may have been received during scanning long ago)
  * @beacon_int: beacon interval
  * @assoc_capability: capabilities taken from assoc resp
  * @basic_rates: bitmap of basic rates, each bit stands for an
@@ -276,7 +277,7 @@ struct ieee80211_bss_conf {
         u8 dtim_period;
         u16 beacon_int;
         u16 assoc_capability;
-        u64 timestamp;
+        u64 last_tsf;
         u32 basic_rates;
         int mcast_rate[IEEE80211_NUM_BANDS];
         u16 ht_operation_mode;
@@ -341,9 +342,9 @@ struct ieee80211_bss_conf {
  *      used to indicate that a frame was already retried due to PS
  * @IEEE80211_TX_INTFL_DONT_ENCRYPT: completely internal to mac80211,
  *      used to indicate frame should not be encrypted
- * @IEEE80211_TX_CTL_POLL_RESPONSE: This frame is a response to a poll
- *      frame (PS-Poll or uAPSD) and should be sent although the station
- *      is in powersave mode.
+ * @IEEE80211_TX_CTL_NO_PS_BUFFER: This frame is a response to a poll
+ *      frame (PS-Poll or uAPSD) or a non-bufferable MMPDU and must
+ *      be sent although the station is in powersave mode.
  * @IEEE80211_TX_CTL_MORE_FRAMES: More frames will be passed to the
  *      transmit function after the current frame, this can be used
  *      by drivers to kick the DMA queue only if unset or when the
@@ -399,7 +400,7 @@ enum mac80211_tx_control_flags {
         IEEE80211_TX_INTFL_NEED_TXPROCESSING    = BIT(14),
         IEEE80211_TX_INTFL_RETRIED              = BIT(15),
         IEEE80211_TX_INTFL_DONT_ENCRYPT         = BIT(16),
-        IEEE80211_TX_CTL_POLL_RESPONSE          = BIT(17),
+        IEEE80211_TX_CTL_NO_PS_BUFFER           = BIT(17),
         IEEE80211_TX_CTL_MORE_FRAMES            = BIT(18),
         IEEE80211_TX_INTFL_RETRANSMISSION       = BIT(19),
         /* hole at 20, use later */
@@ -425,7 +426,7 @@ enum mac80211_tx_control_flags {
         IEEE80211_TX_CTL_SEND_AFTER_DTIM | IEEE80211_TX_CTL_AMPDU |           \
         IEEE80211_TX_STAT_TX_FILTERED | IEEE80211_TX_STAT_ACK |               \
         IEEE80211_TX_STAT_AMPDU | IEEE80211_TX_STAT_AMPDU_NO_BACK |           \
-        IEEE80211_TX_CTL_RATE_CTRL_PROBE | IEEE80211_TX_CTL_POLL_RESPONSE |   \
+        IEEE80211_TX_CTL_RATE_CTRL_PROBE | IEEE80211_TX_CTL_NO_PS_BUFFER |    \
         IEEE80211_TX_CTL_MORE_FRAMES | IEEE80211_TX_CTL_LDPC |                \
         IEEE80211_TX_CTL_STBC | IEEE80211_TX_STATUS_EOSP)
 
@@ -659,6 +660,8 @@ ieee80211_tx_info_clear_status(struct ieee80211_tx_info *info)
  * @RX_FLAG_HT: HT MCS was used and rate_idx is MCS index
  * @RX_FLAG_40MHZ: HT40 (40 MHz) was used
  * @RX_FLAG_SHORT_GI: Short guard interval was used
+ * @RX_FLAG_NO_SIGNAL_VAL: The signal strength value is not present.
+ *      Valid only for data frames (mainly A-MPDU)
  */
 enum mac80211_rx_flags {
         RX_FLAG_MMIC_ERROR      = 1<<0,
@@ -672,6 +675,7 @@ enum mac80211_rx_flags {
         RX_FLAG_HT              = 1<<9,
         RX_FLAG_40MHZ           = 1<<10,
         RX_FLAG_SHORT_GI        = 1<<11,
+        RX_FLAG_NO_SIGNAL_VAL   = 1<<12,
 };
 
 /**
@@ -852,6 +856,21 @@ struct ieee80211_channel_switch {
 };
 
 /**
+ * enum ieee80211_vif_flags - virtual interface flags
+ *
+ * @IEEE80211_VIF_BEACON_FILTER: the device performs beacon filtering
+ *      on this virtual interface to avoid unnecessary CPU wakeups
+ * @IEEE80211_VIF_SUPPORTS_CQM_RSSI: the device can do connection quality
+ *      monitoring on this virtual interface -- i.e. it can monitor
+ *      connection quality related parameters, such as the RSSI level and
+ *      provide notifications if configured trigger levels are reached.
+ */
+enum ieee80211_vif_flags {
+        IEEE80211_VIF_BEACON_FILTER             = BIT(0),
+        IEEE80211_VIF_SUPPORTS_CQM_RSSI         = BIT(1),
+};
+
+/**
  * struct ieee80211_vif - per-interface data
  *
  * Data in this structure is continually present for driver
@@ -863,6 +882,10 @@ struct ieee80211_channel_switch {
  * @addr: address of this interface
  * @p2p: indicates whether this AP or STA interface is a p2p
  *      interface, i.e. a GO or p2p-sta respectively
+ * @driver_flags: flags/capabilities the driver has for this interface,
+ *      these need to be set (or cleared) when the interface is added
+ *      or, if supported by the driver, the interface type is changed
+ *      at runtime, mac80211 will never touch this field
  * @drv_priv: data area for driver use, will always be aligned to
  *      sizeof(void *).
  */
@@ -871,6 +894,7 @@ struct ieee80211_vif {
         struct ieee80211_bss_conf bss_conf;
         u8 addr[ETH_ALEN];
         bool p2p;
+        u32 driver_flags;
         /* must be last */
         u8 drv_priv[0] __attribute__((__aligned__(sizeof(void *))));
 };
@@ -962,6 +986,25 @@ enum set_key_cmd {
 };
 
 /**
+ * enum ieee80211_sta_state - station state
+ *
+ * @IEEE80211_STA_NOTEXIST: station doesn't exist at all,
+ *      this is a special state for add/remove transitions
+ * @IEEE80211_STA_NONE: station exists without special state
+ * @IEEE80211_STA_AUTH: station is authenticated
+ * @IEEE80211_STA_ASSOC: station is associated
+ * @IEEE80211_STA_AUTHORIZED: station is authorized (802.1X)
+ */
+enum ieee80211_sta_state {
+        /* NOTE: These need to be ordered correctly! */
+        IEEE80211_STA_NOTEXIST,
+        IEEE80211_STA_NONE,
+        IEEE80211_STA_AUTH,
+        IEEE80211_STA_ASSOC,
+        IEEE80211_STA_AUTHORIZED,
+};
+
+/**
  * struct ieee80211_sta - station table entry
  *
  * A station table entry represents a station we are possibly
@@ -1079,10 +1122,6 @@ enum sta_notify_cmd {
  * @IEEE80211_HW_MFP_CAPABLE:
  *      Hardware supports management frame protection (MFP, IEEE 802.11w).
  *
- * @IEEE80211_HW_BEACON_FILTER:
- *      Hardware supports dropping of irrelevant beacon frames to
- *      avoid waking up cpu.
- *
  * @IEEE80211_HW_SUPPORTS_STATIC_SMPS:
  *      Hardware supports static spatial multiplexing powersave,
  *      ie. can turn off all but one chain even on HT connections
@@ -1108,11 +1147,6 @@ enum sta_notify_cmd {
  *      When this flag is set, signaling beacon-loss will cause an immediate
  *      change to disassociated state.
  *
- * @IEEE80211_HW_SUPPORTS_CQM_RSSI:
- *      Hardware can do connection quality monitoring - i.e. it can monitor
- *      connection quality related parameters, such as the RSSI level and
- *      provide notifications if configured trigger levels are reached.
- *
  * @IEEE80211_HW_NEED_DTIM_PERIOD:
  *      This device needs to know the DTIM period for the BSS before
  *      associating.
@@ -1134,6 +1168,10 @@ enum sta_notify_cmd {
  * @IEEE80211_HW_TX_AMPDU_SETUP_IN_HW: The device handles TX A-MPDU session
  *      setup strictly in HW. mac80211 should not attempt to do this in
  *      software.
+ *
+ * @IEEE80211_HW_SCAN_WHILE_IDLE: The device can do hw scan while
+ *      being idle (i.e. mac80211 doesn't have to go idle-off during the
+ *      the scan).
  */
 enum ieee80211_hw_flags {
         IEEE80211_HW_HAS_RATE_CONTROL                   = 1<<0,
@@ -1150,16 +1188,17 @@ enum ieee80211_hw_flags {
         IEEE80211_HW_PS_NULLFUNC_STACK                  = 1<<11,
         IEEE80211_HW_SUPPORTS_DYNAMIC_PS                = 1<<12,
         IEEE80211_HW_MFP_CAPABLE                        = 1<<13,
-        IEEE80211_HW_BEACON_FILTER                      = 1<<14,
+        /* reuse bit 14 */
         IEEE80211_HW_SUPPORTS_STATIC_SMPS               = 1<<15,
         IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS              = 1<<16,
         IEEE80211_HW_SUPPORTS_UAPSD                     = 1<<17,
         IEEE80211_HW_REPORTS_TX_ACK_STATUS              = 1<<18,
         IEEE80211_HW_CONNECTION_MONITOR                 = 1<<19,
-        IEEE80211_HW_SUPPORTS_CQM_RSSI                  = 1<<20,
+        /* reuse bit 20 */
         IEEE80211_HW_SUPPORTS_PER_STA_GTK               = 1<<21,
         IEEE80211_HW_AP_LINK_PS                         = 1<<22,
         IEEE80211_HW_TX_AMPDU_SETUP_IN_HW               = 1<<23,
+        IEEE80211_HW_SCAN_WHILE_IDLE                    = 1<<24,
 };
 
 /**
@@ -1446,8 +1485,8 @@ void ieee80211_free_txskb(struct ieee80211_hw *hw, struct sk_buff *skb);
  * way the host will only receive beacons where some relevant information
  * (for example ERP protection or WMM settings) have changed.
  *
- * Beacon filter support is advertised with the %IEEE80211_HW_BEACON_FILTER
- * hardware capability. The driver needs to enable beacon filter support
+ * Beacon filter support is advertised with the %IEEE80211_VIF_BEACON_FILTER
+ * interface capability. The driver needs to enable beacon filter support
  * whenever power save is enabled, that is %IEEE80211_CONF_PS is set. When
  * power save is enabled, the stack will not check for beacon loss and the
  * driver needs to notify about loss of beacons with ieee80211_beacon_loss().
@@ -1599,7 +1638,7 @@ void ieee80211_free_txskb(struct ieee80211_hw *hw, struct sk_buff *skb);
  * the station sends a PS-Poll or a uAPSD trigger frame, mac80211
  * will inform the driver of this with the @allow_buffered_frames
  * callback; this callback is optional. mac80211 will then transmit
- * the frames as usual and set the %IEEE80211_TX_CTL_POLL_RESPONSE
+ * the frames as usual and set the %IEEE80211_TX_CTL_NO_PS_BUFFER
  * on each frame. The last frame in the service period (or the only
  * response to a PS-Poll) also has %IEEE80211_TX_STATUS_EOSP set to
  * indicate that it ends the service period; as this frame must have
@@ -1607,6 +1646,9 @@ void ieee80211_free_txskb(struct ieee80211_hw *hw, struct sk_buff *skb);
  * When TX status is reported for this frame, the service period is
  * marked has having ended and a new one can be started by the peer.
  *
+ * Additionally, non-bufferable MMPDUs can also be transmitted by
+ * mac80211 with the %IEEE80211_TX_CTL_NO_PS_BUFFER set in them.
+ *
  * Another race condition can happen on some devices like iwlwifi
  * when there are frames queued for the station and it wakes up
  * or polls; the frames that are already queued could end up being
@@ -1725,20 +1767,6 @@ enum ieee80211_ampdu_mlme_action {
 };
 
 /**
- * enum ieee80211_tx_sync_type - TX sync type
- * @IEEE80211_TX_SYNC_AUTH: sync TX for authentication
- *      (and possibly also before direct probe)
- * @IEEE80211_TX_SYNC_ASSOC: sync TX for association
- * @IEEE80211_TX_SYNC_ACTION: sync TX for action frame
- *      (not implemented yet)
- */
-enum ieee80211_tx_sync_type {
-        IEEE80211_TX_SYNC_AUTH,
-        IEEE80211_TX_SYNC_ASSOC,
-        IEEE80211_TX_SYNC_ACTION,
-};
-
-/**
  * enum ieee80211_frame_release_type - frame release reason
  * @IEEE80211_FRAME_RELEASE_PSPOLL: frame released for PS-Poll
  * @IEEE80211_FRAME_RELEASE_UAPSD: frame(s) released due to
@@ -1848,26 +1876,6 @@ enum ieee80211_frame_release_type {
  *      of the bss parameters has changed when a call is made. The callback
  *      can sleep.
  *
- * @tx_sync: Called before a frame is sent to an AP/GO. In the GO case, the
- *      driver should sync with the GO's powersaving so the device doesn't
- *      transmit the frame while the GO is asleep. In the regular AP case
- *      it may be used by drivers for devices implementing other restrictions
- *      on talking to APs, e.g. due to regulatory enforcement or just HW
- *      restrictions.
- *      This function is called for every authentication, association and
- *      action frame separately since applications might attempt to auth
- *      with multiple APs before chosing one to associate to. If it returns
- *      an error, the corresponding authentication, association or frame
- *      transmission is aborted and reported as having failed. It is always
- *      called after tuning to the correct channel.
- *      The callback might be called multiple times before @finish_tx_sync
- *      (but @finish_tx_sync will be called once for each) but in practice
- *      this is unlikely to happen. It can also refuse in that case if the
- *      driver cannot handle that situation.
- *      This callback can sleep.
- * @finish_tx_sync: Called as a counterpart to @tx_sync, unless that returned
- *      an error. This callback can sleep.
- *
  * @prepare_multicast: Prepare for multicast filter configuration.
  *      This callback is optional, and its return value is passed
  *      to configure_filter(). This callback must be atomic.
@@ -1963,6 +1971,13 @@ enum ieee80211_frame_release_type {
  *      in AP mode, this callback will not be called when the flag
  *      %IEEE80211_HW_AP_LINK_PS is set. Must be atomic.
  *
+ * @sta_state: Notifies low level driver about state transition of a
+ *      station (which can be the AP, a client, IBSS/WDS/mesh peer etc.)
+ *      This callback is mutually exclusive with @sta_add/@sta_remove.
+ *      It must not fail for down transitions but may fail for transitions
+ *      up the list of states.
+ *      The callback can sleep.
+ *
  * @conf_tx: Configure TX queue parameters (EDCF (aifs, cw_min, cw_max),
  *      bursting) for a hardware TX queue.
  *      Returns a negative error code on failure.
@@ -2098,7 +2113,7 @@ enum ieee80211_frame_release_type {
  * @allow_buffered_frames: Prepare device to allow the given number of frames
  *      to go out to the given station. The frames will be sent by mac80211
  *      via the usual TX path after this call. The TX information for frames
- *      released will also have the %IEEE80211_TX_CTL_POLL_RESPONSE flag set
+ *      released will also have the %IEEE80211_TX_CTL_NO_PS_BUFFER flag set
  *      and the last one will also have %IEEE80211_TX_STATUS_EOSP set. In case
  *      frames from multiple TIDs are released and the driver might reorder
  *      them between the TIDs, it must set the %IEEE80211_TX_STATUS_EOSP flag
@@ -2132,13 +2147,6 @@ struct ieee80211_ops {
                                  struct ieee80211_bss_conf *info,
                                  u32 changed);
 
-        int (*tx_sync)(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
-                       const u8 *bssid, enum ieee80211_tx_sync_type type);
-        void (*finish_tx_sync)(struct ieee80211_hw *hw,
-                               struct ieee80211_vif *vif,
-                               const u8 *bssid,
-                               enum ieee80211_tx_sync_type type);
-
         u64 (*prepare_multicast)(struct ieee80211_hw *hw,
                                  struct netdev_hw_addr_list *mc_list);
         void (*configure_filter)(struct ieee80211_hw *hw,
@@ -2182,6 +2190,10 @@ struct ieee80211_ops {
                           struct ieee80211_sta *sta);
         void (*sta_notify)(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
                         enum sta_notify_cmd, struct ieee80211_sta *sta);
+        int (*sta_state)(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+                         struct ieee80211_sta *sta,
+                         enum ieee80211_sta_state old_state,
+                         enum ieee80211_sta_state new_state);
         int (*conf_tx)(struct ieee80211_hw *hw,
                        struct ieee80211_vif *vif, u16 queue,
                        const struct ieee80211_tx_queue_params *params);
@@ -3316,7 +3328,7 @@ struct sk_buff *ieee80211_ap_probereq_get(struct ieee80211_hw *hw,
  *
  * @vif: &struct ieee80211_vif pointer from the add_interface callback.
  *
- * When beacon filtering is enabled with %IEEE80211_HW_BEACON_FILTER and
+ * When beacon filtering is enabled with %IEEE80211_VIF_BEACON_FILTER and
  * %IEEE80211_CONF_PS is set, the driver needs to inform whenever the
  * hardware is not receiving beacons with this function.
  */
@@ -3327,7 +3339,7 @@ void ieee80211_beacon_loss(struct ieee80211_vif *vif);
  *
  * @vif: &struct ieee80211_vif pointer from the add_interface callback.
  *
- * When beacon filtering is enabled with %IEEE80211_HW_BEACON_FILTER, and
+ * When beacon filtering is enabled with %IEEE80211_VIF_BEACON_FILTER, and
  * %IEEE80211_CONF_PS and %IEEE80211_HW_CONNECTION_MONITOR are set, the driver
  * needs to inform if the connection to the AP has been lost.
  *
@@ -3397,7 +3409,7 @@ void ieee80211_enable_dyn_ps(struct ieee80211_vif *vif);
  * @rssi_event: the RSSI trigger event type
  * @gfp: context flags
  *
- * When the %IEEE80211_HW_SUPPORTS_CQM_RSSI is set, and a connection quality
+ * When the %IEEE80211_VIF_SUPPORTS_CQM_RSSI is set, and a connection quality
  * monitoring is configured with an rssi threshold, the driver will inform
  * whenever the rssi level reaches the threshold.
  */
@@ -3516,6 +3528,8 @@ enum rate_control_changed {
  * @hw: The hardware the algorithm is invoked for.
  * @sband: The band this frame is being transmitted on.
  * @bss_conf: the current BSS configuration
+ * @skb: the skb that will be transmitted, the control information in it needs
+ *      to be filled in
  * @reported_rate: The rate control algorithm can fill this in to indicate
  *      which rate should be reported to userspace as the current rate and
  *      used for rate calculations in the mesh network.
@@ -3523,12 +3537,11 @@ enum rate_control_changed {
  *      RTS threshold
  * @short_preamble: whether mac80211 will request short-preamble transmission
  *      if the selected rate supports it
- * @max_rate_idx: user-requested maximum rate (not MCS for now)
+ * @max_rate_idx: user-requested maximum (legacy) rate
  *      (deprecated; this will be removed once drivers get updated to use
  *      rate_idx_mask)
- * @rate_idx_mask: user-requested rate mask (not MCS for now)
- * @skb: the skb that will be transmitted, the control information in it needs
- *      to be filled in
+ * @rate_idx_mask: user-requested (legacy) rate mask
+ * @rate_idx_mcs_mask: user-requested MCS rate mask
  * @bss: whether this frame is sent out in AP or IBSS mode
  */
 struct ieee80211_tx_rate_control {
@@ -3540,6 +3553,7 @@ struct ieee80211_tx_rate_control {
         bool rts, short_preamble;
         u8 max_rate_idx;
         u32 rate_idx_mask;
+        u8 rate_idx_mcs_mask[IEEE80211_HT_MCS_MASK_LEN];
         bool bss;
 };
 
diff --git a/include/net/ndisc.h b/include/net/ndisc.h
index e3133c23980..6f9c25a76cd 100644
--- a/include/net/ndisc.h
+++ b/include/net/ndisc.h
@@ -133,7 +133,6 @@ extern void			ndisc_send_rs(struct net_device *dev,
                                               const struct in6_addr *daddr);
 
 extern void                     ndisc_send_redirect(struct sk_buff *skb,
-                                                    struct neighbour *neigh,
                                                     const struct in6_addr *target);
 
 extern int                      ndisc_mc_map(const struct in6_addr *addr, char *buf,
diff --git a/include/net/netfilter/nf_conntrack.h b/include/net/netfilter/nf_conntrack.h
index 8a2b0ae7dbd..ab86036bbf0 100644
--- a/include/net/netfilter/nf_conntrack.h
+++ b/include/net/netfilter/nf_conntrack.h
@@ -209,7 +209,7 @@ extern struct nf_conntrack_tuple_hash *
 __nf_conntrack_find(struct net *net, u16 zone,
                     const struct nf_conntrack_tuple *tuple);
 
-extern void nf_conntrack_hash_insert(struct nf_conn *ct);
+extern int nf_conntrack_hash_check_insert(struct nf_conn *ct);
 extern void nf_ct_delete_from_lists(struct nf_conn *ct);
 extern void nf_ct_insert_dying_list(struct nf_conn *ct);
 
diff --git a/include/net/netfilter/nf_conntrack_extend.h b/include/net/netfilter/nf_conntrack_extend.h
index 2dcf31703ac..96755c3798a 100644
--- a/include/net/netfilter/nf_conntrack_extend.h
+++ b/include/net/netfilter/nf_conntrack_extend.h
@@ -20,6 +20,9 @@ enum nf_ct_ext_id {
 #ifdef CONFIG_NF_CONNTRACK_TIMESTAMP
         NF_CT_EXT_TSTAMP,
 #endif
+#ifdef CONFIG_NF_CONNTRACK_TIMEOUT
+        NF_CT_EXT_TIMEOUT,
+#endif
         NF_CT_EXT_NUM,
 };
 
@@ -29,6 +32,7 @@ enum nf_ct_ext_id {
 #define NF_CT_EXT_ECACHE_TYPE struct nf_conntrack_ecache
 #define NF_CT_EXT_ZONE_TYPE struct nf_conntrack_zone
 #define NF_CT_EXT_TSTAMP_TYPE struct nf_conn_tstamp
+#define NF_CT_EXT_TIMEOUT_TYPE struct nf_conn_timeout
 
 /* Extensions: optional stuff which isn't permanently in struct. */
 struct nf_ct_ext {
diff --git a/include/net/netfilter/nf_conntrack_helper.h b/include/net/netfilter/nf_conntrack_helper.h
index f1c1311adc2..5767dc242de 100644
--- a/include/net/netfilter/nf_conntrack_helper.h
+++ b/include/net/netfilter/nf_conntrack_helper.h
@@ -69,4 +69,17 @@ extern int nf_conntrack_broadcast_help(struct sk_buff *skb,
                                        enum ip_conntrack_info ctinfo,
                                        unsigned int timeout);
 
+struct nf_ct_helper_expectfn {
+        struct list_head head;
+        const char *name;
+        void (*expectfn)(struct nf_conn *ct, struct nf_conntrack_expect *exp);
+};
+
+void nf_ct_helper_expectfn_register(struct nf_ct_helper_expectfn *n);
+void nf_ct_helper_expectfn_unregister(struct nf_ct_helper_expectfn *n);
+struct nf_ct_helper_expectfn *
+nf_ct_helper_expectfn_find_by_name(const char *name);
+struct nf_ct_helper_expectfn *
+nf_ct_helper_expectfn_find_by_symbol(const void *symbol);
+
 #endif /*_NF_CONNTRACK_HELPER_H*/
diff --git a/include/net/netfilter/nf_conntrack_l4proto.h b/include/net/netfilter/nf_conntrack_l4proto.h
index e3d3ee3c06a..90c67c7db7e 100644
--- a/include/net/netfilter/nf_conntrack_l4proto.h
+++ b/include/net/netfilter/nf_conntrack_l4proto.h
@@ -39,12 +39,13 @@ struct nf_conntrack_l4proto {
                       unsigned int dataoff,
                       enum ip_conntrack_info ctinfo,
                       u_int8_t pf,
-                      unsigned int hooknum);
+                      unsigned int hooknum,
+                      unsigned int *timeouts);
 
         /* Called when a new connection for this protocol found;
          * returns TRUE if it's OK.  If so, packet() called next. */
         bool (*new)(struct nf_conn *ct, const struct sk_buff *skb,
-                    unsigned int dataoff);
+                    unsigned int dataoff, unsigned int *timeouts);
 
         /* Called when a conntrack entry is destroyed */
         void (*destroy)(struct nf_conn *ct);
@@ -60,6 +61,9 @@ struct nf_conntrack_l4proto {
         /* Print out the private part of the conntrack. */
         int (*print_conntrack)(struct seq_file *s, struct nf_conn *);
 
+        /* Return the array of timeouts for this protocol. */
+        unsigned int *(*get_timeouts)(struct net *net);
+
         /* convert protoinfo to nfnetink attributes */
         int (*to_nlattr)(struct sk_buff *skb, struct nlattr *nla,
                          struct nf_conn *ct);
@@ -79,6 +83,17 @@ struct nf_conntrack_l4proto {
 
         size_t nla_size;
 
+#if IS_ENABLED(CONFIG_NF_CT_NETLINK_TIMEOUT)
+        struct {
+                size_t obj_size;
+                int (*nlattr_to_obj)(struct nlattr *tb[], void *data);
+                int (*obj_to_nlattr)(struct sk_buff *skb, const void *data);
+
+                unsigned int nlattr_max;
+                const struct nla_policy *nla_policy;
+        } ctnl_timeout;
+#endif
+
 #ifdef CONFIG_SYSCTL
         struct ctl_table_header **ctl_table_header;
         struct ctl_table        *ctl_table;
diff --git a/include/net/netfilter/nf_conntrack_timeout.h b/include/net/netfilter/nf_conntrack_timeout.h
new file mode 100644
index 00000000000..0e04db4a086
--- /dev/null
+++ b/include/net/netfilter/nf_conntrack_timeout.h
@@ -0,0 +1,78 @@
+#ifndef _NF_CONNTRACK_TIMEOUT_H
+#define _NF_CONNTRACK_TIMEOUT_H
+
+#include <net/net_namespace.h>
+#include <linux/netfilter/nf_conntrack_common.h>
+#include <linux/netfilter/nf_conntrack_tuple_common.h>
+#include <net/netfilter/nf_conntrack.h>
+#include <net/netfilter/nf_conntrack_extend.h>
+
+#define CTNL_TIMEOUT_NAME_MAX   32
+
+struct ctnl_timeout {
+        struct list_head        head;
+        struct rcu_head         rcu_head;
+        atomic_t                refcnt;
+        char                    name[CTNL_TIMEOUT_NAME_MAX];
+        __u16                   l3num;
+        __u8                    l4num;
+        char                    data[0];
+};
+
+struct nf_conn_timeout {
+        struct ctnl_timeout     *timeout;
+};
+
+#define NF_CT_TIMEOUT_EXT_DATA(__t) (unsigned int *) &((__t)->timeout->data)
+
+static inline
+struct nf_conn_timeout *nf_ct_timeout_find(const struct nf_conn *ct)
+{
+#ifdef CONFIG_NF_CONNTRACK_TIMEOUT
+        return nf_ct_ext_find(ct, NF_CT_EXT_TIMEOUT);
+#else
+        return NULL;
+#endif
+}
+
+static inline
+struct nf_conn_timeout *nf_ct_timeout_ext_add(struct nf_conn *ct,
+                                              struct ctnl_timeout *timeout,
+                                              gfp_t gfp)
+{
+#ifdef CONFIG_NF_CONNTRACK_TIMEOUT
+        struct nf_conn_timeout *timeout_ext;
+
+        timeout_ext = nf_ct_ext_add(ct, NF_CT_EXT_TIMEOUT, gfp);
+        if (timeout_ext == NULL)
+                return NULL;
+
+        timeout_ext->timeout = timeout;
+
+        return timeout_ext;
+#else
+        return NULL;
+#endif
+};
+
+#ifdef CONFIG_NF_CONNTRACK_TIMEOUT
+extern int nf_conntrack_timeout_init(struct net *net);
+extern void nf_conntrack_timeout_fini(struct net *net);
+#else
+static inline int nf_conntrack_timeout_init(struct net *net)
+{
+        return 0;
+}
+
+static inline void nf_conntrack_timeout_fini(struct net *net)
+{
+        return;
+}
+#endif /* CONFIG_NF_CONNTRACK_TIMEOUT */
+
+#ifdef CONFIG_NF_CONNTRACK_TIMEOUT
+extern struct ctnl_timeout *(*nf_ct_timeout_find_get_hook)(const char *name);
+extern void (*nf_ct_timeout_put_hook)(struct ctnl_timeout *timeout);
+#endif
+
+#endif /* _NF_CONNTRACK_TIMEOUT_H */
diff --git a/include/net/netfilter/xt_log.h b/include/net/netfilter/xt_log.h
index 0dfb34a5b53..7e1544e8f70 100644
--- a/include/net/netfilter/xt_log.h
+++ b/include/net/netfilter/xt_log.h
@@ -6,7 +6,7 @@ struct sbuff {
 };
 static struct sbuff emergency, *emergency_ptr = &emergency;
 
-static int sb_add(struct sbuff *m, const char *f, ...)
+static __printf(2, 3) int sb_add(struct sbuff *m, const char *f, ...)
 {
         va_list args;
         int len;
diff --git a/include/net/netlink.h b/include/net/netlink.h
index cb1f3504687..f394fe5d764 100644
--- a/include/net/netlink.h
+++ b/include/net/netlink.h
@@ -441,41 +441,6 @@ static inline int nlmsg_report(const struct nlmsghdr *nlh)
         nla_for_each_attr(pos, nlmsg_attrdata(nlh, hdrlen), \
                           nlmsg_attrlen(nlh, hdrlen), rem)
 
-#if 0
-/* FIXME: Enable once all users have been converted */
-
-/**
- * __nlmsg_put - Add a new netlink message to an skb
- * @skb: socket buffer to store message in
- * @pid: netlink process id
- * @seq: sequence number of message
- * @type: message type
- * @payload: length of message payload
- * @flags: message flags
- *
- * The caller is responsible to ensure that the skb provides enough
- * tailroom for both the netlink header and payload.
- */
-static inline struct nlmsghdr *__nlmsg_put(struct sk_buff *skb, u32 pid,
-                                           u32 seq, int type, int payload,
-                                           int flags)
-{
-        struct nlmsghdr *nlh;
-
-        nlh = (struct nlmsghdr *) skb_put(skb, nlmsg_total_size(payload));
-        nlh->nlmsg_type = type;
-        nlh->nlmsg_len = nlmsg_msg_size(payload);
-        nlh->nlmsg_flags = flags;
-        nlh->nlmsg_pid = pid;
-        nlh->nlmsg_seq = seq;
-
-        memset((unsigned char *) nlmsg_data(nlh) + payload, 0,
-               nlmsg_padlen(payload));
-
-        return nlh;
-}
-#endif
-
 /**
  * nlmsg_put - Add a new netlink message to an skb
  * @skb: socket buffer to store message in
diff --git a/include/net/netns/generic.h b/include/net/netns/generic.h
index 3419bf5cd15..d55f4344333 100644
--- a/include/net/netns/generic.h
+++ b/include/net/netns/generic.h
@@ -41,6 +41,7 @@ static inline void *net_generic(const struct net *net, int id)
         ptr = ng->ptr[id - 1];
         rcu_read_unlock();
 
+        BUG_ON(!ptr);
         return ptr;
 }
 #endif
diff --git a/include/net/netprio_cgroup.h b/include/net/netprio_cgroup.h
index e503b87c4c1..d58fdec4759 100644
--- a/include/net/netprio_cgroup.h
+++ b/include/net/netprio_cgroup.h
@@ -13,7 +13,6 @@
 
 #ifndef _NETPRIO_CGROUP_H
 #define _NETPRIO_CGROUP_H
-#include <linux/module.h>
 #include <linux/cgroup.h>
 #include <linux/hardirq.h>
 #include <linux/rcupdate.h>
@@ -38,19 +37,51 @@ extern int net_prio_subsys_id;
 
 extern void sock_update_netprioidx(struct sock *sk);
 
-static inline struct cgroup_netprio_state
-                *task_netprio_state(struct task_struct *p)
+#if IS_BUILTIN(CONFIG_NETPRIO_CGROUP)
+
+static inline u32 task_netprioidx(struct task_struct *p)
 {
-#if IS_ENABLED(CONFIG_NETPRIO_CGROUP)
-        return container_of(task_subsys_state(p, net_prio_subsys_id),
-                            struct cgroup_netprio_state, css);
-#else
-        return NULL;
-#endif
+        struct cgroup_netprio_state *state;
+        u32 idx;
+
+        rcu_read_lock();
+        state = container_of(task_subsys_state(p, net_prio_subsys_id),
+                             struct cgroup_netprio_state, css);
+        idx = state->prioidx;
+        rcu_read_unlock();
+        return idx;
+}
+
+#elif IS_MODULE(CONFIG_NETPRIO_CGROUP)
+
+static inline u32 task_netprioidx(struct task_struct *p)
+{
+        struct cgroup_netprio_state *state;
+        int subsys_id;
+        u32 idx = 0;
+
+        rcu_read_lock();
+        subsys_id = rcu_dereference_index_check(net_prio_subsys_id,
+                                                rcu_read_lock_held());
+        if (subsys_id >= 0) {
+                state = container_of(task_subsys_state(p, subsys_id),
+                                     struct cgroup_netprio_state, css);
+                idx = state->prioidx;
+        }
+        rcu_read_unlock();
+        return idx;
 }
 
 #else
 
+static inline u32 task_netprioidx(struct task_struct *p)
+{
+        return 0;
+}
+
+#endif /* CONFIG_NETPRIO_CGROUP */
+
+#else
 #define sock_update_netprioidx(sk)
 #endif
 
diff --git a/include/net/nfc/nci.h b/include/net/nfc/nci.h
index 2be95e2626c..276094b91d7 100644
--- a/include/net/nfc/nci.h
+++ b/include/net/nfc/nci.h
@@ -116,6 +116,11 @@
 #define NCI_DISC_MAP_MODE_POLL                                  0x01
 #define NCI_DISC_MAP_MODE_LISTEN                                0x02
 
+/* NCI Discover Notification Type */
+#define NCI_DISCOVER_NTF_TYPE_LAST                              0x00
+#define NCI_DISCOVER_NTF_TYPE_LAST_NFCC                         0x01
+#define NCI_DISCOVER_NTF_TYPE_MORE                              0x02
+
 /* NCI Deactivation Type */
 #define NCI_DEACTIVATE_TYPE_IDLE_MODE                           0x00
 #define NCI_DEACTIVATE_TYPE_SLEEP_MODE                          0x01
@@ -207,6 +212,13 @@ struct nci_rf_disc_cmd {
         struct disc_config              disc_configs[NCI_MAX_NUM_RF_CONFIGS];
 } __packed;
 
+#define NCI_OP_RF_DISCOVER_SELECT_CMD   nci_opcode_pack(NCI_GID_RF_MGMT, 0x04)
+struct nci_rf_discover_select_cmd {
+        __u8    rf_discovery_id;
+        __u8    rf_protocol;
+        __u8    rf_interface;
+} __packed;
+
 #define NCI_OP_RF_DEACTIVATE_CMD        nci_opcode_pack(NCI_GID_RF_MGMT, 0x06)
 struct nci_rf_deactivate_cmd {
         __u8    type;
@@ -244,6 +256,8 @@ struct nci_core_init_rsp_2 {
 
 #define NCI_OP_RF_DISCOVER_RSP          nci_opcode_pack(NCI_GID_RF_MGMT, 0x03)
 
+#define NCI_OP_RF_DISCOVER_SELECT_RSP   nci_opcode_pack(NCI_GID_RF_MGMT, 0x04)
+
 #define NCI_OP_RF_DEACTIVATE_RSP        nci_opcode_pack(NCI_GID_RF_MGMT, 0x06)
 
 /* --------------------------- */
@@ -260,13 +274,15 @@ struct nci_core_conn_credit_ntf {
         struct conn_credit_entry        conn_entries[NCI_MAX_NUM_CONN];
 } __packed;
 
+#define NCI_OP_CORE_GENERIC_ERROR_NTF   nci_opcode_pack(NCI_GID_CORE, 0x07)
+
 #define NCI_OP_CORE_INTF_ERROR_NTF      nci_opcode_pack(NCI_GID_CORE, 0x08)
 struct nci_core_intf_error_ntf {
         __u8    status;
         __u8    conn_id;
 } __packed;
 
-#define NCI_OP_RF_INTF_ACTIVATED_NTF    nci_opcode_pack(NCI_GID_RF_MGMT, 0x05)
+#define NCI_OP_RF_DISCOVER_NTF          nci_opcode_pack(NCI_GID_RF_MGMT, 0x03)
 struct rf_tech_specific_params_nfca_poll {
         __u16   sens_res;
         __u8    nfcid1_len;     /* 0, 4, 7, or 10 Bytes */
@@ -275,11 +291,43 @@ struct rf_tech_specific_params_nfca_poll {
         __u8    sel_res;
 } __packed;
 
+struct rf_tech_specific_params_nfcb_poll {
+        __u8    sensb_res_len;
+        __u8    sensb_res[12];  /* 11 or 12 Bytes */
+} __packed;
+
+struct rf_tech_specific_params_nfcf_poll {
+        __u8    bit_rate;
+        __u8    sensf_res_len;
+        __u8    sensf_res[18];  /* 16 or 18 Bytes */
+} __packed;
+
+struct nci_rf_discover_ntf {
+        __u8    rf_discovery_id;
+        __u8    rf_protocol;
+        __u8    rf_tech_and_mode;
+        __u8    rf_tech_specific_params_len;
+
+        union {
+                struct rf_tech_specific_params_nfca_poll nfca_poll;
+                struct rf_tech_specific_params_nfcb_poll nfcb_poll;
+                struct rf_tech_specific_params_nfcf_poll nfcf_poll;
+        } rf_tech_specific_params;
+
+        __u8    ntf_type;
+} __packed;
+
+#define NCI_OP_RF_INTF_ACTIVATED_NTF    nci_opcode_pack(NCI_GID_RF_MGMT, 0x05)
 struct activation_params_nfca_poll_iso_dep {
         __u8    rats_res_len;
         __u8    rats_res[20];
 };
 
+struct activation_params_nfcb_poll_iso_dep {
+        __u8    attrib_res_len;
+        __u8    attrib_res[50];
+};
+
 struct nci_rf_intf_activated_ntf {
         __u8    rf_discovery_id;
         __u8    rf_interface;
@@ -291,6 +339,8 @@ struct nci_rf_intf_activated_ntf {
 
         union {
                 struct rf_tech_specific_params_nfca_poll nfca_poll;
+                struct rf_tech_specific_params_nfcb_poll nfcb_poll;
+                struct rf_tech_specific_params_nfcf_poll nfcf_poll;
         } rf_tech_specific_params;
 
         __u8    data_exch_rf_tech_and_mode;
@@ -300,6 +350,7 @@ struct nci_rf_intf_activated_ntf {
 
         union {
                 struct activation_params_nfca_poll_iso_dep nfca_poll_iso_dep;
+                struct activation_params_nfcb_poll_iso_dep nfcb_poll_iso_dep;
         } activation_params;
 
 } __packed;
diff --git a/include/net/nfc/nci_core.h b/include/net/nfc/nci_core.h
index bccd89e9d4c..feba74027ff 100644
--- a/include/net/nfc/nci_core.h
+++ b/include/net/nfc/nci_core.h
@@ -34,21 +34,31 @@
 #include <net/nfc/nfc.h>
 #include <net/nfc/nci.h>
 
-/* NCI device state */
-enum {
+/* NCI device flags */
+enum nci_flag {
         NCI_INIT,
         NCI_UP,
+        NCI_DATA_EXCHANGE,
+        NCI_DATA_EXCHANGE_TO,
+};
+
+/* NCI device states */
+enum nci_state {
+        NCI_IDLE,
         NCI_DISCOVERY,
+        NCI_W4_ALL_DISCOVERIES,
+        NCI_W4_HOST_SELECT,
         NCI_POLL_ACTIVE,
-        NCI_DATA_EXCHANGE,
 };
 
 /* NCI timeouts */
 #define NCI_RESET_TIMEOUT                       5000
 #define NCI_INIT_TIMEOUT                        5000
 #define NCI_RF_DISC_TIMEOUT                     5000
-#define NCI_RF_DEACTIVATE_TIMEOUT               5000
+#define NCI_RF_DISC_SELECT_TIMEOUT              5000
+#define NCI_RF_DEACTIVATE_TIMEOUT               30000
 #define NCI_CMD_TIMEOUT                         5000
+#define NCI_DATA_TIMEOUT                        700
 
 struct nci_dev;
 
@@ -59,6 +69,7 @@ struct nci_ops {
 };
 
 #define NCI_MAX_SUPPORTED_RF_INTERFACES         4
+#define NCI_MAX_DISCOVERED_TARGETS              10
 
 /* NCI Core structures */
 struct nci_dev {
@@ -68,12 +79,14 @@ struct nci_dev {
         int                     tx_headroom;
         int                     tx_tailroom;
 
+        atomic_t                state;
         unsigned long           flags;
 
         atomic_t                cmd_cnt;
         atomic_t                credits_cnt;
 
         struct timer_list       cmd_timer;
+        struct timer_list       data_timer;
 
         struct workqueue_struct *cmd_wq;
         struct work_struct      cmd_work;
@@ -96,9 +109,11 @@ struct nci_dev {
         void                    *driver_data;
 
         __u32                   poll_prots;
-        __u32                   target_available_prots;
         __u32                   target_active_prot;
 
+        struct nfc_target       targets[NCI_MAX_DISCOVERED_TARGETS];
+        int                     n_targets;
+
         /* received during NCI_OP_CORE_RESET_RSP */
         __u8                    nci_ver;
 
@@ -126,17 +141,17 @@ struct nci_dev {
 
 /* ----- NCI Devices ----- */
 struct nci_dev *nci_allocate_device(struct nci_ops *ops,
-                                __u32 supported_protocols,
-                                int tx_headroom,
-                                int tx_tailroom);
+                                    __u32 supported_protocols,
+                                    int tx_headroom,
+                                    int tx_tailroom);
 void nci_free_device(struct nci_dev *ndev);
 int nci_register_device(struct nci_dev *ndev);
 void nci_unregister_device(struct nci_dev *ndev);
 int nci_recv_frame(struct sk_buff *skb);
 
 static inline struct sk_buff *nci_skb_alloc(struct nci_dev *ndev,
-                                                unsigned int len,
-                                                gfp_t how)
+                                            unsigned int len,
+                                            gfp_t how)
 {
         struct sk_buff *skb;
 
@@ -169,6 +184,7 @@ int nci_send_cmd(struct nci_dev *ndev, __u16 opcode, __u8 plen, void *payload);
 int nci_send_data(struct nci_dev *ndev, __u8 conn_id, struct sk_buff *skb);
 void nci_data_exchange_complete(struct nci_dev *ndev, struct sk_buff *skb,
                                 int err);
+void nci_clear_target_list(struct nci_dev *ndev);
 
 /* ----- NCI requests ----- */
 #define NCI_REQ_DONE            0
diff --git a/include/net/nfc/nfc.h b/include/net/nfc/nfc.h
index 8696b773a69..bac070bf351 100644
--- a/include/net/nfc/nfc.h
+++ b/include/net/nfc/nfc.h
@@ -24,6 +24,7 @@
 #ifndef __NET_NFC_H
 #define __NET_NFC_H
 
+#include <linux/nfc.h>
 #include <linux/device.h>
 #include <linux/skbuff.h>
 
@@ -52,20 +53,19 @@ struct nfc_ops {
         int (*dev_down)(struct nfc_dev *dev);
         int (*start_poll)(struct nfc_dev *dev, u32 protocols);
         void (*stop_poll)(struct nfc_dev *dev);
-        int (*dep_link_up)(struct nfc_dev *dev, int target_idx,
-                                u8 comm_mode, u8 rf_mode);
+        int (*dep_link_up)(struct nfc_dev *dev, int target_idx, u8 comm_mode,
+                           u8 *gb, size_t gb_len);
         int (*dep_link_down)(struct nfc_dev *dev);
         int (*activate_target)(struct nfc_dev *dev, u32 target_idx,
-                                                        u32 protocol);
+                               u32 protocol);
         void (*deactivate_target)(struct nfc_dev *dev, u32 target_idx);
         int (*data_exchange)(struct nfc_dev *dev, u32 target_idx,
-                                struct sk_buff *skb, data_exchange_cb_t cb,
-                                                        void *cb_context);
+                             struct sk_buff *skb, data_exchange_cb_t cb,
+                             void *cb_context);
 };
 
 #define NFC_TARGET_IDX_ANY -1
 #define NFC_MAX_GT_LEN 48
-#define NFC_MAX_NFCID1_LEN 10
 
 struct nfc_target {
         u32 idx;
@@ -73,7 +73,11 @@ struct nfc_target {
         u16 sens_res;
         u8 sel_res;
         u8 nfcid1_len;
-        u8 nfcid1[NFC_MAX_NFCID1_LEN];
+        u8 nfcid1[NFC_NFCID1_MAXSIZE];
+        u8 sensb_res_len;
+        u8 sensb_res[NFC_SENSB_RES_MAXSIZE];
+        u8 sensf_res_len;
+        u8 sensf_res[NFC_SENSF_RES_MAXSIZE];
 };
 
 struct nfc_genl_data {
@@ -83,7 +87,6 @@ struct nfc_genl_data {
 
 struct nfc_dev {
         unsigned idx;
-        unsigned target_idx;
         struct nfc_target *targets;
         int n_targets;
         int targets_generation;
@@ -107,9 +110,9 @@ struct nfc_dev {
 extern struct class nfc_class;
 
 struct nfc_dev *nfc_allocate_device(struct nfc_ops *ops,
-                                        u32 supported_protocols,
-                                        int tx_headroom,
-                                        int tx_tailroom);
+                                    u32 supported_protocols,
+                                    int tx_headroom,
+                                    int tx_tailroom);
 
 /**
  * nfc_free_device - free nfc device
@@ -132,7 +135,7 @@ void nfc_unregister_device(struct nfc_dev *dev);
  * @dev: The parent device
  */
 static inline void nfc_set_parent_dev(struct nfc_dev *nfc_dev,
-                                        struct device *dev)
+                                      struct device *dev)
 {
         nfc_dev->dev.parent = dev;
 }
@@ -169,17 +172,15 @@ static inline const char *nfc_device_name(struct nfc_dev *dev)
 }
 
 struct sk_buff *nfc_alloc_send_skb(struct nfc_dev *dev, struct sock *sk,
-                                        unsigned int flags, unsigned int size,
-                                        unsigned int *err);
+                                   unsigned int flags, unsigned int size,
+                                   unsigned int *err);
 struct sk_buff *nfc_alloc_recv_skb(unsigned int size, gfp_t gfp);
 
 int nfc_set_remote_general_bytes(struct nfc_dev *dev,
-                                        u8 *gt, u8 gt_len);
+                                 u8 *gt, u8 gt_len);
 
-u8 *nfc_get_local_general_bytes(struct nfc_dev *dev, u8 *gt_len);
-
-int nfc_targets_found(struct nfc_dev *dev, struct nfc_target *targets,
-                                                        int ntargets);
+int nfc_targets_found(struct nfc_dev *dev,
+                      struct nfc_target *targets, int ntargets);
 
 int nfc_dep_link_is_up(struct nfc_dev *dev, u32 target_idx,
                        u8 comm_mode, u8 rf_mode);
diff --git a/include/net/route.h b/include/net/route.h
index 91855d185b5..b1c0d5b564c 100644
--- a/include/net/route.h
+++ b/include/net/route.h
@@ -270,6 +270,7 @@ static inline struct rtable *ip_route_connect(struct flowi4 *fl4,
                 if (IS_ERR(rt))
                         return rt;
                 ip_rt_put(rt);
+                flowi4_update_output(fl4, oif, tos, fl4->daddr, fl4->saddr);
         }
         security_sk_classify_flow(sk, flowi4_to_flowi(fl4));
         return ip_route_output_flow(net, fl4, sk);
@@ -284,6 +285,9 @@ static inline struct rtable *ip_route_newports(struct flowi4 *fl4, struct rtable
                 fl4->fl4_dport = dport;
                 fl4->fl4_sport = sport;
                 ip_rt_put(rt);
+                flowi4_update_output(fl4, sk->sk_bound_dev_if,
+                                     RT_CONN_FLAGS(sk), fl4->daddr,
+                                     fl4->saddr);
                 security_sk_classify_flow(sk, flowi4_to_flowi(fl4));
                 return ip_route_output_flow(sock_net(sk), fl4, sk);
         }
diff --git a/include/net/rtnetlink.h b/include/net/rtnetlink.h
index 678f1ffaf84..37029390197 100644
--- a/include/net/rtnetlink.h
+++ b/include/net/rtnetlink.h
@@ -6,7 +6,7 @@
 
 typedef int (*rtnl_doit_func)(struct sk_buff *, struct nlmsghdr *, void *);
 typedef int (*rtnl_dumpit_func)(struct sk_buff *, struct netlink_callback *);
-typedef u16 (*rtnl_calcit_func)(struct sk_buff *);
+typedef u16 (*rtnl_calcit_func)(struct sk_buff *, struct nlmsghdr *);
 
 extern int      __rtnl_register(int protocol, int msgtype,
                                 rtnl_doit_func, rtnl_dumpit_func,
diff --git a/include/net/sch_generic.h b/include/net/sch_generic.h
index f6bb08b73ca..55ce96b53b0 100644
--- a/include/net/sch_generic.h
+++ b/include/net/sch_generic.h
@@ -220,9 +220,16 @@ struct tcf_proto {
 
 struct qdisc_skb_cb {
         unsigned int            pkt_len;
-        long                    data[];
+        unsigned char           data[24];
 };
 
+static inline void qdisc_cb_private_validate(const struct sk_buff *skb, int sz)
+{
+        struct qdisc_skb_cb *qcb;
+        BUILD_BUG_ON(sizeof(skb->cb) < sizeof(unsigned int) + sz);
+        BUILD_BUG_ON(sizeof(qcb->data) < sz);
+}
+
 static inline int qdisc_qlen(const struct Qdisc *q)
 {
         return q->q.qlen;
diff --git a/include/net/sctp/sctp.h b/include/net/sctp/sctp.h
index d3685615a8b..6ee44b24864 100644
--- a/include/net/sctp/sctp.h
+++ b/include/net/sctp/sctp.h
@@ -413,6 +413,7 @@ static inline sctp_assoc_t sctp_assoc2id(const struct sctp_association *asoc)
 /* Look up the association by its id.  */
 struct sctp_association *sctp_id2assoc(struct sock *sk, sctp_assoc_t id);
 
+int sctp_do_peeloff(struct sock *sk, sctp_assoc_t id, struct socket **sockp);
 
 /* A macro to walk a list of skbs.  */
 #define sctp_skb_for_each(pos, head, tmp) \
diff --git a/include/net/sock.h b/include/net/sock.h
index bb972d254df..f84be9ed611 100644
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -55,6 +55,7 @@
 #include <linux/uaccess.h>
 #include <linux/memcontrol.h>
 #include <linux/res_counter.h>
+#include <linux/static_key.h>
 
 #include <linux/filter.h>
 #include <linux/rculist_nulls.h>
@@ -68,7 +69,7 @@ struct cgroup;
 struct cgroup_subsys;
 #ifdef CONFIG_NET
 int mem_cgroup_sockets_init(struct cgroup *cgrp, struct cgroup_subsys *ss);
-void mem_cgroup_sockets_destroy(struct cgroup *cgrp, struct cgroup_subsys *ss);
+void mem_cgroup_sockets_destroy(struct cgroup *cgrp);
 #else
 static inline
 int mem_cgroup_sockets_init(struct cgroup *cgrp, struct cgroup_subsys *ss)
@@ -76,7 +77,7 @@ int mem_cgroup_sockets_init(struct cgroup *cgrp, struct cgroup_subsys *ss)
         return 0;
 }
 static inline
-void mem_cgroup_sockets_destroy(struct cgroup *cgrp, struct cgroup_subsys *ss)
+void mem_cgroup_sockets_destroy(struct cgroup *cgrp)
 {
 }
 #endif
@@ -226,6 +227,7 @@ struct cg_proto;
   *     @sk_ack_backlog: current listen backlog
   *     @sk_max_ack_backlog: listen backlog set in listen()
   *     @sk_priority: %SO_PRIORITY setting
+  *     @sk_cgrp_prioidx: socket group's priority map index
   *     @sk_type: socket type (%SOCK_STREAM, etc)
   *     @sk_protocol: which protocol this socket belongs in this network family
   *     @sk_peer_pid: &struct pid for this socket's peer
@@ -355,6 +357,7 @@ struct sock {
         struct page             *sk_sndmsg_page;
         struct sk_buff          *sk_send_head;
         __u32                   sk_sndmsg_off;
+        __s32                   sk_peek_off;
         int                     sk_write_pending;
 #ifdef CONFIG_SECURITY
         void                    *sk_security;
@@ -371,6 +374,30 @@ struct sock {
         void                    (*sk_destruct)(struct sock *sk);
 };
 
+static inline int sk_peek_offset(struct sock *sk, int flags)
+{
+        if ((flags & MSG_PEEK) && (sk->sk_peek_off >= 0))
+                return sk->sk_peek_off;
+        else
+                return 0;
+}
+
+static inline void sk_peek_offset_bwd(struct sock *sk, int val)
+{
+        if (sk->sk_peek_off >= 0) {
+                if (sk->sk_peek_off >= val)
+                        sk->sk_peek_off -= val;
+                else
+                        sk->sk_peek_off = 0;
+        }
+}
+
+static inline void sk_peek_offset_fwd(struct sock *sk, int val)
+{
+        if (sk->sk_peek_off >= 0)
+                sk->sk_peek_off += val;
+}
+
 /*
  * Hashed lists helper routines
  */
@@ -588,6 +615,10 @@ enum sock_flags {
         SOCK_RXQ_OVFL,
         SOCK_ZEROCOPY, /* buffers from userspace */
         SOCK_WIFI_STATUS, /* push wifi status to userspace */
+        SOCK_NOFCS, /* Tell NIC not to do the Ethernet FCS.
+                     * Will use last 4 bytes of packet sent from
+                     * user-space instead.
+                     */
 };
 
 static inline void sock_copy_flags(struct sock *nsk, struct sock *osk)
@@ -869,8 +900,7 @@ struct proto {
          */
         int                     (*init_cgroup)(struct cgroup *cgrp,
                                                struct cgroup_subsys *ss);
-        void                    (*destroy_cgroup)(struct cgroup *cgrp,
-                                                  struct cgroup_subsys *ss);
+        void                    (*destroy_cgroup)(struct cgroup *cgrp);
         struct cg_proto         *(*proto_cgroup)(struct mem_cgroup *memcg);
 #endif
 };
@@ -921,14 +951,14 @@ inline void sk_refcnt_debug_release(const struct sock *sk)
 #define sk_refcnt_debug_release(sk) do { } while (0)
 #endif /* SOCK_REFCNT_DEBUG */
 
-#ifdef CONFIG_CGROUP_MEM_RES_CTLR_KMEM
-extern struct jump_label_key memcg_socket_limit_enabled;
+#if defined(CONFIG_CGROUP_MEM_RES_CTLR_KMEM) && defined(CONFIG_NET)
+extern struct static_key memcg_socket_limit_enabled;
 static inline struct cg_proto *parent_cg_proto(struct proto *proto,
                                                struct cg_proto *cg_proto)
 {
         return proto->proto_cgroup(parent_mem_cgroup(cg_proto->memcg));
 }
-#define mem_cgroup_sockets_enabled static_branch(&memcg_socket_limit_enabled)
+#define mem_cgroup_sockets_enabled static_key_false(&memcg_socket_limit_enabled)
 #else
 #define mem_cgroup_sockets_enabled 0
 static inline struct cg_proto *parent_cg_proto(struct proto *proto,
@@ -1007,9 +1037,8 @@ static inline void memcg_memory_allocated_add(struct cg_proto *prot,
         struct res_counter *fail;
         int ret;
 
-        ret = res_counter_charge(prot->memory_allocated,
-                                 amt << PAGE_SHIFT, &fail);
-
+        ret = res_counter_charge_nofail(prot->memory_allocated,
+                                        amt << PAGE_SHIFT, &fail);
         if (ret < 0)
                 *parent_status = OVER_LIMIT;
 }
@@ -1053,12 +1082,11 @@ sk_memory_allocated_add(struct sock *sk, int amt, int *parent_status)
 }
 
 static inline void
-sk_memory_allocated_sub(struct sock *sk, int amt, int parent_status)
+sk_memory_allocated_sub(struct sock *sk, int amt)
 {
         struct proto *prot = sk->sk_prot;
 
-        if (mem_cgroup_sockets_enabled && sk->sk_cgrp &&
-            parent_status != OVER_LIMIT) /* Otherwise was uncharged already */
+        if (mem_cgroup_sockets_enabled && sk->sk_cgrp)
                 memcg_memory_allocated_sub(sk->sk_cgrp, amt);
 
         atomic_long_sub(amt, prot->memory_allocated);
diff --git a/include/net/tcp.h b/include/net/tcp.h
index 0118ea999f6..8607e6aad42 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -273,6 +273,14 @@ static inline int between(__u32 seq1, __u32 seq2, __u32 seq3)
         return seq3 - seq2 >= seq1 - seq2;
 }
 
+static inline bool tcp_out_of_memory(struct sock *sk)
+{
+        if (sk->sk_wmem_queued > SOCK_MIN_SNDBUF &&
+            sk_memory_allocated(sk) > sk_prot_mem_limits(sk, 2))
+                return true;
+        return false;
+}
+
 static inline bool tcp_too_many_orphans(struct sock *sk, int shift)
 {
         struct percpu_counter *ocp = sk->sk_prot->orphan_count;
@@ -283,13 +291,11 @@ static inline bool tcp_too_many_orphans(struct sock *sk, int shift)
                 if (orphans << shift > sysctl_tcp_max_orphans)
                         return true;
         }
-
-        if (sk->sk_wmem_queued > SOCK_MIN_SNDBUF &&
-            sk_memory_allocated(sk) > sk_prot_mem_limits(sk, 2))
-                return true;
         return false;
 }
 
+extern bool tcp_check_oom(struct sock *sk, int shift);
+
 /* syncookies: remember time of last synqueue overflow */
 static inline void tcp_synq_overflow(struct sock *sk)
 {
@@ -311,6 +317,8 @@ extern struct proto tcp_prot;
 #define TCP_ADD_STATS_USER(net, field, val) SNMP_ADD_STATS_USER((net)->mib.tcp_statistics, field, val)
 #define TCP_ADD_STATS(net, field, val)  SNMP_ADD_STATS((net)->mib.tcp_statistics, field, val)
 
+extern void tcp_init_mem(struct net *net);
+
 extern void tcp_v4_err(struct sk_buff *skb, u32);
 
 extern void tcp_shutdown (struct sock *sk, int how);
@@ -1130,35 +1138,27 @@ static inline void tcp_clear_all_retrans_hints(struct tcp_sock *tp)
 /* MD5 Signature */
 struct crypto_hash;
 
+union tcp_md5_addr {
+        struct in_addr  a4;
+#if IS_ENABLED(CONFIG_IPV6)
+        struct in6_addr a6;
+#endif
+};
+
 /* - key database */
 struct tcp_md5sig_key {
-        u8                      *key;
+        struct hlist_node       node;
         u8                      keylen;
-};
-
-struct tcp4_md5sig_key {
-        struct tcp_md5sig_key   base;
-        __be32                  addr;
-};
-
-struct tcp6_md5sig_key {
-        struct tcp_md5sig_key   base;
-#if 0
-        u32                     scope_id;       /* XXX */
-#endif
-        struct in6_addr         addr;
+        u8                      family; /* AF_INET or AF_INET6 */
+        union tcp_md5_addr      addr;
+        u8                      key[TCP_MD5SIG_MAXKEYLEN];
+        struct rcu_head         rcu;
 };
 
 /* - sock block */
 struct tcp_md5sig_info {
-        struct tcp4_md5sig_key  *keys4;
-#if IS_ENABLED(CONFIG_IPV6)
-        struct tcp6_md5sig_key  *keys6;
-        u32                     entries6;
-        u32                     alloced6;
-#endif
-        u32                     entries4;
-        u32                     alloced4;
+        struct hlist_head       head;
+        struct rcu_head         rcu;
 };
 
 /* - pseudo header */
@@ -1195,19 +1195,25 @@ extern int tcp_v4_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
                                const struct sock *sk,
                                const struct request_sock *req,
                                const struct sk_buff *skb);
-extern struct tcp_md5sig_key * tcp_v4_md5_lookup(struct sock *sk,
-                                                 struct sock *addr_sk);
-extern int tcp_v4_md5_do_add(struct sock *sk, __be32 addr, u8 *newkey,
-                             u8 newkeylen);
-extern int tcp_v4_md5_do_del(struct sock *sk, __be32 addr);
+extern int tcp_md5_do_add(struct sock *sk, const union tcp_md5_addr *addr,
+                          int family, const u8 *newkey,
+                          u8 newkeylen, gfp_t gfp);
+extern int tcp_md5_do_del(struct sock *sk, const union tcp_md5_addr *addr,
+                          int family);
+extern struct tcp_md5sig_key *tcp_v4_md5_lookup(struct sock *sk,
+                                         struct sock *addr_sk);
 
 #ifdef CONFIG_TCP_MD5SIG
-#define tcp_twsk_md5_key(twsk)  ((twsk)->tw_md5_keylen ?                 \
-                                 &(struct tcp_md5sig_key) {              \
-                                        .key = (twsk)->tw_md5_key,       \
-                                        .keylen = (twsk)->tw_md5_keylen, \
-                                } : NULL)
+extern struct tcp_md5sig_key *tcp_md5_do_lookup(struct sock *sk,
+                        const union tcp_md5_addr *addr, int family);
+#define tcp_twsk_md5_key(twsk)  ((twsk)->tw_md5_key)
 #else
+static inline struct tcp_md5sig_key *tcp_md5_do_lookup(struct sock *sk,
+                                         const union tcp_md5_addr *addr,
+                                         int family)
+{
+        return NULL;
+}
 #define tcp_twsk_md5_key(twsk)  NULL
 #endif
 
@@ -1356,8 +1362,9 @@ static inline void tcp_push_pending_frames(struct sock *sk)
         }
 }
 
-/* Start sequence of the highest skb with SACKed bit, valid only if
- * sacked > 0 or when the caller has ensured validity by itself.
+/* Start sequence of the skb just after the highest skb with SACKed
+ * bit, valid only if sacked_out > 0 or when the caller has ensured
+ * validity by itself.
  */
 static inline u32 tcp_highest_sack_seq(struct tcp_sock *tp)
 {
@@ -1462,10 +1469,6 @@ struct tcp_sock_af_ops {
                                                   const struct sock *sk,
                                                   const struct request_sock *req,
                                                   const struct sk_buff *skb);
-        int                     (*md5_add) (struct sock *sk,
-                                            struct sock *addr_sk,
-                                            u8 *newkey,
-                                            u8 len);
         int                     (*md5_parse) (struct sock *sk,
                                               char __user *optval,
                                               int optlen);
diff --git a/include/net/tcp_memcontrol.h b/include/net/tcp_memcontrol.h
index 3512082fa90..48410ff25c9 100644
--- a/include/net/tcp_memcontrol.h
+++ b/include/net/tcp_memcontrol.h
@@ -13,7 +13,7 @@ struct tcp_memcontrol {
 
 struct cg_proto *tcp_proto_cgroup(struct mem_cgroup *memcg);
 int tcp_init_cgroup(struct cgroup *cgrp, struct cgroup_subsys *ss);
-void tcp_destroy_cgroup(struct cgroup *cgrp, struct cgroup_subsys *ss);
+void tcp_destroy_cgroup(struct cgroup *cgrp);
 unsigned long long tcp_max_memory(const struct mem_cgroup *memcg);
 void tcp_prot_mem(struct mem_cgroup *memcg, long val, int idx);
 #endif /* _TCP_MEMCG_H */
diff --git a/include/net/udplite.h b/include/net/udplite.h
index 5f097ca7d5c..71375459a88 100644
--- a/include/net/udplite.h
+++ b/include/net/udplite.h
@@ -40,7 +40,7 @@ static inline int udplite_checksum_init(struct sk_buff *skb, struct udphdr *uh)
          * checksum. UDP-Lite (like IPv6) mandates checksums, hence packets
          * with a zero checksum field are illegal.                            */
         if (uh->check == 0) {
-                LIMIT_NETDEBUG(KERN_DEBUG "UDPLITE: zeroed checksum field\n");
+                LIMIT_NETDEBUG(KERN_DEBUG "UDPLite: zeroed checksum field\n");
                 return 1;
         }
 
@@ -52,7 +52,7 @@ static inline int udplite_checksum_init(struct sk_buff *skb, struct udphdr *uh)
                 /*
                  * Coverage length violates RFC 3828: log and discard silently.
                  */
-                LIMIT_NETDEBUG(KERN_DEBUG "UDPLITE: bad csum coverage %d/%d\n",
+                LIMIT_NETDEBUG(KERN_DEBUG "UDPLite: bad csum coverage %d/%d\n",
                                cscov, skb->len);
                 return 1;
 
diff --git a/include/net/xfrm.h b/include/net/xfrm.h
index 89174e29dca..96239e78e62 100644
--- a/include/net/xfrm.h
+++ b/include/net/xfrm.h
@@ -1566,11 +1566,6 @@ extern struct xfrm_algo_desc *xfrm_calg_get_byname(const char *name, int probe);
 extern struct xfrm_algo_desc *xfrm_aead_get_byname(const char *name, int icv_len,
                                                    int probe);
 
-struct hash_desc;
-struct scatterlist;
-typedef int (icv_update_fn_t)(struct hash_desc *, struct scatterlist *,
-                              unsigned int);
-
 static inline int xfrm_addr_cmp(const xfrm_address_t *a,
                                 const xfrm_address_t *b,
                                 int family)
diff --git a/include/scsi/scsi_device.h b/include/scsi/scsi_device.h
index 77273f2fdd8..b3a1c2daf6c 100644
--- a/include/scsi/scsi_device.h
+++ b/include/scsi/scsi_device.h
@@ -136,6 +136,7 @@ struct scsi_device {
         unsigned use_10_for_ms:1; /* first try 10-byte mode sense/select */
         unsigned skip_ms_page_8:1;      /* do not use MODE SENSE page 0x08 */
         unsigned skip_ms_page_3f:1;     /* do not use MODE SENSE page 0x3f */
+        unsigned skip_vpd_pages:1;      /* do not read VPD pages */
         unsigned use_192_bytes_for_3f:1; /* ask for 192 bytes from page 0x3f */
         unsigned no_start_on_add:1;     /* do not issue start on add */
         unsigned allow_restart:1; /* issue START_UNIT in error handler */
@@ -246,8 +247,10 @@ struct scsi_target {
         unsigned int            single_lun:1;   /* Indicates we should only
                                                  * allow I/O to one of the luns
                                                  * for the device at a time. */
-        unsigned int            pdt_1f_for_no_lun;      /* PDT = 0x1f */
-                                                /* means no lun present */
+        unsigned int            pdt_1f_for_no_lun:1;    /* PDT = 0x1f
+                                                 * means no lun present. */
+        unsigned int            no_report_luns:1;       /* Don't use
+                                                 * REPORT LUNS for scanning. */
         /* commands actually active on LLD. protected by host lock. */
         unsigned int            target_busy;
         /*
diff --git a/include/sound/core.h b/include/sound/core.h
index 5ab255f196c..cea1b5426df 100644
--- a/include/sound/core.h
+++ b/include/sound/core.h
@@ -417,6 +417,7 @@ static inline int __snd_bug_on(int cond)
 #define gameport_get_port_data(gp) (gp)->port_data
 #endif
 
+#ifdef CONFIG_PCI
 /* PCI quirk list helper */
 struct snd_pci_quirk {
         unsigned short subvendor;       /* PCI subvendor ID */
@@ -456,5 +457,6 @@ snd_pci_quirk_lookup(struct pci_dev *pci, const struct snd_pci_quirk *list);
 const struct snd_pci_quirk *
 snd_pci_quirk_lookup_id(u16 vendor, u16 device,
                         const struct snd_pci_quirk *list);
+#endif
 
 #endif /* __SOUND_CORE_H */
diff --git a/include/target/target_core_backend.h b/include/target/target_core_backend.h
index 4866499bdee..e5e6ff98f0f 100644
--- a/include/target/target_core_backend.h
+++ b/include/target/target_core_backend.h
@@ -59,7 +59,7 @@ int	transport_set_vpd_ident_type(struct t10_vpd *, unsigned char *);
 int     transport_set_vpd_ident(struct t10_vpd *, unsigned char *);
 
 /* core helpers also used by command snooping in pscsi */
-void    *transport_kmap_first_data_page(struct se_cmd *);
-void    transport_kunmap_first_data_page(struct se_cmd *);
+void    *transport_kmap_data_sg(struct se_cmd *);
+void    transport_kunmap_data_sg(struct se_cmd *);
 
 #endif /* TARGET_CORE_BACKEND_H */
diff --git a/include/target/target_core_base.h b/include/target/target_core_base.h
index daf532bc721..dc4e345a016 100644
--- a/include/target/target_core_base.h
+++ b/include/target/target_core_base.h
@@ -582,6 +582,7 @@ struct se_cmd {
 
         struct scatterlist      *t_data_sg;
         unsigned int            t_data_nents;
+        void                    *t_data_vmap;
         struct scatterlist      *t_bidi_data_sg;
         unsigned int            t_bidi_data_nents;
 
diff --git a/include/target/target_core_fabric.h b/include/target/target_core_fabric.h
index 523e8bc104d..d36fad317e7 100644
--- a/include/target/target_core_fabric.h
+++ b/include/target/target_core_fabric.h
@@ -114,7 +114,7 @@ void	transport_init_se_cmd(struct se_cmd *, struct target_core_fabric_ops *,
                 struct se_session *, u32, int, int, unsigned char *);
 int     transport_lookup_cmd_lun(struct se_cmd *, u32);
 int     transport_generic_allocate_tasks(struct se_cmd *, unsigned char *);
-int     target_submit_cmd(struct se_cmd *, struct se_session *, unsigned char *,
+void    target_submit_cmd(struct se_cmd *, struct se_session *, unsigned char *,
                 unsigned char *, u32, u32, int, int, int);
 int     transport_handle_cdb_direct(struct se_cmd *);
 int     transport_generic_handle_cdb_map(struct se_cmd *);
diff --git a/include/trace/events/power.h b/include/trace/events/power.h
index 1bcc2a8c00e..cae9a94f025 100644
--- a/include/trace/events/power.h
+++ b/include/trace/events/power.h
@@ -65,7 +65,6 @@ TRACE_EVENT(machine_suspend,
         TP_printk("state=%lu", (unsigned long)__entry->state)
 );
 
-/* This code will be removed after deprecation time exceeded (2.6.41) */
 #ifdef CONFIG_EVENT_POWER_TRACING_DEPRECATED
 
 /*
@@ -151,6 +150,8 @@ enum {
    events get removed */
 static inline void trace_power_start(u64 type, u64 state, u64 cpuid) {};
 static inline void trace_power_end(u64 cpuid) {};
+static inline void trace_power_start_rcuidle(u64 type, u64 state, u64 cpuid) {};
+static inline void trace_power_end_rcuidle(u64 cpuid) {};
 static inline void trace_power_frequency(u64 type, u64 state, u64 cpuid) {};
 #endif /* _PWR_EVENT_AVOID_DOUBLE_DEFINING_DEPRECATED */
 
diff --git a/include/trace/events/printk.h b/include/trace/events/printk.h
new file mode 100644
index 00000000000..94ec79cc011
--- /dev/null
+++ b/include/trace/events/printk.h
@@ -0,0 +1,41 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM printk
+
+#if !defined(_TRACE_PRINTK_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_PRINTK_H
+
+#include <linux/tracepoint.h>
+
+TRACE_EVENT_CONDITION(console,
+        TP_PROTO(const char *log_buf, unsigned start, unsigned end,
+                 unsigned log_buf_len),
+
+        TP_ARGS(log_buf, start, end, log_buf_len),
+
+        TP_CONDITION(start != end),
+
+        TP_STRUCT__entry(
+                __dynamic_array(char, msg, end - start + 1)
+        ),
+
+        TP_fast_assign(
+                if ((start & (log_buf_len - 1)) > (end & (log_buf_len - 1))) {
+                        memcpy(__get_dynamic_array(msg),
+                               log_buf + (start & (log_buf_len - 1)),
+                               log_buf_len - (start & (log_buf_len - 1)));
+                        memcpy((char *)__get_dynamic_array(msg) +
+                               log_buf_len - (start & (log_buf_len - 1)),
+                               log_buf, end & (log_buf_len - 1));
+                } else
+                        memcpy(__get_dynamic_array(msg),
+                               log_buf + (start & (log_buf_len - 1)),
+                               end - start);
+                ((char *)__get_dynamic_array(msg))[end - start] = 0;
+        ),
+
+        TP_printk("%s", __get_str(msg))
+);
+#endif /* _TRACE_PRINTK_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
diff --git a/include/trace/events/rcu.h b/include/trace/events/rcu.h
index d2d88bed891..337099783f3 100644
--- a/include/trace/events/rcu.h
+++ b/include/trace/events/rcu.h
@@ -313,19 +313,22 @@ TRACE_EVENT(rcu_prep_idle,
 /*
  * Tracepoint for the registration of a single RCU callback function.
  * The first argument is the type of RCU, the second argument is
- * a pointer to the RCU callback itself, and the third element is the
- * new RCU callback queue length for the current CPU.
+ * a pointer to the RCU callback itself, the third element is the
+ * number of lazy callbacks queued, and the fourth element is the
+ * total number of callbacks queued.
  */
 TRACE_EVENT(rcu_callback,
 
-        TP_PROTO(char *rcuname, struct rcu_head *rhp, long qlen),
+        TP_PROTO(char *rcuname, struct rcu_head *rhp, long qlen_lazy,
+                 long qlen),
 
-        TP_ARGS(rcuname, rhp, qlen),
+        TP_ARGS(rcuname, rhp, qlen_lazy, qlen),
 
         TP_STRUCT__entry(
                 __field(char *, rcuname)
                 __field(void *, rhp)
                 __field(void *, func)
+                __field(long, qlen_lazy)
                 __field(long, qlen)
         ),
 
@@ -333,11 +336,13 @@ TRACE_EVENT(rcu_callback,
                 __entry->rcuname = rcuname;
                 __entry->rhp = rhp;
                 __entry->func = rhp->func;
+                __entry->qlen_lazy = qlen_lazy;
                 __entry->qlen = qlen;
         ),
 
-        TP_printk("%s rhp=%p func=%pf %ld",
-                  __entry->rcuname, __entry->rhp, __entry->func, __entry->qlen)
+        TP_printk("%s rhp=%p func=%pf %ld/%ld",
+                  __entry->rcuname, __entry->rhp, __entry->func,
+                  __entry->qlen_lazy, __entry->qlen)
 );
 
 /*
@@ -345,20 +350,21 @@ TRACE_EVENT(rcu_callback,
  * kfree() form.  The first argument is the RCU type, the second argument
  * is a pointer to the RCU callback, the third argument is the offset
  * of the callback within the enclosing RCU-protected data structure,
- * and the fourth argument is the new RCU callback queue length for the
- * current CPU.
+ * the fourth argument is the number of lazy callbacks queued, and the
+ * fifth argument is the total number of callbacks queued.
  */
 TRACE_EVENT(rcu_kfree_callback,
 
         TP_PROTO(char *rcuname, struct rcu_head *rhp, unsigned long offset,
-                 long qlen),
+                 long qlen_lazy, long qlen),
 
-        TP_ARGS(rcuname, rhp, offset, qlen),
+        TP_ARGS(rcuname, rhp, offset, qlen_lazy, qlen),
 
         TP_STRUCT__entry(
                 __field(char *, rcuname)
                 __field(void *, rhp)
                 __field(unsigned long, offset)
+                __field(long, qlen_lazy)
                 __field(long, qlen)
         ),
 
@@ -366,41 +372,45 @@ TRACE_EVENT(rcu_kfree_callback,
                 __entry->rcuname = rcuname;
                 __entry->rhp = rhp;
                 __entry->offset = offset;
+                __entry->qlen_lazy = qlen_lazy;
                 __entry->qlen = qlen;
         ),
 
-        TP_printk("%s rhp=%p func=%ld %ld",
+        TP_printk("%s rhp=%p func=%ld %ld/%ld",
                   __entry->rcuname, __entry->rhp, __entry->offset,
-                  __entry->qlen)
+                  __entry->qlen_lazy, __entry->qlen)
 );
 
 /*
  * Tracepoint for marking the beginning rcu_do_batch, performed to start
  * RCU callback invocation.  The first argument is the RCU flavor,
- * the second is the total number of callbacks (including those that
- * are not yet ready to be invoked), and the third argument is the
- * current RCU-callback batch limit.
+ * the second is the number of lazy callbacks queued, the third is
+ * the total number of callbacks queued, and the fourth argument is
+ * the current RCU-callback batch limit.
  */
 TRACE_EVENT(rcu_batch_start,
 
-        TP_PROTO(char *rcuname, long qlen, int blimit),
+        TP_PROTO(char *rcuname, long qlen_lazy, long qlen, int blimit),
 
-        TP_ARGS(rcuname, qlen, blimit),
+        TP_ARGS(rcuname, qlen_lazy, qlen, blimit),
 
         TP_STRUCT__entry(
                 __field(char *, rcuname)
+                __field(long, qlen_lazy)
                 __field(long, qlen)
                 __field(int, blimit)
         ),
 
         TP_fast_assign(
                 __entry->rcuname = rcuname;
+                __entry->qlen_lazy = qlen_lazy;
                 __entry->qlen = qlen;
                 __entry->blimit = blimit;
         ),
 
-        TP_printk("%s CBs=%ld bl=%d",
-                  __entry->rcuname, __entry->qlen, __entry->blimit)
+        TP_printk("%s CBs=%ld/%ld bl=%d",
+                  __entry->rcuname, __entry->qlen_lazy, __entry->qlen,
+                  __entry->blimit)
 );
 
 /*
@@ -531,16 +541,21 @@ TRACE_EVENT(rcu_torture_read,
 #else /* #ifdef CONFIG_RCU_TRACE */
 
 #define trace_rcu_grace_period(rcuname, gpnum, gpevent) do { } while (0)
-#define trace_rcu_grace_period_init(rcuname, gpnum, level, grplo, grphi, qsmask) do { } while (0)
+#define trace_rcu_grace_period_init(rcuname, gpnum, level, grplo, grphi, \
+                                    qsmask) do { } while (0)
 #define trace_rcu_preempt_task(rcuname, pid, gpnum) do { } while (0)
 #define trace_rcu_unlock_preempted_task(rcuname, gpnum, pid) do { } while (0)
-#define trace_rcu_quiescent_state_report(rcuname, gpnum, mask, qsmask, level, grplo, grphi, gp_tasks) do { } while (0)
+#define trace_rcu_quiescent_state_report(rcuname, gpnum, mask, qsmask, level, \
+                                         grplo, grphi, gp_tasks) do { } \
+        while (0)
 #define trace_rcu_fqs(rcuname, gpnum, cpu, qsevent) do { } while (0)
 #define trace_rcu_dyntick(polarity, oldnesting, newnesting) do { } while (0)
 #define trace_rcu_prep_idle(reason) do { } while (0)
-#define trace_rcu_callback(rcuname, rhp, qlen) do { } while (0)
-#define trace_rcu_kfree_callback(rcuname, rhp, offset, qlen) do { } while (0)
-#define trace_rcu_batch_start(rcuname, qlen, blimit) do { } while (0)
+#define trace_rcu_callback(rcuname, rhp, qlen_lazy, qlen) do { } while (0)
+#define trace_rcu_kfree_callback(rcuname, rhp, offset, qlen_lazy, qlen) \
+        do { } while (0)
+#define trace_rcu_batch_start(rcuname, qlen_lazy, qlen, blimit) \
+        do { } while (0)
 #define trace_rcu_invoke_callback(rcuname, rhp) do { } while (0)
 #define trace_rcu_invoke_kfree_callback(rcuname, rhp, offset) do { } while (0)
 #define trace_rcu_batch_end(rcuname, callbacks_invoked, cb, nr, iit, risk) \
diff --git a/include/trace/events/sched.h b/include/trace/events/sched.h
index 6ba596b07a7..fbc7b1ad929 100644
--- a/include/trace/events/sched.h
+++ b/include/trace/events/sched.h
@@ -6,6 +6,7 @@
 
 #include <linux/sched.h>
 #include <linux/tracepoint.h>
+#include <linux/binfmts.h>
 
 /*
  * Tracepoint for calling kthread_stop, performed to end a kthread:
@@ -276,6 +277,32 @@ TRACE_EVENT(sched_process_fork,
 );
 
 /*
+ * Tracepoint for exec:
+ */
+TRACE_EVENT(sched_process_exec,
+
+        TP_PROTO(struct task_struct *p, pid_t old_pid,
+                 struct linux_binprm *bprm),
+
+        TP_ARGS(p, old_pid, bprm),
+
+        TP_STRUCT__entry(
+                __string(       filename,       bprm->filename  )
+                __field(        pid_t,          pid             )
+                __field(        pid_t,          old_pid         )
+        ),
+
+        TP_fast_assign(
+                __assign_str(filename, bprm->filename);
+                __entry->pid            = p->pid;
+                __entry->old_pid        = p->pid;
+        ),
+
+        TP_printk("filename=%s pid=%d old_pid=%d", __get_str(filename),
+                  __entry->pid, __entry->old_pid)
+);
+
+/*
  * XXX the below sched_stat tracepoints only apply to SCHED_OTHER/BATCH/IDLE
  *     adding sched_stat support to SCHED_FIFO/RR would be welcome.
  */
@@ -370,56 +397,6 @@ TRACE_EVENT(sched_stat_runtime,
                         (unsigned long long)__entry->vruntime)
 );
 
-#ifdef CREATE_TRACE_POINTS
-static inline u64 trace_get_sleeptime(struct task_struct *tsk)
-{
-#ifdef CONFIG_SCHEDSTATS
-        u64 block, sleep;
-
-        block = tsk->se.statistics.block_start;
-        sleep = tsk->se.statistics.sleep_start;
-        tsk->se.statistics.block_start = 0;
-        tsk->se.statistics.sleep_start = 0;
-
-        return block ? block : sleep ? sleep : 0;
-#else
-        return 0;
-#endif
-}
-#endif
-
-/*
- * Tracepoint for accounting sleeptime (time the task is sleeping
- * or waiting for I/O).
- */
-TRACE_EVENT(sched_stat_sleeptime,
-
-        TP_PROTO(struct task_struct *tsk, u64 now),
-
-        TP_ARGS(tsk, now),
-
-        TP_STRUCT__entry(
-                __array( char,  comm,   TASK_COMM_LEN   )
-                __field( pid_t, pid                     )
-                __field( u64,   sleeptime               )
-        ),
-
-        TP_fast_assign(
-                memcpy(__entry->comm, tsk->comm, TASK_COMM_LEN);
-                __entry->pid            = tsk->pid;
-                __entry->sleeptime = trace_get_sleeptime(tsk);
-                __entry->sleeptime = __entry->sleeptime ?
-                                now - __entry->sleeptime : 0;
-        )
-        TP_perf_assign(
-                __perf_count(__entry->sleeptime);
-        ),
-
-        TP_printk("comm=%s pid=%d sleeptime=%Lu [ns]",
-                        __entry->comm, __entry->pid,
-                        (unsigned long long)__entry->sleeptime)
-);
-
 /*
  * Tracepoint for showing priority inheritance modifying a tasks
  * priority.
diff --git a/include/trace/events/signal.h b/include/trace/events/signal.h
index 17df43464df..39a8a430d90 100644
--- a/include/trace/events/signal.h
+++ b/include/trace/events/signal.h
@@ -23,11 +23,23 @@
                 }                                               \
         } while (0)
 
+#ifndef TRACE_HEADER_MULTI_READ
+enum {
+        TRACE_SIGNAL_DELIVERED,
+        TRACE_SIGNAL_IGNORED,
+        TRACE_SIGNAL_ALREADY_PENDING,
+        TRACE_SIGNAL_OVERFLOW_FAIL,
+        TRACE_SIGNAL_LOSE_INFO,
+};
+#endif
+
 /**
  * signal_generate - called when a signal is generated
  * @sig: signal number
  * @info: pointer to struct siginfo
  * @task: pointer to struct task_struct
+ * @group: shared or private
+ * @result: TRACE_SIGNAL_*
  *
  * Current process sends a 'sig' signal to 'task' process with
  * 'info' siginfo. If 'info' is SEND_SIG_NOINFO or SEND_SIG_PRIV,
@@ -37,9 +49,10 @@
  */
 TRACE_EVENT(signal_generate,
 
-        TP_PROTO(int sig, struct siginfo *info, struct task_struct *task),
+        TP_PROTO(int sig, struct siginfo *info, struct task_struct *task,
+                        int group, int result),
 
-        TP_ARGS(sig, info, task),
+        TP_ARGS(sig, info, task, group, result),
 
         TP_STRUCT__entry(
                 __field(        int,    sig                     )
@@ -47,6 +60,8 @@ TRACE_EVENT(signal_generate,
                 __field(        int,    code                    )
                 __array(        char,   comm,   TASK_COMM_LEN   )
                 __field(        pid_t,  pid                     )
+                __field(        int,    group                   )
+                __field(        int,    result                  )
         ),
 
         TP_fast_assign(
@@ -54,11 +69,14 @@ TRACE_EVENT(signal_generate,
                 TP_STORE_SIGINFO(__entry, info);
                 memcpy(__entry->comm, task->comm, TASK_COMM_LEN);
                 __entry->pid    = task->pid;
+                __entry->group  = group;
+                __entry->result = result;
         ),
 
-        TP_printk("sig=%d errno=%d code=%d comm=%s pid=%d",
+        TP_printk("sig=%d errno=%d code=%d comm=%s pid=%d grp=%d res=%d",
                   __entry->sig, __entry->errno, __entry->code,
-                  __entry->comm, __entry->pid)
+                  __entry->comm, __entry->pid, __entry->group,
+                  __entry->result)
 );
 
 /**
@@ -101,65 +119,6 @@ TRACE_EVENT(signal_deliver,
                   __entry->sa_handler, __entry->sa_flags)
 );
 
-DECLARE_EVENT_CLASS(signal_queue_overflow,
-
-        TP_PROTO(int sig, int group, struct siginfo *info),
-
-        TP_ARGS(sig, group, info),
-
-        TP_STRUCT__entry(
-                __field(        int,    sig     )
-                __field(        int,    group   )
-                __field(        int,    errno   )
-                __field(        int,    code    )
-        ),
-
-        TP_fast_assign(
-                __entry->sig    = sig;
-                __entry->group  = group;
-                TP_STORE_SIGINFO(__entry, info);
-        ),
-
-        TP_printk("sig=%d group=%d errno=%d code=%d",
-                  __entry->sig, __entry->group, __entry->errno, __entry->code)
-);
-
-/**
- * signal_overflow_fail - called when signal queue is overflow
- * @sig: signal number
- * @group: signal to process group or not (bool)
- * @info: pointer to struct siginfo
- *
- * Kernel fails to generate 'sig' signal with 'info' siginfo, because
- * siginfo queue is overflow, and the signal is dropped.
- * 'group' is not 0 if the signal will be sent to a process group.
- * 'sig' is always one of RT signals.
- */
-DEFINE_EVENT(signal_queue_overflow, signal_overflow_fail,
-
-        TP_PROTO(int sig, int group, struct siginfo *info),
-
-        TP_ARGS(sig, group, info)
-);
-
-/**
- * signal_lose_info - called when siginfo is lost
- * @sig: signal number
- * @group: signal to process group or not (bool)
- * @info: pointer to struct siginfo
- *
- * Kernel generates 'sig' signal but loses 'info' siginfo, because siginfo
- * queue is overflow.
- * 'group' is not 0 if the signal will be sent to a process group.
- * 'sig' is always one of non-RT signals.
- */
-DEFINE_EVENT(signal_queue_overflow, signal_lose_info,
-
-        TP_PROTO(int sig, int group, struct siginfo *info),
-
-        TP_ARGS(sig, group, info)
-);
-
 #endif /* _TRACE_SIGNAL_H */
 
 /* This part must be outside protection */
diff --git a/include/trace/events/writeback.h b/include/trace/events/writeback.h
index 8588a891802..5973410e8f8 100644
--- a/include/trace/events/writeback.h
+++ b/include/trace/events/writeback.h
@@ -47,7 +47,10 @@ DECLARE_EVENT_CLASS(writeback_work_class,
                 __field(int, reason)
         ),
         TP_fast_assign(
-                strncpy(__entry->name, dev_name(bdi->dev), 32);
+                struct device *dev = bdi->dev;
+                if (!dev)
+                        dev = default_backing_dev_info.dev;
+                strncpy(__entry->name, dev_name(dev), 32);
                 __entry->nr_pages = work->nr_pages;
                 __entry->sb_dev = work->sb ? work->sb->s_dev : 0;
                 __entry->sync_mode = work->sync_mode;
@@ -426,7 +429,7 @@ DECLARE_EVENT_CLASS(writeback_single_inode_template,
 
         TP_fast_assign(
                 strncpy(__entry->name,
-                        dev_name(inode->i_mapping->backing_dev_info->dev), 32);
+                        dev_name(inode_to_bdi(inode)->dev), 32);
                 __entry->ino            = inode->i_ino;
                 __entry->state          = inode->i_state;
                 __entry->dirtied_when   = inode->dirtied_when;
diff --git a/include/video/omapdss.h b/include/video/omapdss.h
index 062b3b24ff1..483f67caa7a 100644
--- a/include/video/omapdss.h
+++ b/include/video/omapdss.h
@@ -590,6 +590,11 @@ struct omap_dss_device {
         int (*get_backlight)(struct omap_dss_device *dssdev);
 };
 
+struct omap_dss_hdmi_data
+{
+        int hpd_gpio;
+};
+
 struct omap_dss_driver {
         struct device_driver driver;